Inside Bitcoin

751    CFeeRate mempoolMinFee() override
752    {
753        if (!m_node.mempool) return {};
754        return m_node.mempool->GetMinFee();
755    }
756    CFeeRate relayMinFee() override
757    {
758        if (!m_node.mempool) return CFeeRate{DEFAULT_MIN_RELAY_TX_FEE};
759        return m_node.mempool->m_opts.min_relay_feerate;
760    }
761    CFeeRate relayIncrementalFee() override
762    {
763        if (!m_node.mempool) return CFeeRate{DEFAULT_INCREMENTAL_RELAY_FEE};
764        return m_node.mempool->m_opts.incremental_relay_feerate;
765    }
766    CFeeRate relayDustFee() override
767    {
768        if (!m_node.mempool) return CFeeRate{DUST_RELAY_TX_FEE};
769        return m_node.mempool->m_opts.dust_relay_feerate;
770    }
771    bool havePruned() override
772    {
773        LOCK(::cs_main);
774        return chainman().m_blockman.m_have_pruned;
775    }
776    std::optional<int> getPruneHeight() override
777    {
778        LOCK(chainman().GetMutex());
779        return GetPruneHeight(chainman().m_blockman, chainman().ActiveChain());
780    }
781    bool isReadyToBroadcast() override { return !chainman().m_blockman.LoadingBlocks() && !isInitialBlockDownload(); }
782    bool isInitialBlockDownload() override
783    {
784        return chainman().IsInitialBlockDownload();
785    }
786    bool shutdownRequested() override { return ShutdownRequested(m_node); }
787    void initMessage(const std::string& message) override { ::uiInterface.InitMessage(message); }
788    void initWarning(const bilingual_str& message) override { InitWarning(message); }
789    void initError(const bilingual_str& message) override { InitError(message); }
790    void showProgress(const std::string& title, int progress, bool resume_possible) override
791    {
792        ::uiInterface.ShowProgress(title, progress, resume_possible);
793    }
794    std::unique_ptr<Handler> handleNotifications(std::shared_ptr<Notifications> notifications) override
795    {
796        return std::make_unique<NotificationsHandlerImpl>(validation_signals(), std::move(notifications));
797    }
798    void waitForNotificationsIfTipChanged(const uint256& old_tip) override
799    {
800        if (!old_tip.IsNull() && old_tip == WITH_LOCK(::cs_main, return chainman().ActiveChain().Tip()->GetBlockHash())) return;
801        validation_signals().SyncWithValidationInterfaceQueue();
802    }
803    void waitForNotifications() override
804    {
805        validation_signals().SyncWithValidationInterfaceQueue();
806    }
807    std::unique_ptr<Handler> handleRpc(const CRPCCommand& command) override
808    {
809        return std::make_unique<RpcHandlerImpl>(command);
810    }
811    bool rpcEnableDeprecated(const std::string& method) override { return IsDeprecatedRPCEnabled(method); }
812    common::SettingsValue getSetting(const std::string& name) override
813    {
814        return args().GetSetting(name);
815    }
816    std::vector<common::SettingsValue> getSettingsList(const std::string& name) override
817    {
818        return args().GetSettingsList(name);
819    }
820    common::SettingsValue getRwSetting(const std::string& name) override
821    {
822        common::SettingsValue result;
823        args().LockSettings([&](const common::Settings& settings) {
824            if (const common::SettingsValue* value = common::FindKey(settings.rw_settings, name)) {
825                result = *value;
826            }
827        });
828        return result;
829    }
830    bool updateRwSetting(const std::string& name,
831                         const interfaces::SettingsUpdate& update_settings_func) override
832    {
833        std::optional<interfaces::SettingsAction> action;
834        args().LockSettings([&](common::Settings& settings) {
835            if (auto* value = common::FindKey(settings.rw_settings, name)) {
836                action = update_settings_func(*value);
837                if (value->isNull()) settings.rw_settings.erase(name);
838            } else {
839                UniValue new_value;
840                action = update_settings_func(new_value);
841                if (!new_value.isNull()) settings.rw_settings[name] = std::move(new_value);
842            }
843        });
844        if (!action) return false;
845        // Now dump value to disk if requested
846        return *action != interfaces::SettingsAction::WRITE || (args().GetSettingsPath() && args().WriteSettingsFile());
847    }
848    bool overwriteRwSetting(const std::string& name, common::SettingsValue value, interfaces::SettingsAction action) override
849    {
850        return updateRwSetting(name, [&](common::SettingsValue& settings) {
851            settings = std::move(value);
852            return action;
853        });
854    }
855    bool deleteRwSettings(const std::string& name, interfaces::SettingsAction action) override
856    {
857        return overwriteRwSetting(name, {}, action);
858    }
859    void requestMempoolTransactions(Notifications& notifications) override
860    {
861        if (!m_node.mempool) return;
862        LOCK2(::cs_main, m_node.mempool->cs);
863        for (const CTxMemPoolEntry& entry : m_node.mempool->entryAll()) {
864            notifications.transactionAddedToMempool(entry.GetSharedTx());
865        }
866    }
867    bool hasAssumedValidChain() override
868    {
869        LOCK(::cs_main);
870        return bool{chainman().CurrentChainstate().m_from_snapshot_blockhash};
871    }
872
873    NodeContext* context() override { return &m_node; }
874    ArgsManager& args() { return *Assert(m_node.args); }
875    ChainstateManager& chainman() { return *Assert(m_node.chainman); }
876    ValidationSignals& validation_signals() { return *Assert(m_node.validation_signals); }
877    NodeContext& m_node;
878};
879
880class BlockTemplateImpl : public BlockTemplate
881{
882public:
883    explicit BlockTemplateImpl(BlockCreateOptions create_options,
884                               std::unique_ptr<CBlockTemplate> block_template,
885                               const NodeContext& node) : m_create_options(std::move(create_options)),
886                                                          m_block_template(std::move(block_template)),
887                                                          m_node(node)
888    {
889        assert(m_block_template);
890    }
891
892    CBlockHeader getBlockHeader() override
893    {
894        return m_block_template->block;
895    }
896
897    CBlock getBlock() override
898    {
899        return m_block_template->block;
900    }
901
902    std::vector<CAmount> getTxFees() override
903    {
904        return m_block_template->vTxFees;
905    }
906
907    std::vector<int64_t> getTxSigops() override
908    {
909        return m_block_template->vTxSigOpsCost;
910    }
911
912    CoinbaseTx getCoinbaseTx() override
913    {
914        return m_block_template->m_coinbase_tx;
915    }
916
917    std::vector<uint256> getCoinbaseMerklePath() override
918    {
919        return TransactionMerklePath(m_block_template->block, 0);
920    }
921
922    bool submitSolution(uint32_t version, uint32_t timestamp, uint32_t nonce, CTransactionRef coinbase, std::string& reason, std::string& debug) override
923    {
924        if (!coinbase) return false;
925        AddMerkleRootAndCoinbase(m_block_template->block, std::move(coinbase), version, timestamp, nonce);
926        return SubmitBlock(chainman(), std::make_shared<const CBlock>(m_block_template->block), reason, debug);
927    }
928
929    std::unique_ptr<BlockTemplate> waitNext(BlockWaitOptions options) override
930    {
931        auto new_template = WaitAndCreateNewBlock(chainman(),
932                                                  notifications(),
933                                                  m_node.mempool.get(),
934                                                  m_block_template,
935                                                  /*wait_options=*/options,
936                                                  /*create_options=*/m_create_options,
937                                                  /*interrupt_wait=*/m_interrupt_wait);
938        if (new_template) return std::make_unique<BlockTemplateImpl>(m_create_options, std::move(new_template), m_node);
939        return nullptr;
940    }
941
942    void interruptWait() override
943    {
944        InterruptWait(notifications(), m_interrupt_wait);
945    }
946
947    const BlockCreateOptions m_create_options;
948
949    const std::unique_ptr<CBlockTemplate> m_block_template;
950
951    bool m_interrupt_wait{false};
952    ChainstateManager& chainman() { return *Assert(m_node.chainman); }
953    KernelNotifications& notifications() { return *Assert(m_node.notifications); }
954    const NodeContext& m_node;
955};
956
957class MinerImpl : public Mining
958{
959public:
960    explicit MinerImpl(const NodeContext& node) : m_node(node) {}
961
962    bool isTestChain() override
963    {
964        return chainman().GetParams().IsTestChain();
965    }
966
967    bool isInitialBlockDownload() override
968    {
969        return chainman().IsInitialBlockDownload();
970    }
971
972    std::optional<BlockRef> getTip() override
973    {
974        return GetTip(chainman());
975    }
976
977    std::optional<BlockRef> waitTipChanged(uint256 current_tip, MillisecondsDouble timeout) override
978    {
979        return WaitTipChanged(chainman(), notifications(), current_tip, timeout, m_interrupt_mining);
980    }
981
982    std::unique_ptr<BlockTemplate> createNewBlock(const BlockCreateOptions& options, bool cooldown) override
983    {
984        // Ensure m_tip_block is set so consumers of BlockTemplate can rely on that.
985        std::optional<BlockRef> maybe_tip{waitTipChanged(uint256::ZERO, MillisecondsDouble::max())};
986
987        if (!maybe_tip) return {};
988
989        if (cooldown) {
990            // Do not return a template during IBD, because it can have long
991            // pauses and sometimes takes a while to get started. Although this
992            // is useful in general, it's gated behind the cooldown argument,
993            // because on regtest and single miner signets this would wait
994            // forever if no block was mined in the past day.
995            while (chainman().IsInitialBlockDownload()) {
996                maybe_tip = waitTipChanged(maybe_tip->hash, MillisecondsDouble{1000});
997                if (!maybe_tip || chainman().m_interrupt || WITH_LOCK(notifications().m_tip_block_mutex, return m_interrupt_mining)) return {};
998            }
999
1000            // Also wait during the final catch-up moments after IBD.