501class NotificationsHandlerImpl : public Handler
502{
503public:
504    explicit NotificationsHandlerImpl(ValidationSignals& signals, std::shared_ptr<Chain::Notifications> notifications)
505        : m_signals{signals}, m_proxy{std::make_shared<NotificationsProxy>(std::move(notifications))}
506    {
507        m_signals.RegisterSharedValidationInterface(m_proxy);
508    }
509    ~NotificationsHandlerImpl() override { disconnect(); }
510    void disconnect() override
511    {
512        if (m_proxy) {
513            m_signals.UnregisterSharedValidationInterface(m_proxy);
514            m_proxy.reset();
515        }
516    }
517    ValidationSignals& m_signals;
518    std::shared_ptr<NotificationsProxy> m_proxy;
519};
520
521class RpcHandlerImpl : public Handler
522{
523public:
524    explicit RpcHandlerImpl(const CRPCCommand& command) : m_command(command), m_wrapped_command(&command)
525    {
526        m_command.actor = [this](const JSONRPCRequest& request, UniValue& result, bool last_handler) {
527            if (!m_wrapped_command) return false;
528            try {
529                return m_wrapped_command->actor(request, result, last_handler);
530            } catch (const UniValue& e) {
531                // If this is not the last handler and a wallet not found
532                // exception was thrown, return false so the next handler can
533                // try to handle the request. Otherwise, reraise the exception.
534                if (!last_handler) {
535                    const UniValue& code = e["code"];
536                    if (code.isNum() && code.getInt<int>() == RPC_WALLET_NOT_FOUND) {
537                        return false;
538                    }
539                }
540                throw;
541            }
542        };
543        ::tableRPC.appendCommand(m_command.name, &m_command);
544    }
545
546    void disconnect() final
547    {
548        if (m_wrapped_command) {
549            m_wrapped_command = nullptr;
550            ::tableRPC.removeCommand(m_command.name, &m_command);
551        }
552    }
553
554    ~RpcHandlerImpl() override { disconnect(); }
555
556    CRPCCommand m_command;
557    const CRPCCommand* m_wrapped_command;
558};
559
560class ChainImpl : public Chain
561{
562public:
563    explicit ChainImpl(NodeContext& node) : m_node(node) {}
564    std::optional<int> getHeight() override
565    {
566        const int height{WITH_LOCK(::cs_main, return chainman().ActiveChain().Height())};
567        return height >= 0 ? std::optional{height} : std::nullopt;
568    }
569    uint256 getBlockHash(int height) override
570    {
571        LOCK(::cs_main);
572        return Assert(chainman().ActiveChain()[height])->GetBlockHash();
573    }
574    bool haveBlockOnDisk(int height) override
575    {
576        LOCK(::cs_main);
577        const CBlockIndex* block{chainman().ActiveChain()[height]};
578        return block && ((block->nStatus & BLOCK_HAVE_DATA) != 0) && block->nTx > 0;
579    }
580    std::optional<int> findLocatorFork(const CBlockLocator& locator) override
581    {
582        LOCK(::cs_main);
583        if (const CBlockIndex* fork = chainman().ActiveChainstate().FindForkInGlobalIndex(locator)) {
584            return fork->nHeight;
585        }
586        return std::nullopt;
587    }
588    bool hasBlockFilterIndex(BlockFilterType filter_type) override
589    {
590        return GetBlockFilterIndex(filter_type) != nullptr;
591    }
592    std::optional<bool> blockFilterMatchesAny(BlockFilterType filter_type, const uint256& block_hash, const GCSFilter::ElementSet& filter_set) override
593    {
594        const BlockFilterIndex* block_filter_index{GetBlockFilterIndex(filter_type)};
595        if (!block_filter_index) return std::nullopt;
596
597        BlockFilter filter;
598        const CBlockIndex* index{WITH_LOCK(::cs_main, return chainman().m_blockman.LookupBlockIndex(block_hash))};
599        if (index == nullptr || !block_filter_index->LookupFilter(index, filter)) return std::nullopt;
600        return filter.GetFilter().MatchAny(filter_set);
601    }
602    bool findBlock(const uint256& hash, const FoundBlock& block) override
603    {
604        WAIT_LOCK(cs_main, lock);
605        return FillBlock(chainman().m_blockman.LookupBlockIndex(hash), block, lock, chainman().ActiveChain(), chainman().m_blockman);
606    }
607    bool findFirstBlockWithTimeAndHeight(int64_t min_time, int min_height, const FoundBlock& block) override
608    {
609        WAIT_LOCK(cs_main, lock);
610        const CChain& active = chainman().ActiveChain();
611        return FillBlock(active.FindEarliestAtLeast(min_time, min_height), block, lock, active, chainman().m_blockman);
612    }
613    bool findAncestorByHeight(const uint256& block_hash, int ancestor_height, const FoundBlock& ancestor_out) override
614    {
615        WAIT_LOCK(cs_main, lock);
616        const CChain& active = chainman().ActiveChain();
617        if (const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash)) {
618            if (const CBlockIndex* ancestor = block->GetAncestor(ancestor_height)) {
619                return FillBlock(ancestor, ancestor_out, lock, active, chainman().m_blockman);
620            }
621        }
622        return FillBlock(nullptr, ancestor_out, lock, active, chainman().m_blockman);
623    }
624    bool findAncestorByHash(const uint256& block_hash, const uint256& ancestor_hash, const FoundBlock& ancestor_out) override
625    {
626        WAIT_LOCK(cs_main, lock);
627        const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash);
628        const CBlockIndex* ancestor = chainman().m_blockman.LookupBlockIndex(ancestor_hash);
629        if (block && ancestor && block->GetAncestor(ancestor->nHeight) != ancestor) ancestor = nullptr;
630        return FillBlock(ancestor, ancestor_out, lock, chainman().ActiveChain(), chainman().m_blockman);
631    }
632    bool findCommonAncestor(const uint256& block_hash1, const uint256& block_hash2, const FoundBlock& ancestor_out, const FoundBlock& block1_out, const FoundBlock& block2_out) override
633    {
634        WAIT_LOCK(cs_main, lock);
635        const CChain& active = chainman().ActiveChain();
636        const CBlockIndex* block1 = chainman().m_blockman.LookupBlockIndex(block_hash1);
637        const CBlockIndex* block2 = chainman().m_blockman.LookupBlockIndex(block_hash2);
638        const CBlockIndex* ancestor = block1 && block2 ? LastCommonAncestor(block1, block2) : nullptr;
639        // Using & instead of && below to avoid short circuiting and leaving
640        // output uninitialized. Cast bool to int to avoid -Wbitwise-instead-of-logical
641        // compiler warnings.
642        return int{FillBlock(ancestor, ancestor_out, lock, active, chainman().m_blockman)} &
643               int{FillBlock(block1, block1_out, lock, active, chainman().m_blockman)} &
644               int{FillBlock(block2, block2_out, lock, active, chainman().m_blockman)};
645    }
646    void findCoins(std::map<COutPoint, Coin>& coins) override { return FindCoins(m_node, coins); }
647    double guessVerificationProgress(const uint256& block_hash) override
648    {
649        LOCK(chainman().GetMutex());
650        return chainman().GuessVerificationProgress(chainman().m_blockman.LookupBlockIndex(block_hash));
651    }
652    bool hasBlocks(const uint256& block_hash, int min_height, std::optional<int> max_height) override
653    {
654        // hasBlocks returns true if all ancestors of block_hash in specified
655        // range have block data (are not pruned), false if any ancestors in
656        // specified range are missing data.
657        //
658        // For simplicity and robustness, min_height and max_height are only
659        // used to limit the range, and passing min_height that's too low or
660        // max_height that's too high will not crash or change the result.
661        LOCK(::cs_main);
662        if (const CBlockIndex* block = chainman().m_blockman.LookupBlockIndex(block_hash)) {
663            if (max_height && block->nHeight >= *max_height) block = block->GetAncestor(*max_height);
664            for (; block->nStatus & BLOCK_HAVE_DATA; block = block->pprev) {
665                // Check pprev to not segfault if min_height is too low
666                if (block->nHeight <= min_height || !block->pprev) return true;
667            }
668        }
669        return false;
670    }
671    RBFTransactionState isRBFOptIn(const CTransaction& tx) override
672    {
673        if (!m_node.mempool) return IsRBFOptInEmptyMempool(tx);
674        LOCK(m_node.mempool->cs);
675        return IsRBFOptIn(tx, *m_node.mempool);
676    }
677    bool isInMempool(const Txid& txid) override
678    {
679        if (!m_node.mempool) return false;
680        return m_node.mempool->exists(txid);
681    }
682    bool hasDescendantsInMempool(const Txid& txid) override
683    {
684        if (!m_node.mempool) return false;
685        return m_node.mempool->HasDescendants(txid);
686    }
687    bool broadcastTransaction(const CTransactionRef& tx,
688        const CAmount& max_tx_fee,
689        TxBroadcast broadcast_method,
690        std::string& err_string) override
691    {
692        const TransactionError err = BroadcastTransaction(m_node, tx, err_string, max_tx_fee, broadcast_method, /*wait_callback=*/false);
693        // Chain clients only care about failures to accept the tx to the mempool. Disregard non-mempool related failures.
694        // Note: this will need to be updated if BroadcastTransactions() is updated to return other non-mempool failures
695        // that Chain clients do not need to know about.
696        return TransactionError::OK == err;
697    }
698    void getTransactionAncestry(const Txid& txid, size_t& ancestors, size_t& cluster_count, size_t* ancestorsize, CAmount* ancestorfees) override
699    {
700        ancestors = cluster_count = 0;
701        if (!m_node.mempool) return;
702        m_node.mempool->GetTransactionAncestry(txid, ancestors, cluster_count, ancestorsize, ancestorfees);
703    }
704
705    std::map<COutPoint, CAmount> calculateIndividualBumpFees(const std::vector<COutPoint>& outpoints, const CFeeRate& target_feerate) override
706    {
707        if (!m_node.mempool) {
708            std::map<COutPoint, CAmount> bump_fees;
709            for (const auto& outpoint : outpoints) {
710                bump_fees.emplace(outpoint, 0);
711            }
712            return bump_fees;
713        }
714        return MiniMiner(*m_node.mempool, outpoints).CalculateBumpFees(target_feerate);
715    }
716
717    std::optional<CAmount> calculateCombinedBumpFee(const std::vector<COutPoint>& outpoints, const CFeeRate& target_feerate) override
718    {
719        if (!m_node.mempool) {
720            return 0;
721        }
722        return MiniMiner(*m_node.mempool, outpoints).CalculateTotalBumpFees(target_feerate);
723    }
724    void getPackageLimits(unsigned int& limit_ancestor_count, unsigned int& limit_descendant_count) override
725    {
726        const CTxMemPool::Limits default_limits{};
727
728        const CTxMemPool::Limits& limits{m_node.mempool ? m_node.mempool->m_opts.limits : default_limits};
729
730        limit_ancestor_count = limits.ancestor_count;
731        limit_descendant_count = limits.descendant_count;
732    }
733    util::Result<void> checkChainLimits(const CTransactionRef& tx) override
734    {
735        if (!m_node.mempool) return {};
736        if (!m_node.mempool->CheckPolicyLimits(tx)) {
737            return util::Error{Untranslated("too many unconfirmed transactions in cluster")};
738        }
739        return {};
740    }
741    util::Expected<FeeRateEstimation, FeeRateEstimationError> getFeeRateEstimate(int num_blocks, bool conservative) const override
742    {
743        if (!m_node.fee_estimator_man) return EstimationError(FeeRateEstimatorType::AUTO, /*returned_target=*/0, /*error=*/{});
744        return m_node.fee_estimator_man->GetFeeRateEstimate(num_blocks, conservative);
745    }
746    unsigned int maximumFeeEstimationTargetBlocks() const override
747    {
748        if (!m_node.fee_estimator_man) return 0;
749        return m_node.fee_estimator_man->MaximumTarget();
750    }