251            LogError("Logger start failed.");
252            LogInstance().DeleteCallback(connection);
253            if (user_data && user_data_destroy_callback) {
254                user_data_destroy_callback(user_data);
255            }
256            throw std::runtime_error("Failed to start logging");
257        }
258
259        m_connection = std::make_unique<std::list<std::function<void(const std::string&)>>::iterator>(connection);
260        m_user_data = user_data;
261        m_deleter = user_data_destroy_callback;
262
263        LogDebug(BCLog::KERNEL, "Logger connected.");
264    }
265
266    ~LoggingConnection()
267    {
268        LOCK(cs_main);
269        LogDebug(BCLog::KERNEL, "Logger disconnecting.");
270
271        // Switch back to buffering by calling DisconnectTestLogger if the
272        // connection that we are about to remove is the last one.
273        if (LogInstance().NumConnections() == 1) {
274            LogInstance().DisconnectTestLogger();
275        } else {
276            LogInstance().DeleteCallback(*m_connection);
277        }
278
279        m_connection.reset();
280        if (m_user_data && m_deleter) {
281            m_deleter(m_user_data);
282        }
283    }
284};
285
286class KernelNotifications final : public kernel::Notifications
287{
288private:
289    btck_NotificationInterfaceCallbacks m_cbs;
290
291public:
292    KernelNotifications(btck_NotificationInterfaceCallbacks cbs)
293        : m_cbs{cbs}
294    {
295    }
296
297    ~KernelNotifications()
298    {
299        if (m_cbs.user_data && m_cbs.user_data_destroy) {
300            m_cbs.user_data_destroy(m_cbs.user_data);
301        }
302        m_cbs.user_data_destroy = nullptr;
303        m_cbs.user_data = nullptr;
304    }
305
306    kernel::InterruptResult blockTip(SynchronizationState state, const CBlockIndex& index, double verification_progress) override
307    {
308        if (m_cbs.block_tip) m_cbs.block_tip(m_cbs.user_data, cast_state(state), btck_BlockTreeEntry::ref(&index), verification_progress);
309        return {};
310    }
311    void headerTip(SynchronizationState state, int64_t height, int64_t timestamp, bool presync) override
312    {
313        if (m_cbs.header_tip) m_cbs.header_tip(m_cbs.user_data, cast_state(state), height, timestamp, presync ? 1 : 0);
314    }
315    void progress(const bilingual_str& title, int progress_percent, bool resume_possible) override
316    {
317        if (m_cbs.progress) m_cbs.progress(m_cbs.user_data, title.original.c_str(), title.original.length(), progress_percent, resume_possible ? 1 : 0);
318    }
319    void warningSet(kernel::Warning id, const bilingual_str& message) override
320    {
321        if (m_cbs.warning_set) m_cbs.warning_set(m_cbs.user_data, cast_btck_warning(id), message.original.c_str(), message.original.length());
322    }
323    void warningUnset(kernel::Warning id) override
324    {
325        if (m_cbs.warning_unset) m_cbs.warning_unset(m_cbs.user_data, cast_btck_warning(id));
326    }
327    void flushError(const bilingual_str& message) override
328    {
329        if (m_cbs.flush_error) m_cbs.flush_error(m_cbs.user_data, message.original.c_str(), message.original.length());
330    }
331    void fatalError(const bilingual_str& message) override
332    {
333        if (m_cbs.fatal_error) m_cbs.fatal_error(m_cbs.user_data, message.original.c_str(), message.original.length());
334    }
335};
336
337class KernelValidationInterface final : public CValidationInterface
338{
339public:
340    btck_ValidationInterfaceCallbacks m_cbs;
341
342    explicit KernelValidationInterface(const btck_ValidationInterfaceCallbacks vi_cbs) : m_cbs{vi_cbs} {}
343
344    ~KernelValidationInterface()
345    {
346        if (m_cbs.user_data && m_cbs.user_data_destroy) {
347            m_cbs.user_data_destroy(m_cbs.user_data);
348        }
349        m_cbs.user_data = nullptr;
350        m_cbs.user_data_destroy = nullptr;
351    }
352
353protected:
354    void BlockChecked(const std::shared_ptr<const CBlock>& block, const BlockValidationState& stateIn) override
355    {
356        if (m_cbs.block_checked) {
357            m_cbs.block_checked(m_cbs.user_data,
358                                btck_Block::copy(btck_Block::ref(&block)),
359                                btck_BlockValidationState::ref(&stateIn));
360        }
361    }
362
363    void NewPoWValidBlock(const CBlockIndex* pindex, const std::shared_ptr<const CBlock>& block) override
364    {
365        if (m_cbs.pow_valid_block) {
366            m_cbs.pow_valid_block(m_cbs.user_data,
367                                  btck_Block::copy(btck_Block::ref(&block)),
368                                  btck_BlockTreeEntry::ref(pindex));
369        }
370    }
371
372    void BlockConnected(const ChainstateRole& role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override
373    {
374        if (m_cbs.block_connected) {
375            m_cbs.block_connected(m_cbs.user_data,
376                                  btck_Block::copy(btck_Block::ref(&block)),
377                                  btck_BlockTreeEntry::ref(pindex));
378        }
379    }
380
381    void BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override
382    {
383        if (m_cbs.block_disconnected) {
384            m_cbs.block_disconnected(m_cbs.user_data,
385                                     btck_Block::copy(btck_Block::ref(&block)),
386                                     btck_BlockTreeEntry::ref(pindex));
387        }
388    }
389};
390
391struct ContextOptions {
392    mutable Mutex m_mutex;
393    std::unique_ptr<const CChainParams> m_chainparams GUARDED_BY(m_mutex);
394    std::shared_ptr<KernelNotifications> m_notifications GUARDED_BY(m_mutex);
395    std::shared_ptr<KernelValidationInterface> m_validation_interface GUARDED_BY(m_mutex);
396};
397
398class Context
399{
400public:
401    std::unique_ptr<kernel::Context> m_context;
402
403    std::shared_ptr<KernelNotifications> m_notifications;
404
405    std::unique_ptr<util::SignalInterrupt> m_interrupt;
406
407    std::unique_ptr<ValidationSignals> m_signals;
408
409    std::unique_ptr<const CChainParams> m_chainparams;
410
411    std::shared_ptr<KernelValidationInterface> m_validation_interface;
412
413    Context(const ContextOptions* options, bool& sane)
414        : m_context{std::make_unique<kernel::Context>()},
415          m_interrupt{std::make_unique<util::SignalInterrupt>()}
416    {
417        if (options) {
418            LOCK(options->m_mutex);
419            if (options->m_chainparams) {
420                m_chainparams = std::make_unique<const CChainParams>(*options->m_chainparams);
421            }
422            if (options->m_notifications) {
423                m_notifications = options->m_notifications;
424            }
425            if (options->m_validation_interface) {
426                m_signals = std::make_unique<ValidationSignals>(std::make_unique<ImmediateTaskRunner>());
427                m_validation_interface = options->m_validation_interface;
428                m_signals->RegisterSharedValidationInterface(m_validation_interface);
429            }
430        }
431
432        if (!m_chainparams) {
433            m_chainparams = CChainParams::Main();
434        }
435        if (!m_notifications) {
436            m_notifications = std::make_shared<KernelNotifications>(btck_NotificationInterfaceCallbacks{
437                nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr});
438        }
439
440        if (!kernel::SanityChecks(*m_context)) {
441            sane = false;
442        }
443    }
444
445    ~Context()
446    {
447        if (m_signals) {
448            m_signals->UnregisterSharedValidationInterface(m_validation_interface);
449        }
450    }
451};
452
453//! Helper struct to wrap the ChainstateManager-related Options
454struct ChainstateManagerOptions {
455    mutable Mutex m_mutex;
456    ChainstateManager::Options m_chainman_options GUARDED_BY(m_mutex);
457    node::BlockManager::Options m_blockman_options GUARDED_BY(m_mutex);
458    std::shared_ptr<const Context> m_context;
459    node::ChainstateLoadOptions m_chainstate_load_options GUARDED_BY(m_mutex);
460    uint64_t m_db_cache_bytes GUARDED_BY(m_mutex){DEFAULT_KERNEL_CACHE};
461
462    ChainstateManagerOptions(const std::shared_ptr<const Context>& context, const fs::path& data_dir, const fs::path& blocks_dir)
463        : m_chainman_options{ChainstateManager::Options{
464              .chainparams = *context->m_chainparams,
465              .datadir = data_dir,
466              .notifications = *context->m_notifications,
467              .signals = context->m_signals.get()}},
468          m_blockman_options{node::BlockManager::Options{
469              .chainparams = *context->m_chainparams,
470              .blocks_dir = blocks_dir,
471              .notifications = *context->m_notifications,
472              .block_tree_db_params = DBParams{
473                  .path = data_dir / "blocks" / "index",
474                  .cache_bytes = kernel::CacheSizes{DEFAULT_KERNEL_CACHE}.block_tree_db,
475              }}},
476          m_context{context}, m_chainstate_load_options{node::ChainstateLoadOptions{}}
477    {
478    }
479};
480
481struct ChainMan {
482    std::unique_ptr<ChainstateManager> m_chainman;
483    std::shared_ptr<const Context> m_context;
484
485    ChainMan(std::unique_ptr<ChainstateManager> chainman, std::shared_ptr<const Context> context)
486        : m_chainman(std::move(chainman)), m_context(std::move(context)) {}
487};
488
489} // namespace
490
491struct btck_Transaction : Handle<btck_Transaction, std::shared_ptr<const CTransaction>> {};
492struct btck_TransactionOutput : Handle<btck_TransactionOutput, CTxOut> {};
493struct btck_ScriptPubkey : Handle<btck_ScriptPubkey, CScript> {};
494struct btck_LoggingConnection : Handle<btck_LoggingConnection, LoggingConnection> {};
495struct btck_ContextOptions : Handle<btck_ContextOptions, ContextOptions> {};
496struct btck_Context : Handle<btck_Context, std::shared_ptr<const Context>> {};
497struct btck_ChainParameters : Handle<btck_ChainParameters, CChainParams> {};
498struct btck_ChainstateManagerOptions : Handle<btck_ChainstateManagerOptions, ChainstateManagerOptions> {};
499struct btck_ChainstateManager : Handle<btck_ChainstateManager, ChainMan> {};
500struct btck_Chain : Handle<btck_Chain, CChain> {};