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