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