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