C++ lifetime wrappers around kernel C handles

751}
752
753template <typename Derived>
754class BlockHashApi
755{
756private:
757    auto impl() const
758    {
759        return static_cast<const Derived*>(this)->get();
760    }
761
762public:
763    bool operator==(const Derived& other) const
764    {
765        return btck_block_hash_equals(impl(), other.get()) != 0;
766    }
767
768    bool operator!=(const Derived& other) const
769    {
770        return btck_block_hash_equals(impl(), other.get()) == 0;
771    }
772
773    std::array<std::byte, 32> ToBytes() const
774    {
775        std::array<std::byte, 32> hash;
776        btck_block_hash_to_bytes(impl(), reinterpret_cast<unsigned char*>(hash.data()));
777        return hash;
778    }
779};
780
781class BlockHashView : public View<btck_BlockHash>, public BlockHashApi<BlockHashView>
782{
783public:
784    explicit BlockHashView(const btck_BlockHash* ptr) : View{ptr} {}
785};
786
787class BlockHash : public Handle<btck_BlockHash, btck_block_hash_copy, btck_block_hash_destroy>, public BlockHashApi<BlockHash>
788{
789public:
790    explicit BlockHash(const std::array<std::byte, 32>& hash)
791        : Handle{btck_block_hash_create(reinterpret_cast<const unsigned char*>(hash.data()))} {}
792
793    explicit BlockHash(btck_BlockHash* hash)
794        : Handle{hash} {}
795
796    BlockHash(const BlockHashView& view)
797        : Handle{view} {}
798};
799
800template <typename Derived>
801class BlockHeaderApi
802{
803private:
804    auto impl() const
805    {
806        return static_cast<const Derived*>(this)->get();
807    }
808
809    friend Derived;
810    BlockHeaderApi() = default;
811
812public:
813    BlockHash Hash() const
814    {
815        return BlockHash{btck_block_header_get_hash(impl())};
816    }
817
818    BlockHashView PrevHash() const
819    {
820        return BlockHashView{btck_block_header_get_prev_hash(impl())};
821    }
822
823    uint32_t Timestamp() const
824    {
825        return btck_block_header_get_timestamp(impl());
826    }
827
828    uint32_t Bits() const
829    {
830        return btck_block_header_get_bits(impl());
831    }
832
833    int32_t Version() const
834    {
835        return btck_block_header_get_version(impl());
836    }
837
838    uint32_t Nonce() const
839    {
840        return btck_block_header_get_nonce(impl());
841    }
842
843    std::array<std::byte, 80> ToBytes() const
844    {
845        std::array<std::byte, 80> header;
846        int res{btck_block_header_to_bytes(impl(), reinterpret_cast<unsigned char*>(header.data()))};
847        if (res != 0) {
848            throw std::runtime_error("Failed to serialize block header");
849        }
850        return header;
851    }
852};
853
854class BlockHeaderView : public View<btck_BlockHeader>, public BlockHeaderApi<BlockHeaderView>
855{
856public:
857    explicit BlockHeaderView(const btck_BlockHeader* ptr) : View{ptr} {}
858};
859
860class BlockHeader : public Handle<btck_BlockHeader, btck_block_header_copy, btck_block_header_destroy>, public BlockHeaderApi<BlockHeader>
861{
862public:
863    explicit BlockHeader(std::span<const std::byte> raw_header)
864        : Handle{btck_block_header_create(reinterpret_cast<const unsigned char*>(raw_header.data()), raw_header.size())} {}
865
866    BlockHeader(const BlockHeaderView& view)
867        : Handle{view} {}
868
869    BlockHeader(btck_BlockHeader* header)
870        : Handle{header} {}
871};
872
873class ConsensusParamsView : public View<btck_ConsensusParams>
874{
875public:
876    explicit ConsensusParamsView(const btck_ConsensusParams* ptr) : View{ptr} {}
877};
878
879class Block : public Handle<btck_Block, btck_block_copy, btck_block_destroy>
880{
881public:
882    Block(const std::span<const std::byte> raw_block)
883        : Handle{btck_block_create(raw_block.data(), raw_block.size())}
884    {
885    }
886
887    Block(btck_Block* block) : Handle{block} {}
888
889    size_t CountTransactions() const
890    {
891        return btck_block_count_transactions(get());
892    }
893
894    TransactionView GetTransaction(size_t index) const
895    {
896        return TransactionView{btck_block_get_transaction_at(get(), index)};
897    }
898
899    bool Check(const ConsensusParamsView& consensus_params,
900        BlockCheckFlags flags,
901        BlockValidationState& state) const;
902
903    MAKE_RANGE_METHOD(Transactions, Block, &Block::CountTransactions, &Block::GetTransaction, *this)
904
905    BlockHash GetHash() const
906    {
907        return BlockHash{btck_block_get_hash(get())};
908    }
909
910    BlockHeader GetHeader() const
911    {
912        return BlockHeader{btck_block_get_header(get())};
913    }
914
915    std::vector<std::byte> ToBytes() const
916    {
917        return write_bytes(get(), btck_block_to_bytes);
918    }
919};
920
921inline void logging_disable()
922{
923    btck_logging_disable();
924}
925
926inline void logging_set_options(const btck_LoggingOptions& logging_options)
927{
928    btck_logging_set_options(logging_options);
929}
930
931inline void logging_set_level_category(LogCategory category, LogLevel level)
932{
933    btck_logging_set_level_category(static_cast<btck_LogCategory>(category), static_cast<btck_LogLevel>(level));
934}
935
936inline void logging_enable_category(LogCategory category)
937{
938    btck_logging_enable_category(static_cast<btck_LogCategory>(category));
939}
940
941inline void logging_disable_category(LogCategory category)
942{
943    btck_logging_disable_category(static_cast<btck_LogCategory>(category));
944}
945
946template <typename T>
947concept Log = requires(T a, std::string_view message) {
948    { a.LogMessage(message) } -> std::same_as<void>;
949};
950
951template <Log T>
952class Logger : UniqueHandle<btck_LoggingConnection, btck_logging_connection_destroy>
953{
954public:
955    Logger(std::unique_ptr<T> log)
956        : UniqueHandle{btck_logging_connection_create(
957              +[](void* user_data, const char* message, size_t message_len) { static_cast<T*>(user_data)->LogMessage({message, message_len}); },
958              log.release(),
959              +[](void* user_data) { delete static_cast<T*>(user_data); })}
960    {
961    }
962};
963
964class BlockTreeEntry : public View<btck_BlockTreeEntry>
965{
966public:
967    BlockTreeEntry(const btck_BlockTreeEntry* entry)
968        : View{entry}
969    {
970    }
971
972    bool operator==(const BlockTreeEntry& other) const
973    {
974        return btck_block_tree_entry_equals(get(), other.get()) != 0;
975    }
976
977    std::optional<BlockTreeEntry> GetPrevious() const
978    {
979        auto entry{btck_block_tree_entry_get_previous(get())};
980        if (!entry) return std::nullopt;
981        return entry;
982    }
983
984    int32_t GetHeight() const
985    {
986        return btck_block_tree_entry_get_height(get());
987    }
988
989    BlockHashView GetHash() const
990    {
991        return BlockHashView{btck_block_tree_entry_get_block_hash(get())};
992    }
993
994    BlockHeader GetHeader() const
995    {
996        return BlockHeader{btck_block_tree_entry_get_block_header(get())};
997    }
998
999    BlockTreeEntry GetAncestor(int32_t height) const
1000    {