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