82 entry.
pushKV(
"confirmations", 0);
87static std::vector<RPCResult>
DecodeTxDoc(
const std::string& txid_field_doc)
93 {
RPCResult::Type::NUM,
"vsize",
"The virtual transaction size (differs from size for witness transactions)"},
143 "Each key may only appear once, i.e. there can only be one 'data' output, and no address may be duplicated.\n"
144 "At least one output of either type must be specified.\n"
145 "For compatibility reasons, a dictionary, which holds the key-value pairs directly, is also\n"
146 " accepted as second parameter.",
162 "Allows this transaction to be replaced by a transaction with higher fees. If provided, it is an error if explicit sequence numbers are incompatible."},
184 std::map<COutPoint, Coin> coins;
188 for (
unsigned int i = 0; i < psbtx.
tx->vin.size(); ++i) {
190 const CTxIn& tx_in = psbtx.
tx->vin.at(i);
214 if (!coins.empty()) {
216 for (
unsigned int i = 0; i < psbtx.
tx->vin.size(); ++i) {
221 const CTxIn& tx_in = psbtx.
tx->vin.at(i);
232 for (
unsigned int i = 0; i < psbtx.
tx->vin.size(); ++i) {
248 for (
unsigned int i = 0; i < psbtx.
tx->vout.size(); ++i) {
262 "By default, this call only returns a transaction if it is in the mempool. If -txindex is enabled\n"
263 "and no blockhash argument is passed, it will return the transaction if it is in the mempool or any block.\n"
264 "If a blockhash argument is passed, it will return the transaction if\n"
265 "the specified block is available and the transaction is in that block.\n\n"
266 "Hint: Use gettransaction for wallet transactions.\n\n"
268 "If verbosity is 0 or omitted, returns the serialized transaction as a hex-encoded string.\n"
269 "If verbosity is 1, returns a JSON Object with information about the transaction.\n"
270 "If verbosity is 2, returns a JSON Object with information about the transaction, including fee and prevout information.",
278 RPCResult{
"if verbosity is not set or set to 0",
283 Cat<std::vector<RPCResult>>(
285 {
RPCResult::Type::BOOL,
"in_active_chain",
true,
"Whether specified block is in the active chain or not (only present with explicit \"blockhash\" argument)"},
292 DecodeTxDoc(
"The transaction id (same as provided)")),
304 {
RPCResult::Type::OBJ,
"prevout",
true,
"The previous output, omitted if block undo data is not available",
319 +
HelpExampleCli(
"getrawtransaction",
"\"mytxid\" 0 \"myblockhash\"")
320 +
HelpExampleCli(
"getrawtransaction",
"\"mytxid\" 1 \"myblockhash\"")
321 +
HelpExampleCli(
"getrawtransaction",
"\"mytxid\" 2 \"myblockhash\"")
338 if (!request.params[2].isNull()) {
348 bool f_txindex_ready =
false;
350 f_txindex_ready =
g_txindex->BlockUntilSyncedToCurrentChain();
359 if (!block_has_data) {
362 errmsg =
"No such transaction found in the provided block";
364 errmsg =
"No such mempool transaction. Use -txindex or provide a block hash to enable blockchain transaction queries";
365 }
else if (!f_txindex_ready) {
366 errmsg =
"No such mempool transaction. Blockchain transactions are still in the process of being indexed";
368 errmsg =
"No such mempool or blockchain transaction";
373 if (verbosity <= 0) {
383 if (request.params[2].isNull()) {
387 if (verbosity == 1) {
400 throw JSONRPCError(
RPC_INTERNAL_ERROR,
"Undo data expected but can't be read. This could be due to disk corruption or a conflict with a pruning event.");
403 throw JSONRPCError(
RPC_INTERNAL_ERROR,
"Block data expected but can't be read. This could be due to disk corruption or a conflict with a pruning event.");
408 if (it != block.
vtx.end()) {
410 undoTX = &blockUndo.
vtxundo.at(it - block.
vtx.begin() - 1);
421 "createrawtransaction",
422 "Create a transaction spending the given inputs and creating new outputs.\n"
423 "Outputs can be addresses or data.\n"
424 "Returns hex-encoded raw transaction.\n"
425 "Note that the transaction's inputs are not signed, and\n"
426 "it is not stored in the wallet or transmitted to the network.\n",
432 HelpExampleCli(
"createrawtransaction",
"\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"address\\\":0.01}]\"")
433 +
HelpExampleCli(
"createrawtransaction",
"\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"")
434 +
HelpExampleRpc(
"createrawtransaction",
"\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\", \"[{\\\"address\\\":0.01}]\"")
435 +
HelpExampleRpc(
"createrawtransaction",
"\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\", \"[{\\\"data\\\":\\\"00010203\\\"}]\"")
439 std::optional<bool> rbf;
440 if (!request.params[3].isNull()) {
453 "Return a JSON object representing the serialized, hex-encoded transaction.",
457 "If iswitness is not present, heuristic tests will be used in decoding.\n"
458 "If true, only witness deserialization will be tried.\n"
459 "If false, only non-witness deserialization will be tried.\n"
460 "This boolean should reflect whether the transaction has inputs\n"
461 "(e.g. fully valid, or on-chain transactions), if known by the caller."
476 bool try_witness = request.params[1].isNull() ? true : request.params[1].get_bool();
477 bool try_no_witness = request.params[1].isNull() ? true : !request.params[1].get_bool();
479 if (!
DecodeHexTx(mtx, request.params[0].get_str(), try_no_witness, try_witness)) {
495 "Decode a hex-encoded script.\n",
505 {
RPCResult::Type::STR,
"address",
true,
"The Bitcoin address (only if a well-defined address exists)"},
507 "address of P2SH script wrapping this redeem script (not returned for types that should not be wrapped)"},
509 "Result of a witness output script wrapping this redeem script (not returned for types that should not be wrapped)",
513 {
RPCResult::Type::STR,
"type",
"The type of the output script (e.g. witness_v0_keyhash or witness_v0_scripthash)"},
514 {
RPCResult::Type::STR,
"address",
true,
"The Bitcoin address (only if a well-defined address exists)"},
516 {
RPCResult::Type::STR,
"p2sh-segwit",
"address of the P2SH script wrapping this witness redeem script"},
528 if (request.params[0].get_str().size() > 0){
529 std::vector<unsigned char> scriptData(
ParseHexV(request.params[0],
"argument"));
536 std::vector<std::vector<unsigned char>> solutions_data;
539 const bool can_wrap{[&] {
540 switch (which_type) {
574 const bool can_wrap_P2WSH{[&] {
575 switch (which_type) {
580 for (
const auto& solution : solutions_data) {
602 if (can_wrap_P2WSH) {
617 r.
pushKV(
"segwit", std::move(sr));
629 "combinerawtransaction",
630 "Combine multiple partially signed transactions into one transaction.\n"
631 "The combined transaction may be another partially signed transaction or a \n"
632 "fully signed transaction.",
644 HelpExampleCli(
"combinerawtransaction", R
"('["myhex1", "myhex2", "myhex3"]')")
650 std::vector<CMutableTransaction> txVariants(txs.
size());
652 for (
unsigned int idx = 0; idx < txs.
size(); idx++) {
653 if (!
DecodeHexTx(txVariants[idx], txs[idx].get_str())) {
658 if (txVariants.empty()) {
678 for (
const CTxIn& txin : mergedTx.
vin) {
689 for (
unsigned int i = 0; i < mergedTx.
vin.size(); i++) {
699 if (txv.vin.size() > i) {
716 "signrawtransactionwithkey",
717 "Sign inputs for raw transaction (serialized, hex-encoded).\n"
718 "The second argument is an array of base58-encoded private\n"
719 "keys that will be the only keys used to sign the transaction.\n"
720 "The third optional argument (may be null) is an array of previous transaction outputs that\n"
721 "this transaction depends on but may not yet be in the block chain.\n",
748 " \"ALL|ANYONECANPAY\"\n"
749 " \"NONE|ANYONECANPAY\"\n"
750 " \"SINGLE|ANYONECANPAY\"\n"
776 HelpExampleCli(
"signrawtransactionwithkey",
"\"myhex\" \"[\\\"key1\\\",\\\"key2\\\"]\"")
777 +
HelpExampleRpc(
"signrawtransactionwithkey",
"\"myhex\", \"[\\\"key1\\\",\\\"key2\\\"]\"")
782 if (!
DecodeHexTx(mtx, request.params[0].get_str())) {
788 for (
unsigned int idx = 0; idx < keys.
size(); ++idx) {
797 keystore.
pubkeys.emplace(key_id, pubkey);
798 keystore.
keys.emplace(key_id, key);
802 std::map<COutPoint, Coin> coins;
824 {
RPCResult::Type::OBJ,
"non_witness_utxo",
true,
"Decoded network transaction for non-witness UTXOs",
837 {
RPCResult::Type::STR,
"address",
true,
"The Bitcoin address (only if a well-defined address exists)"},
894 {
RPCResult::Type::OBJ,
"signature",
true,
"The signature for the pubkey and leaf hash combination",
932 {
RPCResult::Type::STR_HEX,
"aggregate_pubkey",
"The compressed aggregate public key for which the participants create."},
943 {
RPCResult::Type::STR_HEX,
"participant_pubkey",
"The compressed public key of the participant that created this pubnonce."},
944 {
RPCResult::Type::STR_HEX,
"aggregate_pubkey",
"The compressed aggregate public key for which this pubnonce is for."},
945 {
RPCResult::Type::STR_HEX,
"leaf_hash",
true,
"The hash of the leaf script that contains the aggregate pubkey being signed for. Omitted when signing for the internal key."},
953 {
RPCResult::Type::STR_HEX,
"participant_pubkey",
"The compressed public key of the participant that created this partial signature."},
954 {
RPCResult::Type::STR_HEX,
"aggregate_pubkey",
"The compressed aggregate public key for which this partial signature is for."},
955 {
RPCResult::Type::STR_HEX,
"leaf_hash",
true,
"The hash of the leaf script that contains the aggregate pubkey being signed for. Omitted when signing for the internal key."},
1004 {
RPCResult::Type::ARR,
"taproot_tree",
true,
"The tuples that make up the Taproot tree, in depth first search order",
1030 {
RPCResult::Type::STR_HEX,
"aggregate_pubkey",
"The compressed aggregate public key for which the participants create."},
1059 "Return a JSON object representing the serialized, base64-encoded partially signed Bitcoin transaction.",
1079 {
RPCResult::Type::NUM,
"psbt_version",
"The PSBT version number. Not to be confused with the unsigned transaction version"},
1116 result.
pushKV(
"tx", std::move(tx_univ));
1121 for (
auto& xpub : xpub_pair.second) {
1122 std::vector<unsigned char> ser_xpub;
1124 xpub.EncodeWithVersion(ser_xpub.data());
1128 keypath.
pushKV(
"master_fingerprint",
HexStr(std::span<unsigned char>(xpub_pair.first.fingerprint, xpub_pair.first.fingerprint + 4)));
1130 global_xpubs.
push_back(std::move(keypath));
1133 result.
pushKV(
"global_xpubs", std::move(global_xpubs));
1142 this_prop.
pushKV(
"identifier",
HexStr(entry.identifier));
1143 this_prop.
pushKV(
"subtype", entry.subtype);
1146 proprietary.
push_back(std::move(this_prop));
1148 result.
pushKV(
"proprietary", std::move(proprietary));
1152 for (
auto entry : psbtx.
unknown) {
1155 result.
pushKV(
"unknown", std::move(unknowns));
1159 bool have_all_utxos =
true;
1161 for (
unsigned int i = 0; i < psbtx.
inputs.size(); ++i) {
1165 bool have_a_utxo =
false;
1175 out.pushKV(
"scriptPubKey", std::move(o));
1177 in.
pushKV(
"witness_utxo", std::move(
out));
1186 in.
pushKV(
"non_witness_utxo", std::move(non_wit));
1192 total_in += txout.
nValue;
1195 have_all_utxos =
false;
1198 have_all_utxos =
false;
1207 in.
pushKV(
"partial_signatures", std::move(partial_sigs));
1219 in.
pushKV(
"redeem_script", std::move(r));
1224 in.
pushKV(
"witness_script", std::move(r));
1238 in.
pushKV(
"bip32_derivs", std::move(keypaths));
1246 in.
pushKV(
"final_scriptSig", std::move(scriptsig));
1253 in.
pushKV(
"final_scriptwitness", std::move(txinwitness));
1262 in.
pushKV(
"ripemd160_preimages", std::move(ripemd160_preimages));
1271 in.
pushKV(
"sha256_preimages", std::move(sha256_preimages));
1280 in.
pushKV(
"hash160_preimages", std::move(hash160_preimages));
1289 in.
pushKV(
"hash256_preimages", std::move(hash256_preimages));
1301 const auto& [xonly, leaf_hash] = pubkey_leaf;
1306 script_sigs.
push_back(std::move(sigobj));
1308 in.
pushKV(
"taproot_script_path_sigs", std::move(script_sigs));
1314 for (
const auto& [leaf, control_blocks] : input.
m_tap_scripts) {
1315 const auto& [
script, leaf_ver] = leaf;
1318 script_info.
pushKV(
"leaf_ver", leaf_ver);
1320 for (
const auto& control_block : control_blocks) {
1323 script_info.
pushKV(
"control_blocks", std::move(control_blocks_univ));
1324 tap_scripts.
push_back(std::move(script_info));
1326 in.
pushKV(
"taproot_scripts", std::move(tap_scripts));
1333 const auto& [leaf_hashes, origin] = leaf_origin;
1339 for (
const auto& leaf_hash : leaf_hashes) {
1342 path_obj.
pushKV(
"leaf_hashes", std::move(leaf_hashes_arr));
1343 keypaths.
push_back(std::move(path_obj));
1345 in.
pushKV(
"taproot_bip32_derivs", std::move(keypaths));
1365 for (
const auto& pub : parts) {
1368 musig_part.
pushKV(
"participant_pubkeys", part_pubkeys);
1371 in.
pushKV(
"musig2_participant_pubkeys", musig_pubkeys);
1376 const auto& [agg, lh] = agg_lh;
1377 for (
const auto& [part, pubnonce] : part_pubnonce) {
1381 if (!lh.IsNull()) info.
pushKV(
"leaf_hash",
HexStr(lh));
1386 in.
pushKV(
"musig2_pubnonces", musig_pubnonces);
1391 const auto& [agg, lh] = agg_lh;
1392 for (
const auto& [part, psig] : part_psig) {
1396 if (!lh.IsNull()) info.
pushKV(
"leaf_hash",
HexStr(lh));
1401 in.
pushKV(
"musig2_partial_sigs", musig_partial_sigs);
1409 this_prop.
pushKV(
"identifier",
HexStr(entry.identifier));
1410 this_prop.
pushKV(
"subtype", entry.subtype);
1413 proprietary.
push_back(std::move(this_prop));
1415 in.
pushKV(
"proprietary", std::move(proprietary));
1419 if (input.
unknown.size() > 0) {
1421 for (
auto entry : input.
unknown) {
1424 in.
pushKV(
"unknown", std::move(unknowns));
1429 result.
pushKV(
"inputs", std::move(inputs));
1434 for (
unsigned int i = 0; i < psbtx.
outputs.size(); ++i) {
1441 out.pushKV(
"redeem_script", std::move(r));
1446 out.pushKV(
"witness_script", std::move(r));
1459 out.pushKV(
"bip32_derivs", std::move(keypaths));
1472 elem.
pushKV(
"depth", (
int)depth);
1473 elem.
pushKV(
"leaf_ver", (
int)leaf_ver);
1477 out.pushKV(
"taproot_tree", std::move(tree));
1484 const auto& [leaf_hashes, origin] = leaf_origin;
1490 for (
const auto& leaf_hash : leaf_hashes) {
1493 path_obj.
pushKV(
"leaf_hashes", std::move(leaf_hashes_arr));
1494 keypaths.
push_back(std::move(path_obj));
1496 out.pushKV(
"taproot_bip32_derivs", std::move(keypaths));
1506 for (
const auto& pub : parts) {
1509 musig_part.
pushKV(
"participant_pubkeys", part_pubkeys);
1512 out.pushKV(
"musig2_participant_pubkeys", musig_pubkeys);
1520 this_prop.
pushKV(
"identifier",
HexStr(entry.identifier));
1521 this_prop.
pushKV(
"subtype", entry.subtype);
1524 proprietary.
push_back(std::move(this_prop));
1526 out.pushKV(
"proprietary", std::move(proprietary));
1530 if (output.
unknown.size() > 0) {
1532 for (
auto entry : output.
unknown) {
1535 out.pushKV(
"unknown", std::move(unknowns));
1542 output_value += psbtx.
tx->vout[i].nValue;
1545 have_all_utxos =
false;
1548 result.
pushKV(
"outputs", std::move(outputs));
1549 if (have_all_utxos) {
1562 "Combine multiple partially signed Bitcoin transactions into one transaction.\n"
1563 "Implements the Combiner role.\n",
1575 HelpExampleCli(
"combinepsbt", R
"('["mybase64_1", "mybase64_2", "mybase64_3"]')")
1580 std::vector<PartiallySignedTransaction> psbtxs;
1585 for (
unsigned int i = 0; i < txs.
size(); ++i) {
1591 psbtxs.push_back(psbtx);
1600 ssTx << merged_psbt;
1609 "Finalize the inputs of a PSBT. If the transaction is fully signed, it will produce a\n"
1610 "network serialized transaction which can be broadcast with sendrawtransaction. Otherwise a PSBT will be\n"
1611 "created which has the final_scriptSig and final_scriptWitness fields filled for inputs that are complete.\n"
1612 "Implements the Finalizer and Extractor roles.\n",
1616 " extract and return the complete transaction in normal network serialization instead of the PSBT."},
1621 {
RPCResult::Type::STR,
"psbt",
true,
"The base64-encoded partially signed transaction if not extracted"},
1638 bool extract = request.params[1].isNull() || (!request.params[1].isNull() && request.params[1].get_bool());
1645 std::string result_str;
1649 result_str =
HexStr(ssTx);
1650 result.
pushKV(
"hex", result_str);
1654 result.
pushKV(
"psbt", result_str);
1656 result.
pushKV(
"complete", complete);
1667 "Creates a transaction in the Partially Signed Transaction format.\n"
1668 "Implements the Creator role.\n"
1669 "Note that the transaction's inputs are not signed, and\n"
1670 "it is not stored in the wallet or transmitted to the network.\n",
1676 HelpExampleCli(
"createpsbt",
"\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"address\\\":0.01}]\"")
1681 std::optional<bool> rbf;
1682 if (!request.params[3].isNull()) {
1683 rbf = request.params[3].
get_bool();
1690 for (
unsigned int i = 0; i < rawTx.
vin.size(); ++i) {
1691 psbtx.
inputs.emplace_back();
1693 for (
unsigned int i = 0; i < rawTx.
vout.size(); ++i) {
1710 "Converts a network serialized transaction to a PSBT. This should be used only with createrawtransaction and fundrawtransaction\n"
1711 "createpsbt and walletcreatefundedpsbt should be used for new applications.\n",
1715 " will continue. If false, RPC will fail if any signatures are present."},
1717 "If iswitness is not present, heuristic tests will be used in decoding.\n"
1718 "If true, only witness deserialization will be tried.\n"
1719 "If false, only non-witness deserialization will be tried.\n"
1720 "This boolean should reflect whether the transaction has inputs\n"
1721 "(e.g. fully valid, or on-chain transactions), if known by the caller."
1728 "\nCreate a transaction\n"
1729 +
HelpExampleCli(
"createrawtransaction",
"\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"") +
1730 "\nConvert the transaction to a PSBT\n"
1737 bool permitsigdata = request.params[1].isNull() ? false : request.params[1].get_bool();
1738 bool witness_specified = !request.params[2].isNull();
1739 bool iswitness = witness_specified ? request.params[2].get_bool() :
false;
1740 const bool try_witness = witness_specified ? iswitness :
true;
1741 const bool try_no_witness = witness_specified ? !iswitness :
true;
1742 if (!
DecodeHexTx(tx, request.params[0].get_str(), try_no_witness, try_witness)) {
1758 for (
unsigned int i = 0; i < tx.
vin.size(); ++i) {
1759 psbtx.
inputs.emplace_back();
1761 for (
unsigned int i = 0; i < tx.
vout.size(); ++i) {
1778 "Updates all segwit inputs and outputs in a PSBT with data from output descriptors, the UTXO set, txindex, or the mempool.\n",
1790 RPCResult::Type::STR,
"",
"The base64-encoded partially signed transaction with inputs updated"
1799 if (!request.params[1].isNull()) {
1800 auto descs = request.params[1].get_array();
1801 for (
size_t i = 0; i < descs.size(); ++i) {
1808 request.params[0].get_str(),
1825 "Joins multiple distinct PSBTs with different inputs and outputs into one PSBT with inputs and outputs from all of the PSBTs\n"
1826 "No input in any of the PSBTs can be in more than one of the PSBTs.\n",
1842 std::vector<PartiallySignedTransaction> psbtxs;
1845 if (txs.
size() <= 1) {
1849 uint32_t best_version = 1;
1850 uint32_t best_locktime = 0xffffffff;
1851 for (
unsigned int i = 0; i < txs.
size(); ++i) {
1857 psbtxs.push_back(psbtx);
1859 if (psbtx.
tx->version > best_version) {
1860 best_version = psbtx.
tx->version;
1863 if (psbtx.
tx->nLockTime < best_locktime) {
1864 best_locktime = psbtx.
tx->nLockTime;
1871 merged_psbt.
tx->version = best_version;
1872 merged_psbt.
tx->nLockTime = best_locktime;
1875 for (
auto& psbt : psbtxs) {
1876 for (
unsigned int i = 0; i < psbt.tx->vin.size(); ++i) {
1877 if (!merged_psbt.
AddInput(psbt.tx->vin[i], psbt.inputs[i])) {
1881 for (
unsigned int i = 0; i < psbt.tx->vout.size(); ++i) {
1882 merged_psbt.
AddOutput(psbt.tx->vout[i], psbt.outputs[i]);
1884 for (
auto& xpub_pair : psbt.m_xpubs) {
1885 if (merged_psbt.
m_xpubs.count(xpub_pair.first) == 0) {
1886 merged_psbt.
m_xpubs[xpub_pair.first] = xpub_pair.second;
1888 merged_psbt.
m_xpubs[xpub_pair.first].insert(xpub_pair.second.begin(), xpub_pair.second.end());
1891 merged_psbt.
unknown.insert(psbt.unknown.begin(), psbt.unknown.end());
1895 std::vector<int> input_indices(merged_psbt.
inputs.size());
1896 std::iota(input_indices.begin(), input_indices.end(), 0);
1897 std::vector<int> output_indices(merged_psbt.
outputs.size());
1898 std::iota(output_indices.begin(), output_indices.end(), 0);
1902 std::shuffle(output_indices.begin(), output_indices.end(),
FastRandomContext());
1906 shuffled_psbt.
tx->version = merged_psbt.
tx->version;
1907 shuffled_psbt.
tx->nLockTime = merged_psbt.
tx->nLockTime;
1908 for (
int i : input_indices) {
1911 for (
int i : output_indices) {
1917 ssTx << shuffled_psbt;
1927 "Analyzes and provides information about the current status of a PSBT and its inputs\n",
1940 {
RPCResult::Type::OBJ,
"missing",
true,
"Things that are missing that are required to complete this input",
1944 {
RPCResult::Type::STR_HEX,
"keyid",
"Public key ID, hash160 of the public key, of a public key whose BIP 32 derivation path is missing"},
1948 {
RPCResult::Type::STR_HEX,
"keyid",
"Public key ID, hash160 of the public key, of a public key whose signature is missing"},
1953 {
RPCResult::Type::STR,
"next",
true,
"Role of the next person that this input needs to go to"},
1956 {
RPCResult::Type::NUM,
"estimated_vsize",
true,
"Estimated vsize of the final signed transaction"},
1957 {
RPCResult::Type::STR_AMOUNT,
"estimated_feerate",
true,
"Estimated feerate of the final signed transaction in " +
CURRENCY_UNIT +
"/kvB. Shown only if all UTXO slots in the PSBT have been filled"},
1958 {
RPCResult::Type::STR_AMOUNT,
"fee",
true,
"The transaction fee paid. Shown only if all UTXO slots in the PSBT have been filled"},
1979 for (
const auto& input : psbta.
inputs) {
1983 input_univ.
pushKV(
"has_utxo", input.has_utxo);
1984 input_univ.
pushKV(
"is_final", input.is_final);
1987 if (!input.missing_pubkeys.empty()) {
1989 for (
const CKeyID& pubkey : input.missing_pubkeys) {
1992 missing.
pushKV(
"pubkeys", std::move(missing_pubkeys_univ));
1994 if (!input.missing_redeem_script.IsNull()) {
1995 missing.
pushKV(
"redeemscript",
HexStr(input.missing_redeem_script));
1997 if (!input.missing_witness_script.IsNull()) {
1998 missing.
pushKV(
"witnessscript",
HexStr(input.missing_witness_script));
2000 if (!input.missing_sigs.empty()) {
2002 for (
const CKeyID& pubkey : input.missing_sigs) {
2005 missing.
pushKV(
"signatures", std::move(missing_sigs_univ));
2007 if (!missing.
getKeys().empty()) {
2008 input_univ.
pushKV(
"missing", std::move(missing));
2010 inputs_result.
push_back(std::move(input_univ));
2012 if (!inputs_result.
empty()) result.
pushKV(
"inputs", std::move(inputs_result));
2020 if (psbta.
fee != std::nullopt) {
2024 if (!psbta.
error.empty()) {
2036 "descriptorprocesspsbt",
2037 "Update all segwit inputs in a PSBT with information from output descriptors, the UTXO set or the mempool. \n"
2038 "Then, sign the inputs we are able to with information from the output descriptors. ",
2048 {
"sighashtype",
RPCArg::Type::STR,
RPCArg::Default{
"DEFAULT for Taproot, ALL otherwise"},
"The signature hash type to sign with if not specified by the PSBT. Must be one of\n"
2053 " \"ALL|ANYONECANPAY\"\n"
2054 " \"NONE|ANYONECANPAY\"\n"
2055 " \"SINGLE|ANYONECANPAY\""},
2068 HelpExampleCli(
"descriptorprocesspsbt",
"\"psbt\" \"[\\\"descriptor1\\\", \\\"descriptor2\\\"]\"") +
2069 HelpExampleCli(
"descriptorprocesspsbt",
"\"psbt\" \"[{\\\"desc\\\":\\\"mydescriptor\\\", \\\"range\\\":21}]\"")
2076 auto descs = request.params[1].get_array();
2077 for (
size_t i = 0; i < descs.size(); ++i) {
2082 bool bip32derivs = request.params[3].isNull() ? true : request.params[3].get_bool();
2083 bool finalize = request.params[4].isNull() ? true : request.params[4].get_bool();
2086 request.params[0].get_str(),
2093 bool complete =
true;
2094 for (
const auto& input : psbtx.
inputs) {
2104 result.
pushKV(
"complete", complete);
2137 for (
const auto& c : commands) {
2138 t.appendCommand(c.name, &c);
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
bool MoneyRange(const CAmount &nValue)
int64_t CAmount
Amount in satoshis (Can be negative)
std::string EncodeBase58Check(std::span< const unsigned char > input)
Encode a byte span into a base58-encoded string, including checksum.
std::string WriteHDKeypath(const std::vector< uint32_t > &keypath, bool apostrophe)
Write HD keypaths as strings.
@ BLOCK_HAVE_DATA
full block available in blk*.dat
#define CHECK_NONFATAL(condition)
Identity function.
#define NONFATAL_UNREACHABLE()
NONFATAL_UNREACHABLE() is a macro that is used to mark unreachable code.
std::vector< CTransactionRef > vtx
The block chain is a tree shaped structure starting with the genesis block at the root,...
int64_t GetBlockTime() const
int nHeight
height of the entry in the chain. The genesis block has height 0
Undo information for a CBlock.
std::vector< CTxUndo > vtxundo
int Height() const
Return the maximal height in the chain.
bool Contains(const CBlockIndex *pindex) const
Efficiently check whether a block is present in this chain.
const CBlock & GenesisBlock() const
void SetBackend(CCoinsView &viewIn)
CCoinsView that adds a memory cache for transactions to another CCoinsView.
const Coin & AccessCoin(const COutPoint &output) const
Return a reference to Coin in the cache, or coinEmpty if not found.
Abstract view on the open txout dataset.
CCoinsView that brings transactions from a mempool into view.
An encapsulated private key.
bool IsValid() const
Check whether this private key is valid.
CPubKey GetPubKey() const
Compute the public key from a private key.
A reference to a CKey: the Hash160 of its serialized public key.
An encapsulated public key.
bool IsCompressed() const
Check whether this is a compressed public key.
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
Serialized script, used inside transaction inputs and outputs.
A reference to a CScript: the Hash160 of its serialization.
The basic transaction that is broadcasted on the network and contained in blocks.
static const uint32_t CURRENT_VERSION
An input of a transaction.
CScriptWitness scriptWitness
Only serialized through CTransaction.
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
An output of a transaction.
Undo information for a CTransaction.
Chainstate stores and provides an API to update our local knowledge of the current best chain.
CChain m_chain
The current chain of blockheaders we consult and build on.
node::BlockManager & m_blockman
Reference to a BlockManager instance which itself is shared across all Chainstate instances.
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
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...
const CChainParams & GetParams() const
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
CTxOut out
unspent transaction output
bool IsSpent() const
Either this coin never existed (see e.g.
Double ended buffer combining vector and stream-like interfaces.
A signature creator for transactions.
auto Arg(std::string_view key) const
Helper to get a required or default-valued request argument.
void push_back(UniValue val)
const std::vector< std::string > & getKeys() const
const UniValue & get_array() const
void pushKV(std::string key, UniValue val)
bool IsNull() const
Test whether this is the 0 key (the result of default construction).
constexpr bool IsNull() const
std::string GetHex() const
CBlockIndex * LookupBlockIndex(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
bool ReadBlockUndo(CBlockUndo &blockundo, const CBlockIndex &index) const
bool ReadBlock(CBlock &block, const FlatFilePos &pos, const std::optional< uint256 > &expected_hash) const
Functions for disk access for blocks.
static transaction_identifier FromUint256(const uint256 &id)
std::string EncodeHexTx(const CTransaction &tx)
std::string SighashToStr(unsigned char sighash_type)
void TxToUniv(const CTransaction &tx, const uint256 &block_hash, UniValue &entry, bool include_hex=true, const CTxUndo *txundo=nullptr, TxVerbosity verbosity=TxVerbosity::SHOW_DETAILS)
TxVerbosity
Verbose level for block's transaction.
@ 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.
void ScriptToUniv(const CScript &script, UniValue &out, bool include_hex=true, bool include_address=false, const SigningProvider *provider=nullptr)
UniValue ValueFromAmount(const CAmount amount)
bool DecodeHexTx(CMutableTransaction &tx, const std::string &hex_tx, bool try_no_witness=false, bool try_witness=true)
uint32_t ReadBE32(const B *ptr)
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
const std::string CURRENCY_UNIT
uint160 Hash160(const T1 &in1)
Compute the 160-bit hash an object.
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
std::string EncodeDestination(const CTxDestination &dest)
CKey DecodeSecret(const std::string &str)
PSBTAnalysis AnalyzePSBT(PartiallySignedTransaction psbtx)
Provides helpful miscellaneous information about where a PSBT is in the signing workflow.
void FindCoins(const NodeContext &node, std::map< COutPoint, Coin > &coins)
Look up unspent output information.
CTransactionRef GetTransaction(const CBlockIndex *const block_index, const CTxMemPool *const mempool, const Txid &hash, uint256 &hashBlock, const BlockManager &blockman)
Return transaction with a given hash.
is a home for public enum and struct type definitions that are used internally by node code,...
static constexpr TransactionSerParams TX_WITH_WITNESS
std::shared_ptr< const CTransaction > CTransactionRef
bool DecodeBase64PSBT(PartiallySignedTransaction &psbt, const std::string &base64_tx, std::string &error)
Decode a base64ed PSBT into a PartiallySignedTransaction.
void UpdatePSBTOutput(const SigningProvider &provider, PartiallySignedTransaction &psbt, int index)
Updates a PSBTOutput with information from provider.
std::string PSBTRoleName(PSBTRole role)
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...
void RemoveUnnecessaryTransactions(PartiallySignedTransaction &psbtx)
Reduces the size of the PSBT by dropping unnecessary non_witness_utxos (i.e.
bool FinalizeAndExtractPSBT(PartiallySignedTransaction &psbtx, CMutableTransaction &result)
Finalizes a PSBT if possible, and extracts it to a CMutableTransaction if it could be finalized.
bool PSBTInputSigned(const PSBTInput &input)
Checks whether a PSBTInput is already signed by checking for non-null finalized fields.
PrecomputedTransactionData PrecomputePSBTData(const PartiallySignedTransaction &psbt)
Compute a PrecomputedTransactionData object from a psbt.
PSBTError SignPSBTInput(const SigningProvider &provider, PartiallySignedTransaction &psbt, int index, const PrecomputedTransactionData *txdata, std::optional< int > sighash, SignatureData *out_sigdata, bool finalize)
Signs a PSBTInput, verifying that all provided data matches what is being signed.
const unsigned int BIP32_EXTKEY_WITH_VERSION_SIZE
static RPCHelpMan getrawtransaction()
static RPCHelpMan utxoupdatepsbt()
const RPCResult decodepsbt_inputs
static void TxToJSON(const CTransaction &tx, const uint256 hashBlock, UniValue &entry, Chainstate &active_chainstate, const CTxUndo *txundo=nullptr, TxVerbosity verbosity=TxVerbosity::SHOW_DETAILS)
static RPCHelpMan converttopsbt()
PartiallySignedTransaction ProcessPSBT(const std::string &psbt_string, const std::any &context, const HidingSigningProvider &provider, std::optional< int > sighash_type, bool finalize)
const RPCResult decodepsbt_outputs
static std::vector< RPCArg > CreateTxDoc()
static RPCHelpMan analyzepsbt()
static RPCHelpMan decoderawtransaction()
RPCHelpMan descriptorprocesspsbt()
static RPCHelpMan combinepsbt()
static RPCHelpMan decodepsbt()
static RPCHelpMan decodescript()
static RPCHelpMan createpsbt()
static RPCHelpMan joinpsbts()
static std::vector< RPCResult > DecodeTxDoc(const std::string &txid_field_doc)
static RPCHelpMan combinerawtransaction()
static constexpr decltype(CTransaction::version) DEFAULT_RAWTX_VERSION
static RPCHelpMan signrawtransactionwithkey()
static RPCHelpMan createrawtransaction()
static RPCHelpMan finalizepsbt()
void RegisterRawTransactionRPCCommands(CRPCTable &t)
void SignTransaction(CMutableTransaction &mtx, const SigningProvider *keystore, const std::map< COutPoint, Coin > &coins, const UniValue &hashType, UniValue &result)
Sign a transaction with the given keystore and previous transactions.
CMutableTransaction ConstructTransaction(const UniValue &inputs_in, const UniValue &outputs_in, const UniValue &locktime, std::optional< bool > rbf, const uint32_t version)
Create a transaction from univalue parameters.
void ParsePrevouts(const UniValue &prevTxsUnival, FlatSigningProvider *keystore, std::map< COutPoint, Coin > &coins)
Parse a prevtxs UniValue array and get the map of coins from it.
UniValue JSONRPCError(int code, const std::string &message)
@ RPC_MISC_ERROR
General application defined errors.
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
@ RPC_VERIFY_ERROR
General error during transaction or block submission.
@ RPC_DESERIALIZATION_ERROR
Error parsing or validating structure in raw format.
@ RPC_INVALID_ADDRESS_OR_KEY
Invalid address or key.
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 ...
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
std::vector< unsigned char > ParseHexV(const UniValue &v, std::string_view name)
UniValue JSONRPCPSBTError(PSBTError err)
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
const std::string UNIX_EPOCH_TIME
String used to describe UNIX epoch time in documentation, factored out to a constant for consistency.
std::string GetAllOutputTypes()
Gets all existing output types formatted for RPC help sections.
int ParseVerbosity(const UniValue &arg, int default_verbosity, bool allow_bool)
Parses verbosity from provided UniValue.
std::optional< int > ParseSighashString(const UniValue &sighash)
Returns a sighash value corresponding to the passed in argument.
uint256 ParseHashV(const UniValue &v, std::string_view name)
Utilities: convert hex-encoded Values (throws error if not hex).
std::vector< RPCResult > ScriptPubKeyDoc()
#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.
opcodetype
Script opcodes.
NodeContext & EnsureAnyNodeContext(const std::any &context)
CTxMemPool & EnsureMemPool(const NodeContext &node)
ChainstateManager & EnsureChainman(const NodeContext &node)
bool ProduceSignature(const SigningProvider &provider, const BaseSignatureCreator &creator, const CScript &fromPubKey, SignatureData &sigdata)
Produce a script signature using a generic signature creator.
void UpdateInput(CTxIn &input, const SignatureData &data)
bool IsSegWitOutput(const SigningProvider &provider, const CScript &script)
Check whether a scriptPubKey is known to be segwit.
SignatureData DataFromTransaction(const CMutableTransaction &tx, unsigned int nIn, const CTxOut &txout)
Extract signature data from a transaction input, and insert it.
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.
@ WITNESS_UNKNOWN
Only for Witness versions not already defined above.
@ ANCHOR
anyone can spend script
@ NULL_DATA
unspendable OP_RETURN script that carries data
A mutable version of CTransaction.
std::vector< CTxOut > vout
std::vector< std::vector< unsigned char > > stack
std::map< CKeyID, CPubKey > pubkeys
std::map< CKeyID, CKey > keys
std::map< CScriptID, CScript > scripts
A structure for PSBTs which contains per output information.
std::map< CPubKey, std::vector< CPubKey > > m_musig2_participants
XOnlyPubKey m_tap_internal_key
std::map< XOnlyPubKey, std::pair< std::set< uint256 >, KeyOriginInfo > > m_tap_bip32_paths
std::set< PSBTProprietary > m_proprietary
std::map< CPubKey, KeyOriginInfo > hd_keypaths
std::vector< std::tuple< uint8_t, uint8_t, std::vector< unsigned char > > > m_tap_tree
std::map< std::vector< unsigned char >, std::vector< unsigned char > > unknown
A version of CTransaction with the PSBT format.
uint32_t GetVersion() const
std::map< KeyOriginInfo, std::set< CExtPubKey > > m_xpubs
std::map< std::vector< unsigned char >, std::vector< unsigned char > > unknown
bool AddOutput(const CTxOut &txout, const PSBTOutput &psbtout)
std::vector< PSBTInput > inputs
std::optional< CMutableTransaction > tx
bool AddInput(const CTxIn &txin, PSBTInput &psbtin)
std::vector< PSBTOutput > outputs
std::set< PSBTProprietary > m_proprietary
@ 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.
@ OMITTED
Optional argument for which the default value is omitted from help text for one of two reasons:
@ 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)
NodeContext struct containing references to chain state and connection state.
Holds the results of AnalyzePSBT (miscellaneous information about a PSBT)
std::vector< PSBTInputAnalysis > inputs
More information about the individual inputs of the transaction.
std::string error
Error message.
std::optional< CAmount > fee
Amount of fee being paid by the transaction.
std::optional< size_t > estimated_vsize
Estimated weight of the transaction.
std::optional< CFeeRate > estimated_feerate
Estimated feerate (fee / weight) of the transaction.
PSBTRole next
Which of the BIP 174 roles needs to handle the transaction next.
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
std::unique_ptr< TxIndex > g_txindex
The global transaction index, used in GetTransaction. May be null.
std::string EncodeBase64(std::span< const unsigned char > input)