Mining templates, work estimates and block submission

751        if (modeval.isStr())
752            strMode = modeval.get_str();
753        else if (modeval.isNull())
754        {
755            /* Do nothing */
756        }
757        else
758            throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
759        lpval = oparam.find_value("longpollid");
760
761        if (strMode == "proposal")
762        {
763            const UniValue& dataval = oparam.find_value("data");
764            if (!dataval.isStr())
765                throw JSONRPCError(RPC_TYPE_ERROR, "Missing data String key for proposal");
766
767            CBlock block;
768            if (!DecodeHexBlk(block, dataval.get_str()))
769                throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
770
771            uint256 hash = block.GetHash();
772            LOCK(cs_main);
773            const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(hash);
774            if (pindex) {
775                if (pindex->IsValid(BLOCK_VALID_SCRIPTS))
776                    return "duplicate";
777                if (pindex->nStatus & BLOCK_FAILED_VALID)
778                    return "duplicate-invalid";
779                return "duplicate-inconclusive";
780            }
781
782            return BIP22ValidationResult(TestBlockValidity(chainman.ActiveChainstate(), block, /*check_pow=*/false, /*check_merkle_root=*/true));
783        }
784
785        const UniValue& aClientRules = oparam.find_value("rules");
786        if (aClientRules.isArray()) {
787            for (unsigned int i = 0; i < aClientRules.size(); ++i) {
788                const UniValue& v = aClientRules[i];
789                setClientRules.insert(v.get_str());
790            }
791        }
792    }
793
794    if (strMode != "template")
795        throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
796
797    if (!miner.isTestChain()) {
798        const CConnman& connman = EnsureConnman(node);
799        if (connman.GetNodeCount(ConnectionDirection::Both) == 0) {
800            throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, CLIENT_NAME " is not connected!");
801        }
802
803        if (miner.isInitialBlockDownload()) {
804            throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, CLIENT_NAME " is in initial sync and waiting for blocks...");
805        }
806    }
807
808    static unsigned int nTransactionsUpdatedLast;
809    const CTxMemPool& mempool = EnsureMemPool(node);
810
811    WAIT_LOCK(cs_main, cs_main_lock);
812    uint256 tip{CHECK_NONFATAL(miner.getTip()).value().hash};
813
814    // Long Polling (BIP22)
815    if (!lpval.isNull()) {
816        /**
817         * Wait to respond until either the best block changes, OR there are more
818         * transactions.
819         *
820         * The check for new transactions first happens after 1 minute and
821         * subsequently every 10 seconds. BIP22 does not require this particular interval.
822         * On mainnet the mempool changes frequently enough that in practice this RPC
823         * returns after 60 seconds, or sooner if the best block changes.
824         *
825         * getblocktemplate is unlikely to be called by bitcoin-cli, so
826         * -rpcclienttimeout is not a concern. BIP22 recommends a long request timeout.
827         *
828         * The longpollid is assumed to be a tip hash if it has the right format.
829         */
830        uint256 hashWatchedChain;
831        unsigned int nTransactionsUpdatedLastLP;
832
833        if (lpval.isStr())
834        {
835            // Format: <hashBestChain><nTransactionsUpdatedLast>
836            const std::string& lpstr = lpval.get_str();
837
838            // Assume the longpollid is a block hash. If it's not then we return
839            // early below.
840            hashWatchedChain = ParseHashV(lpstr.substr(0, 64), "longpollid");
841            nTransactionsUpdatedLastLP = LocaleIndependentAtoi<int64_t>(lpstr.substr(64));
842        }
843        else
844        {
845            // NOTE: Spec does not specify behaviour for non-string longpollid, but this makes testing easier
846            hashWatchedChain = tip;
847            nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
848        }
849
850        // Release lock while waiting
851        {
852            REVERSE_LOCK(cs_main_lock, cs_main);
853            MillisecondsDouble checktxtime{std::chrono::minutes(1)};
854            while (IsRPCRunning()) {
855                // If hashWatchedChain is not a real block hash, this will
856                // return immediately.
857                std::optional<BlockRef> maybe_tip{miner.waitTipChanged(hashWatchedChain, checktxtime)};
858                // Node is shutting down
859                if (!maybe_tip) break;
860                tip = maybe_tip->hash;
861                if (tip != hashWatchedChain) break;
862
863                // Check transactions for update without holding the mempool
864                // lock to avoid deadlocks.
865                if (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLastLP) {
866                    break;
867                }
868                checktxtime = std::chrono::seconds(10);
869            }
870        }
871        tip = CHECK_NONFATAL(miner.getTip()).value().hash;
872
873        if (!IsRPCRunning())
874            throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Shutting down");
875        // TODO: Maybe recheck connections/IBD and (if something wrong) send an expires-immediately template to stop miners?
876    }
877
878    const Consensus::Params& consensusParams = chainman.GetParams().GetConsensus();
879
880    // GBT must be called with 'signet' set in the rules for signet chains
881    if (consensusParams.signet_blocks && !setClientRules.contains("signet")) {
882        throw JSONRPCError(RPC_INVALID_PARAMETER, "getblocktemplate must be called with the signet rule set (call with {\"rules\": [\"segwit\", \"signet\"]})");
883    }
884
885    // GBT must be called with 'segwit' set in the rules
886    if (!setClientRules.contains("segwit")) {
887        throw JSONRPCError(RPC_INVALID_PARAMETER, "getblocktemplate must be called with the segwit rule set (call with {\"rules\": [\"segwit\"]})");
888    }
889
890    // Update block
891    static CBlockIndex* pindexPrev;
892    static int64_t time_start;
893    static std::unique_ptr<BlockTemplate> block_template;
894    if (!pindexPrev || pindexPrev->GetBlockHash() != tip ||
895        (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast && GetTime() - time_start > 5))
896    {
897        // Clear pindexPrev so future calls make a new block, despite any failures from here on
898        pindexPrev = nullptr;
899
900        // Store the pindexBest used before createNewBlock, to avoid races
901        nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
902        CBlockIndex* pindexPrevNew = chainman.m_blockman.LookupBlockIndex(tip);
903        time_start = GetTime();
904
905        // Create new block. Opt-out of cooldown mechanism, because it would add
906        // a delay to each getblocktemplate call. This differs from typical
907        // long-lived IPC usage, where the overhead is paid only when creating
908        // the initial template.
909        block_template = miner.createNewBlock({}, /*cooldown=*/false);
910        CHECK_NONFATAL(block_template);
911
912
913        // Need to update only after we know createNewBlock succeeded
914        pindexPrev = pindexPrevNew;
915    }
916    CHECK_NONFATAL(pindexPrev);
917    CBlock block{block_template->getBlock()};
918
919    // Update nTime
920    UpdateTime(&block, consensusParams, pindexPrev);
921    block.nNonce = 0;
922
923    // NOTE: If at some point we support pre-segwit miners post-segwit-activation, this needs to take segwit support into consideration
924    const bool fPreSegWit = !DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_SEGWIT);
925
926    UniValue aCaps(UniValue::VARR); aCaps.push_back("proposal");
927
928    UniValue transactions(UniValue::VARR);
929    std::map<Txid, int64_t> setTxIndex;
930    std::vector<CAmount> tx_fees{block_template->getTxFees()};
931    std::vector<int64_t> tx_sigops{block_template->getTxSigops()};
932
933    int i = 0;
934    for (const auto& it : block.vtx) {
935        const CTransaction& tx = *it;
936        Txid txHash = tx.GetHash();
937        setTxIndex[txHash] = i++;
938
939        if (tx.IsCoinBase())
940            continue;
941
942        UniValue entry(UniValue::VOBJ);
943
944        entry.pushKV("data", EncodeHexTx(tx));
945        entry.pushKV("txid", txHash.GetHex());
946        entry.pushKV("hash", tx.GetWitnessHash().GetHex());
947
948        UniValue deps(UniValue::VARR);
949        for (const CTxIn &in : tx.vin)
950        {
951            if (setTxIndex.contains(in.prevout.hash))
952                deps.push_back(setTxIndex[in.prevout.hash]);
953        }
954        entry.pushKV("depends", std::move(deps));
955
956        int index_in_template = i - 2;
957        entry.pushKV("fee", tx_fees.at(index_in_template));
958        int64_t nTxSigOps{tx_sigops.at(index_in_template)};
959        if (fPreSegWit) {
960            CHECK_NONFATAL(nTxSigOps % WITNESS_SCALE_FACTOR == 0);
961            nTxSigOps /= WITNESS_SCALE_FACTOR;
962        }
963        entry.pushKV("sigops", nTxSigOps);
964        entry.pushKV("weight", GetTransactionWeight(tx));
965
966        transactions.push_back(std::move(entry));
967    }
968
969    UniValue aux(UniValue::VOBJ);
970
971    arith_uint256 hashTarget = arith_uint256().SetCompact(block.nBits);
972
973    UniValue aMutable(UniValue::VARR);
974    aMutable.push_back("time");
975    aMutable.push_back("transactions");
976    aMutable.push_back("prevblock");
977
978    UniValue result(UniValue::VOBJ);
979    result.pushKV("capabilities", std::move(aCaps));
980
981    UniValue aRules(UniValue::VARR);
982    // See getblocktemplate changes in BIP 9:
983    // ! indicates a more subtle change to the block structure or generation transaction
984    // Otherwise clients may assume the rule will not impact usage of the template as-is.
985    aRules.push_back("csv");
986    if (!fPreSegWit) {
987        aRules.push_back("!segwit");
988        aRules.push_back("taproot");
989    }
990    if (consensusParams.signet_blocks) {
991        // indicate to miner that they must understand signet rules
992        // when attempting to mine with this template
993        aRules.push_back("!signet");
994    }
995
996    UniValue vbavailable(UniValue::VOBJ);
997    const auto gbtstatus = chainman.m_versionbitscache.GBTStatus(*pindexPrev, consensusParams);
998
999    for (const auto& [name, info] : gbtstatus.signalling) {
1000        vbavailable.pushKV(gbt_rule_value(name, info.gbt_optional_rule), info.bit);