rawtransaction.cpp
1 // Copyright (c) 2010 Satoshi Nakamoto 2 // Copyright (c) 2009-2022 The Bitcoin Core developers 3 // Distributed under the MIT software license, see the accompanying 4 // file COPYING or http://www.opensource.org/licenses/mit-license.php. 5 6 #include <base58.h> 7 #include <chain.h> 8 #include <coins.h> 9 #include <consensus/amount.h> 10 #include <consensus/validation.h> 11 #include <core_io.h> 12 #include <index/txindex.h> 13 #include <key_io.h> 14 #include <node/blockstorage.h> 15 #include <node/coin.h> 16 #include <node/context.h> 17 #include <node/psbt.h> 18 #include <node/transaction.h> 19 #include <policy/packages.h> 20 #include <policy/policy.h> 21 #include <policy/rbf.h> 22 #include <primitives/transaction.h> 23 #include <psbt.h> 24 #include <random.h> 25 #include <rpc/blockchain.h> 26 #include <rpc/rawtransaction_util.h> 27 #include <rpc/server.h> 28 #include <rpc/server_util.h> 29 #include <rpc/util.h> 30 #include <script/script.h> 31 #include <script/sign.h> 32 #include <script/signingprovider.h> 33 #include <script/solver.h> 34 #include <uint256.h> 35 #include <undo.h> 36 #include <util/bip32.h> 37 #include <util/check.h> 38 #include <util/strencodings.h> 39 #include <util/string.h> 40 #include <util/vector.h> 41 #include <validation.h> 42 #include <validationinterface.h> 43 44 #include <numeric> 45 #include <stdint.h> 46 47 #include <univalue.h> 48 49 using node::AnalyzePSBT; 50 using node::FindCoins; 51 using node::GetTransaction; 52 using node::NodeContext; 53 using node::PSBTAnalysis; 54 55 static void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry, 56 Chainstate& active_chainstate, const CTxUndo* txundo = nullptr, 57 TxVerbosity verbosity = TxVerbosity::SHOW_DETAILS) 58 { 59 CHECK_NONFATAL(verbosity >= TxVerbosity::SHOW_DETAILS); 60 // Call into TxToUniv() in bitcoin-common to decode the transaction hex. 61 // 62 // Blockchain contextual information (confirmations and blocktime) is not 63 // available to code in bitcoin-common, so we query them here and push the 64 // data into the returned UniValue. 65 TxToUniv(tx, /*block_hash=*/uint256(), entry, /*include_hex=*/true, txundo, verbosity); 66 67 if (!hashBlock.IsNull()) { 68 LOCK(cs_main); 69 70 entry.pushKV("blockhash", hashBlock.GetHex()); 71 const CBlockIndex* pindex = active_chainstate.m_blockman.LookupBlockIndex(hashBlock); 72 if (pindex) { 73 if (active_chainstate.m_chain.Contains(pindex)) { 74 entry.pushKV("confirmations", 1 + active_chainstate.m_chain.Height() - pindex->nHeight); 75 entry.pushKV("time", pindex->GetBlockTime()); 76 entry.pushKV("blocktime", pindex->GetBlockTime()); 77 } 78 else 79 entry.pushKV("confirmations", 0); 80 } 81 } 82 } 83 84 static std::vector<RPCResult> ScriptPubKeyDoc() { 85 return 86 { 87 {RPCResult::Type::STR, "asm", "Disassembly of the public key script"}, 88 {RPCResult::Type::STR, "desc", "Inferred descriptor for the output"}, 89 {RPCResult::Type::STR_HEX, "hex", "The raw public key script bytes, hex-encoded"}, 90 {RPCResult::Type::STR, "address", /*optional=*/true, "The Bitcoin address (only if a well-defined address exists)"}, 91 {RPCResult::Type::STR, "type", "The type (one of: " + GetAllOutputTypes() + ")"}, 92 }; 93 } 94 95 static std::vector<RPCResult> DecodeTxDoc(const std::string& txid_field_doc) 96 { 97 return { 98 {RPCResult::Type::STR_HEX, "txid", txid_field_doc}, 99 {RPCResult::Type::STR_HEX, "hash", "The transaction hash (differs from txid for witness transactions)"}, 100 {RPCResult::Type::NUM, "size", "The serialized transaction size"}, 101 {RPCResult::Type::NUM, "vsize", "The virtual transaction size (differs from size for witness transactions)"}, 102 {RPCResult::Type::NUM, "weight", "The transaction's weight (between vsize*4-3 and vsize*4)"}, 103 {RPCResult::Type::NUM, "version", "The version"}, 104 {RPCResult::Type::NUM_TIME, "locktime", "The lock time"}, 105 {RPCResult::Type::ARR, "vin", "", 106 { 107 {RPCResult::Type::OBJ, "", "", 108 { 109 {RPCResult::Type::STR_HEX, "coinbase", /*optional=*/true, "The coinbase value (only if coinbase transaction)"}, 110 {RPCResult::Type::STR_HEX, "txid", /*optional=*/true, "The transaction id (if not coinbase transaction)"}, 111 {RPCResult::Type::NUM, "vout", /*optional=*/true, "The output number (if not coinbase transaction)"}, 112 {RPCResult::Type::OBJ, "scriptSig", /*optional=*/true, "The script (if not coinbase transaction)", 113 { 114 {RPCResult::Type::STR, "asm", "Disassembly of the signature script"}, 115 {RPCResult::Type::STR_HEX, "hex", "The raw signature script bytes, hex-encoded"}, 116 }}, 117 {RPCResult::Type::ARR, "txinwitness", /*optional=*/true, "", 118 { 119 {RPCResult::Type::STR_HEX, "hex", "hex-encoded witness data (if any)"}, 120 }}, 121 {RPCResult::Type::NUM, "sequence", "The script sequence number"}, 122 }}, 123 }}, 124 {RPCResult::Type::ARR, "vout", "", 125 { 126 {RPCResult::Type::OBJ, "", "", 127 { 128 {RPCResult::Type::STR_AMOUNT, "value", "The value in " + CURRENCY_UNIT}, 129 {RPCResult::Type::NUM, "n", "index"}, 130 {RPCResult::Type::OBJ, "scriptPubKey", "", ScriptPubKeyDoc()}, 131 }}, 132 }}, 133 }; 134 } 135 136 static std::vector<RPCArg> CreateTxDoc() 137 { 138 return { 139 {"inputs", RPCArg::Type::ARR, RPCArg::Optional::NO, "The inputs", 140 { 141 {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "", 142 { 143 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"}, 144 {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"}, 145 {"sequence", RPCArg::Type::NUM, RPCArg::DefaultHint{"depends on the value of the 'replaceable' and 'locktime' arguments"}, "The sequence number"}, 146 }, 147 }, 148 }, 149 }, 150 {"outputs", RPCArg::Type::ARR, RPCArg::Optional::NO, "The outputs specified as key-value pairs.\n" 151 "Each key may only appear once, i.e. there can only be one 'data' output, and no address may be duplicated.\n" 152 "At least one output of either type must be specified.\n" 153 "For compatibility reasons, a dictionary, which holds the key-value pairs directly, is also\n" 154 " accepted as second parameter.", 155 { 156 {"", RPCArg::Type::OBJ_USER_KEYS, RPCArg::Optional::OMITTED, "", 157 { 158 {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "A key-value pair. The key (string) is the bitcoin address, the value (float or string) is the amount in " + CURRENCY_UNIT}, 159 }, 160 }, 161 {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "", 162 { 163 {"data", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "A key-value pair. The key must be \"data\", the value is hex-encoded data"}, 164 }, 165 }, 166 }, 167 RPCArgOptions{.skip_type_check = true}}, 168 {"locktime", RPCArg::Type::NUM, RPCArg::Default{0}, "Raw locktime. Non-0 value also locktime-activates inputs"}, 169 {"replaceable", RPCArg::Type::BOOL, RPCArg::Default{true}, "Marks this transaction as BIP125-replaceable.\n" 170 "Allows this transaction to be replaced by a transaction with higher fees. If provided, it is an error if explicit sequence numbers are incompatible."}, 171 }; 172 } 173 174 // Update PSBT with information from the mempool, the UTXO set, the txindex, and the provided descriptors. 175 // Optionally, sign the inputs that we can using information from the descriptors. 176 PartiallySignedTransaction ProcessPSBT(const std::string& psbt_string, const std::any& context, const HidingSigningProvider& provider, int sighash_type, bool finalize) 177 { 178 // Unserialize the transactions 179 PartiallySignedTransaction psbtx; 180 std::string error; 181 if (!DecodeBase64PSBT(psbtx, psbt_string, error)) { 182 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", error)); 183 } 184 185 if (g_txindex) g_txindex->BlockUntilSyncedToCurrentChain(); 186 const NodeContext& node = EnsureAnyNodeContext(context); 187 188 // If we can't find the corresponding full transaction for all of our inputs, 189 // this will be used to find just the utxos for the segwit inputs for which 190 // the full transaction isn't found 191 std::map<COutPoint, Coin> coins; 192 193 // Fetch previous transactions: 194 // First, look in the txindex and the mempool 195 for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) { 196 PSBTInput& psbt_input = psbtx.inputs.at(i); 197 const CTxIn& tx_in = psbtx.tx->vin.at(i); 198 199 // The `non_witness_utxo` is the whole previous transaction 200 if (psbt_input.non_witness_utxo) continue; 201 202 CTransactionRef tx; 203 204 // Look in the txindex 205 if (g_txindex) { 206 uint256 block_hash; 207 g_txindex->FindTx(tx_in.prevout.hash, block_hash, tx); 208 } 209 // If we still don't have it look in the mempool 210 if (!tx) { 211 tx = node.mempool->get(tx_in.prevout.hash); 212 } 213 if (tx) { 214 psbt_input.non_witness_utxo = tx; 215 } else { 216 coins[tx_in.prevout]; // Create empty map entry keyed by prevout 217 } 218 } 219 220 // If we still haven't found all of the inputs, look for the missing ones in the utxo set 221 if (!coins.empty()) { 222 FindCoins(node, coins); 223 for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) { 224 PSBTInput& input = psbtx.inputs.at(i); 225 226 // If there are still missing utxos, add them if they were found in the utxo set 227 if (!input.non_witness_utxo) { 228 const CTxIn& tx_in = psbtx.tx->vin.at(i); 229 const Coin& coin = coins.at(tx_in.prevout); 230 if (!coin.out.IsNull() && IsSegWitOutput(provider, coin.out.scriptPubKey)) { 231 input.witness_utxo = coin.out; 232 } 233 } 234 } 235 } 236 237 const PrecomputedTransactionData& txdata = PrecomputePSBTData(psbtx); 238 239 for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) { 240 if (PSBTInputSigned(psbtx.inputs.at(i))) { 241 continue; 242 } 243 244 // Update script/keypath information using descriptor data. 245 // Note that SignPSBTInput does a lot more than just constructing ECDSA signatures. 246 // We only actually care about those if our signing provider doesn't hide private 247 // information, as is the case with `descriptorprocesspsbt` 248 SignPSBTInput(provider, psbtx, /*index=*/i, &txdata, sighash_type, /*out_sigdata=*/nullptr, finalize); 249 } 250 251 // Update script/keypath information using descriptor data. 252 for (unsigned int i = 0; i < psbtx.tx->vout.size(); ++i) { 253 UpdatePSBTOutput(provider, psbtx, i); 254 } 255 256 RemoveUnnecessaryTransactions(psbtx, /*sighash_type=*/1); 257 258 return psbtx; 259 } 260 261 static RPCHelpMan getrawtransaction() 262 { 263 return RPCHelpMan{ 264 "getrawtransaction", 265 266 "By default, this call only returns a transaction if it is in the mempool. If -txindex is enabled\n" 267 "and no blockhash argument is passed, it will return the transaction if it is in the mempool or any block.\n" 268 "If a blockhash argument is passed, it will return the transaction if\n" 269 "the specified block is available and the transaction is in that block.\n\n" 270 "Hint: Use gettransaction for wallet transactions.\n\n" 271 272 "If verbosity is 0 or omitted, returns the serialized transaction as a hex-encoded string.\n" 273 "If verbosity is 1, returns a JSON Object with information about the transaction.\n" 274 "If verbosity is 2, returns a JSON Object with information about the transaction, including fee and prevout information.", 275 { 276 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"}, 277 {"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", 278 RPCArgOptions{.skip_type_check = true}}, 279 {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "The block in which to look for the transaction"}, 280 }, 281 { 282 RPCResult{"if verbosity is not set or set to 0", 283 RPCResult::Type::STR, "data", "The serialized transaction as a hex-encoded string for 'txid'" 284 }, 285 RPCResult{"if verbosity is set to 1", 286 RPCResult::Type::OBJ, "", "", 287 Cat<std::vector<RPCResult>>( 288 { 289 {RPCResult::Type::BOOL, "in_active_chain", /*optional=*/true, "Whether specified block is in the active chain or not (only present with explicit \"blockhash\" argument)"}, 290 {RPCResult::Type::STR_HEX, "blockhash", /*optional=*/true, "the block hash"}, 291 {RPCResult::Type::NUM, "confirmations", /*optional=*/true, "The confirmations"}, 292 {RPCResult::Type::NUM_TIME, "blocktime", /*optional=*/true, "The block time expressed in " + UNIX_EPOCH_TIME}, 293 {RPCResult::Type::NUM, "time", /*optional=*/true, "Same as \"blocktime\""}, 294 {RPCResult::Type::STR_HEX, "hex", "The serialized, hex-encoded data for 'txid'"}, 295 }, 296 DecodeTxDoc(/*txid_field_doc=*/"The transaction id (same as provided)")), 297 }, 298 RPCResult{"for verbosity = 2", 299 RPCResult::Type::OBJ, "", "", 300 { 301 {RPCResult::Type::ELISION, "", "Same output as verbosity = 1"}, 302 {RPCResult::Type::NUM, "fee", /*optional=*/true, "transaction fee in " + CURRENCY_UNIT + ", omitted if block undo data is not available"}, 303 {RPCResult::Type::ARR, "vin", "", 304 { 305 {RPCResult::Type::OBJ, "", "utxo being spent", 306 { 307 {RPCResult::Type::ELISION, "", "Same output as verbosity = 1"}, 308 {RPCResult::Type::OBJ, "prevout", /*optional=*/true, "The previous output, omitted if block undo data is not available", 309 { 310 {RPCResult::Type::BOOL, "generated", "Coinbase or not"}, 311 {RPCResult::Type::NUM, "height", "The height of the prevout"}, 312 {RPCResult::Type::STR_AMOUNT, "value", "The value in " + CURRENCY_UNIT}, 313 {RPCResult::Type::OBJ, "scriptPubKey", "", ScriptPubKeyDoc()}, 314 }}, 315 }}, 316 }}, 317 }}, 318 }, 319 RPCExamples{ 320 HelpExampleCli("getrawtransaction", "\"mytxid\"") 321 + HelpExampleCli("getrawtransaction", "\"mytxid\" 1") 322 + HelpExampleRpc("getrawtransaction", "\"mytxid\", 1") 323 + HelpExampleCli("getrawtransaction", "\"mytxid\" 0 \"myblockhash\"") 324 + HelpExampleCli("getrawtransaction", "\"mytxid\" 1 \"myblockhash\"") 325 + HelpExampleCli("getrawtransaction", "\"mytxid\" 2 \"myblockhash\"") 326 }, 327 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 328 { 329 const NodeContext& node = EnsureAnyNodeContext(request.context); 330 ChainstateManager& chainman = EnsureChainman(node); 331 332 uint256 hash = ParseHashV(request.params[0], "parameter 1"); 333 const CBlockIndex* blockindex = nullptr; 334 335 if (hash == chainman.GetParams().GenesisBlock().hashMerkleRoot) { 336 // Special exception for the genesis block coinbase transaction 337 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "The genesis block coinbase is not considered an ordinary transaction and cannot be retrieved"); 338 } 339 340 // Accept either a bool (true) or a num (>=0) to indicate verbosity. 341 int verbosity{0}; 342 if (!request.params[1].isNull()) { 343 if (request.params[1].isBool()) { 344 verbosity = request.params[1].get_bool(); 345 } else { 346 verbosity = request.params[1].getInt<int>(); 347 } 348 } 349 350 if (!request.params[2].isNull()) { 351 LOCK(cs_main); 352 353 uint256 blockhash = ParseHashV(request.params[2], "parameter 3"); 354 blockindex = chainman.m_blockman.LookupBlockIndex(blockhash); 355 if (!blockindex) { 356 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block hash not found"); 357 } 358 } 359 360 bool f_txindex_ready = false; 361 if (g_txindex && !blockindex) { 362 f_txindex_ready = g_txindex->BlockUntilSyncedToCurrentChain(); 363 } 364 365 uint256 hash_block; 366 const CTransactionRef tx = GetTransaction(blockindex, node.mempool.get(), hash, hash_block, chainman.m_blockman); 367 if (!tx) { 368 std::string errmsg; 369 if (blockindex) { 370 const bool block_has_data = WITH_LOCK(::cs_main, return blockindex->nStatus & BLOCK_HAVE_DATA); 371 if (!block_has_data) { 372 throw JSONRPCError(RPC_MISC_ERROR, "Block not available"); 373 } 374 errmsg = "No such transaction found in the provided block"; 375 } else if (!g_txindex) { 376 errmsg = "No such mempool transaction. Use -txindex or provide a block hash to enable blockchain transaction queries"; 377 } else if (!f_txindex_ready) { 378 errmsg = "No such mempool transaction. Blockchain transactions are still in the process of being indexed"; 379 } else { 380 errmsg = "No such mempool or blockchain transaction"; 381 } 382 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, errmsg + ". Use gettransaction for wallet transactions."); 383 } 384 385 if (verbosity <= 0) { 386 return EncodeHexTx(*tx); 387 } 388 389 UniValue result(UniValue::VOBJ); 390 if (blockindex) { 391 LOCK(cs_main); 392 result.pushKV("in_active_chain", chainman.ActiveChain().Contains(blockindex)); 393 } 394 // If request is verbosity >= 1 but no blockhash was given, then look up the blockindex 395 if (request.params[2].isNull()) { 396 LOCK(cs_main); 397 blockindex = chainman.m_blockman.LookupBlockIndex(hash_block); // May be nullptr for mempool transactions 398 } 399 if (verbosity == 1) { 400 TxToJSON(*tx, hash_block, result, chainman.ActiveChainstate()); 401 return result; 402 } 403 404 CBlockUndo blockUndo; 405 CBlock block; 406 407 if (tx->IsCoinBase() || !blockindex || WITH_LOCK(::cs_main, return chainman.m_blockman.IsBlockPruned(*blockindex)) || 408 !(chainman.m_blockman.UndoReadFromDisk(blockUndo, *blockindex) && chainman.m_blockman.ReadBlockFromDisk(block, *blockindex))) { 409 TxToJSON(*tx, hash_block, result, chainman.ActiveChainstate()); 410 return result; 411 } 412 413 CTxUndo* undoTX {nullptr}; 414 auto it = std::find_if(block.vtx.begin(), block.vtx.end(), [tx](CTransactionRef t){ return *t == *tx; }); 415 if (it != block.vtx.end()) { 416 // -1 as blockundo does not have coinbase tx 417 undoTX = &blockUndo.vtxundo.at(it - block.vtx.begin() - 1); 418 } 419 TxToJSON(*tx, hash_block, result, chainman.ActiveChainstate(), undoTX, TxVerbosity::SHOW_DETAILS_AND_PREVOUT); 420 return result; 421 }, 422 }; 423 } 424 425 static RPCHelpMan createrawtransaction() 426 { 427 return RPCHelpMan{"createrawtransaction", 428 "\nCreate a transaction spending the given inputs and creating new outputs.\n" 429 "Outputs can be addresses or data.\n" 430 "Returns hex-encoded raw transaction.\n" 431 "Note that the transaction's inputs are not signed, and\n" 432 "it is not stored in the wallet or transmitted to the network.\n", 433 CreateTxDoc(), 434 RPCResult{ 435 RPCResult::Type::STR_HEX, "transaction", "hex string of the transaction" 436 }, 437 RPCExamples{ 438 HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"address\\\":0.01}]\"") 439 + HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"") 440 + HelpExampleRpc("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\", \"[{\\\"address\\\":0.01}]\"") 441 + HelpExampleRpc("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\", \"[{\\\"data\\\":\\\"00010203\\\"}]\"") 442 }, 443 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 444 { 445 std::optional<bool> rbf; 446 if (!request.params[3].isNull()) { 447 rbf = request.params[3].get_bool(); 448 } 449 CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2], rbf); 450 451 return EncodeHexTx(CTransaction(rawTx)); 452 }, 453 }; 454 } 455 456 static RPCHelpMan decoderawtransaction() 457 { 458 return RPCHelpMan{"decoderawtransaction", 459 "Return a JSON object representing the serialized, hex-encoded transaction.", 460 { 461 {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction hex string"}, 462 {"iswitness", RPCArg::Type::BOOL, RPCArg::DefaultHint{"depends on heuristic tests"}, "Whether the transaction hex is a serialized witness transaction.\n" 463 "If iswitness is not present, heuristic tests will be used in decoding.\n" 464 "If true, only witness deserialization will be tried.\n" 465 "If false, only non-witness deserialization will be tried.\n" 466 "This boolean should reflect whether the transaction has inputs\n" 467 "(e.g. fully valid, or on-chain transactions), if known by the caller." 468 }, 469 }, 470 RPCResult{ 471 RPCResult::Type::OBJ, "", "", 472 DecodeTxDoc(/*txid_field_doc=*/"The transaction id"), 473 }, 474 RPCExamples{ 475 HelpExampleCli("decoderawtransaction", "\"hexstring\"") 476 + HelpExampleRpc("decoderawtransaction", "\"hexstring\"") 477 }, 478 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 479 { 480 CMutableTransaction mtx; 481 482 bool try_witness = request.params[1].isNull() ? true : request.params[1].get_bool(); 483 bool try_no_witness = request.params[1].isNull() ? true : !request.params[1].get_bool(); 484 485 if (!DecodeHexTx(mtx, request.params[0].get_str(), try_no_witness, try_witness)) { 486 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed"); 487 } 488 489 UniValue result(UniValue::VOBJ); 490 TxToUniv(CTransaction(std::move(mtx)), /*block_hash=*/uint256(), /*entry=*/result, /*include_hex=*/false); 491 492 return result; 493 }, 494 }; 495 } 496 497 static RPCHelpMan decodescript() 498 { 499 return RPCHelpMan{ 500 "decodescript", 501 "\nDecode a hex-encoded script.\n", 502 { 503 {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded script"}, 504 }, 505 RPCResult{ 506 RPCResult::Type::OBJ, "", "", 507 { 508 {RPCResult::Type::STR, "asm", "Script public key"}, 509 {RPCResult::Type::STR, "desc", "Inferred descriptor for the script"}, 510 {RPCResult::Type::STR, "type", "The output type (e.g. " + GetAllOutputTypes() + ")"}, 511 {RPCResult::Type::STR, "address", /*optional=*/true, "The Bitcoin address (only if a well-defined address exists)"}, 512 {RPCResult::Type::STR, "p2sh", /*optional=*/true, 513 "address of P2SH script wrapping this redeem script (not returned for types that should not be wrapped)"}, 514 {RPCResult::Type::OBJ, "segwit", /*optional=*/true, 515 "Result of a witness script public key wrapping this redeem script (not returned for types that should not be wrapped)", 516 { 517 {RPCResult::Type::STR, "asm", "String representation of the script public key"}, 518 {RPCResult::Type::STR_HEX, "hex", "Hex string of the script public key"}, 519 {RPCResult::Type::STR, "type", "The type of the script public key (e.g. witness_v0_keyhash or witness_v0_scripthash)"}, 520 {RPCResult::Type::STR, "address", /*optional=*/true, "The Bitcoin address (only if a well-defined address exists)"}, 521 {RPCResult::Type::STR, "desc", "Inferred descriptor for the script"}, 522 {RPCResult::Type::STR, "p2sh-segwit", "address of the P2SH script wrapping this witness redeem script"}, 523 }}, 524 }, 525 }, 526 RPCExamples{ 527 HelpExampleCli("decodescript", "\"hexstring\"") 528 + HelpExampleRpc("decodescript", "\"hexstring\"") 529 }, 530 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 531 { 532 UniValue r(UniValue::VOBJ); 533 CScript script; 534 if (request.params[0].get_str().size() > 0){ 535 std::vector<unsigned char> scriptData(ParseHexV(request.params[0], "argument")); 536 script = CScript(scriptData.begin(), scriptData.end()); 537 } else { 538 // Empty scripts are valid 539 } 540 ScriptToUniv(script, /*out=*/r, /*include_hex=*/false, /*include_address=*/true); 541 542 std::vector<std::vector<unsigned char>> solutions_data; 543 const TxoutType which_type{Solver(script, solutions_data)}; 544 545 const bool can_wrap{[&] { 546 switch (which_type) { 547 case TxoutType::MULTISIG: 548 case TxoutType::NONSTANDARD: 549 case TxoutType::PUBKEY: 550 case TxoutType::PUBKEYHASH: 551 case TxoutType::WITNESS_V0_KEYHASH: 552 case TxoutType::WITNESS_V0_SCRIPTHASH: 553 // Can be wrapped if the checks below pass 554 break; 555 case TxoutType::NULL_DATA: 556 case TxoutType::SCRIPTHASH: 557 case TxoutType::WITNESS_UNKNOWN: 558 case TxoutType::WITNESS_V1_TAPROOT: 559 // Should not be wrapped 560 return false; 561 } // no default case, so the compiler can warn about missing cases 562 if (!script.HasValidOps() || script.IsUnspendable()) { 563 return false; 564 } 565 for (CScript::const_iterator it{script.begin()}; it != script.end();) { 566 opcodetype op; 567 CHECK_NONFATAL(script.GetOp(it, op)); 568 if (op == OP_CHECKSIGADD || IsOpSuccess(op)) { 569 return false; 570 } 571 } 572 return true; 573 }()}; 574 575 if (can_wrap) { 576 r.pushKV("p2sh", EncodeDestination(ScriptHash(script))); 577 // P2SH and witness programs cannot be wrapped in P2WSH, if this script 578 // is a witness program, don't return addresses for a segwit programs. 579 const bool can_wrap_P2WSH{[&] { 580 switch (which_type) { 581 case TxoutType::MULTISIG: 582 case TxoutType::PUBKEY: 583 // Uncompressed pubkeys cannot be used with segwit checksigs. 584 // If the script contains an uncompressed pubkey, skip encoding of a segwit program. 585 for (const auto& solution : solutions_data) { 586 if ((solution.size() != 1) && !CPubKey(solution).IsCompressed()) { 587 return false; 588 } 589 } 590 return true; 591 case TxoutType::NONSTANDARD: 592 case TxoutType::PUBKEYHASH: 593 // Can be P2WSH wrapped 594 return true; 595 case TxoutType::NULL_DATA: 596 case TxoutType::SCRIPTHASH: 597 case TxoutType::WITNESS_UNKNOWN: 598 case TxoutType::WITNESS_V0_KEYHASH: 599 case TxoutType::WITNESS_V0_SCRIPTHASH: 600 case TxoutType::WITNESS_V1_TAPROOT: 601 // Should not be wrapped 602 return false; 603 } // no default case, so the compiler can warn about missing cases 604 NONFATAL_UNREACHABLE(); 605 }()}; 606 if (can_wrap_P2WSH) { 607 UniValue sr(UniValue::VOBJ); 608 CScript segwitScr; 609 FlatSigningProvider provider; 610 if (which_type == TxoutType::PUBKEY) { 611 segwitScr = GetScriptForDestination(WitnessV0KeyHash(Hash160(solutions_data[0]))); 612 } else if (which_type == TxoutType::PUBKEYHASH) { 613 segwitScr = GetScriptForDestination(WitnessV0KeyHash(uint160{solutions_data[0]})); 614 } else { 615 // Scripts that are not fit for P2WPKH are encoded as P2WSH. 616 provider.scripts[CScriptID(script)] = script; 617 segwitScr = GetScriptForDestination(WitnessV0ScriptHash(script)); 618 } 619 ScriptToUniv(segwitScr, /*out=*/sr, /*include_hex=*/true, /*include_address=*/true, /*provider=*/&provider); 620 sr.pushKV("p2sh-segwit", EncodeDestination(ScriptHash(segwitScr))); 621 r.pushKV("segwit", sr); 622 } 623 } 624 625 return r; 626 }, 627 }; 628 } 629 630 static RPCHelpMan combinerawtransaction() 631 { 632 return RPCHelpMan{"combinerawtransaction", 633 "\nCombine multiple partially signed transactions into one transaction.\n" 634 "The combined transaction may be another partially signed transaction or a \n" 635 "fully signed transaction.", 636 { 637 {"txs", RPCArg::Type::ARR, RPCArg::Optional::NO, "The hex strings of partially signed transactions", 638 { 639 {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "A hex-encoded raw transaction"}, 640 }, 641 }, 642 }, 643 RPCResult{ 644 RPCResult::Type::STR, "", "The hex-encoded raw transaction with signature(s)" 645 }, 646 RPCExamples{ 647 HelpExampleCli("combinerawtransaction", R"('["myhex1", "myhex2", "myhex3"]')") 648 }, 649 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 650 { 651 652 UniValue txs = request.params[0].get_array(); 653 std::vector<CMutableTransaction> txVariants(txs.size()); 654 655 for (unsigned int idx = 0; idx < txs.size(); idx++) { 656 if (!DecodeHexTx(txVariants[idx], txs[idx].get_str())) { 657 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed for tx %d. Make sure the tx has at least one input.", idx)); 658 } 659 } 660 661 if (txVariants.empty()) { 662 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Missing transactions"); 663 } 664 665 // mergedTx will end up with all the signatures; it 666 // starts as a clone of the rawtx: 667 CMutableTransaction mergedTx(txVariants[0]); 668 669 // Fetch previous transactions (inputs): 670 CCoinsView viewDummy; 671 CCoinsViewCache view(&viewDummy); 672 { 673 NodeContext& node = EnsureAnyNodeContext(request.context); 674 const CTxMemPool& mempool = EnsureMemPool(node); 675 ChainstateManager& chainman = EnsureChainman(node); 676 LOCK2(cs_main, mempool.cs); 677 CCoinsViewCache &viewChain = chainman.ActiveChainstate().CoinsTip(); 678 CCoinsViewMemPool viewMempool(&viewChain, mempool); 679 view.SetBackend(viewMempool); // temporarily switch cache backend to db+mempool view 680 681 for (const CTxIn& txin : mergedTx.vin) { 682 view.AccessCoin(txin.prevout); // Load entries from viewChain into view; can fail. 683 } 684 685 view.SetBackend(viewDummy); // switch back to avoid locking mempool for too long 686 } 687 688 // Use CTransaction for the constant parts of the 689 // transaction to avoid rehashing. 690 const CTransaction txConst(mergedTx); 691 // Sign what we can: 692 for (unsigned int i = 0; i < mergedTx.vin.size(); i++) { 693 CTxIn& txin = mergedTx.vin[i]; 694 const Coin& coin = view.AccessCoin(txin.prevout); 695 if (coin.IsSpent()) { 696 throw JSONRPCError(RPC_VERIFY_ERROR, "Input not found or already spent"); 697 } 698 SignatureData sigdata; 699 700 // ... and merge in other signatures: 701 for (const CMutableTransaction& txv : txVariants) { 702 if (txv.vin.size() > i) { 703 sigdata.MergeSignatureData(DataFromTransaction(txv, i, coin.out)); 704 } 705 } 706 ProduceSignature(DUMMY_SIGNING_PROVIDER, MutableTransactionSignatureCreator(mergedTx, i, coin.out.nValue, 1), coin.out.scriptPubKey, sigdata); 707 708 UpdateInput(txin, sigdata); 709 } 710 711 return EncodeHexTx(CTransaction(mergedTx)); 712 }, 713 }; 714 } 715 716 static RPCHelpMan signrawtransactionwithkey() 717 { 718 return RPCHelpMan{"signrawtransactionwithkey", 719 "\nSign inputs for raw transaction (serialized, hex-encoded).\n" 720 "The second argument is an array of base58-encoded private\n" 721 "keys that will be the only keys used to sign the transaction.\n" 722 "The third optional argument (may be null) is an array of previous transaction outputs that\n" 723 "this transaction depends on but may not yet be in the block chain.\n", 724 { 725 {"hexstring", RPCArg::Type::STR, RPCArg::Optional::NO, "The transaction hex string"}, 726 {"privkeys", RPCArg::Type::ARR, RPCArg::Optional::NO, "The base58-encoded private keys for signing", 727 { 728 {"privatekey", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "private key in base58-encoding"}, 729 }, 730 }, 731 {"prevtxs", RPCArg::Type::ARR, RPCArg::Optional::OMITTED, "The previous dependent transaction outputs", 732 { 733 {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "", 734 { 735 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"}, 736 {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"}, 737 {"scriptPubKey", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "script key"}, 738 {"redeemScript", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "(required for P2SH) redeem script"}, 739 {"witnessScript", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "(required for P2WSH or P2SH-P2WSH) witness script"}, 740 {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::OMITTED, "(required for Segwit inputs) the amount spent"}, 741 }, 742 }, 743 }, 744 }, 745 {"sighashtype", RPCArg::Type::STR, RPCArg::Default{"DEFAULT for Taproot, ALL otherwise"}, "The signature hash type. Must be one of:\n" 746 " \"DEFAULT\"\n" 747 " \"ALL\"\n" 748 " \"NONE\"\n" 749 " \"SINGLE\"\n" 750 " \"ALL|ANYONECANPAY\"\n" 751 " \"NONE|ANYONECANPAY\"\n" 752 " \"SINGLE|ANYONECANPAY\"\n" 753 }, 754 }, 755 RPCResult{ 756 RPCResult::Type::OBJ, "", "", 757 { 758 {RPCResult::Type::STR_HEX, "hex", "The hex-encoded raw transaction with signature(s)"}, 759 {RPCResult::Type::BOOL, "complete", "If the transaction has a complete set of signatures"}, 760 {RPCResult::Type::ARR, "errors", /*optional=*/true, "Script verification errors (if there are any)", 761 { 762 {RPCResult::Type::OBJ, "", "", 763 { 764 {RPCResult::Type::STR_HEX, "txid", "The hash of the referenced, previous transaction"}, 765 {RPCResult::Type::NUM, "vout", "The index of the output to spent and used as input"}, 766 {RPCResult::Type::ARR, "witness", "", 767 { 768 {RPCResult::Type::STR_HEX, "witness", ""}, 769 }}, 770 {RPCResult::Type::STR_HEX, "scriptSig", "The hex-encoded signature script"}, 771 {RPCResult::Type::NUM, "sequence", "Script sequence number"}, 772 {RPCResult::Type::STR, "error", "Verification or signing error related to the input"}, 773 }}, 774 }}, 775 } 776 }, 777 RPCExamples{ 778 HelpExampleCli("signrawtransactionwithkey", "\"myhex\" \"[\\\"key1\\\",\\\"key2\\\"]\"") 779 + HelpExampleRpc("signrawtransactionwithkey", "\"myhex\", \"[\\\"key1\\\",\\\"key2\\\"]\"") 780 }, 781 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 782 { 783 CMutableTransaction mtx; 784 if (!DecodeHexTx(mtx, request.params[0].get_str())) { 785 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed. Make sure the tx has at least one input."); 786 } 787 788 FillableSigningProvider keystore; 789 const UniValue& keys = request.params[1].get_array(); 790 for (unsigned int idx = 0; idx < keys.size(); ++idx) { 791 UniValue k = keys[idx]; 792 CKey key = DecodeSecret(k.get_str()); 793 if (!key.IsValid()) { 794 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid private key"); 795 } 796 keystore.AddKey(key); 797 } 798 799 // Fetch previous transactions (inputs): 800 std::map<COutPoint, Coin> coins; 801 for (const CTxIn& txin : mtx.vin) { 802 coins[txin.prevout]; // Create empty map entry keyed by prevout. 803 } 804 NodeContext& node = EnsureAnyNodeContext(request.context); 805 FindCoins(node, coins); 806 807 // Parse the prevtxs array 808 ParsePrevouts(request.params[2], &keystore, coins); 809 810 UniValue result(UniValue::VOBJ); 811 SignTransaction(mtx, &keystore, coins, request.params[3], result); 812 return result; 813 }, 814 }; 815 } 816 817 const RPCResult decodepsbt_inputs{ 818 RPCResult::Type::ARR, "inputs", "", 819 { 820 {RPCResult::Type::OBJ, "", "", 821 { 822 {RPCResult::Type::OBJ, "non_witness_utxo", /*optional=*/true, "Decoded network transaction for non-witness UTXOs", 823 { 824 {RPCResult::Type::ELISION, "",""}, 825 }}, 826 {RPCResult::Type::OBJ, "witness_utxo", /*optional=*/true, "Transaction output for witness UTXOs", 827 { 828 {RPCResult::Type::NUM, "amount", "The value in " + CURRENCY_UNIT}, 829 {RPCResult::Type::OBJ, "scriptPubKey", "", 830 { 831 {RPCResult::Type::STR, "asm", "Disassembly of the public key script"}, 832 {RPCResult::Type::STR, "desc", "Inferred descriptor for the output"}, 833 {RPCResult::Type::STR_HEX, "hex", "The raw public key script bytes, hex-encoded"}, 834 {RPCResult::Type::STR, "type", "The type, eg 'pubkeyhash'"}, 835 {RPCResult::Type::STR, "address", /*optional=*/true, "The Bitcoin address (only if a well-defined address exists)"}, 836 }}, 837 }}, 838 {RPCResult::Type::OBJ_DYN, "partial_signatures", /*optional=*/true, "", 839 { 840 {RPCResult::Type::STR, "pubkey", "The public key and signature that corresponds to it."}, 841 }}, 842 {RPCResult::Type::STR, "sighash", /*optional=*/true, "The sighash type to be used"}, 843 {RPCResult::Type::OBJ, "redeem_script", /*optional=*/true, "", 844 { 845 {RPCResult::Type::STR, "asm", "Disassembly of the redeem script"}, 846 {RPCResult::Type::STR_HEX, "hex", "The raw redeem script bytes, hex-encoded"}, 847 {RPCResult::Type::STR, "type", "The type, eg 'pubkeyhash'"}, 848 }}, 849 {RPCResult::Type::OBJ, "witness_script", /*optional=*/true, "", 850 { 851 {RPCResult::Type::STR, "asm", "Disassembly of the witness script"}, 852 {RPCResult::Type::STR_HEX, "hex", "The raw witness script bytes, hex-encoded"}, 853 {RPCResult::Type::STR, "type", "The type, eg 'pubkeyhash'"}, 854 }}, 855 {RPCResult::Type::ARR, "bip32_derivs", /*optional=*/true, "", 856 { 857 {RPCResult::Type::OBJ, "", "", 858 { 859 {RPCResult::Type::STR, "pubkey", "The public key with the derivation path as the value."}, 860 {RPCResult::Type::STR, "master_fingerprint", "The fingerprint of the master key"}, 861 {RPCResult::Type::STR, "path", "The path"}, 862 }}, 863 }}, 864 {RPCResult::Type::OBJ, "final_scriptSig", /*optional=*/true, "", 865 { 866 {RPCResult::Type::STR, "asm", "Disassembly of the final signature script"}, 867 {RPCResult::Type::STR_HEX, "hex", "The raw final signature script bytes, hex-encoded"}, 868 }}, 869 {RPCResult::Type::ARR, "final_scriptwitness", /*optional=*/true, "", 870 { 871 {RPCResult::Type::STR_HEX, "", "hex-encoded witness data (if any)"}, 872 }}, 873 {RPCResult::Type::OBJ_DYN, "ripemd160_preimages", /*optional=*/ true, "", 874 { 875 {RPCResult::Type::STR, "hash", "The hash and preimage that corresponds to it."}, 876 }}, 877 {RPCResult::Type::OBJ_DYN, "sha256_preimages", /*optional=*/ true, "", 878 { 879 {RPCResult::Type::STR, "hash", "The hash and preimage that corresponds to it."}, 880 }}, 881 {RPCResult::Type::OBJ_DYN, "hash160_preimages", /*optional=*/ true, "", 882 { 883 {RPCResult::Type::STR, "hash", "The hash and preimage that corresponds to it."}, 884 }}, 885 {RPCResult::Type::OBJ_DYN, "hash256_preimages", /*optional=*/ true, "", 886 { 887 {RPCResult::Type::STR, "hash", "The hash and preimage that corresponds to it."}, 888 }}, 889 {RPCResult::Type::STR_HEX, "taproot_key_path_sig", /*optional=*/ true, "hex-encoded signature for the Taproot key path spend"}, 890 {RPCResult::Type::ARR, "taproot_script_path_sigs", /*optional=*/ true, "", 891 { 892 {RPCResult::Type::OBJ, "signature", /*optional=*/ true, "The signature for the pubkey and leaf hash combination", 893 { 894 {RPCResult::Type::STR, "pubkey", "The x-only pubkey for this signature"}, 895 {RPCResult::Type::STR, "leaf_hash", "The leaf hash for this signature"}, 896 {RPCResult::Type::STR, "sig", "The signature itself"}, 897 }}, 898 }}, 899 {RPCResult::Type::ARR, "taproot_scripts", /*optional=*/ true, "", 900 { 901 {RPCResult::Type::OBJ, "", "", 902 { 903 {RPCResult::Type::STR_HEX, "script", "A leaf script"}, 904 {RPCResult::Type::NUM, "leaf_ver", "The version number for the leaf script"}, 905 {RPCResult::Type::ARR, "control_blocks", "The control blocks for this script", 906 { 907 {RPCResult::Type::STR_HEX, "control_block", "A hex-encoded control block for this script"}, 908 }}, 909 }}, 910 }}, 911 {RPCResult::Type::ARR, "taproot_bip32_derivs", /*optional=*/ true, "", 912 { 913 {RPCResult::Type::OBJ, "", "", 914 { 915 {RPCResult::Type::STR, "pubkey", "The x-only public key this path corresponds to"}, 916 {RPCResult::Type::STR, "master_fingerprint", "The fingerprint of the master key"}, 917 {RPCResult::Type::STR, "path", "The path"}, 918 {RPCResult::Type::ARR, "leaf_hashes", "The hashes of the leaves this pubkey appears in", 919 { 920 {RPCResult::Type::STR_HEX, "hash", "The hash of a leaf this pubkey appears in"}, 921 }}, 922 }}, 923 }}, 924 {RPCResult::Type::STR_HEX, "taproot_internal_key", /*optional=*/ true, "The hex-encoded Taproot x-only internal key"}, 925 {RPCResult::Type::STR_HEX, "taproot_merkle_root", /*optional=*/ true, "The hex-encoded Taproot merkle root"}, 926 {RPCResult::Type::OBJ_DYN, "unknown", /*optional=*/ true, "The unknown input fields", 927 { 928 {RPCResult::Type::STR_HEX, "key", "(key-value pair) An unknown key-value pair"}, 929 }}, 930 {RPCResult::Type::ARR, "proprietary", /*optional=*/true, "The input proprietary map", 931 { 932 {RPCResult::Type::OBJ, "", "", 933 { 934 {RPCResult::Type::STR_HEX, "identifier", "The hex string for the proprietary identifier"}, 935 {RPCResult::Type::NUM, "subtype", "The number for the subtype"}, 936 {RPCResult::Type::STR_HEX, "key", "The hex for the key"}, 937 {RPCResult::Type::STR_HEX, "value", "The hex for the value"}, 938 }}, 939 }}, 940 }}, 941 } 942 }; 943 944 const RPCResult decodepsbt_outputs{ 945 RPCResult::Type::ARR, "outputs", "", 946 { 947 {RPCResult::Type::OBJ, "", "", 948 { 949 {RPCResult::Type::OBJ, "redeem_script", /*optional=*/true, "", 950 { 951 {RPCResult::Type::STR, "asm", "Disassembly of the redeem script"}, 952 {RPCResult::Type::STR_HEX, "hex", "The raw redeem script bytes, hex-encoded"}, 953 {RPCResult::Type::STR, "type", "The type, eg 'pubkeyhash'"}, 954 }}, 955 {RPCResult::Type::OBJ, "witness_script", /*optional=*/true, "", 956 { 957 {RPCResult::Type::STR, "asm", "Disassembly of the witness script"}, 958 {RPCResult::Type::STR_HEX, "hex", "The raw witness script bytes, hex-encoded"}, 959 {RPCResult::Type::STR, "type", "The type, eg 'pubkeyhash'"}, 960 }}, 961 {RPCResult::Type::ARR, "bip32_derivs", /*optional=*/true, "", 962 { 963 {RPCResult::Type::OBJ, "", "", 964 { 965 {RPCResult::Type::STR, "pubkey", "The public key this path corresponds to"}, 966 {RPCResult::Type::STR, "master_fingerprint", "The fingerprint of the master key"}, 967 {RPCResult::Type::STR, "path", "The path"}, 968 }}, 969 }}, 970 {RPCResult::Type::STR_HEX, "taproot_internal_key", /*optional=*/ true, "The hex-encoded Taproot x-only internal key"}, 971 {RPCResult::Type::ARR, "taproot_tree", /*optional=*/ true, "The tuples that make up the Taproot tree, in depth first search order", 972 { 973 {RPCResult::Type::OBJ, "tuple", /*optional=*/ true, "A single leaf script in the taproot tree", 974 { 975 {RPCResult::Type::NUM, "depth", "The depth of this element in the tree"}, 976 {RPCResult::Type::NUM, "leaf_ver", "The version of this leaf"}, 977 {RPCResult::Type::STR, "script", "The hex-encoded script itself"}, 978 }}, 979 }}, 980 {RPCResult::Type::ARR, "taproot_bip32_derivs", /*optional=*/ true, "", 981 { 982 {RPCResult::Type::OBJ, "", "", 983 { 984 {RPCResult::Type::STR, "pubkey", "The x-only public key this path corresponds to"}, 985 {RPCResult::Type::STR, "master_fingerprint", "The fingerprint of the master key"}, 986 {RPCResult::Type::STR, "path", "The path"}, 987 {RPCResult::Type::ARR, "leaf_hashes", "The hashes of the leaves this pubkey appears in", 988 { 989 {RPCResult::Type::STR_HEX, "hash", "The hash of a leaf this pubkey appears in"}, 990 }}, 991 }}, 992 }}, 993 {RPCResult::Type::OBJ_DYN, "unknown", /*optional=*/true, "The unknown output fields", 994 { 995 {RPCResult::Type::STR_HEX, "key", "(key-value pair) An unknown key-value pair"}, 996 }}, 997 {RPCResult::Type::ARR, "proprietary", /*optional=*/true, "The output proprietary map", 998 { 999 {RPCResult::Type::OBJ, "", "", 1000 { 1001 {RPCResult::Type::STR_HEX, "identifier", "The hex string for the proprietary identifier"}, 1002 {RPCResult::Type::NUM, "subtype", "The number for the subtype"}, 1003 {RPCResult::Type::STR_HEX, "key", "The hex for the key"}, 1004 {RPCResult::Type::STR_HEX, "value", "The hex for the value"}, 1005 }}, 1006 }}, 1007 }}, 1008 } 1009 }; 1010 1011 static RPCHelpMan decodepsbt() 1012 { 1013 return RPCHelpMan{ 1014 "decodepsbt", 1015 "Return a JSON object representing the serialized, base64-encoded partially signed Bitcoin transaction.", 1016 { 1017 {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO, "The PSBT base64 string"}, 1018 }, 1019 RPCResult{ 1020 RPCResult::Type::OBJ, "", "", 1021 { 1022 {RPCResult::Type::OBJ, "tx", "The decoded network-serialized unsigned transaction.", 1023 { 1024 {RPCResult::Type::ELISION, "", "The layout is the same as the output of decoderawtransaction."}, 1025 }}, 1026 {RPCResult::Type::ARR, "global_xpubs", "", 1027 { 1028 {RPCResult::Type::OBJ, "", "", 1029 { 1030 {RPCResult::Type::STR, "xpub", "The extended public key this path corresponds to"}, 1031 {RPCResult::Type::STR_HEX, "master_fingerprint", "The fingerprint of the master key"}, 1032 {RPCResult::Type::STR, "path", "The path"}, 1033 }}, 1034 }}, 1035 {RPCResult::Type::NUM, "psbt_version", "The PSBT version number. Not to be confused with the unsigned transaction version"}, 1036 {RPCResult::Type::ARR, "proprietary", "The global proprietary map", 1037 { 1038 {RPCResult::Type::OBJ, "", "", 1039 { 1040 {RPCResult::Type::STR_HEX, "identifier", "The hex string for the proprietary identifier"}, 1041 {RPCResult::Type::NUM, "subtype", "The number for the subtype"}, 1042 {RPCResult::Type::STR_HEX, "key", "The hex for the key"}, 1043 {RPCResult::Type::STR_HEX, "value", "The hex for the value"}, 1044 }}, 1045 }}, 1046 {RPCResult::Type::OBJ_DYN, "unknown", "The unknown global fields", 1047 { 1048 {RPCResult::Type::STR_HEX, "key", "(key-value pair) An unknown key-value pair"}, 1049 }}, 1050 decodepsbt_inputs, 1051 decodepsbt_outputs, 1052 {RPCResult::Type::STR_AMOUNT, "fee", /*optional=*/true, "The transaction fee paid if all UTXOs slots in the PSBT have been filled."}, 1053 } 1054 }, 1055 RPCExamples{ 1056 HelpExampleCli("decodepsbt", "\"psbt\"") 1057 }, 1058 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 1059 { 1060 // Unserialize the transactions 1061 PartiallySignedTransaction psbtx; 1062 std::string error; 1063 if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) { 1064 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", error)); 1065 } 1066 1067 UniValue result(UniValue::VOBJ); 1068 1069 // Add the decoded tx 1070 UniValue tx_univ(UniValue::VOBJ); 1071 TxToUniv(CTransaction(*psbtx.tx), /*block_hash=*/uint256(), /*entry=*/tx_univ, /*include_hex=*/false); 1072 result.pushKV("tx", tx_univ); 1073 1074 // Add the global xpubs 1075 UniValue global_xpubs(UniValue::VARR); 1076 for (std::pair<KeyOriginInfo, std::set<CExtPubKey>> xpub_pair : psbtx.m_xpubs) { 1077 for (auto& xpub : xpub_pair.second) { 1078 std::vector<unsigned char> ser_xpub; 1079 ser_xpub.assign(BIP32_EXTKEY_WITH_VERSION_SIZE, 0); 1080 xpub.EncodeWithVersion(ser_xpub.data()); 1081 1082 UniValue keypath(UniValue::VOBJ); 1083 keypath.pushKV("xpub", EncodeBase58Check(ser_xpub)); 1084 keypath.pushKV("master_fingerprint", HexStr(Span<unsigned char>(xpub_pair.first.fingerprint, xpub_pair.first.fingerprint + 4))); 1085 keypath.pushKV("path", WriteHDKeypath(xpub_pair.first.path)); 1086 global_xpubs.push_back(keypath); 1087 } 1088 } 1089 result.pushKV("global_xpubs", global_xpubs); 1090 1091 // PSBT version 1092 result.pushKV("psbt_version", static_cast<uint64_t>(psbtx.GetVersion())); 1093 1094 // Proprietary 1095 UniValue proprietary(UniValue::VARR); 1096 for (const auto& entry : psbtx.m_proprietary) { 1097 UniValue this_prop(UniValue::VOBJ); 1098 this_prop.pushKV("identifier", HexStr(entry.identifier)); 1099 this_prop.pushKV("subtype", entry.subtype); 1100 this_prop.pushKV("key", HexStr(entry.key)); 1101 this_prop.pushKV("value", HexStr(entry.value)); 1102 proprietary.push_back(this_prop); 1103 } 1104 result.pushKV("proprietary", proprietary); 1105 1106 // Unknown data 1107 UniValue unknowns(UniValue::VOBJ); 1108 for (auto entry : psbtx.unknown) { 1109 unknowns.pushKV(HexStr(entry.first), HexStr(entry.second)); 1110 } 1111 result.pushKV("unknown", unknowns); 1112 1113 // inputs 1114 CAmount total_in = 0; 1115 bool have_all_utxos = true; 1116 UniValue inputs(UniValue::VARR); 1117 for (unsigned int i = 0; i < psbtx.inputs.size(); ++i) { 1118 const PSBTInput& input = psbtx.inputs[i]; 1119 UniValue in(UniValue::VOBJ); 1120 // UTXOs 1121 bool have_a_utxo = false; 1122 CTxOut txout; 1123 if (!input.witness_utxo.IsNull()) { 1124 txout = input.witness_utxo; 1125 1126 UniValue o(UniValue::VOBJ); 1127 ScriptToUniv(txout.scriptPubKey, /*out=*/o, /*include_hex=*/true, /*include_address=*/true); 1128 1129 UniValue out(UniValue::VOBJ); 1130 out.pushKV("amount", ValueFromAmount(txout.nValue)); 1131 out.pushKV("scriptPubKey", o); 1132 1133 in.pushKV("witness_utxo", out); 1134 1135 have_a_utxo = true; 1136 } 1137 if (input.non_witness_utxo) { 1138 txout = input.non_witness_utxo->vout[psbtx.tx->vin[i].prevout.n]; 1139 1140 UniValue non_wit(UniValue::VOBJ); 1141 TxToUniv(*input.non_witness_utxo, /*block_hash=*/uint256(), /*entry=*/non_wit, /*include_hex=*/false); 1142 in.pushKV("non_witness_utxo", non_wit); 1143 1144 have_a_utxo = true; 1145 } 1146 if (have_a_utxo) { 1147 if (MoneyRange(txout.nValue) && MoneyRange(total_in + txout.nValue)) { 1148 total_in += txout.nValue; 1149 } else { 1150 // Hack to just not show fee later 1151 have_all_utxos = false; 1152 } 1153 } else { 1154 have_all_utxos = false; 1155 } 1156 1157 // Partial sigs 1158 if (!input.partial_sigs.empty()) { 1159 UniValue partial_sigs(UniValue::VOBJ); 1160 for (const auto& sig : input.partial_sigs) { 1161 partial_sigs.pushKV(HexStr(sig.second.first), HexStr(sig.second.second)); 1162 } 1163 in.pushKV("partial_signatures", partial_sigs); 1164 } 1165 1166 // Sighash 1167 if (input.sighash_type != std::nullopt) { 1168 in.pushKV("sighash", SighashToStr((unsigned char)*input.sighash_type)); 1169 } 1170 1171 // Redeem script and witness script 1172 if (!input.redeem_script.empty()) { 1173 UniValue r(UniValue::VOBJ); 1174 ScriptToUniv(input.redeem_script, /*out=*/r); 1175 in.pushKV("redeem_script", r); 1176 } 1177 if (!input.witness_script.empty()) { 1178 UniValue r(UniValue::VOBJ); 1179 ScriptToUniv(input.witness_script, /*out=*/r); 1180 in.pushKV("witness_script", r); 1181 } 1182 1183 // keypaths 1184 if (!input.hd_keypaths.empty()) { 1185 UniValue keypaths(UniValue::VARR); 1186 for (auto entry : input.hd_keypaths) { 1187 UniValue keypath(UniValue::VOBJ); 1188 keypath.pushKV("pubkey", HexStr(entry.first)); 1189 1190 keypath.pushKV("master_fingerprint", strprintf("%08x", ReadBE32(entry.second.fingerprint))); 1191 keypath.pushKV("path", WriteHDKeypath(entry.second.path)); 1192 keypaths.push_back(keypath); 1193 } 1194 in.pushKV("bip32_derivs", keypaths); 1195 } 1196 1197 // Final scriptSig and scriptwitness 1198 if (!input.final_script_sig.empty()) { 1199 UniValue scriptsig(UniValue::VOBJ); 1200 scriptsig.pushKV("asm", ScriptToAsmStr(input.final_script_sig, true)); 1201 scriptsig.pushKV("hex", HexStr(input.final_script_sig)); 1202 in.pushKV("final_scriptSig", scriptsig); 1203 } 1204 if (!input.final_script_witness.IsNull()) { 1205 UniValue txinwitness(UniValue::VARR); 1206 for (const auto& item : input.final_script_witness.stack) { 1207 txinwitness.push_back(HexStr(item)); 1208 } 1209 in.pushKV("final_scriptwitness", txinwitness); 1210 } 1211 1212 // Ripemd160 hash preimages 1213 if (!input.ripemd160_preimages.empty()) { 1214 UniValue ripemd160_preimages(UniValue::VOBJ); 1215 for (const auto& [hash, preimage] : input.ripemd160_preimages) { 1216 ripemd160_preimages.pushKV(HexStr(hash), HexStr(preimage)); 1217 } 1218 in.pushKV("ripemd160_preimages", ripemd160_preimages); 1219 } 1220 1221 // Sha256 hash preimages 1222 if (!input.sha256_preimages.empty()) { 1223 UniValue sha256_preimages(UniValue::VOBJ); 1224 for (const auto& [hash, preimage] : input.sha256_preimages) { 1225 sha256_preimages.pushKV(HexStr(hash), HexStr(preimage)); 1226 } 1227 in.pushKV("sha256_preimages", sha256_preimages); 1228 } 1229 1230 // Hash160 hash preimages 1231 if (!input.hash160_preimages.empty()) { 1232 UniValue hash160_preimages(UniValue::VOBJ); 1233 for (const auto& [hash, preimage] : input.hash160_preimages) { 1234 hash160_preimages.pushKV(HexStr(hash), HexStr(preimage)); 1235 } 1236 in.pushKV("hash160_preimages", hash160_preimages); 1237 } 1238 1239 // Hash256 hash preimages 1240 if (!input.hash256_preimages.empty()) { 1241 UniValue hash256_preimages(UniValue::VOBJ); 1242 for (const auto& [hash, preimage] : input.hash256_preimages) { 1243 hash256_preimages.pushKV(HexStr(hash), HexStr(preimage)); 1244 } 1245 in.pushKV("hash256_preimages", hash256_preimages); 1246 } 1247 1248 // Taproot key path signature 1249 if (!input.m_tap_key_sig.empty()) { 1250 in.pushKV("taproot_key_path_sig", HexStr(input.m_tap_key_sig)); 1251 } 1252 1253 // Taproot script path signatures 1254 if (!input.m_tap_script_sigs.empty()) { 1255 UniValue script_sigs(UniValue::VARR); 1256 for (const auto& [pubkey_leaf, sig] : input.m_tap_script_sigs) { 1257 const auto& [xonly, leaf_hash] = pubkey_leaf; 1258 UniValue sigobj(UniValue::VOBJ); 1259 sigobj.pushKV("pubkey", HexStr(xonly)); 1260 sigobj.pushKV("leaf_hash", HexStr(leaf_hash)); 1261 sigobj.pushKV("sig", HexStr(sig)); 1262 script_sigs.push_back(sigobj); 1263 } 1264 in.pushKV("taproot_script_path_sigs", script_sigs); 1265 } 1266 1267 // Taproot leaf scripts 1268 if (!input.m_tap_scripts.empty()) { 1269 UniValue tap_scripts(UniValue::VARR); 1270 for (const auto& [leaf, control_blocks] : input.m_tap_scripts) { 1271 const auto& [script, leaf_ver] = leaf; 1272 UniValue script_info(UniValue::VOBJ); 1273 script_info.pushKV("script", HexStr(script)); 1274 script_info.pushKV("leaf_ver", leaf_ver); 1275 UniValue control_blocks_univ(UniValue::VARR); 1276 for (const auto& control_block : control_blocks) { 1277 control_blocks_univ.push_back(HexStr(control_block)); 1278 } 1279 script_info.pushKV("control_blocks", control_blocks_univ); 1280 tap_scripts.push_back(script_info); 1281 } 1282 in.pushKV("taproot_scripts", tap_scripts); 1283 } 1284 1285 // Taproot bip32 keypaths 1286 if (!input.m_tap_bip32_paths.empty()) { 1287 UniValue keypaths(UniValue::VARR); 1288 for (const auto& [xonly, leaf_origin] : input.m_tap_bip32_paths) { 1289 const auto& [leaf_hashes, origin] = leaf_origin; 1290 UniValue path_obj(UniValue::VOBJ); 1291 path_obj.pushKV("pubkey", HexStr(xonly)); 1292 path_obj.pushKV("master_fingerprint", strprintf("%08x", ReadBE32(origin.fingerprint))); 1293 path_obj.pushKV("path", WriteHDKeypath(origin.path)); 1294 UniValue leaf_hashes_arr(UniValue::VARR); 1295 for (const auto& leaf_hash : leaf_hashes) { 1296 leaf_hashes_arr.push_back(HexStr(leaf_hash)); 1297 } 1298 path_obj.pushKV("leaf_hashes", leaf_hashes_arr); 1299 keypaths.push_back(path_obj); 1300 } 1301 in.pushKV("taproot_bip32_derivs", keypaths); 1302 } 1303 1304 // Taproot internal key 1305 if (!input.m_tap_internal_key.IsNull()) { 1306 in.pushKV("taproot_internal_key", HexStr(input.m_tap_internal_key)); 1307 } 1308 1309 // Write taproot merkle root 1310 if (!input.m_tap_merkle_root.IsNull()) { 1311 in.pushKV("taproot_merkle_root", HexStr(input.m_tap_merkle_root)); 1312 } 1313 1314 // Proprietary 1315 if (!input.m_proprietary.empty()) { 1316 UniValue proprietary(UniValue::VARR); 1317 for (const auto& entry : input.m_proprietary) { 1318 UniValue this_prop(UniValue::VOBJ); 1319 this_prop.pushKV("identifier", HexStr(entry.identifier)); 1320 this_prop.pushKV("subtype", entry.subtype); 1321 this_prop.pushKV("key", HexStr(entry.key)); 1322 this_prop.pushKV("value", HexStr(entry.value)); 1323 proprietary.push_back(this_prop); 1324 } 1325 in.pushKV("proprietary", proprietary); 1326 } 1327 1328 // Unknown data 1329 if (input.unknown.size() > 0) { 1330 UniValue unknowns(UniValue::VOBJ); 1331 for (auto entry : input.unknown) { 1332 unknowns.pushKV(HexStr(entry.first), HexStr(entry.second)); 1333 } 1334 in.pushKV("unknown", unknowns); 1335 } 1336 1337 inputs.push_back(in); 1338 } 1339 result.pushKV("inputs", inputs); 1340 1341 // outputs 1342 CAmount output_value = 0; 1343 UniValue outputs(UniValue::VARR); 1344 for (unsigned int i = 0; i < psbtx.outputs.size(); ++i) { 1345 const PSBTOutput& output = psbtx.outputs[i]; 1346 UniValue out(UniValue::VOBJ); 1347 // Redeem script and witness script 1348 if (!output.redeem_script.empty()) { 1349 UniValue r(UniValue::VOBJ); 1350 ScriptToUniv(output.redeem_script, /*out=*/r); 1351 out.pushKV("redeem_script", r); 1352 } 1353 if (!output.witness_script.empty()) { 1354 UniValue r(UniValue::VOBJ); 1355 ScriptToUniv(output.witness_script, /*out=*/r); 1356 out.pushKV("witness_script", r); 1357 } 1358 1359 // keypaths 1360 if (!output.hd_keypaths.empty()) { 1361 UniValue keypaths(UniValue::VARR); 1362 for (auto entry : output.hd_keypaths) { 1363 UniValue keypath(UniValue::VOBJ); 1364 keypath.pushKV("pubkey", HexStr(entry.first)); 1365 keypath.pushKV("master_fingerprint", strprintf("%08x", ReadBE32(entry.second.fingerprint))); 1366 keypath.pushKV("path", WriteHDKeypath(entry.second.path)); 1367 keypaths.push_back(keypath); 1368 } 1369 out.pushKV("bip32_derivs", keypaths); 1370 } 1371 1372 // Taproot internal key 1373 if (!output.m_tap_internal_key.IsNull()) { 1374 out.pushKV("taproot_internal_key", HexStr(output.m_tap_internal_key)); 1375 } 1376 1377 // Taproot tree 1378 if (!output.m_tap_tree.empty()) { 1379 UniValue tree(UniValue::VARR); 1380 for (const auto& [depth, leaf_ver, script] : output.m_tap_tree) { 1381 UniValue elem(UniValue::VOBJ); 1382 elem.pushKV("depth", (int)depth); 1383 elem.pushKV("leaf_ver", (int)leaf_ver); 1384 elem.pushKV("script", HexStr(script)); 1385 tree.push_back(elem); 1386 } 1387 out.pushKV("taproot_tree", tree); 1388 } 1389 1390 // Taproot bip32 keypaths 1391 if (!output.m_tap_bip32_paths.empty()) { 1392 UniValue keypaths(UniValue::VARR); 1393 for (const auto& [xonly, leaf_origin] : output.m_tap_bip32_paths) { 1394 const auto& [leaf_hashes, origin] = leaf_origin; 1395 UniValue path_obj(UniValue::VOBJ); 1396 path_obj.pushKV("pubkey", HexStr(xonly)); 1397 path_obj.pushKV("master_fingerprint", strprintf("%08x", ReadBE32(origin.fingerprint))); 1398 path_obj.pushKV("path", WriteHDKeypath(origin.path)); 1399 UniValue leaf_hashes_arr(UniValue::VARR); 1400 for (const auto& leaf_hash : leaf_hashes) { 1401 leaf_hashes_arr.push_back(HexStr(leaf_hash)); 1402 } 1403 path_obj.pushKV("leaf_hashes", leaf_hashes_arr); 1404 keypaths.push_back(path_obj); 1405 } 1406 out.pushKV("taproot_bip32_derivs", keypaths); 1407 } 1408 1409 // Proprietary 1410 if (!output.m_proprietary.empty()) { 1411 UniValue proprietary(UniValue::VARR); 1412 for (const auto& entry : output.m_proprietary) { 1413 UniValue this_prop(UniValue::VOBJ); 1414 this_prop.pushKV("identifier", HexStr(entry.identifier)); 1415 this_prop.pushKV("subtype", entry.subtype); 1416 this_prop.pushKV("key", HexStr(entry.key)); 1417 this_prop.pushKV("value", HexStr(entry.value)); 1418 proprietary.push_back(this_prop); 1419 } 1420 out.pushKV("proprietary", proprietary); 1421 } 1422 1423 // Unknown data 1424 if (output.unknown.size() > 0) { 1425 UniValue unknowns(UniValue::VOBJ); 1426 for (auto entry : output.unknown) { 1427 unknowns.pushKV(HexStr(entry.first), HexStr(entry.second)); 1428 } 1429 out.pushKV("unknown", unknowns); 1430 } 1431 1432 outputs.push_back(out); 1433 1434 // Fee calculation 1435 if (MoneyRange(psbtx.tx->vout[i].nValue) && MoneyRange(output_value + psbtx.tx->vout[i].nValue)) { 1436 output_value += psbtx.tx->vout[i].nValue; 1437 } else { 1438 // Hack to just not show fee later 1439 have_all_utxos = false; 1440 } 1441 } 1442 result.pushKV("outputs", outputs); 1443 if (have_all_utxos) { 1444 result.pushKV("fee", ValueFromAmount(total_in - output_value)); 1445 } 1446 1447 return result; 1448 }, 1449 }; 1450 } 1451 1452 static RPCHelpMan combinepsbt() 1453 { 1454 return RPCHelpMan{"combinepsbt", 1455 "\nCombine multiple partially signed Bitcoin transactions into one transaction.\n" 1456 "Implements the Combiner role.\n", 1457 { 1458 {"txs", RPCArg::Type::ARR, RPCArg::Optional::NO, "The base64 strings of partially signed transactions", 1459 { 1460 {"psbt", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "A base64 string of a PSBT"}, 1461 }, 1462 }, 1463 }, 1464 RPCResult{ 1465 RPCResult::Type::STR, "", "The base64-encoded partially signed transaction" 1466 }, 1467 RPCExamples{ 1468 HelpExampleCli("combinepsbt", R"('["mybase64_1", "mybase64_2", "mybase64_3"]')") 1469 }, 1470 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 1471 { 1472 // Unserialize the transactions 1473 std::vector<PartiallySignedTransaction> psbtxs; 1474 UniValue txs = request.params[0].get_array(); 1475 if (txs.empty()) { 1476 throw JSONRPCError(RPC_INVALID_PARAMETER, "Parameter 'txs' cannot be empty"); 1477 } 1478 for (unsigned int i = 0; i < txs.size(); ++i) { 1479 PartiallySignedTransaction psbtx; 1480 std::string error; 1481 if (!DecodeBase64PSBT(psbtx, txs[i].get_str(), error)) { 1482 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", error)); 1483 } 1484 psbtxs.push_back(psbtx); 1485 } 1486 1487 PartiallySignedTransaction merged_psbt; 1488 const TransactionError error = CombinePSBTs(merged_psbt, psbtxs); 1489 if (error != TransactionError::OK) { 1490 throw JSONRPCTransactionError(error); 1491 } 1492 1493 DataStream ssTx{}; 1494 ssTx << merged_psbt; 1495 return EncodeBase64(ssTx); 1496 }, 1497 }; 1498 } 1499 1500 static RPCHelpMan finalizepsbt() 1501 { 1502 return RPCHelpMan{"finalizepsbt", 1503 "Finalize the inputs of a PSBT. If the transaction is fully signed, it will produce a\n" 1504 "network serialized transaction which can be broadcast with sendrawtransaction. Otherwise a PSBT will be\n" 1505 "created which has the final_scriptSig and final_scriptWitness fields filled for inputs that are complete.\n" 1506 "Implements the Finalizer and Extractor roles.\n", 1507 { 1508 {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO, "A base64 string of a PSBT"}, 1509 {"extract", RPCArg::Type::BOOL, RPCArg::Default{true}, "If true and the transaction is complete,\n" 1510 " extract and return the complete transaction in normal network serialization instead of the PSBT."}, 1511 }, 1512 RPCResult{ 1513 RPCResult::Type::OBJ, "", "", 1514 { 1515 {RPCResult::Type::STR, "psbt", /*optional=*/true, "The base64-encoded partially signed transaction if not extracted"}, 1516 {RPCResult::Type::STR_HEX, "hex", /*optional=*/true, "The hex-encoded network transaction if extracted"}, 1517 {RPCResult::Type::BOOL, "complete", "If the transaction has a complete set of signatures"}, 1518 } 1519 }, 1520 RPCExamples{ 1521 HelpExampleCli("finalizepsbt", "\"psbt\"") 1522 }, 1523 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 1524 { 1525 // Unserialize the transactions 1526 PartiallySignedTransaction psbtx; 1527 std::string error; 1528 if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) { 1529 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", error)); 1530 } 1531 1532 bool extract = request.params[1].isNull() || (!request.params[1].isNull() && request.params[1].get_bool()); 1533 1534 CMutableTransaction mtx; 1535 bool complete = FinalizeAndExtractPSBT(psbtx, mtx); 1536 1537 UniValue result(UniValue::VOBJ); 1538 DataStream ssTx{}; 1539 std::string result_str; 1540 1541 if (complete && extract) { 1542 ssTx << TX_WITH_WITNESS(mtx); 1543 result_str = HexStr(ssTx); 1544 result.pushKV("hex", result_str); 1545 } else { 1546 ssTx << psbtx; 1547 result_str = EncodeBase64(ssTx.str()); 1548 result.pushKV("psbt", result_str); 1549 } 1550 result.pushKV("complete", complete); 1551 1552 return result; 1553 }, 1554 }; 1555 } 1556 1557 static RPCHelpMan createpsbt() 1558 { 1559 return RPCHelpMan{"createpsbt", 1560 "\nCreates a transaction in the Partially Signed Transaction format.\n" 1561 "Implements the Creator role.\n", 1562 CreateTxDoc(), 1563 RPCResult{ 1564 RPCResult::Type::STR, "", "The resulting raw transaction (base64-encoded string)" 1565 }, 1566 RPCExamples{ 1567 HelpExampleCli("createpsbt", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"") 1568 }, 1569 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 1570 { 1571 1572 std::optional<bool> rbf; 1573 if (!request.params[3].isNull()) { 1574 rbf = request.params[3].get_bool(); 1575 } 1576 CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2], rbf); 1577 1578 // Make a blank psbt 1579 PartiallySignedTransaction psbtx; 1580 psbtx.tx = rawTx; 1581 for (unsigned int i = 0; i < rawTx.vin.size(); ++i) { 1582 psbtx.inputs.emplace_back(); 1583 } 1584 for (unsigned int i = 0; i < rawTx.vout.size(); ++i) { 1585 psbtx.outputs.emplace_back(); 1586 } 1587 1588 // Serialize the PSBT 1589 DataStream ssTx{}; 1590 ssTx << psbtx; 1591 1592 return EncodeBase64(ssTx); 1593 }, 1594 }; 1595 } 1596 1597 static RPCHelpMan converttopsbt() 1598 { 1599 return RPCHelpMan{"converttopsbt", 1600 "\nConverts a network serialized transaction to a PSBT. This should be used only with createrawtransaction and fundrawtransaction\n" 1601 "createpsbt and walletcreatefundedpsbt should be used for new applications.\n", 1602 { 1603 {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex string of a raw transaction"}, 1604 {"permitsigdata", RPCArg::Type::BOOL, RPCArg::Default{false}, "If true, any signatures in the input will be discarded and conversion\n" 1605 " will continue. If false, RPC will fail if any signatures are present."}, 1606 {"iswitness", RPCArg::Type::BOOL, RPCArg::DefaultHint{"depends on heuristic tests"}, "Whether the transaction hex is a serialized witness transaction.\n" 1607 "If iswitness is not present, heuristic tests will be used in decoding.\n" 1608 "If true, only witness deserialization will be tried.\n" 1609 "If false, only non-witness deserialization will be tried.\n" 1610 "This boolean should reflect whether the transaction has inputs\n" 1611 "(e.g. fully valid, or on-chain transactions), if known by the caller." 1612 }, 1613 }, 1614 RPCResult{ 1615 RPCResult::Type::STR, "", "The resulting raw transaction (base64-encoded string)" 1616 }, 1617 RPCExamples{ 1618 "\nCreate a transaction\n" 1619 + HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"") + 1620 "\nConvert the transaction to a PSBT\n" 1621 + HelpExampleCli("converttopsbt", "\"rawtransaction\"") 1622 }, 1623 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 1624 { 1625 // parse hex string from parameter 1626 CMutableTransaction tx; 1627 bool permitsigdata = request.params[1].isNull() ? false : request.params[1].get_bool(); 1628 bool witness_specified = !request.params[2].isNull(); 1629 bool iswitness = witness_specified ? request.params[2].get_bool() : false; 1630 const bool try_witness = witness_specified ? iswitness : true; 1631 const bool try_no_witness = witness_specified ? !iswitness : true; 1632 if (!DecodeHexTx(tx, request.params[0].get_str(), try_no_witness, try_witness)) { 1633 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed"); 1634 } 1635 1636 // Remove all scriptSigs and scriptWitnesses from inputs 1637 for (CTxIn& input : tx.vin) { 1638 if ((!input.scriptSig.empty() || !input.scriptWitness.IsNull()) && !permitsigdata) { 1639 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Inputs must not have scriptSigs and scriptWitnesses"); 1640 } 1641 input.scriptSig.clear(); 1642 input.scriptWitness.SetNull(); 1643 } 1644 1645 // Make a blank psbt 1646 PartiallySignedTransaction psbtx; 1647 psbtx.tx = tx; 1648 for (unsigned int i = 0; i < tx.vin.size(); ++i) { 1649 psbtx.inputs.emplace_back(); 1650 } 1651 for (unsigned int i = 0; i < tx.vout.size(); ++i) { 1652 psbtx.outputs.emplace_back(); 1653 } 1654 1655 // Serialize the PSBT 1656 DataStream ssTx{}; 1657 ssTx << psbtx; 1658 1659 return EncodeBase64(ssTx); 1660 }, 1661 }; 1662 } 1663 1664 static RPCHelpMan utxoupdatepsbt() 1665 { 1666 return RPCHelpMan{"utxoupdatepsbt", 1667 "\nUpdates all segwit inputs and outputs in a PSBT with data from output descriptors, the UTXO set, txindex, or the mempool.\n", 1668 { 1669 {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO, "A base64 string of a PSBT"}, 1670 {"descriptors", RPCArg::Type::ARR, RPCArg::Optional::OMITTED, "An array of either strings or objects", { 1671 {"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "An output descriptor"}, 1672 {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "An object with an output descriptor and extra information", { 1673 {"desc", RPCArg::Type::STR, RPCArg::Optional::NO, "An output descriptor"}, 1674 {"range", RPCArg::Type::RANGE, RPCArg::Default{1000}, "Up to what index HD chains should be explored (either end or [begin,end])"}, 1675 }}, 1676 }}, 1677 }, 1678 RPCResult { 1679 RPCResult::Type::STR, "", "The base64-encoded partially signed transaction with inputs updated" 1680 }, 1681 RPCExamples { 1682 HelpExampleCli("utxoupdatepsbt", "\"psbt\"") 1683 }, 1684 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 1685 { 1686 // Parse descriptors, if any. 1687 FlatSigningProvider provider; 1688 if (!request.params[1].isNull()) { 1689 auto descs = request.params[1].get_array(); 1690 for (size_t i = 0; i < descs.size(); ++i) { 1691 EvalDescriptorStringOrObject(descs[i], provider); 1692 } 1693 } 1694 1695 // We don't actually need private keys further on; hide them as a precaution. 1696 const PartiallySignedTransaction& psbtx = ProcessPSBT( 1697 request.params[0].get_str(), 1698 request.context, 1699 HidingSigningProvider(&provider, /*hide_secret=*/true, /*hide_origin=*/false), 1700 /*sighash_type=*/SIGHASH_ALL, 1701 /*finalize=*/false); 1702 1703 DataStream ssTx{}; 1704 ssTx << psbtx; 1705 return EncodeBase64(ssTx); 1706 }, 1707 }; 1708 } 1709 1710 static RPCHelpMan joinpsbts() 1711 { 1712 return RPCHelpMan{"joinpsbts", 1713 "\nJoins multiple distinct PSBTs with different inputs and outputs into one PSBT with inputs and outputs from all of the PSBTs\n" 1714 "No input in any of the PSBTs can be in more than one of the PSBTs.\n", 1715 { 1716 {"txs", RPCArg::Type::ARR, RPCArg::Optional::NO, "The base64 strings of partially signed transactions", 1717 { 1718 {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO, "A base64 string of a PSBT"} 1719 }} 1720 }, 1721 RPCResult { 1722 RPCResult::Type::STR, "", "The base64-encoded partially signed transaction" 1723 }, 1724 RPCExamples { 1725 HelpExampleCli("joinpsbts", "\"psbt\"") 1726 }, 1727 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 1728 { 1729 // Unserialize the transactions 1730 std::vector<PartiallySignedTransaction> psbtxs; 1731 UniValue txs = request.params[0].get_array(); 1732 1733 if (txs.size() <= 1) { 1734 throw JSONRPCError(RPC_INVALID_PARAMETER, "At least two PSBTs are required to join PSBTs."); 1735 } 1736 1737 uint32_t best_version = 1; 1738 uint32_t best_locktime = 0xffffffff; 1739 for (unsigned int i = 0; i < txs.size(); ++i) { 1740 PartiallySignedTransaction psbtx; 1741 std::string error; 1742 if (!DecodeBase64PSBT(psbtx, txs[i].get_str(), error)) { 1743 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", error)); 1744 } 1745 psbtxs.push_back(psbtx); 1746 // Choose the highest version number 1747 if (static_cast<uint32_t>(psbtx.tx->nVersion) > best_version) { 1748 best_version = static_cast<uint32_t>(psbtx.tx->nVersion); 1749 } 1750 // Choose the lowest lock time 1751 if (psbtx.tx->nLockTime < best_locktime) { 1752 best_locktime = psbtx.tx->nLockTime; 1753 } 1754 } 1755 1756 // Create a blank psbt where everything will be added 1757 PartiallySignedTransaction merged_psbt; 1758 merged_psbt.tx = CMutableTransaction(); 1759 merged_psbt.tx->nVersion = static_cast<int32_t>(best_version); 1760 merged_psbt.tx->nLockTime = best_locktime; 1761 1762 // Merge 1763 for (auto& psbt : psbtxs) { 1764 for (unsigned int i = 0; i < psbt.tx->vin.size(); ++i) { 1765 if (!merged_psbt.AddInput(psbt.tx->vin[i], psbt.inputs[i])) { 1766 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Input %s:%d exists in multiple PSBTs", psbt.tx->vin[i].prevout.hash.ToString(), psbt.tx->vin[i].prevout.n)); 1767 } 1768 } 1769 for (unsigned int i = 0; i < psbt.tx->vout.size(); ++i) { 1770 merged_psbt.AddOutput(psbt.tx->vout[i], psbt.outputs[i]); 1771 } 1772 for (auto& xpub_pair : psbt.m_xpubs) { 1773 if (merged_psbt.m_xpubs.count(xpub_pair.first) == 0) { 1774 merged_psbt.m_xpubs[xpub_pair.first] = xpub_pair.second; 1775 } else { 1776 merged_psbt.m_xpubs[xpub_pair.first].insert(xpub_pair.second.begin(), xpub_pair.second.end()); 1777 } 1778 } 1779 merged_psbt.unknown.insert(psbt.unknown.begin(), psbt.unknown.end()); 1780 } 1781 1782 // Generate list of shuffled indices for shuffling inputs and outputs of the merged PSBT 1783 std::vector<int> input_indices(merged_psbt.inputs.size()); 1784 std::iota(input_indices.begin(), input_indices.end(), 0); 1785 std::vector<int> output_indices(merged_psbt.outputs.size()); 1786 std::iota(output_indices.begin(), output_indices.end(), 0); 1787 1788 // Shuffle input and output indices lists 1789 Shuffle(input_indices.begin(), input_indices.end(), FastRandomContext()); 1790 Shuffle(output_indices.begin(), output_indices.end(), FastRandomContext()); 1791 1792 PartiallySignedTransaction shuffled_psbt; 1793 shuffled_psbt.tx = CMutableTransaction(); 1794 shuffled_psbt.tx->nVersion = merged_psbt.tx->nVersion; 1795 shuffled_psbt.tx->nLockTime = merged_psbt.tx->nLockTime; 1796 for (int i : input_indices) { 1797 shuffled_psbt.AddInput(merged_psbt.tx->vin[i], merged_psbt.inputs[i]); 1798 } 1799 for (int i : output_indices) { 1800 shuffled_psbt.AddOutput(merged_psbt.tx->vout[i], merged_psbt.outputs[i]); 1801 } 1802 shuffled_psbt.unknown.insert(merged_psbt.unknown.begin(), merged_psbt.unknown.end()); 1803 1804 DataStream ssTx{}; 1805 ssTx << shuffled_psbt; 1806 return EncodeBase64(ssTx); 1807 }, 1808 }; 1809 } 1810 1811 static RPCHelpMan analyzepsbt() 1812 { 1813 return RPCHelpMan{"analyzepsbt", 1814 "\nAnalyzes and provides information about the current status of a PSBT and its inputs\n", 1815 { 1816 {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO, "A base64 string of a PSBT"} 1817 }, 1818 RPCResult { 1819 RPCResult::Type::OBJ, "", "", 1820 { 1821 {RPCResult::Type::ARR, "inputs", /*optional=*/true, "", 1822 { 1823 {RPCResult::Type::OBJ, "", "", 1824 { 1825 {RPCResult::Type::BOOL, "has_utxo", "Whether a UTXO is provided"}, 1826 {RPCResult::Type::BOOL, "is_final", "Whether the input is finalized"}, 1827 {RPCResult::Type::OBJ, "missing", /*optional=*/true, "Things that are missing that are required to complete this input", 1828 { 1829 {RPCResult::Type::ARR, "pubkeys", /*optional=*/true, "", 1830 { 1831 {RPCResult::Type::STR_HEX, "keyid", "Public key ID, hash160 of the public key, of a public key whose BIP 32 derivation path is missing"}, 1832 }}, 1833 {RPCResult::Type::ARR, "signatures", /*optional=*/true, "", 1834 { 1835 {RPCResult::Type::STR_HEX, "keyid", "Public key ID, hash160 of the public key, of a public key whose signature is missing"}, 1836 }}, 1837 {RPCResult::Type::STR_HEX, "redeemscript", /*optional=*/true, "Hash160 of the redeemScript that is missing"}, 1838 {RPCResult::Type::STR_HEX, "witnessscript", /*optional=*/true, "SHA256 of the witnessScript that is missing"}, 1839 }}, 1840 {RPCResult::Type::STR, "next", /*optional=*/true, "Role of the next person that this input needs to go to"}, 1841 }}, 1842 }}, 1843 {RPCResult::Type::NUM, "estimated_vsize", /*optional=*/true, "Estimated vsize of the final signed transaction"}, 1844 {RPCResult::Type::STR_AMOUNT, "estimated_feerate", /*optional=*/true, "Estimated feerate of the final signed transaction in " + CURRENCY_UNIT + "/kvB. Shown only if all UTXO slots in the PSBT have been filled"}, 1845 {RPCResult::Type::STR_AMOUNT, "fee", /*optional=*/true, "The transaction fee paid. Shown only if all UTXO slots in the PSBT have been filled"}, 1846 {RPCResult::Type::STR, "next", "Role of the next person that this psbt needs to go to"}, 1847 {RPCResult::Type::STR, "error", /*optional=*/true, "Error message (if there is one)"}, 1848 } 1849 }, 1850 RPCExamples { 1851 HelpExampleCli("analyzepsbt", "\"psbt\"") 1852 }, 1853 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 1854 { 1855 // Unserialize the transaction 1856 PartiallySignedTransaction psbtx; 1857 std::string error; 1858 if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) { 1859 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", error)); 1860 } 1861 1862 PSBTAnalysis psbta = AnalyzePSBT(psbtx); 1863 1864 UniValue result(UniValue::VOBJ); 1865 UniValue inputs_result(UniValue::VARR); 1866 for (const auto& input : psbta.inputs) { 1867 UniValue input_univ(UniValue::VOBJ); 1868 UniValue missing(UniValue::VOBJ); 1869 1870 input_univ.pushKV("has_utxo", input.has_utxo); 1871 input_univ.pushKV("is_final", input.is_final); 1872 input_univ.pushKV("next", PSBTRoleName(input.next)); 1873 1874 if (!input.missing_pubkeys.empty()) { 1875 UniValue missing_pubkeys_univ(UniValue::VARR); 1876 for (const CKeyID& pubkey : input.missing_pubkeys) { 1877 missing_pubkeys_univ.push_back(HexStr(pubkey)); 1878 } 1879 missing.pushKV("pubkeys", missing_pubkeys_univ); 1880 } 1881 if (!input.missing_redeem_script.IsNull()) { 1882 missing.pushKV("redeemscript", HexStr(input.missing_redeem_script)); 1883 } 1884 if (!input.missing_witness_script.IsNull()) { 1885 missing.pushKV("witnessscript", HexStr(input.missing_witness_script)); 1886 } 1887 if (!input.missing_sigs.empty()) { 1888 UniValue missing_sigs_univ(UniValue::VARR); 1889 for (const CKeyID& pubkey : input.missing_sigs) { 1890 missing_sigs_univ.push_back(HexStr(pubkey)); 1891 } 1892 missing.pushKV("signatures", missing_sigs_univ); 1893 } 1894 if (!missing.getKeys().empty()) { 1895 input_univ.pushKV("missing", missing); 1896 } 1897 inputs_result.push_back(input_univ); 1898 } 1899 if (!inputs_result.empty()) result.pushKV("inputs", inputs_result); 1900 1901 if (psbta.estimated_vsize != std::nullopt) { 1902 result.pushKV("estimated_vsize", (int)*psbta.estimated_vsize); 1903 } 1904 if (psbta.estimated_feerate != std::nullopt) { 1905 result.pushKV("estimated_feerate", ValueFromAmount(psbta.estimated_feerate->GetFeePerK())); 1906 } 1907 if (psbta.fee != std::nullopt) { 1908 result.pushKV("fee", ValueFromAmount(*psbta.fee)); 1909 } 1910 result.pushKV("next", PSBTRoleName(psbta.next)); 1911 if (!psbta.error.empty()) { 1912 result.pushKV("error", psbta.error); 1913 } 1914 1915 return result; 1916 }, 1917 }; 1918 } 1919 1920 RPCHelpMan descriptorprocesspsbt() 1921 { 1922 return RPCHelpMan{"descriptorprocesspsbt", 1923 "\nUpdate all segwit inputs in a PSBT with information from output descriptors, the UTXO set or the mempool. \n" 1924 "Then, sign the inputs we are able to with information from the output descriptors. ", 1925 { 1926 {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO, "The transaction base64 string"}, 1927 {"descriptors", RPCArg::Type::ARR, RPCArg::Optional::NO, "An array of either strings or objects", { 1928 {"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "An output descriptor"}, 1929 {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "An object with an output descriptor and extra information", { 1930 {"desc", RPCArg::Type::STR, RPCArg::Optional::NO, "An output descriptor"}, 1931 {"range", RPCArg::Type::RANGE, RPCArg::Default{1000}, "Up to what index HD chains should be explored (either end or [begin,end])"}, 1932 }}, 1933 }}, 1934 {"sighashtype", RPCArg::Type::STR, RPCArg::Default{"DEFAULT for Taproot, ALL otherwise"}, "The signature hash type to sign with if not specified by the PSBT. Must be one of\n" 1935 " \"DEFAULT\"\n" 1936 " \"ALL\"\n" 1937 " \"NONE\"\n" 1938 " \"SINGLE\"\n" 1939 " \"ALL|ANYONECANPAY\"\n" 1940 " \"NONE|ANYONECANPAY\"\n" 1941 " \"SINGLE|ANYONECANPAY\""}, 1942 {"bip32derivs", RPCArg::Type::BOOL, RPCArg::Default{true}, "Include BIP 32 derivation paths for public keys if we know them"}, 1943 {"finalize", RPCArg::Type::BOOL, RPCArg::Default{true}, "Also finalize inputs if possible"}, 1944 }, 1945 RPCResult{ 1946 RPCResult::Type::OBJ, "", "", 1947 { 1948 {RPCResult::Type::STR, "psbt", "The base64-encoded partially signed transaction"}, 1949 {RPCResult::Type::BOOL, "complete", "If the transaction has a complete set of signatures"}, 1950 {RPCResult::Type::STR_HEX, "hex", /*optional=*/true, "The hex-encoded network transaction if complete"}, 1951 } 1952 }, 1953 RPCExamples{ 1954 HelpExampleCli("descriptorprocesspsbt", "\"psbt\" \"[\\\"descriptor1\\\", \\\"descriptor2\\\"]\"") + 1955 HelpExampleCli("descriptorprocesspsbt", "\"psbt\" \"[{\\\"desc\\\":\\\"mydescriptor\\\", \\\"range\\\":21}]\"") 1956 }, 1957 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue 1958 { 1959 // Add descriptor information to a signing provider 1960 FlatSigningProvider provider; 1961 1962 auto descs = request.params[1].get_array(); 1963 for (size_t i = 0; i < descs.size(); ++i) { 1964 EvalDescriptorStringOrObject(descs[i], provider, /*expand_priv=*/true); 1965 } 1966 1967 int sighash_type = ParseSighashString(request.params[2]); 1968 bool bip32derivs = request.params[3].isNull() ? true : request.params[3].get_bool(); 1969 bool finalize = request.params[4].isNull() ? true : request.params[4].get_bool(); 1970 1971 const PartiallySignedTransaction& psbtx = ProcessPSBT( 1972 request.params[0].get_str(), 1973 request.context, 1974 HidingSigningProvider(&provider, /*hide_secret=*/false, !bip32derivs), 1975 sighash_type, 1976 finalize); 1977 1978 // Check whether or not all of the inputs are now signed 1979 bool complete = true; 1980 for (const auto& input : psbtx.inputs) { 1981 complete &= PSBTInputSigned(input); 1982 } 1983 1984 DataStream ssTx{}; 1985 ssTx << psbtx; 1986 1987 UniValue result(UniValue::VOBJ); 1988 1989 result.pushKV("psbt", EncodeBase64(ssTx)); 1990 result.pushKV("complete", complete); 1991 if (complete) { 1992 CMutableTransaction mtx; 1993 PartiallySignedTransaction psbtx_copy = psbtx; 1994 CHECK_NONFATAL(FinalizeAndExtractPSBT(psbtx_copy, mtx)); 1995 DataStream ssTx_final; 1996 ssTx_final << TX_WITH_WITNESS(mtx); 1997 result.pushKV("hex", HexStr(ssTx_final)); 1998 } 1999 return result; 2000 }, 2001 }; 2002 } 2003 2004 void RegisterRawTransactionRPCCommands(CRPCTable& t) 2005 { 2006 static const CRPCCommand commands[]{ 2007 {"rawtransactions", &getrawtransaction}, 2008 {"rawtransactions", &createrawtransaction}, 2009 {"rawtransactions", &decoderawtransaction}, 2010 {"rawtransactions", &decodescript}, 2011 {"rawtransactions", &combinerawtransaction}, 2012 {"rawtransactions", &signrawtransactionwithkey}, 2013 {"rawtransactions", &decodepsbt}, 2014 {"rawtransactions", &combinepsbt}, 2015 {"rawtransactions", &finalizepsbt}, 2016 {"rawtransactions", &createpsbt}, 2017 {"rawtransactions", &converttopsbt}, 2018 {"rawtransactions", &utxoupdatepsbt}, 2019 {"rawtransactions", &descriptorprocesspsbt}, 2020 {"rawtransactions", &joinpsbts}, 2021 {"rawtransactions", &analyzepsbt}, 2022 }; 2023 for (const auto& c : commands) { 2024 t.appendCommand(c.name, &c); 2025 } 2026 }