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