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