C++ lifetime wrappers around kernel C handles

251    using iterator = Iterator<Container, value_type, GetFunc>;
252    using const_iterator = iterator;
253
254private:
255    const Container* m_container;
256
257public:
258    explicit Range(const Container& container) : m_container(&container)
259    {
260        static_assert(std::ranges::random_access_range<Range>);
261    }
262
263    iterator begin() const { return iterator(m_container, 0); }
264    iterator end() const { return iterator(m_container, size()); }
265
266    const_iterator cbegin() const { return begin(); }
267    const_iterator cend() const { return end(); }
268
269    size_t size() const { return std::invoke(SizeFunc, *m_container); }
270
271    bool empty() const { return size() == 0; }
272
273    value_type operator[](size_t index) const { return std::invoke(GetFunc, *m_container, index); }
274
275    value_type at(size_t index) const
276    {
277        if (index >= size()) {
278            throw std::out_of_range("Index out of range");
279        }
280        return (*this)[index];
281    }
282
283    value_type front() const { return (*this)[0]; }
284    value_type back() const { return (*this)[size() - 1]; }
285};
286
287#define MAKE_RANGE_METHOD(method_name, ContainerType, SizeFunc, GetFunc, container_expr) \
288    auto method_name() const & { \
289        return Range<ContainerType, SizeFunc, GetFunc>{container_expr}; \
290    } \
291    auto method_name() const && = delete;
292
293template <typename T>
294std::vector<std::byte> write_bytes(const T* object, int (*to_bytes)(const T*, btck_WriteBytes, void*))
295{
296    std::vector<std::byte> bytes;
297    struct UserData {
298        std::vector<std::byte>* bytes;
299        std::exception_ptr exception;
300    };
301    UserData user_data = UserData{.bytes = &bytes, .exception = nullptr};
302
303    constexpr auto const write = +[](const void* buffer, size_t len, void* user_data) -> int {
304        auto& data = *reinterpret_cast<UserData*>(user_data);
305        auto& bytes = *data.bytes;
306        try {
307            auto const* first = static_cast<const std::byte*>(buffer);
308            auto const* last = first + len;
309            bytes.insert(bytes.end(), first, last);
310            return 0;
311        } catch (...) {
312            data.exception = std::current_exception();
313            return -1;
314        }
315    };
316
317    if (to_bytes(object, write, &user_data) != 0) {
318        std::rethrow_exception(user_data.exception);
319    }
320    return bytes;
321}
322
323template <typename CType>
324class View
325{
326protected:
327    const CType* m_ptr;
328
329public:
330    explicit View(const CType* ptr) : m_ptr{check(ptr)} {}
331
332    const CType* get() const { return m_ptr; }
333};
334
335template <typename CType, CType* (*CopyFunc)(const CType*), void (*DestroyFunc)(CType*)>
336class Handle
337{
338protected:
339    CType* m_ptr;
340
341public:
342    explicit Handle(CType* ptr) : m_ptr{check(ptr)} {}
343
344    // Copy constructors
345    Handle(const Handle& other)
346        : m_ptr{check(CopyFunc(other.m_ptr))} {}
347    Handle& operator=(const Handle& other)
348    {
349        if (this != &other) {
350            Handle temp(other);
351            std::swap(m_ptr, temp.m_ptr);
352        }
353        return *this;
354    }
355
356    // Move constructors
357    Handle(Handle&& other) noexcept : m_ptr(other.m_ptr) { other.m_ptr = nullptr; }
358    Handle& operator=(Handle&& other) noexcept
359    {
360        if (this != &other) {
361            DestroyFunc(m_ptr);
362            m_ptr = std::exchange(other.m_ptr, nullptr);
363        }
364        return *this;
365    }
366
367    template <typename ViewType>
368        requires std::derived_from<ViewType, View<CType>>
369    Handle(const ViewType& view)
370        : Handle{CopyFunc(view.get())}
371    {
372    }
373
374    ~Handle() { DestroyFunc(m_ptr); }
375
376    CType* get() { return m_ptr; }
377    const CType* get() const { return m_ptr; }
378};
379
380template <typename CType, void (*DestroyFunc)(CType*)>
381class UniqueHandle
382{
383protected:
384    struct Deleter {
385        void operator()(CType* ptr) const noexcept
386        {
387            if (ptr) DestroyFunc(ptr);
388        }
389    };
390    std::unique_ptr<CType, Deleter> m_ptr;
391
392public:
393    explicit UniqueHandle(CType* ptr) : m_ptr{check(ptr)} {}
394
395    CType* get() { return m_ptr.get(); }
396    const CType* get() const { return m_ptr.get(); }
397};
398
399class PrecomputedTransactionData;
400class Transaction;
401class TransactionOutput;
402class BlockValidationState;
403
404template <typename Derived>
405class ScriptPubkeyApi
406{
407private:
408    auto impl() const
409    {
410        return static_cast<const Derived*>(this)->get();
411    }
412
413    friend Derived;
414    ScriptPubkeyApi() = default;
415
416public:
417    bool Verify(int64_t amount,
418                const Transaction& tx_to,
419                const PrecomputedTransactionData* precomputed_txdata,
420                unsigned int input_index,
421                ScriptVerificationFlags flags,
422                ScriptVerifyStatus& status) const;
423
424    std::vector<std::byte> ToBytes() const
425    {
426        return write_bytes(impl(), btck_script_pubkey_to_bytes);
427    }
428};
429
430class ScriptPubkeyView : public View<btck_ScriptPubkey>, public ScriptPubkeyApi<ScriptPubkeyView>
431{
432public:
433    explicit ScriptPubkeyView(const btck_ScriptPubkey* ptr) : View{ptr} {}
434};
435
436class ScriptPubkey : public Handle<btck_ScriptPubkey, btck_script_pubkey_copy, btck_script_pubkey_destroy>, public ScriptPubkeyApi<ScriptPubkey>
437{
438public:
439    explicit ScriptPubkey(std::span<const std::byte> raw)
440        : Handle{btck_script_pubkey_create(raw.data(), raw.size())} {}
441
442    ScriptPubkey(const ScriptPubkeyView& view)
443        : Handle(view) {}
444};
445
446template <typename Derived>
447class TransactionOutputApi
448{
449private:
450    auto impl() const
451    {
452        return static_cast<const Derived*>(this)->get();
453    }
454
455    friend Derived;
456    TransactionOutputApi() = default;
457
458public:
459    int64_t Amount() const
460    {
461        return btck_transaction_output_get_amount(impl());
462    }
463
464    ScriptPubkeyView GetScriptPubkey() const
465    {
466        return ScriptPubkeyView{btck_transaction_output_get_script_pubkey(impl())};
467    }
468};
469
470class TransactionOutputView : public View<btck_TransactionOutput>, public TransactionOutputApi<TransactionOutputView>
471{
472public:
473    explicit TransactionOutputView(const btck_TransactionOutput* ptr) : View{ptr} {}
474};
475
476class TransactionOutput : public Handle<btck_TransactionOutput, btck_transaction_output_copy, btck_transaction_output_destroy>, public TransactionOutputApi<TransactionOutput>
477{
478public:
479    explicit TransactionOutput(const ScriptPubkey& script_pubkey, int64_t amount)
480        : Handle{btck_transaction_output_create(script_pubkey.get(), amount)} {}
481
482    TransactionOutput(const TransactionOutputView& view)
483        : Handle(view) {}
484};
485
486template <typename Derived>
487class TxidApi
488{
489private:
490    auto impl() const
491    {
492        return static_cast<const Derived*>(this)->get();
493    }
494
495    friend Derived;
496    TxidApi() = default;
497
498public:
499    bool operator==(const TxidApi& other) const
500    {