251        return false;
252    }
253    bool unban(const CSubNet& ip) override
254    {
255        if (m_context->banman) {
256            m_context->banman->Unban(ip);
257            return true;
258        }
259        return false;
260    }
261    bool disconnectByAddress(const CNetAddr& net_addr) override
262    {
263        if (m_context->connman) {
264            return m_context->connman->DisconnectNode(net_addr);
265        }
266        return false;
267    }
268    bool disconnectById(NodeId id) override
269    {
270        if (m_context->connman) {
271            return m_context->connman->DisconnectNode(id);
272        }
273        return false;
274    }
275    std::vector<std::unique_ptr<interfaces::ExternalSigner>> listExternalSigners() override
276    {
277#ifdef ENABLE_EXTERNAL_SIGNER
278        std::vector<ExternalSigner> signers = {};
279        const std::string command = args().GetArg("-signer", "");
280        if (command == "") return {};
281        ExternalSigner::Enumerate(command, signers, Params().GetChainTypeString());
282        std::vector<std::unique_ptr<interfaces::ExternalSigner>> result;
283        result.reserve(signers.size());
284        for (auto& signer : signers) {
285            result.emplace_back(std::make_unique<ExternalSignerImpl>(std::move(signer)));
286        }
287        return result;
288#else
289        // This result is indistinguishable from a successful call that returns
290        // no signers. For the current GUI this doesn't matter, because the wallet
291        // creation dialog disables the external signer checkbox in both
292        // cases. The return type could be changed to std::optional<std::vector>
293        // (or something that also includes error messages) if this distinction
294        // becomes important.
295        return {};
296#endif // ENABLE_EXTERNAL_SIGNER
297    }
298    int64_t getTotalBytesRecv() override { return m_context->connman ? m_context->connman->GetTotalBytesRecv() : 0; }
299    int64_t getTotalBytesSent() override { return m_context->connman ? m_context->connman->GetTotalBytesSent() : 0; }
300    size_t getMempoolSize() override { return m_context->mempool ? m_context->mempool->size() : 0; }
301    size_t getMempoolDynamicUsage() override { return m_context->mempool ? m_context->mempool->DynamicMemoryUsage() : 0; }
302    size_t getMempoolMaxUsage() override { return m_context->mempool ? m_context->mempool->m_opts.max_size_bytes : 0; }
303    bool getHeaderTip(int& height, int64_t& block_time) override
304    {
305        LOCK(::cs_main);
306        auto best_header = chainman().m_best_header;
307        if (best_header) {
308            height = best_header->nHeight;
309            block_time = best_header->GetBlockTime();
310            return true;
311        }
312        return false;
313    }
314    std::map<CNetAddr, LocalServiceInfo> getNetLocalAddresses() override
315    {
316        if (m_context->connman)
317            return m_context->connman->getNetLocalAddresses();
318        else
319            return {};
320    }
321    int getNumBlocks() override
322    {
323        LOCK(::cs_main);
324        return chainman().ActiveChain().Height();
325    }
326    uint256 getBestBlockHash() override
327    {
328        const CBlockIndex* tip = WITH_LOCK(::cs_main, return chainman().ActiveChain().Tip());
329        return tip ? tip->GetBlockHash() : chainman().GetParams().GenesisBlock().GetHash();
330    }
331    int64_t getLastBlockTime() override
332    {
333        LOCK(::cs_main);
334        if (chainman().ActiveChain().Tip()) {
335            return chainman().ActiveChain().Tip()->GetBlockTime();
336        }
337        return chainman().GetParams().GenesisBlock().GetBlockTime(); // Genesis block's time of current network
338    }
339    double getVerificationProgress() override
340    {
341        LOCK(chainman().GetMutex());
342        return chainman().GuessVerificationProgress(chainman().ActiveTip());
343    }
344    bool isInitialBlockDownload() override
345    {
346        return chainman().IsInitialBlockDownload();
347    }
348    bool isLoadingBlocks() override { return chainman().m_blockman.LoadingBlocks(); }
349    void setNetworkActive(bool active) override
350    {
351        if (m_context->connman) {
352            m_context->connman->SetNetworkActive(active);
353        }
354    }
355    bool getNetworkActive() override { return m_context->connman && m_context->connman->GetNetworkActive(); }
356    CFeeRate getDustRelayFee() override
357    {
358        if (!m_context->mempool) return CFeeRate{DUST_RELAY_TX_FEE};
359        return m_context->mempool->m_opts.dust_relay_feerate;
360    }
361    UniValue executeRpc(const std::string& command, const UniValue& params, const std::string& uri) override
362    {
363        JSONRPCRequest req;
364        req.context = m_context;
365        req.params = params;
366        req.strMethod = command;
367        req.URI = uri;
368        return ::tableRPC.execute(req);
369    }
370    std::vector<std::string> listRpcCommands() override { return ::tableRPC.listCommands(); }
371    std::optional<Coin> getUnspentOutput(const COutPoint& output) override
372    {
373        LOCK(::cs_main);
374        return chainman().ActiveChainstate().CoinsTip().GetCoin(output);
375    }
376    TransactionError broadcastTransaction(CTransactionRef tx, CAmount max_tx_fee, std::string& err_string) override
377    {
378        return BroadcastTransaction(*m_context,
379                                    std::move(tx),
380                                    err_string,
381                                    max_tx_fee,
382                                    TxBroadcast::MEMPOOL_AND_BROADCAST_TO_ALL,
383                                    /*wait_callback=*/false);
384    }
385    WalletLoader& walletLoader() override
386    {
387        return *Assert(m_context->wallet_loader);
388    }
389    std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) override
390    {
391        return MakeSignalHandler(::uiInterface.InitMessage.connect(fn));
392    }
393    std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn) override
394    {
395        return MakeSignalHandler(::uiInterface.ThreadSafeMessageBox.connect(fn));
396    }
397    std::unique_ptr<Handler> handleQuestion(QuestionFn fn) override
398    {
399        return MakeSignalHandler(::uiInterface.ThreadSafeQuestion.connect(fn));
400    }
401    std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn) override
402    {
403        return MakeSignalHandler(::uiInterface.ShowProgress.connect(fn));
404    }
405    std::unique_ptr<Handler> handleInitWallet(InitWalletFn fn) override
406    {
407        return MakeSignalHandler(::uiInterface.InitWallet.connect(fn));
408    }
409    std::unique_ptr<Handler> handleNotifyNumConnectionsChanged(NotifyNumConnectionsChangedFn fn) override
410    {
411        return MakeSignalHandler(::uiInterface.NotifyNumConnectionsChanged.connect(fn));
412    }
413    std::unique_ptr<Handler> handleNotifyNetworkActiveChanged(NotifyNetworkActiveChangedFn fn) override
414    {
415        return MakeSignalHandler(::uiInterface.NotifyNetworkActiveChanged.connect(fn));
416    }
417    std::unique_ptr<Handler> handleNotifyAlertChanged(NotifyAlertChangedFn fn) override
418    {
419        return MakeSignalHandler(::uiInterface.NotifyAlertChanged.connect(fn));
420    }
421    std::unique_ptr<Handler> handleBannedListChanged(BannedListChangedFn fn) override
422    {
423        return MakeSignalHandler(::uiInterface.BannedListChanged.connect(fn));
424    }
425    std::unique_ptr<Handler> handleNotifyBlockTip(NotifyBlockTipFn fn) override
426    {
427        return MakeSignalHandler(::uiInterface.NotifyBlockTip.connect([fn](SynchronizationState sync_state, const CBlockIndex& block, double verification_progress) {
428            fn(sync_state, BlockTip{block.nHeight, block.GetBlockTime(), block.GetBlockHash()}, verification_progress);
429        }));
430    }
431    std::unique_ptr<Handler> handleNotifyHeaderTip(NotifyHeaderTipFn fn) override
432    {
433        return MakeSignalHandler(
434            ::uiInterface.NotifyHeaderTip.connect([fn](SynchronizationState sync_state, int64_t height, int64_t timestamp, bool presync) {
435                fn(sync_state, BlockTip{(int)height, timestamp, uint256{}}, presync);
436            }));
437    }
438    NodeContext* context() override { return m_context; }
439    void setContext(NodeContext* context) override
440    {
441        m_context = context;
442    }
443    ArgsManager& args() { return *Assert(Assert(m_context)->args); }
444    ChainstateManager& chainman() { return *Assert(m_context->chainman); }
445    NodeContext* m_context{nullptr};
446};
447
448// NOLINTNEXTLINE(misc-no-recursion)
449bool FillBlock(const CBlockIndex* index, const FoundBlock& block, UniqueLock<RecursiveMutex>& lock, const CChain& active, const BlockManager& blockman) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
450{
451    if (!index) return false;
452    if (block.m_hash) *block.m_hash = index->GetBlockHash();
453    if (block.m_height) *block.m_height = index->nHeight;
454    if (block.m_time) *block.m_time = index->GetBlockTime();
455    if (block.m_max_time) *block.m_max_time = index->GetBlockTimeMax();
456    if (block.m_mtp_time) *block.m_mtp_time = index->GetMedianTimePast();
457    if (block.m_in_active_chain) *block.m_in_active_chain = active[index->nHeight] == index;
458    if (block.m_locator) { *block.m_locator = GetLocator(index); }
459    if (block.m_next_block) FillBlock(active[index->nHeight] == index ? active[index->nHeight + 1] : nullptr, *block.m_next_block, lock, active, blockman);
460    if (block.m_data) {
461        REVERSE_LOCK(lock, cs_main);
462        if (!blockman.ReadBlock(*block.m_data, *index)) block.m_data->SetNull();
463    }
464    block.found = true;
465    return true;
466}
467
468class NotificationsProxy : public CValidationInterface
469{
470public:
471    explicit NotificationsProxy(std::shared_ptr<Chain::Notifications> notifications)
472        : m_notifications(std::move(notifications)) {}
473    virtual ~NotificationsProxy() = default;
474    void TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t mempool_sequence) override
475    {
476        m_notifications->transactionAddedToMempool(tx.info.m_tx);
477    }
478    void TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason, uint64_t mempool_sequence) override
479    {
480        m_notifications->transactionRemovedFromMempool(tx, reason);
481    }
482    void BlockConnected(const ChainstateRole& role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* index) override
483    {
484        m_notifications->blockConnected(role, kernel::MakeBlockInfo(index, block.get()));
485    }
486    void BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* index) override
487    {
488        m_notifications->blockDisconnected(kernel::MakeBlockInfo(index, block.get()));
489    }
490    void UpdatedBlockTip(const CBlockIndex* index, const CBlockIndex* fork_index, bool is_ibd) override
491    {
492        m_notifications->updatedBlockTip();
493    }
494    void ChainStateFlushed(const ChainstateRole& role, const CBlockLocator& locator) override
495    {
496        m_notifications->chainStateFlushed(role, locator);
497    }
498    std::shared_ptr<Chain::Notifications> m_notifications;
499};
500