251    const auto v2_extras = Cat<std::vector<RPCResult>>(
252        std::vector<RPCResult>{{
253            RPCResult::Type::NUM, "fee", /*optional=*/true,
254            "transaction fee in " + CURRENCY_UNIT + ", omitted if block undo data is not available"
255        }},
256        TxDoc({.elision_mode = ElisionMode::Silent,
257               .prevout = true,
258               .prevout_optional = true,
259               .vin_inner_elision = "Same vin fields as verbosity = 1"}));
260    return RPCMethod{
261                "getrawtransaction",
262
263                "By default, this call only returns a transaction if it is in the mempool. If -txindex is enabled\n"
264                "and no blockhash argument is passed, it will return the transaction if it is in the mempool or any block.\n"
265                "If a blockhash argument is passed, it will return the transaction if\n"
266                "the specified block is available and the transaction is in that block.\n\n"
267                "Hint: Use gettransaction for wallet transactions.\n\n"
268
269                "If verbosity is 0 or omitted, returns the serialized transaction as a hex-encoded string.\n"
270                "If verbosity is 1, returns a JSON Object with information about the transaction.\n"
271                "If verbosity is 2, returns a JSON Object with information about the transaction, including fee and prevout information.",
272                {
273                    {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
274                    {"verbosity|verbose", RPCArg::Type::NUM, RPCArg::Default{0}, "0 for hex-encoded data, 1 for a JSON object, and 2 for JSON object with fee and prevout",
275                     RPCArgOptions{.skip_type_check = true}},
276                    {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "The block in which to look for the transaction"},
277                },
278                {
279                    RPCResult{"if verbosity is not set or set to 0",
280                         RPCResult::Type::STR, "data", "The serialized transaction as a hex-encoded string for 'txid'"
281                     },
282                     RPCResult{"if verbosity is set to 1",
283                         RPCResult::Type::OBJ, "", "",
284                         Cat<std::vector<RPCResult>>(
285                         verbosity_1_block,
286                         TxDoc({.txid_field_doc="The transaction id (same as provided)"})),
287                    },
288                    RPCResult{"for verbosity = 2", RPCResult::Type::OBJ, "", "",
289                    Cat(ElideGroup(verbosity_1_block, "Same output as verbosity = 1"), v2_extras)},
290                },
291                RPCExamples{
292                    HelpExampleCli("getrawtransaction", "\"mytxid\"")
293            + HelpExampleCli("getrawtransaction", "\"mytxid\" 1")
294            + HelpExampleRpc("getrawtransaction", "\"mytxid\", 1")
295            + HelpExampleCli("getrawtransaction", "\"mytxid\" 0 \"myblockhash\"")
296            + HelpExampleCli("getrawtransaction", "\"mytxid\" 1 \"myblockhash\"")
297            + HelpExampleCli("getrawtransaction", "\"mytxid\" 2 \"myblockhash\"")
298                },
299        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
300{
301    const NodeContext& node = EnsureAnyNodeContext(request.context);
302    ChainstateManager& chainman = EnsureChainman(node);
303
304    auto txid{Txid::FromUint256(ParseHashV(request.params[0], "parameter 1"))};
305    const CBlockIndex* blockindex = nullptr;
306
307    if (txid.ToUint256() == chainman.GetParams().GenesisBlock().hashMerkleRoot) {
308        // Special exception for the genesis block coinbase transaction
309        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "The genesis block coinbase is not considered an ordinary transaction and cannot be retrieved");
310    }
311
312    int verbosity{ParseVerbosity(request.params[1], /*default_verbosity=*/0, /*allow_bool=*/true)};
313
314    if (!request.params[2].isNull()) {
315        LOCK(cs_main);
316
317        uint256 blockhash = ParseHashV(request.params[2], "parameter 3");
318        blockindex = chainman.m_blockman.LookupBlockIndex(blockhash);
319        if (!blockindex) {
320            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block hash not found");
321        }
322    }
323
324    bool f_txindex_ready = false;
325    if (g_txindex && !blockindex) {
326        f_txindex_ready = g_txindex->BlockUntilSyncedToCurrentChain();
327    }
328
329    uint256 hash_block;
330    const CTransactionRef tx = GetTransaction(blockindex, node.mempool.get(), txid, chainman.m_blockman, hash_block);
331    if (!tx) {
332        std::string errmsg;
333        if (blockindex) {
334            const bool block_has_data = WITH_LOCK(::cs_main, return blockindex->nStatus & BLOCK_HAVE_DATA);
335            if (!block_has_data) {
336                throw JSONRPCError(RPC_MISC_ERROR, "Block not available");
337            }
338            errmsg = "No such transaction found in the provided block";
339        } else if (!g_txindex) {
340            errmsg = "No such mempool transaction. Use -txindex or provide a block hash to enable blockchain transaction queries";
341        } else if (!f_txindex_ready) {
342            errmsg = "No such mempool transaction. Blockchain transactions are still in the process of being indexed";
343        } else {
344            errmsg = "No such mempool or blockchain transaction";
345        }
346        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, errmsg + ". Use gettransaction for wallet transactions.");
347    }
348
349    if (verbosity <= 0) {
350        return EncodeHexTx(*tx);
351    }
352
353    UniValue result(UniValue::VOBJ);
354    if (blockindex) {
355        LOCK(cs_main);
356        result.pushKV("in_active_chain", chainman.ActiveChain().Contains(*blockindex));
357    }
358    // If request is verbosity >= 1 but no blockhash was given, then look up the blockindex
359    if (request.params[2].isNull()) {
360        LOCK(cs_main);
361        blockindex = chainman.m_blockman.LookupBlockIndex(hash_block); // May be nullptr for mempool transactions
362    }
363
364    // Add sigop-adjusted virtual size if the transaction exists in the mempool.
365    if (blockindex == nullptr && hash_block.IsNull() && node.mempool) {
366        auto info = node.mempool->info(tx->GetHash());
367        if (info.tx) {
368            result.pushKV("vsize_adjusted", info.vsize);
369        }
370    }
371
372    if (verbosity == 1) {
373        TxToJSON(*tx, hash_block, result, chainman.ActiveChainstate());
374        return result;
375    }
376
377    CBlockUndo blockUndo;
378    CBlock block;
379
380    if (tx->IsCoinBase() || !blockindex || WITH_LOCK(::cs_main, return !(blockindex->nStatus & BLOCK_HAVE_MASK))) {
381        TxToJSON(*tx, hash_block, result, chainman.ActiveChainstate());
382        return result;
383    }
384    if (!chainman.m_blockman.ReadBlockUndo(blockUndo, *blockindex)) {
385        throw JSONRPCError(RPC_INTERNAL_ERROR, "Undo data expected but can't be read. This could be due to disk corruption or a conflict with a pruning event.");
386    }
387    if (!chainman.m_blockman.ReadBlock(block, *blockindex)) {
388        throw JSONRPCError(RPC_INTERNAL_ERROR, "Block data expected but can't be read. This could be due to disk corruption or a conflict with a pruning event.");
389    }
390
391    CTxUndo* undoTX {nullptr};
392    auto it = std::find_if(block.vtx.begin(), block.vtx.end(), [tx](CTransactionRef t){ return t->Equals(*tx); });
393    if (it != block.vtx.end()) {
394        // -1 as blockundo does not have coinbase tx
395        undoTX = &blockUndo.vtxundo.at(it - block.vtx.begin() - 1);
396    }
397    TxToJSON(*tx, hash_block, result, chainman.ActiveChainstate(), undoTX, TxVerbosity::SHOW_DETAILS_AND_PREVOUT);
398    return result;
399},
400    };
401}
402
403static RPCMethod createrawtransaction()
404{
405    return RPCMethod{
406        "createrawtransaction",
407        "Create a transaction spending the given inputs and creating new outputs.\n"
408                "Outputs can be addresses or data.\n"
409                "Returns hex-encoded raw transaction.\n"
410                "Note that the transaction's inputs are not signed, and\n"
411                "it is not stored in the wallet or transmitted to the network.\n",
412                CreateTxDoc(),
413                RPCResult{
414                    RPCResult::Type::STR_HEX, "transaction", "hex string of the transaction"
415                },
416                RPCExamples{
417                    HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"address\\\":0.01}]\"")
418            + HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"")
419            + HelpExampleRpc("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\", \"[{\\\"address\\\":0.01}]\"")
420            + HelpExampleRpc("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\", \"[{\\\"data\\\":\\\"00010203\\\"}]\"")
421                },
422        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
423{
424    std::optional<bool> rbf;
425    if (!request.params[3].isNull()) {
426        rbf = request.params[3].get_bool();
427    }
428    CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2], rbf, self.Arg<uint32_t>("version"));
429
430    return EncodeHexTx(CTransaction(rawTx));
431},
432    };
433}
434
435static RPCMethod decoderawtransaction()
436{
437    return RPCMethod{"decoderawtransaction",
438                "Return a JSON object representing the serialized, hex-encoded transaction.",
439                {
440                    {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction hex string"},
441                    {"iswitness", RPCArg::Type::BOOL, RPCArg::DefaultHint{"depends on heuristic tests"}, "Whether the transaction hex is a serialized witness transaction.\n"
442                        "If iswitness is not present, heuristic tests will be used in decoding.\n"
443                        "If true, only witness deserialization will be tried.\n"
444                        "If false, only non-witness deserialization will be tried.\n"
445                        "This boolean should reflect whether the transaction has inputs\n"
446                        "(e.g. fully valid, or on-chain transactions), if known by the caller."
447                    },
448                },
449                RPCResult{
450                    RPCResult::Type::OBJ, "", "",
451                    TxDoc(),
452                },
453                RPCExamples{
454                    HelpExampleCli("decoderawtransaction", "\"hexstring\"")
455            + HelpExampleRpc("decoderawtransaction", "\"hexstring\"")
456                },
457        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
458{
459    CMutableTransaction mtx;
460
461    bool try_witness = request.params[1].isNull() ? true : request.params[1].get_bool();
462    bool try_no_witness = request.params[1].isNull() ? true : !request.params[1].get_bool();
463
464    if (!DecodeHexTx(mtx, request.params[0].get_str(), try_no_witness, try_witness)) {
465        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
466    }
467
468    UniValue result(UniValue::VOBJ);
469    TxToUniv(CTransaction(std::move(mtx)), /*block_hash=*/uint256(), /*entry=*/result, /*include_hex=*/false);
470
471    return result;
472},
473    };
474}
475
476static RPCMethod decodescript()
477{
478    return RPCMethod{
479        "decodescript",
480        "Decode a hex-encoded script.\n",
481        {
482            {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded script"},
483        },
484        RPCResult{
485            RPCResult::Type::OBJ, "", "",
486            {
487                {RPCResult::Type::STR, "asm", "Disassembly of the script"},
488                {RPCResult::Type::STR, "desc", "Inferred descriptor for the script"},
489                {RPCResult::Type::STR, "type", "The output type (e.g. " + GetAllOutputTypes() + ")"},
490                {RPCResult::Type::STR, "address", /*optional=*/true, "The Bitcoin address (only if a well-defined address exists)"},
491                {RPCResult::Type::STR, "p2sh", /*optional=*/true,
492                 "address of P2SH script wrapping this redeem script (not returned for types that should not be wrapped)"},
493                {RPCResult::Type::OBJ, "segwit", /*optional=*/true,
494                 "Result of a witness output script wrapping this redeem script (not returned for types that should not be wrapped)",
495                 {
496                     {RPCResult::Type::STR, "asm", "Disassembly of the output script"},
497                     {RPCResult::Type::STR_HEX, "hex", "The raw output script bytes, hex-encoded"},
498                     {RPCResult::Type::STR, "type", "The type of the output script (e.g. witness_v0_keyhash or witness_v0_scripthash)"},
499                     {RPCResult::Type::STR, "address", /*optional=*/true, "The Bitcoin address (only if a well-defined address exists)"},
500                     {RPCResult::Type::STR, "desc", "Inferred descriptor for the script"},