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