Mining templates, work estimates and block submission

1001        if (!info.gbt_optional_rule && !setClientRules.contains(name)) {
1002            // If the client doesn't support this, don't indicate it in the [default] version
1003            block.nVersion &= ~info.mask;
1004        }
1005    }
1006
1007    for (const auto& [name, info] : gbtstatus.locked_in) {
1008        block.nVersion |= info.mask;
1009        vbavailable.pushKV(gbt_rule_value(name, info.gbt_optional_rule), info.bit);
1010        if (!info.gbt_optional_rule && !setClientRules.contains(name)) {
1011            // If the client doesn't support this, don't indicate it in the [default] version
1012            block.nVersion &= ~info.mask;
1013        }
1014    }
1015
1016    for (const auto& [name, info] : gbtstatus.active) {
1017        aRules.push_back(gbt_rule_value(name, info.gbt_optional_rule));
1018        if (!info.gbt_optional_rule && !setClientRules.contains(name)) {
1019            // Not supported by the client; make sure it's safe to proceed
1020            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Support for '%s' rule requires explicit client support", name));
1021        }
1022    }
1023
1024    result.pushKV("version", block.nVersion);
1025    result.pushKV("rules", std::move(aRules));
1026    result.pushKV("vbavailable", std::move(vbavailable));
1027    result.pushKV("vbrequired", 0);
1028
1029    result.pushKV("previousblockhash", block.hashPrevBlock.GetHex());
1030    result.pushKV("transactions", std::move(transactions));
1031    result.pushKV("coinbaseaux", std::move(aux));
1032    result.pushKV("coinbasevalue", block.vtx[0]->vout[0].nValue);
1033    result.pushKV("longpollid", tip.GetHex() + ToString(nTransactionsUpdatedLast));
1034    result.pushKV("target", hashTarget.GetHex());
1035    result.pushKV("mintime", GetMinimumTime(pindexPrev, consensusParams.DifficultyAdjustmentInterval()));
1036    result.pushKV("mutable", std::move(aMutable));
1037    result.pushKV("noncerange", "00000000ffffffff");
1038    int64_t nSigOpLimit = MAX_BLOCK_SIGOPS_COST;
1039    int64_t nSizeLimit = MAX_BLOCK_SERIALIZED_SIZE;
1040    if (fPreSegWit) {
1041        CHECK_NONFATAL(nSigOpLimit % WITNESS_SCALE_FACTOR == 0);
1042        nSigOpLimit /= WITNESS_SCALE_FACTOR;
1043        CHECK_NONFATAL(nSizeLimit % WITNESS_SCALE_FACTOR == 0);
1044        nSizeLimit /= WITNESS_SCALE_FACTOR;
1045    }
1046    result.pushKV("sigoplimit", nSigOpLimit);
1047    result.pushKV("sizelimit", nSizeLimit);
1048    if (!fPreSegWit) {
1049        result.pushKV("weightlimit", MAX_BLOCK_WEIGHT);
1050    }
1051    result.pushKV("curtime", block.GetBlockTime());
1052    result.pushKV("bits", strprintf("%08x", block.nBits));
1053    result.pushKV("height", pindexPrev->nHeight + 1);
1054
1055    if (consensusParams.signet_blocks) {
1056        result.pushKV("signet_challenge", HexStr(consensusParams.signet_challenge));
1057    }
1058
1059    if (auto coinbase{block_template->getCoinbaseTx()}; coinbase.required_outputs.size() > 0) {
1060        CHECK_NONFATAL(coinbase.required_outputs.size() == 1); // Only one output is currently expected
1061        result.pushKV("default_witness_commitment", HexStr(coinbase.required_outputs[0].scriptPubKey));
1062    }
1063
1064    return result;
1065},
1066    };
1067}
1068
1069class submitblock_StateCatcher final : public CValidationInterface
1070{
1071public:
1072    uint256 hash;
1073    bool found{false};
1074    BlockValidationState state;
1075
1076    explicit submitblock_StateCatcher(const uint256 &hashIn) : hash(hashIn), state() {}
1077
1078protected:
1079    void BlockChecked(const std::shared_ptr<const CBlock>& block, const BlockValidationState& stateIn) override
1080    {
1081        if (block->GetHash() != hash) return;
1082        found = true;
1083        state = stateIn;
1084    }
1085};
1086
1087static RPCMethod submitblock()
1088{
1089    // We allow 2 arguments for compliance with BIP22. Argument 2 is ignored.
1090    return RPCMethod{
1091        "submitblock",
1092        "Attempts to submit new block to network.\n"
1093        "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n",
1094        {
1095            {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded block data to submit"},
1096            {"dummy", RPCArg::Type::STR, RPCArg::DefaultHint{"ignored"}, "dummy value, for compatibility with BIP22. This value is ignored.",
1097                RPCArgOptions{.placeholder = true}},
1098        },
1099        {
1100            RPCResult{"If the block was accepted", RPCResult::Type::NONE, "", ""},
1101            RPCResult{"Otherwise", RPCResult::Type::STR, "", "According to BIP22"},
1102        },
1103        RPCExamples{
1104                    HelpExampleCli("submitblock", "\"mydata\"")
1105            + HelpExampleRpc("submitblock", "\"mydata\"")
1106                },
1107        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
1108{
1109    std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
1110    CBlock& block = *blockptr;
1111    if (!DecodeHexBlk(block, request.params[0].get_str())) {
1112        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
1113    }
1114
1115    ChainstateManager& chainman = EnsureAnyChainman(request.context);
1116    {
1117        LOCK(cs_main);
1118        const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock);
1119        if (pindex) {
1120            chainman.UpdateUncommittedBlockStructures(block, pindex);
1121        }
1122    }
1123
1124    bool new_block;
1125    auto sc = std::make_shared<submitblock_StateCatcher>(block.GetHash());
1126    CHECK_NONFATAL(chainman.m_options.signals)->RegisterSharedValidationInterface(sc);
1127    bool accepted = chainman.ProcessNewBlock(blockptr, /*force_processing=*/true, /*min_pow_checked=*/true, /*new_block=*/&new_block);
1128    CHECK_NONFATAL(chainman.m_options.signals)->UnregisterSharedValidationInterface(sc);
1129    if (!new_block && accepted) {
1130        return "duplicate";
1131    }
1132    if (!sc->found) {
1133        return "inconclusive";
1134    }
1135    return BIP22ValidationResult(sc->state);
1136},
1137    };
1138}
1139
1140static RPCMethod submitheader()
1141{
1142    return RPCMethod{
1143        "submitheader",
1144        "Decode the given hexdata as a header and submit it as a candidate chain tip if valid."
1145                "\nThrows when the header is invalid.\n",
1146                {
1147                    {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded block header data"},
1148                },
1149                RPCResult{
1150                    RPCResult::Type::NONE, "", "None"},
1151                RPCExamples{
1152                    HelpExampleCli("submitheader", "\"aabbcc\"") +
1153                    HelpExampleRpc("submitheader", "\"aabbcc\"")
1154                },
1155        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
1156{
1157    CBlockHeader h;
1158    if (!DecodeHexBlockHeader(h, request.params[0].get_str())) {
1159        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block header decode failed");
1160    }
1161    ChainstateManager& chainman = EnsureAnyChainman(request.context);
1162    {
1163        LOCK(cs_main);
1164        if (!chainman.m_blockman.LookupBlockIndex(h.hashPrevBlock)) {
1165            throw JSONRPCError(RPC_VERIFY_ERROR, "Must submit previous header (" + h.hashPrevBlock.GetHex() + ") first");
1166        }
1167    }
1168
1169    BlockValidationState state;
1170    chainman.ProcessNewBlockHeaders({{h}}, /*min_pow_checked=*/true, state);
1171    if (state.IsValid()) return UniValue::VNULL;
1172    if (state.IsError()) {
1173        throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
1174    }
1175    throw JSONRPCError(RPC_VERIFY_ERROR, state.GetRejectReason());
1176},
1177    };
1178}
1179
1180void RegisterMiningRPCCommands(CRPCTable& t)
1181{
1182    static const CRPCCommand commands[]{
1183        {"mining", &getnetworkhashps},
1184        {"mining", &getmininginfo},
1185        {"mining", &prioritisetransaction},
1186        {"mining", &getprioritisedtransactions},
1187        {"mining", &getblocktemplate},
1188        {"mining", &submitblock},
1189        {"mining", &submitheader},
1190
1191        {"hidden", &generatetoaddress},
1192        {"hidden", &generatetodescriptor},
1193        {"hidden", &generateblock},
1194        {"hidden", &generate},
1195    };
1196    for (const auto& c : commands) {
1197        t.appendCommand(c.name, &c);
1198    }
1199}
1200