Function finalizecompactblock

src/rpc/mining.cpp:1666–1733

}

static RPCHelpMan finalizecompactblock()
{
    return RPCHelpMan{"finalizecompactblock",
                "Takes the two transaction lists, fills out the compact block and attempts to finalize it.",
                {
                    {"compact_hex", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Hex serialized compact block."},
                    {"block_transactions", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Hex serialized BlockTransactions, the response to getblocktxn."},
                    {"found_transactions", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Hex serialized list of transactions that were found in response to receiving a compact sketch in `consumecompactsketch`."},
                },
                RPCResult{
                    RPCResult::Type::STR_HEX, "block", "The serialized final block",
                },
                RPCExamples{
                    HelpExampleCli("finalizecompactblock", "<compact_hex> <block_transactions> <found_transactions>")
                },
        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
{
    // Compact block
    std::vector<unsigned char> compact_block_bytes(ParseHex(request.params[0].get_str()));
    CDataStream ssCompactBlock(compact_block_bytes, SER_NETWORK, PROTOCOL_VERSION);
    CBlockHeaderAndShortTxIDs cmpctblock;
    ssCompactBlock >> cmpctblock;

    // BlockTransactions from the server
    std::vector<unsigned char> block_tx(ParseHex(request.params[1].get_str()));
    CDataStream ssResp(block_tx, SER_NETWORK, PROTOCOL_VERSION);

    BlockTransactions transactions;
    ssResp >> transactions;

    // Cached transactions
    std::vector<unsigned char> found_tx(ParseHex(request.params[2].get_str()));
    CDataStream ssFound(found_tx, SER_NETWORK, PROTOCOL_VERSION);

    std::vector<CTransactionRef> found;
    ssFound >> found;

    // Make mega-list
    found.insert(found.end(), transactions.txn.begin(), transactions.txn.end());

    // Now construct the final block! (use dummy mempool here, otherwise reconstruction may fail)
    CTxMemPool dummy_pool;
    PartiallyDownloadedBlock partialBlock(&dummy_pool);

    // "Extra" list is really our combined list that will be put into place using InitData
    std::vector<std::pair<uint256, CTransactionRef>> extra_txn;
    for (const auto& found_tx : found) {
        extra_txn.push_back(std::make_pair(found_tx->GetWitnessHash(), found_tx));
    }
    std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
    if (partialBlock.InitData(cmpctblock, extra_txn) != READ_STATUS_OK) {
        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "compact_hex appears malformed.");
    }
    const std::vector<CTransactionRef> dummy_missing;
    auto result = partialBlock.FillBlock(*pblock, dummy_missing, false /* pow_check*/);
    if (result == READ_STATUS_FAILED) {
        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Failed to complete block though all transactions were apparently found. Could be random short ID collision; requires full block instead.");
    } else if (result != READ_STATUS_OK) {