C++ lifetime wrappers around kernel C handles

1001        return BlockTreeEntry{btck_block_tree_entry_get_ancestor(get(), height)};
1002    }
1003
1004};
1005
1006class KernelNotifications
1007{
1008public:
1009    virtual ~KernelNotifications() = default;
1010
1011    virtual void BlockTipHandler(SynchronizationState state, BlockTreeEntry entry, double verification_progress) {}
1012
1013    virtual void HeaderTipHandler(SynchronizationState state, int64_t height, int64_t timestamp, bool presync) {}
1014
1015    virtual void ProgressHandler(std::string_view title, int progress_percent, bool resume_possible) {}
1016
1017    virtual void WarningSetHandler(Warning warning, std::string_view message) {}
1018
1019    virtual void WarningUnsetHandler(Warning warning) {}
1020
1021    virtual void FlushErrorHandler(std::string_view error) {}
1022
1023    virtual void FatalErrorHandler(std::string_view error) {}
1024};
1025
1026template <typename Derived>
1027class BlockValidationStateApi
1028{
1029private:
1030    auto impl() const
1031    {
1032        return static_cast<const Derived*>(this)->get();
1033    }
1034
1035    friend Derived;
1036    BlockValidationStateApi() = default;
1037
1038public:
1039    ValidationMode GetValidationMode() const
1040    {
1041        return static_cast<ValidationMode>(btck_block_validation_state_get_validation_mode(impl()));
1042    }
1043
1044    BlockValidationResult GetBlockValidationResult() const
1045    {
1046        return static_cast<BlockValidationResult>(btck_block_validation_state_get_block_validation_result(impl()));
1047    }
1048};
1049
1050class BlockValidationStateView : public View<btck_BlockValidationState>, public BlockValidationStateApi<BlockValidationStateView>
1051{
1052public:
1053    explicit BlockValidationStateView(const btck_BlockValidationState* ptr) : View{ptr} {}
1054};
1055
1056class BlockValidationState : public Handle<btck_BlockValidationState, btck_block_validation_state_copy, btck_block_validation_state_destroy>, public BlockValidationStateApi<BlockValidationState>
1057{
1058public:
1059    explicit BlockValidationState() : Handle{btck_block_validation_state_create()} {}
1060
1061    explicit BlockValidationState(const BlockValidationStateView& view) : Handle{view} {}
1062
1063    explicit BlockValidationState(btck_BlockValidationState* state) : Handle{state} {}
1064};
1065
1066inline bool Block::Check(const ConsensusParamsView& consensus_params,
1067    BlockCheckFlags flags,
1068    BlockValidationState& state) const
1069{
1070    return btck_block_check(get(), consensus_params.get(), static_cast<btck_BlockCheckFlags>(flags), state.get()) == 1;
1071}
1072
1073class TxValidationState : public UniqueHandle<btck_TxValidationState, btck_tx_validation_state_destroy>
1074{
1075public:
1076    using UniqueHandle::UniqueHandle; // inherit ctor
1077    explicit TxValidationState() : UniqueHandle{btck_tx_validation_state_create()} {}
1078
1079    ValidationMode GetValidationMode() const
1080    {
1081        return static_cast<ValidationMode>(btck_tx_validation_state_get_validation_mode(get()));
1082    }
1083
1084    TxValidationResult GetTxValidationResult() const
1085    {
1086        return static_cast<TxValidationResult>(btck_tx_validation_state_get_tx_validation_result(get()));
1087    }
1088};
1089
1090inline bool CheckTransaction(const Transaction& tx, TxValidationState& state)
1091{
1092    return btck_transaction_check(tx.get(), state.get()) == 1;
1093}
1094
1095class ValidationInterface
1096{
1097public:
1098    virtual ~ValidationInterface() = default;
1099
1100    virtual void BlockChecked(Block block, BlockValidationStateView state) {}
1101
1102    virtual void PowValidBlock(BlockTreeEntry entry, Block block) {}
1103
1104    virtual void BlockConnected(Block block, BlockTreeEntry entry) {}
1105
1106    virtual void BlockDisconnected(Block block, BlockTreeEntry entry) {}
1107};
1108
1109class ChainParams : public Handle<btck_ChainParameters, btck_chain_parameters_copy, btck_chain_parameters_destroy>
1110{
1111public:
1112    explicit ChainParams(ChainType chain_type)
1113        : Handle{btck_chain_parameters_create(static_cast<btck_ChainType>(chain_type))} {}
1114
1115    explicit ChainParams(std::span<const std::byte> signet_challenge)
1116        : Handle{btck_chain_parameters_create_signet(signet_challenge.data(), signet_challenge.size())} {}
1117
1118    ConsensusParamsView GetConsensusParams() const
1119    {
1120        return ConsensusParamsView{btck_chain_parameters_get_consensus_params(get())};
1121    }
1122};
1123
1124class ContextOptions : public UniqueHandle<btck_ContextOptions, btck_context_options_destroy>
1125{
1126public:
1127    ContextOptions() : UniqueHandle{btck_context_options_create()} {}
1128
1129    void SetChainParams(ChainParams& chain_params)
1130    {
1131        btck_context_options_set_chainparams(get(), chain_params.get());
1132    }
1133
1134    template <typename T>
1135    void SetNotifications(std::shared_ptr<T> notifications)
1136    {
1137        static_assert(std::is_base_of_v<KernelNotifications, T>);
1138        auto heap_notifications = std::make_unique<std::shared_ptr<T>>(std::move(notifications));
1139        using user_type = std::shared_ptr<T>*;
1140        btck_context_options_set_notifications(
1141            get(),
1142            btck_NotificationInterfaceCallbacks{
1143                .user_data = heap_notifications.release(),
1144                .user_data_destroy = +[](void* user_data) { delete static_cast<user_type>(user_data); },
1145                .block_tip = +[](void* user_data, btck_SynchronizationState state, const btck_BlockTreeEntry* entry, double verification_progress) { (*static_cast<user_type>(user_data))->BlockTipHandler(static_cast<SynchronizationState>(state), BlockTreeEntry{entry}, verification_progress); },
1146                .header_tip = +[](void* user_data, btck_SynchronizationState state, int64_t height, int64_t timestamp, int presync) { (*static_cast<user_type>(user_data))->HeaderTipHandler(static_cast<SynchronizationState>(state), height, timestamp, presync == 1); },
1147                .progress = +[](void* user_data, const char* title, size_t title_len, int progress_percent, int resume_possible) { (*static_cast<user_type>(user_data))->ProgressHandler({title, title_len}, progress_percent, resume_possible == 1); },
1148                .warning_set = +[](void* user_data, btck_Warning warning, const char* message, size_t message_len) { (*static_cast<user_type>(user_data))->WarningSetHandler(static_cast<Warning>(warning), {message, message_len}); },
1149                .warning_unset = +[](void* user_data, btck_Warning warning) { (*static_cast<user_type>(user_data))->WarningUnsetHandler(static_cast<Warning>(warning)); },
1150                .flush_error = +[](void* user_data, const char* error, size_t error_len) { (*static_cast<user_type>(user_data))->FlushErrorHandler({error, error_len}); },
1151                .fatal_error = +[](void* user_data, const char* error, size_t error_len) { (*static_cast<user_type>(user_data))->FatalErrorHandler({error, error_len}); },
1152            });
1153    }
1154
1155    template <typename T>
1156    void SetValidationInterface(std::shared_ptr<T> validation_interface)
1157    {
1158        static_assert(std::is_base_of_v<ValidationInterface, T>);
1159        auto heap_vi = std::make_unique<std::shared_ptr<T>>(std::move(validation_interface));
1160        using user_type = std::shared_ptr<T>*;
1161        btck_context_options_set_validation_interface(
1162            get(),
1163            btck_ValidationInterfaceCallbacks{
1164                .user_data = heap_vi.release(),
1165                .user_data_destroy = +[](void* user_data) { delete static_cast<user_type>(user_data); },
1166                .block_checked = +[](void* user_data, btck_Block* block, const btck_BlockValidationState* state) { (*static_cast<user_type>(user_data))->BlockChecked(Block{block}, BlockValidationStateView{state}); },
1167                .pow_valid_block = +[](void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry) { (*static_cast<user_type>(user_data))->PowValidBlock(BlockTreeEntry{entry}, Block{block}); },
1168                .block_connected = +[](void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry) { (*static_cast<user_type>(user_data))->BlockConnected(Block{block}, BlockTreeEntry{entry}); },
1169                .block_disconnected = +[](void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry) { (*static_cast<user_type>(user_data))->BlockDisconnected(Block{block}, BlockTreeEntry{entry}); },
1170            });
1171    }
1172};
1173
1174class Context : public Handle<btck_Context, btck_context_copy, btck_context_destroy>
1175{
1176public:
1177    Context(ContextOptions& opts)
1178        : Handle{btck_context_create(opts.get())} {}
1179
1180    Context()
1181        : Handle{btck_context_create(ContextOptions{}.get())} {}
1182
1183    bool interrupt()
1184    {
1185        return btck_context_interrupt(get()) == 0;
1186    }
1187};
1188
1189class ChainstateManagerOptions : public UniqueHandle<btck_ChainstateManagerOptions, btck_chainstate_manager_options_destroy>
1190{
1191public:
1192    ChainstateManagerOptions(const Context& context, std::string_view data_dir, std::string_view blocks_dir)
1193        : UniqueHandle{btck_chainstate_manager_options_create(
1194              context.get(), data_dir.data(), data_dir.length(), blocks_dir.data(), blocks_dir.length())}
1195    {
1196    }
1197
1198    void SetWorkerThreads(int worker_threads)
1199    {
1200        btck_chainstate_manager_options_set_worker_threads_num(get(), worker_threads);
1201    }
1202
1203    bool SetDatabaseCacheBytes(uint64_t database_cache_bytes)
1204    {
1205        return btck_chainstate_manager_options_set_database_cache_bytes(get(), database_cache_bytes) == 0;
1206    }
1207
1208    bool SetWipeDbs(bool wipe_block_tree, bool wipe_chainstate)
1209    {
1210        return btck_chainstate_manager_options_set_wipe_dbs(get(), wipe_block_tree, wipe_chainstate) == 0;
1211    }
1212
1213    void UpdateBlockTreeDbInMemory(bool block_tree_db_in_memory)
1214    {
1215        btck_chainstate_manager_options_update_block_tree_db_in_memory(get(), block_tree_db_in_memory);
1216    }
1217
1218    void UpdateChainstateDbInMemory(bool chainstate_db_in_memory)
1219    {
1220        btck_chainstate_manager_options_update_chainstate_db_in_memory(get(), chainstate_db_in_memory);
1221    }
1222};
1223
1224class ChainView : public View<btck_Chain>
1225{
1226public:
1227    explicit ChainView(const btck_Chain* ptr) : View{ptr} {}
1228
1229    int32_t Height() const
1230    {
1231        return btck_chain_get_height(get());
1232    }
1233
1234    int32_t CountEntries() const
1235    {
1236        return btck_chain_get_height(get()) + 1;
1237    }
1238
1239    BlockTreeEntry GetByHeight(int32_t height) const
1240    {
1241        auto index{btck_chain_get_by_height(get(), height)};
1242        if (!index) throw std::runtime_error("No entry in the chain at the provided height");
1243        return index;
1244    }
1245
1246    bool Contains(BlockTreeEntry& entry) const
1247    {
1248        return btck_chain_contains(get(), entry.get());
1249    }
1250