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