C++ Wrapper — Classes¶

class ScriptPubkey : public Handle<btck_ScriptPubkey,
                                   btck_script_pubkey_copy,
                                   btck_script_pubkey_destroy>,
                     public ScriptPubkeyApi<ScriptPubkey>;

class ScriptPubkeyView : public View<btck_ScriptPubkey>,
                         public ScriptPubkeyApi<ScriptPubkeyView>;

// Owned — from raw bytes
btck::ScriptPubkey spk{std::span<const std::byte>{script_bytes}};

// View — from btck_TransactionOutput (non-owning)
btck::ScriptPubkeyView spk_view = output.GetScriptPubkey();

class TransactionOutput : public Handle<btck_TransactionOutput,
                                        btck_transaction_output_copy,
                                        btck_transaction_output_destroy>,
                          public TransactionOutputApi<TransactionOutput>;

btck::TransactionOutput out{script_pubkey, amount_satoshis};

class Transaction : public Handle<btck_Transaction,
                                   btck_transaction_copy,
                                   btck_transaction_destroy>,
                    public TransactionApi<Transaction>;

btck::Transaction tx{std::span<const std::byte>{raw_tx}};

btck::Transaction tx{raw_tx_span};
for (auto output : tx.Outputs()) {
    std::cout << output.Amount() << " sat\n";
}

class Block : public Handle<btck_Block, btck_block_copy, btck_block_destroy>;

// From raw bytes
btck::Block blk{std::span<const std::byte>{raw_block}};

// From disk (via ChainMan)
auto blk = chain_man.ReadBlock(entry);  // returns std::optional<Block>

class BlockHeader : public Handle<btck_BlockHeader,
                                   btck_block_header_copy,
                                   btck_block_header_destroy>;

btck::BlockHeader hdr{std::span<const std::byte>{raw_header_80_bytes}};
// or from block tree entry:
btck::BlockHeader hdr = entry.GetHeader();

std::array<std::byte, 32> hash_bytes = /* ... */;
btck::BlockHash bh{hash_bytes};

class BlockValidationState : public Handle<btck_BlockValidationState,
                                            btck_block_validation_state_copy,
                                            btck_block_validation_state_destroy>,
                             public BlockValidationStateApi<BlockValidationState>;

btck::BlockValidationState state{};  // default constructor

class BlockTreeEntry : public View<btck_BlockTreeEntry>;

class ChainView : public View<btck_Chain>;

for (auto entry : chain.Entries()) {
    std::cout << entry.GetHeight() << " : "
              << hex(entry.GetHash().ToBytes()) << "\n";
}

class ChainMan : UniqueHandle<btck_ChainstateManager, btck_chainstate_manager_destroy>;

btck::ChainParams params{btck::ChainType::MAINNET};
btck::ContextOptions opts{};
opts.SetChainParams(params);
opts.SetNotifications(std::make_shared<MyNotifications>());

btck::Context ctx{opts};
btck::ChainstateManagerOptions chainman_opts{ctx, data_dir, blocks_dir};
btck::ChainMan chain_man{ctx, chainman_opts};

class ChainParams : public Handle<btck_ChainParameters,
                                   btck_chain_parameters_copy,
                                   btck_chain_parameters_destroy>;

btck::ChainParams params{btck::ChainType::MAINNET};

class ContextOptions : public UniqueHandle<btck_ContextOptions, btck_context_options_destroy>;

btck::ContextOptions opts{};

class Context : public Handle<btck_Context, btck_context_copy, btck_context_destroy>;

btck::Context ctx{opts};       // with options
btck::Context ctx{};           // default (mainnet, no callbacks)

class ChainstateManagerOptions : public UniqueHandle<btck_ChainstateManagerOptions,
                                                      btck_chainstate_manager_options_destroy>;

btck::ChainstateManagerOptions opts{ctx, "/path/to/data", "/path/to/blocks"};

class KernelNotifications {
public:
    virtual ~KernelNotifications() = default;
    virtual void BlockTipHandler(SynchronizationState, BlockTreeEntry, double progress) {}
    virtual void HeaderTipHandler(SynchronizationState, int64_t height,
                                   int64_t timestamp, bool presync) {}
    virtual void ProgressHandler(std::string_view title, int percent, bool resumable) {}
    virtual void WarningSetHandler(Warning, std::string_view message) {}
    virtual void WarningUnsetHandler(Warning) {}
    virtual void FlushErrorHandler(std::string_view error) {}
    virtual void FatalErrorHandler(std::string_view error) {}
};

class MyNotifications : public btck::KernelNotifications {
public:
    void BlockTipHandler(btck::SynchronizationState state,
                         btck::BlockTreeEntry entry,
                         double progress) override {
        std::cout << "New tip height: " << entry.GetHeight()
                  << " (" << (progress * 100) << "%)\n";
    }
    void FatalErrorHandler(std::string_view error) override {
        std::cerr << "FATAL: " << error << "\n";
        std::exit(1);
    }
};

opts.SetNotifications(std::make_shared<MyNotifications>());

class ValidationInterface {
public:
    virtual ~ValidationInterface() = default;
    virtual void BlockChecked(Block block, BlockValidationStateView state) {}
    virtual void PowValidBlock(BlockTreeEntry entry, Block block) {}
    virtual void BlockConnected(Block block, BlockTreeEntry entry) {}
    virtual void BlockDisconnected(Block block, BlockTreeEntry entry) {}
};

template <Log T>
class Logger : UniqueHandle<btck_LoggingConnection, btck_logging_connection_destroy>;

struct StdoutLog {
    void LogMessage(std::string_view msg) {
        std::cout << msg;
    }
};

btck::Logger<StdoutLog> logger{std::make_unique<StdoutLog>()};

btck::logging_disable();
btck::logging_set_options(options);
btck::logging_set_level_category(LogCategory::VALIDATION, LogLevel::DEBUG_LEVEL);
btck::logging_enable_category(LogCategory::ALL);
btck::logging_disable_category(LogCategory::LEVELDB);

class BlockSpentOutputs : public Handle<btck_BlockSpentOutputs,
                                         btck_block_spent_outputs_copy,
                                         btck_block_spent_outputs_destroy>;