Bitcoin ABC 0.31.2
P2P Digital Currency
rawtransaction.cpp
Go to the documentation of this file.
1// Copyright (c) 2010 Satoshi Nakamoto
2// Copyright (c) 2009-2016 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 <chain.h>
7#include <chainparams.h>
8#include <coins.h>
9#include <config.h>
10#include <consensus/amount.h>
11#include <consensus/validation.h>
12#include <core_io.h>
13#include <index/txindex.h>
14#include <key_io.h>
15#include <node/blockstorage.h>
16#include <node/coin.h>
17#include <node/context.h>
18#include <node/psbt.h>
19#include <node/transaction.h>
20#include <policy/packages.h>
21#include <policy/policy.h>
22#include <primitives/transaction.h>
23#include <psbt.h>
24#include <random.h>
25#include <rpc/blockchain.h>
26#include <rpc/rawtransaction_util.h>
27#include <rpc/server.h>
28#include <rpc/server_util.h>
29#include <rpc/util.h>
30#include <script/script.h>
31#include <script/sign.h>
32#include <script/signingprovider.h>
33#include <script/standard.h>
34#include <txmempool.h>
35#include <uint256.h>
36#include <util/bip32.h>
37#include <util/check.h>
38#include <util/error.h>
39#include <util/strencodings.h>
40#include <util/string.h>
41#include <validation.h>
42#include <validationinterface.h>
43
44#include <cstdint>
45#include <numeric>
46
47#include <univalue.h>
48
49using node::AnalyzePSBT;
50using node::BroadcastTransaction;
51using node::FindCoins;
52using node::GetTransaction;
53using node::NodeContext;
54using node::PSBTAnalysis;
55
56static void TxToJSON(const CTransaction &tx, const BlockHash &hashBlock,
57 UniValue &entry, Chainstate &active_chainstate) {
58 // Call into TxToUniv() in bitcoin-common to decode the transaction hex.
59 //
60 // Blockchain contextual information (confirmations and blocktime) is not
61 // available to code in bitcoin-common, so we query them here and push the
62 // data into the returned UniValue.
63 TxToUniv(tx, BlockHash(), entry, true, RPCSerializationFlags());
64
65 if (!hashBlock.IsNull()) {
66 LOCK(cs_main);
67
68 entry.pushKV("blockhash", hashBlock.GetHex());
69 const CBlockIndex *pindex =
70 active_chainstate.m_blockman.LookupBlockIndex(hashBlock);
71 if (pindex) {
72 if (active_chainstate.m_chain.Contains(pindex)) {
73 entry.pushKV("confirmations",
74 1 + active_chainstate.m_chain.Height() -
75 pindex->nHeight);
76 entry.pushKV("time", pindex->GetBlockTime());
77 entry.pushKV("blocktime", pindex->GetBlockTime());
78 } else {
79 entry.pushKV("confirmations", 0);
80 }
81 }
82 }
83}
84
85static RPCHelpMan getrawtransaction() {
86 return RPCHelpMan{
87 "getrawtransaction",
88 "\nReturn the raw transaction data.\n"
89 "\nBy default, this call only returns a transaction if it is in the "
90 "mempool. If -txindex is enabled\n"
91 "and no blockhash argument is passed, it will return the transaction "
92 "if it is in the mempool or any block.\n"
93 "If a blockhash argument is passed, it will return the transaction if\n"
94 "the specified block is available and the transaction is in that "
95 "block.\n"
96 "\nIf verbose is 'true', returns an Object with information about "
97 "'txid'.\n"
98 "If verbose is 'false' or omitted, returns a string that is "
99 "serialized, hex-encoded data for 'txid'.\n",
100 {
101 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
102 "The transaction id"},
103 // Verbose is a boolean, but we accept an int for backward
104 // compatibility
105 {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false},
106 "If false, return a string, otherwise return a json object",
107 RPCArgOptions{.skip_type_check = true}},
108 {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED,
109 "The block in which to look for the transaction"},
110 },
111 {
112 RPCResult{"if verbose is not set or set to false",
113 RPCResult::Type::STR, "data",
114 "The serialized, hex-encoded data for 'txid'"},
115 RPCResult{
116 "if verbose is set to true",
117 RPCResult::Type::OBJ,
118 "",
119 "",
120 {
121 {RPCResult::Type::BOOL, "in_active_chain",
122 "Whether specified block is in the active chain or not "
123 "(only present with explicit \"blockhash\" argument)"},
124 {RPCResult::Type::STR_HEX, "hex",
125 "The serialized, hex-encoded data for 'txid'"},
126 {RPCResult::Type::STR_HEX, "txid",
127 "The transaction id (same as provided)"},
128 {RPCResult::Type::STR_HEX, "hash", "The transaction hash"},
129 {RPCResult::Type::NUM, "size",
130 "The serialized transaction size"},
131 {RPCResult::Type::NUM, "version", "The version"},
132 {RPCResult::Type::NUM_TIME, "locktime", "The lock time"},
133 {RPCResult::Type::ARR,
134 "vin",
135 "",
136 {
137 {RPCResult::Type::OBJ,
138 "",
139 "",
140 {
141 {RPCResult::Type::STR_HEX, "txid",
142 "The transaction id"},
143 {RPCResult::Type::STR, "vout", ""},
144 {RPCResult::Type::OBJ,
145 "scriptSig",
146 "The script",
147 {
148 {RPCResult::Type::STR, "asm", "asm"},
149 {RPCResult::Type::STR_HEX, "hex", "hex"},
150 }},
151 {RPCResult::Type::NUM, "sequence",
152 "The script sequence number"},
153 }},
154 }},
155 {RPCResult::Type::ARR,
156 "vout",
157 "",
158 {
159 {RPCResult::Type::OBJ,
160 "",
161 "",
162 {
163 {RPCResult::Type::NUM, "value",
164 "The value in " + Currency::get().ticker},
165 {RPCResult::Type::NUM, "n", "index"},
166 {RPCResult::Type::OBJ,
167 "scriptPubKey",
168 "",
169 {
170 {RPCResult::Type::STR, "asm", "the asm"},
171 {RPCResult::Type::STR, "hex", "the hex"},
172 {RPCResult::Type::NUM, "reqSigs",
173 "The required sigs"},
174 {RPCResult::Type::STR, "type",
175 "The type, eg 'pubkeyhash'"},
176 {RPCResult::Type::ARR,
177 "addresses",
178 "",
179 {
180 {RPCResult::Type::STR, "address",
181 "bitcoin address"},
182 }},
183 }},
184 }},
185 }},
186 {RPCResult::Type::STR_HEX, "blockhash", "the block hash"},
187 {RPCResult::Type::NUM, "confirmations",
188 "The confirmations"},
189 {RPCResult::Type::NUM_TIME, "blocktime",
190 "The block time expressed in " + UNIX_EPOCH_TIME},
191 {RPCResult::Type::NUM, "time", "Same as \"blocktime\""},
192 }},
193 },
194 RPCExamples{HelpExampleCli("getrawtransaction", "\"mytxid\"") +
195 HelpExampleCli("getrawtransaction", "\"mytxid\" true") +
196 HelpExampleRpc("getrawtransaction", "\"mytxid\", true") +
197 HelpExampleCli("getrawtransaction",
198 "\"mytxid\" false \"myblockhash\"") +
199 HelpExampleCli("getrawtransaction",
200 "\"mytxid\" true \"myblockhash\"")},
201 [&](const RPCHelpMan &self, const Config &config,
202 const JSONRPCRequest &request) -> UniValue {
203 const NodeContext &node = EnsureAnyNodeContext(request.context);
204 ChainstateManager &chainman = EnsureChainman(node);
205
206 bool in_active_chain = true;
207 TxId txid = TxId(ParseHashV(request.params[0], "parameter 1"));
208 const CBlockIndex *blockindex = nullptr;
209
210 const CChainParams &params = config.GetChainParams();
211 if (txid == params.GenesisBlock().hashMerkleRoot) {
212 // Special exception for the genesis block coinbase transaction
213 throw JSONRPCError(
214 RPC_INVALID_ADDRESS_OR_KEY,
215 "The genesis block coinbase is not considered an "
216 "ordinary transaction and cannot be retrieved");
217 }
218
219 // Accept either a bool (true) or a num (>=1) to indicate verbose
220 // output.
221 bool fVerbose = false;
222 if (!request.params[1].isNull()) {
223 fVerbose = request.params[1].isNum()
224 ? (request.params[1].getInt<int>() != 0)
225 : request.params[1].get_bool();
226 }
227
228 if (!request.params[2].isNull()) {
229 LOCK(cs_main);
230
231 BlockHash blockhash(
232 ParseHashV(request.params[2], "parameter 3"));
233 blockindex = chainman.m_blockman.LookupBlockIndex(blockhash);
234 if (!blockindex) {
235 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
236 "Block hash not found");
237 }
238 in_active_chain = chainman.ActiveChain().Contains(blockindex);
239 }
240
241 bool f_txindex_ready = false;
242 if (g_txindex && !blockindex) {
243 f_txindex_ready = g_txindex->BlockUntilSyncedToCurrentChain();
244 }
245
246 BlockHash hash_block;
247 const CTransactionRef tx =
248 GetTransaction(blockindex, node.mempool.get(), txid, hash_block,
249 chainman.m_blockman);
250 if (!tx) {
251 std::string errmsg;
252 if (blockindex) {
253 if (WITH_LOCK(::cs_main,
254 return !blockindex->nStatus.hasData())) {
255 throw JSONRPCError(RPC_MISC_ERROR,
256 "Block not available");
257 }
258 errmsg = "No such transaction found in the provided block";
259 } else if (!g_txindex) {
260 errmsg =
261 "No such mempool transaction. Use -txindex or provide "
262 "a block hash to enable blockchain transaction queries";
263 } else if (!f_txindex_ready) {
264 errmsg = "No such mempool transaction. Blockchain "
265 "transactions are still in the process of being "
266 "indexed";
267 } else {
268 errmsg = "No such mempool or blockchain transaction";
269 }
270 throw JSONRPCError(
271 RPC_INVALID_ADDRESS_OR_KEY,
272 errmsg + ". Use gettransaction for wallet transactions.");
273 }
274
275 if (!fVerbose) {
276 return EncodeHexTx(*tx, RPCSerializationFlags());
277 }
278
279 UniValue result(UniValue::VOBJ);
280 if (blockindex) {
281 result.pushKV("in_active_chain", in_active_chain);
282 }
283 TxToJSON(*tx, hash_block, result, chainman.ActiveChainstate());
284 return result;
285 },
286 };
287}
288
289static RPCHelpMan createrawtransaction() {
290 return RPCHelpMan{
291 "createrawtransaction",
292 "Create a transaction spending the given inputs and creating new "
293 "outputs.\n"
294 "Outputs can be addresses or data.\n"
295 "Returns hex-encoded raw transaction.\n"
296 "Note that the transaction's inputs are not signed, and\n"
297 "it is not stored in the wallet or transmitted to the network.\n",
298 {
299 {
300 "inputs",
301 RPCArg::Type::ARR,
302 RPCArg::Optional::NO,
303 "The inputs",
304 {
305 {
306 "",
307 RPCArg::Type::OBJ,
308 RPCArg::Optional::OMITTED,
309 "",
310 {
311 {"txid", RPCArg::Type::STR_HEX,
312 RPCArg::Optional::NO, "The transaction id"},
313 {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
314 "The output number"},
315 {"sequence", RPCArg::Type::NUM,
316 RPCArg::DefaultHint{"depends on the value of the "
317 "'locktime' argument"},
318 "The sequence number"},
319 },
320 },
321 },
322 },
323 {"outputs",
324 RPCArg::Type::ARR,
325 RPCArg::Optional::NO,
326 "The outputs (key-value pairs), where none of "
327 "the keys are duplicated.\n"
328 "That is, each address can only appear once and there can only "
329 "be one 'data' object.\n"
330 "For compatibility reasons, a dictionary, which holds the "
331 "key-value pairs directly, is also\n"
332 " accepted as second parameter.",
333 {
334 {
335 "",
336 RPCArg::Type::OBJ_USER_KEYS,
337 RPCArg::Optional::OMITTED,
338 "",
339 {
340 {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO,
341 "A key-value pair. The key (string) is the "
342 "bitcoin address, the value (float or string) is "
343 "the amount in " +
344 Currency::get().ticker},
345 },
346 },
347 {
348 "",
349 RPCArg::Type::OBJ,
350 RPCArg::Optional::OMITTED,
351 "",
352 {
353 {"data", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
354 "A key-value pair. The key must be \"data\", the "
355 "value is hex-encoded data"},
356 },
357 },
358 },
359 RPCArgOptions{.skip_type_check = true}},
360 {"locktime", RPCArg::Type::NUM, RPCArg::Default{0},
361 "Raw locktime. Non-0 value also locktime-activates inputs"},
362 },
363 RPCResult{RPCResult::Type::STR_HEX, "transaction",
364 "hex string of the transaction"},
365 RPCExamples{
366 HelpExampleCli("createrawtransaction",
367 "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
368 "\" \"[{\\\"address\\\":10000.00}]\"") +
369 HelpExampleCli("createrawtransaction",
370 "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
371 "\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"") +
372 HelpExampleRpc("createrawtransaction",
373 "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
374 "\", \"[{\\\"address\\\":10000.00}]\"") +
375 HelpExampleRpc("createrawtransaction",
376 "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
377 "\", \"[{\\\"data\\\":\\\"00010203\\\"}]\"")},
378 [&](const RPCHelpMan &self, const Config &config,
379 const JSONRPCRequest &request) -> UniValue {
380 CMutableTransaction rawTx =
381 ConstructTransaction(config.GetChainParams(), request.params[0],
382 request.params[1], request.params[2]);
383
384 return EncodeHexTx(CTransaction(rawTx));
385 },
386 };
387}
388
389static RPCHelpMan decoderawtransaction() {
390 return RPCHelpMan{
391 "decoderawtransaction",
392 "Return a JSON object representing the serialized, hex-encoded "
393 "transaction.\n",
394 {
395 {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
396 "The transaction hex string"},
397 },
398 RPCResult{
399 RPCResult::Type::OBJ,
400 "",
401 "",
402 {
403 {RPCResult::Type::STR_HEX, "txid", "The transaction id"},
404 {RPCResult::Type::STR_HEX, "hash", "The transaction hash"},
405 {RPCResult::Type::NUM, "size", "The transaction size"},
406 {RPCResult::Type::NUM, "version", "The version"},
407 {RPCResult::Type::NUM_TIME, "locktime", "The lock time"},
408 {RPCResult::Type::ARR,
409 "vin",
410 "",
411 {
412 {RPCResult::Type::OBJ,
413 "",
414 "",
415 {
416 {RPCResult::Type::STR_HEX, "txid",
417 "The transaction id"},
418 {RPCResult::Type::NUM, "vout", "The output number"},
419 {RPCResult::Type::OBJ,
420 "scriptSig",
421 "The script",
422 {
423 {RPCResult::Type::STR, "asm", "asm"},
424 {RPCResult::Type::STR_HEX, "hex", "hex"},
425 }},
426 {RPCResult::Type::NUM, "sequence",
427 "The script sequence number"},
428 }},
429 }},
430 {RPCResult::Type::ARR,
431 "vout",
432 "",
433 {
434 {RPCResult::Type::OBJ,
435 "",
436 "",
437 {
438 {RPCResult::Type::NUM, "value",
439 "The value in " + Currency::get().ticker},
440 {RPCResult::Type::NUM, "n", "index"},
441 {RPCResult::Type::OBJ,
442 "scriptPubKey",
443 "",
444 {
445 {RPCResult::Type::STR, "asm", "the asm"},
446 {RPCResult::Type::STR_HEX, "hex", "the hex"},
447 {RPCResult::Type::NUM, "reqSigs",
448 "The required sigs"},
449 {RPCResult::Type::STR, "type",
450 "The type, eg 'pubkeyhash'"},
451 {RPCResult::Type::ARR,
452 "addresses",
453 "",
454 {
455 {RPCResult::Type::STR, "address",
456 "bitcoin address"},
457 }},
458 }},
459 }},
460 }},
461 }},
462 RPCExamples{HelpExampleCli("decoderawtransaction", "\"hexstring\"") +
463 HelpExampleRpc("decoderawtransaction", "\"hexstring\"")},
464 [&](const RPCHelpMan &self, const Config &config,
465 const JSONRPCRequest &request) -> UniValue {
466 CMutableTransaction mtx;
467
468 if (!DecodeHexTx(mtx, request.params[0].get_str())) {
469 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
470 "TX decode failed");
471 }
472
473 UniValue result(UniValue::VOBJ);
474 TxToUniv(CTransaction(std::move(mtx)), BlockHash(), result, false);
475
476 return result;
477 },
478 };
479}
480
481static RPCHelpMan decodescript() {
482 return RPCHelpMan{
483 "decodescript",
484 "Decode a hex-encoded script.\n",
485 {
486 {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
487 "the hex-encoded script"},
488 },
489 RPCResult{
490 RPCResult::Type::OBJ,
491 "",
492 "",
493 {
494 {RPCResult::Type::STR, "asm", "Script public key"},
495 {RPCResult::Type::STR, "type",
496 "The output type (e.g. " + GetAllOutputTypes() + ")"},
497 {RPCResult::Type::NUM, "reqSigs", "The required signatures"},
498 {RPCResult::Type::ARR,
499 "addresses",
500 "",
501 {
502 {RPCResult::Type::STR, "address", "bitcoin address"},
503 }},
504 {RPCResult::Type::STR, "p2sh",
505 "address of P2SH script wrapping this redeem script (not "
506 "returned if the script is already a P2SH)"},
507 }},
508 RPCExamples{HelpExampleCli("decodescript", "\"hexstring\"") +
509 HelpExampleRpc("decodescript", "\"hexstring\"")},
510 [&](const RPCHelpMan &self, const Config &config,
511 const JSONRPCRequest &request) -> UniValue {
512 UniValue r(UniValue::VOBJ);
513 CScript script;
514 if (request.params[0].get_str().size() > 0) {
515 std::vector<uint8_t> scriptData(
516 ParseHexV(request.params[0], "argument"));
517 script = CScript(scriptData.begin(), scriptData.end());
518 } else {
519 // Empty scripts are valid.
520 }
521
522 ScriptPubKeyToUniv(script, r, /* fIncludeHex */ false);
523
524 UniValue type;
525 type = r.find_value("type");
526
527 if (type.isStr() && type.get_str() != "scripthash") {
528 // P2SH cannot be wrapped in a P2SH. If this script is already a
529 // P2SH, don't return the address for a P2SH of the P2SH.
530 r.pushKV("p2sh", EncodeDestination(ScriptHash(script), config));
531 }
532
533 return r;
534 },
535 };
536}
537
538static RPCHelpMan combinerawtransaction() {
539 return RPCHelpMan{
540 "combinerawtransaction",
541 "Combine multiple partially signed transactions into one "
542 "transaction.\n"
543 "The combined transaction may be another partially signed transaction "
544 "or a \n"
545 "fully signed transaction.",
546 {
547 {
548 "txs",
549 RPCArg::Type::ARR,
550 RPCArg::Optional::NO,
551 "The hex strings of partially signed "
552 "transactions",
553 {
554 {"hexstring", RPCArg::Type::STR_HEX,
555 RPCArg::Optional::OMITTED,
556 "A hex-encoded raw transaction"},
557 },
558 },
559 },
560 RPCResult{RPCResult::Type::STR, "",
561 "The hex-encoded raw transaction with signature(s)"},
562 RPCExamples{HelpExampleCli("combinerawtransaction",
563 R"('["myhex1", "myhex2", "myhex3"]')")},
564 [&](const RPCHelpMan &self, const Config &config,
565 const JSONRPCRequest &request) -> UniValue {
566 UniValue txs = request.params[0].get_array();
567 std::vector<CMutableTransaction> txVariants(txs.size());
568
569 for (unsigned int idx = 0; idx < txs.size(); idx++) {
570 if (!DecodeHexTx(txVariants[idx], txs[idx].get_str())) {
571 throw JSONRPCError(
572 RPC_DESERIALIZATION_ERROR,
573 strprintf("TX decode failed for tx %d", idx));
574 }
575 }
576
577 if (txVariants.empty()) {
578 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
579 "Missing transactions");
580 }
581
582 // mergedTx will end up with all the signatures; it
583 // starts as a clone of the rawtx:
584 CMutableTransaction mergedTx(txVariants[0]);
585
586 // Fetch previous transactions (inputs):
587 CCoinsView viewDummy;
588 CCoinsViewCache view(&viewDummy);
589 {
590 NodeContext &node = EnsureAnyNodeContext(request.context);
591 const CTxMemPool &mempool = EnsureMemPool(node);
592 ChainstateManager &chainman = EnsureChainman(node);
593 LOCK2(cs_main, mempool.cs);
594 CCoinsViewCache &viewChain =
595 chainman.ActiveChainstate().CoinsTip();
596 CCoinsViewMemPool viewMempool(&viewChain, mempool);
597 // temporarily switch cache backend to db+mempool view
598 view.SetBackend(viewMempool);
599
600 for (const CTxIn &txin : mergedTx.vin) {
601 // Load entries from viewChain into view; can fail.
602 view.AccessCoin(txin.prevout);
603 }
604
605 // switch back to avoid locking mempool for too long
606 view.SetBackend(viewDummy);
607 }
608
609 // Use CTransaction for the constant parts of the
610 // transaction to avoid rehashing.
611 const CTransaction txConst(mergedTx);
612 // Sign what we can:
613 for (size_t i = 0; i < mergedTx.vin.size(); i++) {
614 CTxIn &txin = mergedTx.vin[i];
615 const Coin &coin = view.AccessCoin(txin.prevout);
616 if (coin.IsSpent()) {
617 throw JSONRPCError(RPC_VERIFY_ERROR,
618 "Input not found or already spent");
619 }
620 SignatureData sigdata;
621
622 const CTxOut &txout = coin.GetTxOut();
623
624 // ... and merge in other signatures:
625 for (const CMutableTransaction &txv : txVariants) {
626 if (txv.vin.size() > i) {
627 sigdata.MergeSignatureData(
628 DataFromTransaction(txv, i, txout));
629 }
630 }
631 ProduceSignature(DUMMY_SIGNING_PROVIDER,
632 MutableTransactionSignatureCreator(
633 &mergedTx, i, txout.nValue),
634 txout.scriptPubKey, sigdata);
635
636 UpdateInput(txin, sigdata);
637 }
638
639 return EncodeHexTx(CTransaction(mergedTx));
640 },
641 };
642}
643
644static RPCHelpMan signrawtransactionwithkey() {
645 return RPCHelpMan{
646 "signrawtransactionwithkey",
647 "Sign inputs for raw transaction (serialized, hex-encoded).\n"
648 "The second argument is an array of base58-encoded private\n"
649 "keys that will be the only keys used to sign the transaction.\n"
650 "The third optional argument (may be null) is an array of previous "
651 "transaction outputs that\n"
652 "this transaction depends on but may not yet be in the block chain.\n",
653 {
654 {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
655 "The transaction hex string"},
656 {
657 "privkeys",
658 RPCArg::Type::ARR,
659 RPCArg::Optional::NO,
660 "The base58-encoded private keys for signing",
661 {
662 {"privatekey", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
663 "private key in base58-encoding"},
664 },
665 },
666 {
667 "prevtxs",
668 RPCArg::Type::ARR,
669 RPCArg::Optional::OMITTED,
670 "The previous dependent transaction outputs",
671 {
672 {
673 "",
674 RPCArg::Type::OBJ,
675 RPCArg::Optional::OMITTED,
676 "",
677 {
678 {"txid", RPCArg::Type::STR_HEX,
679 RPCArg::Optional::NO, "The transaction id"},
680 {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
681 "The output number"},
682 {"scriptPubKey", RPCArg::Type::STR_HEX,
683 RPCArg::Optional::NO, "script key"},
684 {"redeemScript", RPCArg::Type::STR_HEX,
685 RPCArg::Optional::OMITTED,
686 "(required for P2SH) redeem script"},
687 {"amount", RPCArg::Type::AMOUNT,
688 RPCArg::Optional::NO, "The amount spent"},
689 },
690 },
691 },
692 },
693 {"sighashtype", RPCArg::Type::STR, RPCArg::Default{"ALL|FORKID"},
694 "The signature hash type. Must be one of:\n"
695 " \"ALL|FORKID\"\n"
696 " \"NONE|FORKID\"\n"
697 " \"SINGLE|FORKID\"\n"
698 " \"ALL|FORKID|ANYONECANPAY\"\n"
699 " \"NONE|FORKID|ANYONECANPAY\"\n"
700 " \"SINGLE|FORKID|ANYONECANPAY\""},
701 },
702 RPCResult{
703 RPCResult::Type::OBJ,
704 "",
705 "",
706 {
707 {RPCResult::Type::STR_HEX, "hex",
708 "The hex-encoded raw transaction with signature(s)"},
709 {RPCResult::Type::BOOL, "complete",
710 "If the transaction has a complete set of signatures"},
711 {RPCResult::Type::ARR,
712 "errors",
713 /* optional */ true,
714 "Script verification errors (if there are any)",
715 {
716 {RPCResult::Type::OBJ,
717 "",
718 "",
719 {
720 {RPCResult::Type::STR_HEX, "txid",
721 "The hash of the referenced, previous transaction"},
722 {RPCResult::Type::NUM, "vout",
723 "The index of the output to spent and used as "
724 "input"},
725 {RPCResult::Type::STR_HEX, "scriptSig",
726 "The hex-encoded signature script"},
727 {RPCResult::Type::NUM, "sequence",
728 "Script sequence number"},
729 {RPCResult::Type::STR, "error",
730 "Verification or signing error related to the "
731 "input"},
732 }},
733 }},
734 }},
735 RPCExamples{
736 HelpExampleCli("signrawtransactionwithkey",
737 "\"myhex\" \"[\\\"key1\\\",\\\"key2\\\"]\"") +
738 HelpExampleRpc("signrawtransactionwithkey",
739 "\"myhex\", \"[\\\"key1\\\",\\\"key2\\\"]\"")},
740 [&](const RPCHelpMan &self, const Config &config,
741 const JSONRPCRequest &request) -> UniValue {
742 CMutableTransaction mtx;
743 if (!DecodeHexTx(mtx, request.params[0].get_str())) {
744 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
745 "TX decode failed");
746 }
747
748 FillableSigningProvider keystore;
749 const UniValue &keys = request.params[1].get_array();
750 for (size_t idx = 0; idx < keys.size(); ++idx) {
751 UniValue k = keys[idx];
752 CKey key = DecodeSecret(k.get_str());
753 if (!key.IsValid()) {
754 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
755 "Invalid private key");
756 }
757 keystore.AddKey(key);
758 }
759
760 // Fetch previous transactions (inputs):
761 std::map<COutPoint, Coin> coins;
762 for (const CTxIn &txin : mtx.vin) {
763 // Create empty map entry keyed by prevout.
764 coins[txin.prevout];
765 }
766 NodeContext &node = EnsureAnyNodeContext(request.context);
767 FindCoins(node, coins);
768
769 // Parse the prevtxs array
770 ParsePrevouts(request.params[2], &keystore, coins);
771
772 UniValue result(UniValue::VOBJ);
773 SignTransaction(mtx, &keystore, coins, request.params[3], result);
774 return result;
775 },
776 };
777}
778
779static RPCHelpMan decodepsbt() {
780 return RPCHelpMan{
781 "decodepsbt",
782 "Return a JSON object representing the serialized, base64-encoded "
783 "partially signed Bitcoin transaction.\n",
784 {
785 {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
786 "The PSBT base64 string"},
787 },
788 RPCResult{
789 RPCResult::Type::OBJ,
790 "",
791 "",
792 {
793 {RPCResult::Type::OBJ,
794 "tx",
795 "The decoded network-serialized unsigned transaction.",
796 {
797 {RPCResult::Type::ELISION, "",
798 "The layout is the same as the output of "
799 "decoderawtransaction."},
800 }},
801 {RPCResult::Type::OBJ_DYN,
802 "unknown",
803 "The unknown global fields",
804 {
805 {RPCResult::Type::STR_HEX, "key",
806 "(key-value pair) An unknown key-value pair"},
807 }},
808 {RPCResult::Type::ARR,
809 "inputs",
810 "",
811 {
812 {RPCResult::Type::OBJ,
813 "",
814 "",
815 {
816 {RPCResult::Type::OBJ,
817 "utxo",
818 /* optional */ true,
819 "Transaction output for UTXOs",
820 {
821 {RPCResult::Type::NUM, "amount",
822 "The value in " + Currency::get().ticker},
823 {RPCResult::Type::OBJ,
824 "scriptPubKey",
825 "",
826 {
827 {RPCResult::Type::STR, "asm", "The asm"},
828 {RPCResult::Type::STR_HEX, "hex",
829 "The hex"},
830 {RPCResult::Type::STR, "type",
831 "The type, eg 'pubkeyhash'"},
832 {RPCResult::Type::STR, "address",
833 " Bitcoin address if there is one"},
834 }},
835 }},
836 {RPCResult::Type::OBJ_DYN,
837 "partial_signatures",
838 /* optional */ true,
839 "",
840 {
841 {RPCResult::Type::STR, "pubkey",
842 "The public key and signature that corresponds "
843 "to it."},
844 }},
845 {RPCResult::Type::STR, "sighash", /* optional */ true,
846 "The sighash type to be used"},
847 {RPCResult::Type::OBJ,
848 "redeem_script",
849 /* optional */ true,
850 "",
851 {
852 {RPCResult::Type::STR, "asm", "The asm"},
853 {RPCResult::Type::STR_HEX, "hex", "The hex"},
854 {RPCResult::Type::STR, "type",
855 "The type, eg 'pubkeyhash'"},
856 }},
857 {RPCResult::Type::ARR,
858 "bip32_derivs",
859 /* optional */ true,
860 "",
861 {
862 {RPCResult::Type::OBJ,
863 "pubkey",
864 /* optional */ true,
865 "The public key with the derivation path as "
866 "the value.",
867 {
868 {RPCResult::Type::STR, "master_fingerprint",
869 "The fingerprint of the master key"},
870 {RPCResult::Type::STR, "path", "The path"},
871 }},
872 }},
873 {RPCResult::Type::OBJ,
874 "final_scriptsig",
875 /* optional */ true,
876 "",
877 {
878 {RPCResult::Type::STR, "asm", "The asm"},
879 {RPCResult::Type::STR, "hex", "The hex"},
880 }},
881 {RPCResult::Type::OBJ_DYN,
882 "unknown",
883 "The unknown global fields",
884 {
885 {RPCResult::Type::STR_HEX, "key",
886 "(key-value pair) An unknown key-value pair"},
887 }},
888 }},
889 }},
890 {RPCResult::Type::ARR,
891 "outputs",
892 "",
893 {
894 {RPCResult::Type::OBJ,
895 "",
896 "",
897 {
898 {RPCResult::Type::OBJ,
899 "redeem_script",
900 /* optional */ true,
901 "",
902 {
903 {RPCResult::Type::STR, "asm", "The asm"},
904 {RPCResult::Type::STR_HEX, "hex", "The hex"},
905 {RPCResult::Type::STR, "type",
906 "The type, eg 'pubkeyhash'"},
907 }},
908 {RPCResult::Type::ARR,
909 "bip32_derivs",
910 /* optional */ true,
911 "",
912 {
913 {RPCResult::Type::OBJ,
914 "",
915 "",
916 {
917 {RPCResult::Type::STR, "pubkey",
918 "The public key this path corresponds to"},
919 {RPCResult::Type::STR, "master_fingerprint",
920 "The fingerprint of the master key"},
921 {RPCResult::Type::STR, "path", "The path"},
922 }},
923 }},
924 {RPCResult::Type::OBJ_DYN,
925 "unknown",
926 "The unknown global fields",
927 {
928 {RPCResult::Type::STR_HEX, "key",
929 "(key-value pair) An unknown key-value pair"},
930 }},
931 }},
932 }},
933 {RPCResult::Type::STR_AMOUNT, "fee", /* optional */ true,
934 "The transaction fee paid if all UTXOs slots in the PSBT have "
935 "been filled."},
936 }},
937 RPCExamples{HelpExampleCli("decodepsbt", "\"psbt\"")},
938 [&](const RPCHelpMan &self, const Config &config,
939 const JSONRPCRequest &request) -> UniValue {
940 // Unserialize the transactions
941 PartiallySignedTransaction psbtx;
942 std::string error;
943 if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
944 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
945 strprintf("TX decode failed %s", error));
946 }
947
948 UniValue result(UniValue::VOBJ);
949
950 // Add the decoded tx
951 UniValue tx_univ(UniValue::VOBJ);
952 TxToUniv(CTransaction(*psbtx.tx), BlockHash(), tx_univ, false);
953 result.pushKV("tx", tx_univ);
954
955 // Unknown data
956 if (psbtx.unknown.size() > 0) {
957 UniValue unknowns(UniValue::VOBJ);
958 for (auto entry : psbtx.unknown) {
959 unknowns.pushKV(HexStr(entry.first), HexStr(entry.second));
960 }
961 result.pushKV("unknown", unknowns);
962 }
963
964 // inputs
965 Amount total_in = Amount::zero();
966 bool have_all_utxos = true;
967 UniValue inputs(UniValue::VARR);
968 for (size_t i = 0; i < psbtx.inputs.size(); ++i) {
969 const PSBTInput &input = psbtx.inputs[i];
970 UniValue in(UniValue::VOBJ);
971 // UTXOs
972 if (!input.utxo.IsNull()) {
973 const CTxOut &txout = input.utxo;
974
975 UniValue out(UniValue::VOBJ);
976
977 out.pushKV("amount", txout.nValue);
978 if (MoneyRange(txout.nValue) &&
979 MoneyRange(total_in + txout.nValue)) {
980 total_in += txout.nValue;
981 } else {
982 // Hack to just not show fee later
983 have_all_utxos = false;
984 }
985
986 UniValue o(UniValue::VOBJ);
987 ScriptToUniv(txout.scriptPubKey, o, true);
988 out.pushKV("scriptPubKey", o);
989 in.pushKV("utxo", out);
990 } else {
991 have_all_utxos = false;
992 }
993
994 // Partial sigs
995 if (!input.partial_sigs.empty()) {
996 UniValue partial_sigs(UniValue::VOBJ);
997 for (const auto &sig : input.partial_sigs) {
998 partial_sigs.pushKV(HexStr(sig.second.first),
999 HexStr(sig.second.second));
1000 }
1001 in.pushKV("partial_signatures", partial_sigs);
1002 }
1003
1004 // Sighash
1005 uint8_t sighashbyte =
1006 input.sighash_type.getRawSigHashType() & 0xff;
1007 if (sighashbyte > 0) {
1008 in.pushKV("sighash", SighashToStr(sighashbyte));
1009 }
1010
1011 // Redeem script
1012 if (!input.redeem_script.empty()) {
1013 UniValue r(UniValue::VOBJ);
1014 ScriptToUniv(input.redeem_script, r, false);
1015 in.pushKV("redeem_script", r);
1016 }
1017
1018 // keypaths
1019 if (!input.hd_keypaths.empty()) {
1020 UniValue keypaths(UniValue::VARR);
1021 for (auto entry : input.hd_keypaths) {
1022 UniValue keypath(UniValue::VOBJ);
1023 keypath.pushKV("pubkey", HexStr(entry.first));
1024
1025 keypath.pushKV(
1026 "master_fingerprint",
1027 strprintf("%08x",
1028 ReadBE32(entry.second.fingerprint)));
1029 keypath.pushKV("path",
1030 WriteHDKeypath(entry.second.path));
1031 keypaths.push_back(keypath);
1032 }
1033 in.pushKV("bip32_derivs", keypaths);
1034 }
1035
1036 // Final scriptSig
1037 if (!input.final_script_sig.empty()) {
1038 UniValue scriptsig(UniValue::VOBJ);
1039 scriptsig.pushKV(
1040 "asm", ScriptToAsmStr(input.final_script_sig, true));
1041 scriptsig.pushKV("hex", HexStr(input.final_script_sig));
1042 in.pushKV("final_scriptSig", scriptsig);
1043 }
1044
1045 // Unknown data
1046 if (input.unknown.size() > 0) {
1047 UniValue unknowns(UniValue::VOBJ);
1048 for (auto entry : input.unknown) {
1049 unknowns.pushKV(HexStr(entry.first),
1050 HexStr(entry.second));
1051 }
1052 in.pushKV("unknown", unknowns);
1053 }
1054
1055 inputs.push_back(in);
1056 }
1057 result.pushKV("inputs", inputs);
1058
1059 // outputs
1060 Amount output_value = Amount::zero();
1061 UniValue outputs(UniValue::VARR);
1062 for (size_t i = 0; i < psbtx.outputs.size(); ++i) {
1063 const PSBTOutput &output = psbtx.outputs[i];
1064 UniValue out(UniValue::VOBJ);
1065 // Redeem script
1066 if (!output.redeem_script.empty()) {
1067 UniValue r(UniValue::VOBJ);
1068 ScriptToUniv(output.redeem_script, r, false);
1069 out.pushKV("redeem_script", r);
1070 }
1071
1072 // keypaths
1073 if (!output.hd_keypaths.empty()) {
1074 UniValue keypaths(UniValue::VARR);
1075 for (auto entry : output.hd_keypaths) {
1076 UniValue keypath(UniValue::VOBJ);
1077 keypath.pushKV("pubkey", HexStr(entry.first));
1078 keypath.pushKV(
1079 "master_fingerprint",
1080 strprintf("%08x",
1081 ReadBE32(entry.second.fingerprint)));
1082 keypath.pushKV("path",
1083 WriteHDKeypath(entry.second.path));
1084 keypaths.push_back(keypath);
1085 }
1086 out.pushKV("bip32_derivs", keypaths);
1087 }
1088
1089 // Unknown data
1090 if (output.unknown.size() > 0) {
1091 UniValue unknowns(UniValue::VOBJ);
1092 for (auto entry : output.unknown) {
1093 unknowns.pushKV(HexStr(entry.first),
1094 HexStr(entry.second));
1095 }
1096 out.pushKV("unknown", unknowns);
1097 }
1098
1099 outputs.push_back(out);
1100
1101 // Fee calculation
1102 if (MoneyRange(psbtx.tx->vout[i].nValue) &&
1103 MoneyRange(output_value + psbtx.tx->vout[i].nValue)) {
1104 output_value += psbtx.tx->vout[i].nValue;
1105 } else {
1106 // Hack to just not show fee later
1107 have_all_utxos = false;
1108 }
1109 }
1110 result.pushKV("outputs", outputs);
1111 if (have_all_utxos) {
1112 result.pushKV("fee", total_in - output_value);
1113 }
1114
1115 return result;
1116 },
1117 };
1118}
1119
1120static RPCHelpMan combinepsbt() {
1121 return RPCHelpMan{
1122 "combinepsbt",
1123 "Combine multiple partially signed Bitcoin transactions into one "
1124 "transaction.\n"
1125 "Implements the Combiner role.\n",
1126 {
1127 {
1128 "txs",
1129 RPCArg::Type::ARR,
1130 RPCArg::Optional::NO,
1131 "The base64 strings of partially signed transactions",
1132 {
1133 {"psbt", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
1134 "A base64 string of a PSBT"},
1135 },
1136 },
1137 },
1138 RPCResult{RPCResult::Type::STR, "",
1139 "The base64-encoded partially signed transaction"},
1140 RPCExamples{HelpExampleCli(
1141 "combinepsbt", R"('["mybase64_1", "mybase64_2", "mybase64_3"]')")},
1142 [&](const RPCHelpMan &self, const Config &config,
1143 const JSONRPCRequest &request) -> UniValue {
1144 // Unserialize the transactions
1145 std::vector<PartiallySignedTransaction> psbtxs;
1146 UniValue txs = request.params[0].get_array();
1147 if (txs.empty()) {
1148 throw JSONRPCError(RPC_INVALID_PARAMETER,
1149 "Parameter 'txs' cannot be empty");
1150 }
1151 for (size_t i = 0; i < txs.size(); ++i) {
1152 PartiallySignedTransaction psbtx;
1153 std::string error;
1154 if (!DecodeBase64PSBT(psbtx, txs[i].get_str(), error)) {
1155 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
1156 strprintf("TX decode failed %s", error));
1157 }
1158 psbtxs.push_back(psbtx);
1159 }
1160
1161 PartiallySignedTransaction merged_psbt;
1162 const TransactionError error = CombinePSBTs(merged_psbt, psbtxs);
1163 if (error != TransactionError::OK) {
1164 throw JSONRPCTransactionError(error);
1165 }
1166
1167 CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
1168 ssTx << merged_psbt;
1169 return EncodeBase64(ssTx);
1170 },
1171 };
1172}
1173
1174static RPCHelpMan finalizepsbt() {
1175 return RPCHelpMan{
1176 "finalizepsbt",
1177 "Finalize the inputs of a PSBT. If the transaction is fully signed, it "
1178 "will produce a\n"
1179 "network serialized transaction which can be broadcast with "
1180 "sendrawtransaction. Otherwise a PSBT will be\n"
1181 "created which has the final_scriptSigfields filled for inputs that "
1182 "are complete.\n"
1183 "Implements the Finalizer and Extractor roles.\n",
1184 {
1185 {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
1186 "A base64 string of a PSBT"},
1187 {"extract", RPCArg::Type::BOOL, RPCArg::Default{true},
1188 "If true and the transaction is complete,\n"
1189 " extract and return the complete "
1190 "transaction in normal network serialization instead of the "
1191 "PSBT."},
1192 },
1193 RPCResult{RPCResult::Type::OBJ,
1194 "",
1195 "",
1196 {
1197 {RPCResult::Type::STR, "psbt",
1198 "The base64-encoded partially signed transaction if not "
1199 "extracted"},
1200 {RPCResult::Type::STR_HEX, "hex",
1201 "The hex-encoded network transaction if extracted"},
1202 {RPCResult::Type::BOOL, "complete",
1203 "If the transaction has a complete set of signatures"},
1204 }},
1205 RPCExamples{HelpExampleCli("finalizepsbt", "\"psbt\"")},
1206 [&](const RPCHelpMan &self, const Config &config,
1207 const JSONRPCRequest &request) -> UniValue {
1208 // Unserialize the transactions
1209 PartiallySignedTransaction psbtx;
1210 std::string error;
1211 if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
1212 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
1213 strprintf("TX decode failed %s", error));
1214 }
1215
1216 bool extract =
1217 request.params[1].isNull() ||
1218 (!request.params[1].isNull() && request.params[1].get_bool());
1219
1220 CMutableTransaction mtx;
1221 bool complete = FinalizeAndExtractPSBT(psbtx, mtx);
1222
1223 UniValue result(UniValue::VOBJ);
1224 CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
1225 std::string result_str;
1226
1227 if (complete && extract) {
1228 ssTx << mtx;
1229 result_str = HexStr(ssTx);
1230 result.pushKV("hex", result_str);
1231 } else {
1232 ssTx << psbtx;
1233 result_str = EncodeBase64(ssTx.str());
1234 result.pushKV("psbt", result_str);
1235 }
1236 result.pushKV("complete", complete);
1237
1238 return result;
1239 },
1240 };
1241}
1242
1243static RPCHelpMan createpsbt() {
1244 return RPCHelpMan{
1245 "createpsbt",
1246 "Creates a transaction in the Partially Signed Transaction format.\n"
1247 "Implements the Creator role.\n",
1248 {
1249 {
1250 "inputs",
1251 RPCArg::Type::ARR,
1252 RPCArg::Optional::NO,
1253 "The json objects",
1254 {
1255 {
1256 "",
1257 RPCArg::Type::OBJ,
1258 RPCArg::Optional::OMITTED,
1259 "",
1260 {
1261 {"txid", RPCArg::Type::STR_HEX,
1262 RPCArg::Optional::NO, "The transaction id"},
1263 {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO,
1264 "The output number"},
1265 {"sequence", RPCArg::Type::NUM,
1266 RPCArg::DefaultHint{"depends on the value of the "
1267 "'locktime' argument"},
1268 "The sequence number"},
1269 },
1270 },
1271 },
1272 },
1273 {"outputs",
1274 RPCArg::Type::ARR,
1275 RPCArg::Optional::NO,
1276 "The outputs (key-value pairs), where none of "
1277 "the keys are duplicated.\n"
1278 "That is, each address can only appear once and there can only "
1279 "be one 'data' object.\n"
1280 "For compatibility reasons, a dictionary, which holds the "
1281 "key-value pairs directly, is also\n"
1282 " accepted as second parameter.",
1283 {
1284 {
1285 "",
1286 RPCArg::Type::OBJ_USER_KEYS,
1287 RPCArg::Optional::OMITTED,
1288 "",
1289 {
1290 {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO,
1291 "A key-value pair. The key (string) is the "
1292 "bitcoin address, the value (float or string) is "
1293 "the amount in " +
1294 Currency::get().ticker},
1295 },
1296 },
1297 {
1298 "",
1299 RPCArg::Type::OBJ,
1300 RPCArg::Optional::OMITTED,
1301 "",
1302 {
1303 {"data", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
1304 "A key-value pair. The key must be \"data\", the "
1305 "value is hex-encoded data"},
1306 },
1307 },
1308 },
1309 RPCArgOptions{.skip_type_check = true}},
1310 {"locktime", RPCArg::Type::NUM, RPCArg::Default{0},
1311 "Raw locktime. Non-0 value also locktime-activates inputs"},
1312 },
1313 RPCResult{RPCResult::Type::STR, "",
1314 "The resulting raw transaction (base64-encoded string)"},
1315 RPCExamples{HelpExampleCli(
1316 "createpsbt", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
1317 "\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"")},
1318 [&](const RPCHelpMan &self, const Config &config,
1319 const JSONRPCRequest &request) -> UniValue {
1320 CMutableTransaction rawTx =
1321 ConstructTransaction(config.GetChainParams(), request.params[0],
1322 request.params[1], request.params[2]);
1323
1324 // Make a blank psbt
1325 PartiallySignedTransaction psbtx;
1326 psbtx.tx = rawTx;
1327 for (size_t i = 0; i < rawTx.vin.size(); ++i) {
1328 psbtx.inputs.push_back(PSBTInput());
1329 }
1330 for (size_t i = 0; i < rawTx.vout.size(); ++i) {
1331 psbtx.outputs.push_back(PSBTOutput());
1332 }
1333
1334 // Serialize the PSBT
1335 CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
1336 ssTx << psbtx;
1337
1338 return EncodeBase64(ssTx);
1339 },
1340 };
1341}
1342
1343static RPCHelpMan converttopsbt() {
1344 return RPCHelpMan{
1345 "converttopsbt",
1346 "Converts a network serialized transaction to a PSBT. "
1347 "This should be used only with createrawtransaction and "
1348 "fundrawtransaction\n"
1349 "createpsbt and walletcreatefundedpsbt should be used for new "
1350 "applications.\n",
1351 {
1352 {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
1353 "The hex string of a raw transaction"},
1354 {"permitsigdata", RPCArg::Type::BOOL, RPCArg::Default{false},
1355 "If true, any signatures in the input will be discarded and "
1356 "conversion.\n"
1357 " will continue. If false, RPC will "
1358 "fail if any signatures are present."},
1359 },
1360 RPCResult{RPCResult::Type::STR, "",
1361 "The resulting raw transaction (base64-encoded string)"},
1362 RPCExamples{
1363 "\nCreate a transaction\n" +
1364 HelpExampleCli("createrawtransaction",
1365 "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]"
1366 "\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"") +
1367 "\nConvert the transaction to a PSBT\n" +
1368 HelpExampleCli("converttopsbt", "\"rawtransaction\"")},
1369 [&](const RPCHelpMan &self, const Config &config,
1370 const JSONRPCRequest &request) -> UniValue {
1371 // parse hex string from parameter
1372 CMutableTransaction tx;
1373 bool permitsigdata = request.params[1].isNull()
1374 ? false
1375 : request.params[1].get_bool();
1376 if (!DecodeHexTx(tx, request.params[0].get_str())) {
1377 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
1378 "TX decode failed");
1379 }
1380
1381 // Remove all scriptSigs from inputs
1382 for (CTxIn &input : tx.vin) {
1383 if (!input.scriptSig.empty() && !permitsigdata) {
1384 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
1385 "Inputs must not have scriptSigs");
1386 }
1387 input.scriptSig.clear();
1388 }
1389
1390 // Make a blank psbt
1391 PartiallySignedTransaction psbtx;
1392 psbtx.tx = tx;
1393 for (size_t i = 0; i < tx.vin.size(); ++i) {
1394 psbtx.inputs.push_back(PSBTInput());
1395 }
1396 for (size_t i = 0; i < tx.vout.size(); ++i) {
1397 psbtx.outputs.push_back(PSBTOutput());
1398 }
1399
1400 // Serialize the PSBT
1401 CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
1402 ssTx << psbtx;
1403
1404 return EncodeBase64(ssTx);
1405 },
1406 };
1407}
1408
1409RPCHelpMan utxoupdatepsbt() {
1410 return RPCHelpMan{
1411 "utxoupdatepsbt",
1412 "Updates all inputs and outputs in a PSBT with data from output "
1413 "descriptors, the UTXO set or the mempool.\n",
1414 {
1415 {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
1416 "A base64 string of a PSBT"},
1417 {"descriptors",
1418 RPCArg::Type::ARR,
1419 RPCArg::Optional::OMITTED,
1420 "An array of either strings or objects",
1421 {
1422 {"", RPCArg::Type::STR, RPCArg::Optional::OMITTED,
1423 "An output descriptor"},
1424 {"",
1425 RPCArg::Type::OBJ,
1426 RPCArg::Optional::OMITTED,
1427 "An object with an output descriptor and extra information",
1428 {
1429 {"desc", RPCArg::Type::STR, RPCArg::Optional::NO,
1430 "An output descriptor"},
1431 {"range", RPCArg::Type::RANGE, RPCArg::Default{1000},
1432 "Up to what index HD chains should be explored (either "
1433 "end or [begin,end])"},
1434 }},
1435 }},
1436 },
1437 RPCResult{RPCResult::Type::STR, "",
1438 "The base64-encoded partially signed transaction with inputs "
1439 "updated"},
1440 RPCExamples{HelpExampleCli("utxoupdatepsbt", "\"psbt\"")},
1441 [&](const RPCHelpMan &self, const Config &config,
1442 const JSONRPCRequest &request) -> UniValue {
1443 // Unserialize the transactions
1444 PartiallySignedTransaction psbtx;
1445 std::string error;
1446 if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
1447 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
1448 strprintf("TX decode failed %s", error));
1449 }
1450
1451 // Parse descriptors, if any.
1452 FlatSigningProvider provider;
1453 if (!request.params[1].isNull()) {
1454 auto descs = request.params[1].get_array();
1455 for (size_t i = 0; i < descs.size(); ++i) {
1456 EvalDescriptorStringOrObject(descs[i], provider);
1457 }
1458 }
1459 // We don't actually need private keys further on; hide them as a
1460 // precaution.
1461 HidingSigningProvider public_provider(&provider, /* nosign */ true,
1462 /* nobip32derivs */ false);
1463
1464 // Fetch previous transactions (inputs):
1465 CCoinsView viewDummy;
1466 CCoinsViewCache view(&viewDummy);
1467 {
1468 NodeContext &node = EnsureAnyNodeContext(request.context);
1469 const CTxMemPool &mempool = EnsureMemPool(node);
1470 ChainstateManager &chainman = EnsureChainman(node);
1471 LOCK2(cs_main, mempool.cs);
1472 CCoinsViewCache &viewChain =
1473 chainman.ActiveChainstate().CoinsTip();
1474 CCoinsViewMemPool viewMempool(&viewChain, mempool);
1475 // temporarily switch cache backend to db+mempool view
1476 view.SetBackend(viewMempool);
1477
1478 for (const CTxIn &txin : psbtx.tx->vin) {
1479 // Load entries from viewChain into view; can fail.
1480 view.AccessCoin(txin.prevout);
1481 }
1482
1483 // switch back to avoid locking mempool for too long
1484 view.SetBackend(viewDummy);
1485 }
1486
1487 // Fill the inputs
1488 for (size_t i = 0; i < psbtx.tx->vin.size(); ++i) {
1489 PSBTInput &input = psbtx.inputs.at(i);
1490
1491 if (!input.utxo.IsNull()) {
1492 continue;
1493 }
1494
1495 // Update script/keypath information using descriptor data.
1496 // Note that SignPSBTInput does a lot more than just
1497 // constructing ECDSA signatures we don't actually care about
1498 // those here, in fact.
1499 SignPSBTInput(public_provider, psbtx, i,
1500 /* sighash_type */ SigHashType().withForkId());
1501 }
1502
1503 // Update script/keypath information using descriptor data.
1504 for (unsigned int i = 0; i < psbtx.tx->vout.size(); ++i) {
1505 UpdatePSBTOutput(public_provider, psbtx, i);
1506 }
1507
1508 CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
1509 ssTx << psbtx;
1510 return EncodeBase64(ssTx);
1511 },
1512 };
1513}
1514
1515RPCHelpMan joinpsbts() {
1516 return RPCHelpMan{
1517 "joinpsbts",
1518 "Joins multiple distinct PSBTs with different inputs and outputs "
1519 "into one PSBT with inputs and outputs from all of the PSBTs\n"
1520 "No input in any of the PSBTs can be in more than one of the PSBTs.\n",
1521 {{"txs",
1522 RPCArg::Type::ARR,
1523 RPCArg::Optional::NO,
1524 "The base64 strings of partially signed transactions",
1525 {{"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
1526 "A base64 string of a PSBT"}}}},
1527 RPCResult{RPCResult::Type::STR, "",
1528 "The base64-encoded partially signed transaction"},
1529 RPCExamples{HelpExampleCli("joinpsbts", "\"psbt\"")},
1530 [&](const RPCHelpMan &self, const Config &config,
1531 const JSONRPCRequest &request) -> UniValue {
1532 // Unserialize the transactions
1533 std::vector<PartiallySignedTransaction> psbtxs;
1534 UniValue txs = request.params[0].get_array();
1535
1536 if (txs.size() <= 1) {
1537 throw JSONRPCError(
1538 RPC_INVALID_PARAMETER,
1539 "At least two PSBTs are required to join PSBTs.");
1540 }
1541
1542 uint32_t best_version = 1;
1543 uint32_t best_locktime = 0xffffffff;
1544 for (size_t i = 0; i < txs.size(); ++i) {
1545 PartiallySignedTransaction psbtx;
1546 std::string error;
1547 if (!DecodeBase64PSBT(psbtx, txs[i].get_str(), error)) {
1548 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
1549 strprintf("TX decode failed %s", error));
1550 }
1551 psbtxs.push_back(psbtx);
1552 // Choose the highest version number
1553 if (static_cast<uint32_t>(psbtx.tx->nVersion) > best_version) {
1554 best_version = static_cast<uint32_t>(psbtx.tx->nVersion);
1555 }
1556 // Choose the lowest lock time
1557 if (psbtx.tx->nLockTime < best_locktime) {
1558 best_locktime = psbtx.tx->nLockTime;
1559 }
1560 }
1561
1562 // Create a blank psbt where everything will be added
1563 PartiallySignedTransaction merged_psbt;
1564 merged_psbt.tx = CMutableTransaction();
1565 merged_psbt.tx->nVersion = static_cast<int32_t>(best_version);
1566 merged_psbt.tx->nLockTime = best_locktime;
1567
1568 // Merge
1569 for (auto &psbt : psbtxs) {
1570 for (size_t i = 0; i < psbt.tx->vin.size(); ++i) {
1571 if (!merged_psbt.AddInput(psbt.tx->vin[i],
1572 psbt.inputs[i])) {
1573 throw JSONRPCError(
1574 RPC_INVALID_PARAMETER,
1575 strprintf("Input %s:%d exists in multiple PSBTs",
1576 psbt.tx->vin[i]
1577 .prevout.GetTxId()
1578 .ToString()
1579 .c_str(),
1580 psbt.tx->vin[i].prevout.GetN()));
1581 }
1582 }
1583 for (size_t i = 0; i < psbt.tx->vout.size(); ++i) {
1584 merged_psbt.AddOutput(psbt.tx->vout[i], psbt.outputs[i]);
1585 }
1586 merged_psbt.unknown.insert(psbt.unknown.begin(),
1587 psbt.unknown.end());
1588 }
1589
1590 // Generate list of shuffled indices for shuffling inputs and
1591 // outputs of the merged PSBT
1592 std::vector<int> input_indices(merged_psbt.inputs.size());
1593 std::iota(input_indices.begin(), input_indices.end(), 0);
1594 std::vector<int> output_indices(merged_psbt.outputs.size());
1595 std::iota(output_indices.begin(), output_indices.end(), 0);
1596
1597 // Shuffle input and output indices lists
1598 Shuffle(input_indices.begin(), input_indices.end(),
1599 FastRandomContext());
1600 Shuffle(output_indices.begin(), output_indices.end(),
1601 FastRandomContext());
1602
1603 PartiallySignedTransaction shuffled_psbt;
1604 shuffled_psbt.tx = CMutableTransaction();
1605 shuffled_psbt.tx->nVersion = merged_psbt.tx->nVersion;
1606 shuffled_psbt.tx->nLockTime = merged_psbt.tx->nLockTime;
1607 for (int i : input_indices) {
1608 shuffled_psbt.AddInput(merged_psbt.tx->vin[i],
1609 merged_psbt.inputs[i]);
1610 }
1611 for (int i : output_indices) {
1612 shuffled_psbt.AddOutput(merged_psbt.tx->vout[i],
1613 merged_psbt.outputs[i]);
1614 }
1615 shuffled_psbt.unknown.insert(merged_psbt.unknown.begin(),
1616 merged_psbt.unknown.end());
1617
1618 CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
1619 ssTx << shuffled_psbt;
1620 return EncodeBase64(ssTx);
1621 },
1622 };
1623}
1624
1625RPCHelpMan analyzepsbt() {
1626 return RPCHelpMan{
1627 "analyzepsbt",
1628 "Analyzes and provides information about the current status of a "
1629 "PSBT and its inputs\n",
1630 {{"psbt", RPCArg::Type::STR, RPCArg::Optional::NO,
1631 "A base64 string of a PSBT"}},
1632 RPCResult{
1633 RPCResult::Type::OBJ,
1634 "",
1635 "",
1636 {
1637 {RPCResult::Type::ARR,
1638 "inputs",
1639 "",
1640 {
1641 {RPCResult::Type::OBJ,
1642 "",
1643 "",
1644 {
1645 {RPCResult::Type::BOOL, "has_utxo",
1646 "Whether a UTXO is provided"},
1647 {RPCResult::Type::BOOL, "is_final",
1648 "Whether the input is finalized"},
1649 {RPCResult::Type::OBJ,
1650 "missing",
1651 /* optional */ true,
1652 "Things that are missing that are required to "
1653 "complete this input",
1654 {
1655 {RPCResult::Type::ARR,
1656 "pubkeys",
1657 /* optional */ true,
1658 "",
1659 {
1660 {RPCResult::Type::STR_HEX, "keyid",
1661 "Public key ID, hash160 of the public "
1662 "key, of a public key whose BIP 32 "
1663 "derivation path is missing"},
1664 }},
1665 {RPCResult::Type::ARR,
1666 "signatures",
1667 /* optional */ true,
1668 "",
1669 {
1670 {RPCResult::Type::STR_HEX, "keyid",
1671 "Public key ID, hash160 of the public "
1672 "key, of a public key whose signature is "
1673 "missing"},
1674 }},
1675 {RPCResult::Type::STR_HEX, "redeemscript",
1676 /* optional */ true,
1677 "Hash160 of the redeemScript that is missing"},
1678 }},
1679 {RPCResult::Type::STR, "next", /* optional */ true,
1680 "Role of the next person that this input needs to "
1681 "go to"},
1682 }},
1683 }},
1684 {RPCResult::Type::NUM, "estimated_vsize", /* optional */ true,
1685 "Estimated vsize of the final signed transaction"},
1686 {RPCResult::Type::STR_AMOUNT, "estimated_feerate",
1687 /* optional */ true,
1688 "Estimated feerate of the final signed transaction in " +
1689 Currency::get().ticker +
1690 "/kB. Shown only if all UTXO slots in the PSBT have been "
1691 "filled"},
1692 {RPCResult::Type::STR_AMOUNT, "fee", /* optional */ true,
1693 "The transaction fee paid. Shown only if all UTXO slots in "
1694 "the PSBT have been filled"},
1695 {RPCResult::Type::STR, "next",
1696 "Role of the next person that this psbt needs to go to"},
1697 {RPCResult::Type::STR, "error", /* optional */ true,
1698 "Error message (if there is one)"},
1699 }},
1700 RPCExamples{HelpExampleCli("analyzepsbt", "\"psbt\"")},
1701 [&](const RPCHelpMan &self, const Config &config,
1702 const JSONRPCRequest &request) -> UniValue {
1703 // Unserialize the transaction
1704 PartiallySignedTransaction psbtx;
1705 std::string error;
1706 if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
1707 throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
1708 strprintf("TX decode failed %s", error));
1709 }
1710
1711 PSBTAnalysis psbta = AnalyzePSBT(psbtx);
1712
1713 UniValue result(UniValue::VOBJ);
1714 UniValue inputs_result(UniValue::VARR);
1715 for (const auto &input : psbta.inputs) {
1716 UniValue input_univ(UniValue::VOBJ);
1717 UniValue missing(UniValue::VOBJ);
1718
1719 input_univ.pushKV("has_utxo", input.has_utxo);
1720 input_univ.pushKV("is_final", input.is_final);
1721 input_univ.pushKV("next", PSBTRoleName(input.next));
1722
1723 if (!input.missing_pubkeys.empty()) {
1724 UniValue missing_pubkeys_univ(UniValue::VARR);
1725 for (const CKeyID &pubkey : input.missing_pubkeys) {
1726 missing_pubkeys_univ.push_back(HexStr(pubkey));
1727 }
1728 missing.pushKV("pubkeys", missing_pubkeys_univ);
1729 }
1730 if (!input.missing_redeem_script.IsNull()) {
1731 missing.pushKV("redeemscript",
1732 HexStr(input.missing_redeem_script));
1733 }
1734 if (!input.missing_sigs.empty()) {
1735 UniValue missing_sigs_univ(UniValue::VARR);
1736 for (const CKeyID &pubkey : input.missing_sigs) {
1737 missing_sigs_univ.push_back(HexStr(pubkey));
1738 }
1739 missing.pushKV("signatures", missing_sigs_univ);
1740 }
1741 if (!missing.getKeys().empty()) {
1742 input_univ.pushKV("missing", missing);
1743 }
1744 inputs_result.push_back(input_univ);
1745 }
1746 if (!inputs_result.empty()) {
1747 result.pushKV("inputs", inputs_result);
1748 }
1749 if (psbta.estimated_vsize != std::nullopt) {
1750 result.pushKV("estimated_vsize", (int)*psbta.estimated_vsize);
1751 }
1752 if (psbta.estimated_feerate != std::nullopt) {
1753 result.pushKV("estimated_feerate",
1754 psbta.estimated_feerate->GetFeePerK());
1755 }
1756 if (psbta.fee != std::nullopt) {
1757 result.pushKV("fee", *psbta.fee);
1758 }
1759 result.pushKV("next", PSBTRoleName(psbta.next));
1760 if (!psbta.error.empty()) {
1761 result.pushKV("error", psbta.error);
1762 }
1763
1764 return result;
1765 },
1766 };
1767}
1768
1769RPCHelpMan gettransactionstatus() {
1770 return RPCHelpMan{
1771 "gettransactionstatus",
1772 "Return the current pool a transaction belongs to\n",
1773 {
1774 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO,
1775 "The transaction id"},
1776 },
1777 RPCResult{
1778 RPCResult::Type::OBJ,
1779 "",
1780 "",
1781 {
1782 {RPCResult::Type::STR, "pool",
1783 "In which pool the transaction is currently located, "
1784 "either none, mempool, orphanage or conflicting"},
1785 {RPCResult::Type::STR, "block",
1786 "If the transaction is mined, this is the blockhash of the "
1787 "mining block, otherwise \"none\". This field is only "
1788 "present if -txindex is enabled."},
1789 }},
1790 RPCExamples{HelpExampleCli("gettransactionstatus", "\"txid\"")},
1791 [&](const RPCHelpMan &self, const Config &config,
1792 const JSONRPCRequest &request) -> UniValue {
1793 const NodeContext &node = EnsureAnyNodeContext(request.context);
1794 CTxMemPool &mempool = EnsureMemPool(node);
1795
1796 TxId txid = TxId(ParseHashV(request.params[0], "parameter 1"));
1797
1798 UniValue ret(UniValue::VOBJ);
1799
1800 if (mempool.exists(txid)) {
1801 ret.pushKV("pool", "mempool");
1802 } else if (mempool.withOrphanage(
1803 [&txid](const TxOrphanage &orphanage) {
1804 return orphanage.HaveTx(txid);
1805 })) {
1806 ret.pushKV("pool", "orphanage");
1807 } else if (mempool.withConflicting(
1808 [&txid](const TxConflicting &conflicting) {
1809 return conflicting.HaveTx(txid);
1810 })) {
1811 ret.pushKV("pool", "conflicting");
1812 } else {
1813 ret.pushKV("pool", "none");
1814 }
1815
1816 if (g_txindex) {
1817 if (!g_txindex->BlockUntilSyncedToCurrentChain()) {
1818 throw JSONRPCError(
1819 RPC_MISC_ERROR,
1820 "Blockchain transactions are still in the process of "
1821 "being indexed");
1822 }
1823
1824 CTransactionRef tx;
1825 BlockHash blockhash;
1826 if (g_txindex->FindTx(txid, blockhash, tx)) {
1827 ret.pushKV("block", blockhash.GetHex());
1828 } else {
1829 ret.pushKV("block", "none");
1830 }
1831 }
1832
1833 return ret;
1834 },
1835 };
1836}
1837
1838void RegisterRawTransactionRPCCommands(CRPCTable &t) {
1839 // clang-format off
1840 static const CRPCCommand commands[] = {
1841 // category actor (function)
1842 // ------------------ ----------------------
1843 { "rawtransactions", getrawtransaction, },
1844 { "rawtransactions", createrawtransaction, },
1845 { "rawtransactions", decoderawtransaction, },
1846 { "rawtransactions", decodescript, },
1847 { "rawtransactions", combinerawtransaction, },
1848 { "rawtransactions", signrawtransactionwithkey, },
1849 { "rawtransactions", decodepsbt, },
1850 { "rawtransactions", combinepsbt, },
1851 { "rawtransactions", finalizepsbt, },
1852 { "rawtransactions", createpsbt, },
1853 { "rawtransactions", converttopsbt, },
1854 { "rawtransactions", utxoupdatepsbt, },
1855 { "rawtransactions", joinpsbts, },
1856 { "rawtransactions", analyzepsbt, },
1857 { "rawtransactions", gettransactionstatus, },
1858 };
1859 // clang-format on
1860 for (const auto &c : commands) {
1861 t.appendCommand(c.name, &c);
1862 }
1863}
MoneyRange
bool MoneyRange(const Amount nValue)
Definition: amount.h:166
WriteHDKeypath
std::string WriteHDKeypath(const std::vector< uint32_t > &keypath)
Write HD keypaths as strings.
Definition: bip32.cpp:66
CBlockHeader::hashMerkleRoot
uint256 hashMerkleRoot
Definition: block.h:28
CBlockIndex
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: blockindex.h:25
CBlockIndex::GetBlockTime
int64_t GetBlockTime() const
Definition: blockindex.h:160
CBlockIndex::nHeight
int nHeight
height of the entry in the chain. The genesis block has height 0
Definition: blockindex.h:38
CChain::Height
int Height() const
Return the maximal height in the chain.
Definition: chain.h:186
CChain::Contains
bool Contains(const CBlockIndex *pindex) const
Efficiently check whether a block is present in this chain.
Definition: chain.h:166
CChainParams
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
Definition: chainparams.h:85
CChainParams::GenesisBlock
const CBlock & GenesisBlock() const
Definition: chainparams.h:110
CCoinsViewBacked::SetBackend
void SetBackend(CCoinsView &viewIn)
Definition: coins.cpp:47
CCoinsViewCache
CCoinsView that adds a memory cache for transactions to another CCoinsView.
Definition: coins.h:221
CCoinsViewCache::AccessCoin
const Coin & AccessCoin(const COutPoint &output) const
Return a reference to Coin in the cache, or coinEmpty if not found.
Definition: coins.cpp:196
CCoinsView
Abstract view on the open txout dataset.
Definition: coins.h:163
CCoinsViewMemPool
CCoinsView that brings transactions from a mempool into view.
Definition: txmempool.h:635
CDataStream
Double ended buffer combining vector and stream-like interfaces.
Definition: streams.h:177
CDataStream::str
std::string str() const
Definition: streams.h:212
CKey
An encapsulated secp256k1 private key.
Definition: key.h:28
CKey::IsValid
bool IsValid() const
Check whether this private key is valid.
Definition: key.h:97
CKeyID
A reference to a CKey: the Hash160 of its serialized public key.
Definition: pubkey.h:22
CMutableTransaction
A mutable version of CTransaction.
Definition: transaction.h:274
CMutableTransaction::vout
std::vector< CTxOut > vout
Definition: transaction.h:277
CMutableTransaction::vin
std::vector< CTxIn > vin
Definition: transaction.h:276
CRPCTable
RPC command dispatcher.
Definition: server.h:194
CRPCTable::appendCommand
void appendCommand(const std::string &name, const CRPCCommand *pcmd)
Appends a CRPCCommand to the dispatch table.
Definition: server.cpp:327
CTxMemPool
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
Definition: txmempool.h:214
CTxMemPool::cs
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
Definition: txmempool.h:310
CTxMemPool::exists
bool exists(const TxId &txid) const
Definition: txmempool.h:521
CTxMemPool::withOrphanage
auto withOrphanage(Callable &&func) const EXCLUSIVE_LOCKS_REQUIRED(!cs_orphanage)
Definition: txmempool.h:578
CTxMemPool::withConflicting
auto withConflicting(Callable &&func) const EXCLUSIVE_LOCKS_REQUIRED(!cs_conflicting)
Definition: txmempool.h:586
CTxOut
An output of a transaction.
Definition: transaction.h:128
CTxOut::scriptPubKey
CScript scriptPubKey
Definition: transaction.h:131
CTxOut::nValue
Amount nValue
Definition: transaction.h:130
CTxOut::IsNull
bool IsNull() const
Definition: transaction.h:145
Chainstate
Chainstate stores and provides an API to update our local knowledge of the current best chain.
Definition: validation.h:700
Chainstate::m_chain
CChain m_chain
The current chain of blockheaders we consult and build on.
Definition: validation.h:799
Chainstate::m_blockman
node::BlockManager & m_blockman
Reference to a BlockManager instance which itself is shared across all Chainstate instances.
Definition: validation.h:757
ChainstateManager
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Definition: validation.h:1149
ChainstateManager::ActiveChainstate
SnapshotCompletionResult MaybeCompleteSnapshotValidation(std::function< void(bilingual_str)> shutdown_fnc=[](bilingual_str msg) { AbortNode(msg.original, msg);}) 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:1397
ChainstateManager::ActiveChain
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:1398
ChainstateManager::m_blockman
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
Definition: validation.h:1287
Coin
A UTXO entry.
Definition: coins.h:28
Coin::GetTxOut
CTxOut & GetTxOut()
Definition: coins.h:49
Coin::IsSpent
bool IsSpent() const
Definition: coins.h:47
Config
Definition: config.h:19
FastRandomContext
Fast randomness source.
Definition: random.h:156
FillableSigningProvider
Fillable signing provider that keeps keys in an address->secret map.
Definition: signingprovider.h:76
FillableSigningProvider::AddKey
virtual bool AddKey(const CKey &key)
Definition: signingprovider.h:110
MutableTransactionSignatureCreator
A signature creator for transactions.
Definition: sign.h:38
SigHashType
Signature hash type wrapper class.
Definition: sighashtype.h:37
SigHashType::getRawSigHashType
uint32_t getRawSigHashType() const
Definition: sighashtype.h:83
UniValue::push_back
void push_back(UniValue val)
Definition: univalue.cpp:96
UniValue::get_str
const std::string & get_str() const
Definition: univalue_get.cpp:74
UniValue::find_value
const UniValue & find_value(std::string_view key) const
Definition: univalue.cpp:229
UniValue::VOBJ
@ VOBJ
Definition: univalue.h:31
UniValue::VARR
@ VARR
Definition: univalue.h:32
UniValue::size
size_t size() const
Definition: univalue.h:92
UniValue::getKeys
const std::vector< std::string > & getKeys() const
Definition: univalue_get.cpp:56
UniValue::empty
bool empty() const
Definition: univalue.h:90
UniValue::isStr
bool isStr() const
Definition: univalue.h:108
UniValue::get_array
const UniValue & get_array() const
Definition: univalue_get.cpp:93
UniValue::pushKV
void pushKV(std::string key, UniValue val)
Definition: univalue.cpp:115
base_blob::IsNull
bool IsNull() const
Definition: uint256.h:32
base_blob::GetHex
std::string GetHex() const
Definition: uint256.cpp:16
node::BlockManager::LookupBlockIndex
CBlockIndex * LookupBlockIndex(const BlockHash &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Definition: blockstorage.cpp:44
core_io.h
ScriptToUniv
void ScriptToUniv(const CScript &script, UniValue &out, bool include_address)
Definition: core_write.cpp:175
TxToUniv
void TxToUniv(const CTransaction &tx, const BlockHash &hashBlock, UniValue &entry, bool include_hex=true, int serialize_flags=0, const CTxUndo *txundo=nullptr)
Definition: core_write.cpp:217
SighashToStr
std::string SighashToStr(uint8_t sighash_type)
Definition: core_write.cpp:89
ScriptPubKeyToUniv
void ScriptPubKeyToUniv(const CScript &scriptPubKey, UniValue &out, bool fIncludeHex)
Definition: core_write.cpp:190
DecodeHexTx
bool DecodeHexTx(CMutableTransaction &tx, const std::string &strHexTx)
Definition: core_read.cpp:197
ScriptToAsmStr
std::string ScriptToAsmStr(const CScript &script, const bool fAttemptSighashDecode=false)
Create the assembly string representation of a CScript object.
Definition: core_write.cpp:106
EncodeHexTx
std::string EncodeHexTx(const CTransaction &tx, const int serializeFlags=0)
Definition: core_write.cpp:169
ReadBE32
static uint32_t ReadBE32(const uint8_t *ptr)
Definition: common.h:56
cs_main
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:7
TransactionError
TransactionError
Definition: error.h:22
EncodeDestination
std::string EncodeDestination(const CTxDestination &dest, const Config &config)
Definition: key_io.cpp:167
DecodeSecret
CKey DecodeSecret(const std::string &str)
Definition: key_io.cpp:77
key_io.h
error
bool error(const char *fmt, const Args &...args)
Definition: logging.h:263
node
Definition: init.h:31
node::AnalyzePSBT
PSBTAnalysis AnalyzePSBT(PartiallySignedTransaction psbtx)
Provides helpful miscellaneous information about where a PSBT is in the signing workflow.
Definition: psbt.cpp:16
node::BroadcastTransaction
TransactionError BroadcastTransaction(const NodeContext &node, const CTransactionRef tx, std::string &err_string, const Amount max_tx_fee, bool relay, bool wait_callback)
Submit a transaction to the mempool and (optionally) relay it to all P2P peers.
Definition: transaction.cpp:37
node::GetTransaction
CTransactionRef GetTransaction(const CBlockIndex *const block_index, const CTxMemPool *const mempool, const TxId &txid, BlockHash &hashBlock, const BlockManager &blockman)
Return transaction with a given txid.
Definition: transaction.cpp:129
node::FindCoins
void FindCoins(const NodeContext &node, std::map< COutPoint, Coin > &coins)
Look up unspent output information.
Definition: coin.cpp:12
CTransactionRef
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:315
sig
SchnorrSig sig
Definition: processor.cpp:511
DecodeBase64PSBT
bool DecodeBase64PSBT(PartiallySignedTransaction &psbt, const std::string &base64_tx, std::string &error)
Decode a base64ed PSBT into a PartiallySignedTransaction.
Definition: psbt.cpp:296
UpdatePSBTOutput
void UpdatePSBTOutput(const SigningProvider &provider, PartiallySignedTransaction &psbt, int index)
Updates a PSBTOutput with information from provider.
Definition: psbt.cpp:164
PSBTRoleName
std::string PSBTRoleName(const PSBTRole role)
Definition: psbt.cpp:279
FinalizeAndExtractPSBT
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:247
CombinePSBTs
TransactionError CombinePSBTs(PartiallySignedTransaction &out, const std::vector< PartiallySignedTransaction > &psbtxs)
Combines PSBTs with the same underlying transaction, resulting in a single PSBT with all partial sign...
Definition: psbt.cpp:264
SignPSBTInput
bool SignPSBTInput(const SigningProvider &provider, PartiallySignedTransaction &psbt, int index, SigHashType sighash, SignatureData *out_sigdata, bool use_dummy)
Signs a PSBTInput, verifying that all provided data matches what is being signed.
Definition: psbt.cpp:186
Shuffle
void Shuffle(I first, I last, R &&rng)
More efficient than using std::shuffle on a FastRandomContext.
Definition: random.h:291
joinpsbts
RPCHelpMan joinpsbts()
Definition: rawtransaction.cpp:1515
getrawtransaction
static RPCHelpMan getrawtransaction()
Definition: rawtransaction.cpp:85
converttopsbt
static RPCHelpMan converttopsbt()
Definition: rawtransaction.cpp:1343
analyzepsbt
RPCHelpMan analyzepsbt()
Definition: rawtransaction.cpp:1625
decoderawtransaction
static RPCHelpMan decoderawtransaction()
Definition: rawtransaction.cpp:389
combinepsbt
static RPCHelpMan combinepsbt()
Definition: rawtransaction.cpp:1120
decodepsbt
static RPCHelpMan decodepsbt()
Definition: rawtransaction.cpp:779
gettransactionstatus
RPCHelpMan gettransactionstatus()
Definition: rawtransaction.cpp:1769
decodescript
static RPCHelpMan decodescript()
Definition: rawtransaction.cpp:481
createpsbt
static RPCHelpMan createpsbt()
Definition: rawtransaction.cpp:1243
utxoupdatepsbt
RPCHelpMan utxoupdatepsbt()
Definition: rawtransaction.cpp:1409
combinerawtransaction
static RPCHelpMan combinerawtransaction()
Definition: rawtransaction.cpp:538
TxToJSON
static void TxToJSON(const CTransaction &tx, const BlockHash &hashBlock, UniValue &entry, Chainstate &active_chainstate)
Definition: rawtransaction.cpp:56
signrawtransactionwithkey
static RPCHelpMan signrawtransactionwithkey()
Definition: rawtransaction.cpp:644
createrawtransaction
static RPCHelpMan createrawtransaction()
Definition: rawtransaction.cpp:289
finalizepsbt
static RPCHelpMan finalizepsbt()
Definition: rawtransaction.cpp:1174
RegisterRawTransactionRPCCommands
void RegisterRawTransactionRPCCommands(CRPCTable &t)
Definition: rawtransaction.cpp:1838
SignTransaction
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.
Definition: rawtransaction_util.cpp:263
ConstructTransaction
CMutableTransaction ConstructTransaction(const CChainParams &params, const UniValue &inputs_in, const UniValue &outputs_in, const UniValue &locktime)
Create a transaction from univalue parameters.
Definition: rawtransaction_util.cpp:22
ParsePrevouts
void ParsePrevouts(const UniValue &prevTxsUnival, FillableSigningProvider *keystore, std::map< COutPoint, Coin > &coins)
Parse a prevtxs UniValue array and get the map of coins from it.
Definition: rawtransaction_util.cpp:175
rawtransaction_util.h
JSONRPCError
UniValue JSONRPCError(int code, const std::string &message)
Definition: request.cpp:58
RPC_MISC_ERROR
@ RPC_MISC_ERROR
General application defined errors std::exception thrown in command handling.
Definition: protocol.h:38
RPC_INVALID_PARAMETER
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
Definition: protocol.h:46
RPC_VERIFY_ERROR
@ RPC_VERIFY_ERROR
General error during transaction or block submission.
Definition: protocol.h:52
RPC_DESERIALIZATION_ERROR
@ RPC_DESERIALIZATION_ERROR
Error parsing or validating structure in raw format.
Definition: protocol.h:50
RPC_INVALID_ADDRESS_OR_KEY
@ RPC_INVALID_ADDRESS_OR_KEY
Invalid address or key.
Definition: protocol.h:42
HelpExampleCli
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
Definition: util.cpp:153
JSONRPCTransactionError
UniValue JSONRPCTransactionError(TransactionError terr, const std::string &err_string)
Definition: util.cpp:336
ParseHexV
std::vector< uint8_t > ParseHexV(const UniValue &v, std::string strName)
Definition: util.cpp:97
HelpExampleRpc
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
Definition: util.cpp:170
EvalDescriptorStringOrObject
std::vector< CScript > EvalDescriptorStringOrObject(const UniValue &scanobject, FlatSigningProvider &provider)
Evaluate a descriptor given as a string, or as a {"desc":...,"range":...} object, with default range ...
Definition: util.cpp:1362
UNIX_EPOCH_TIME
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:25
GetAllOutputTypes
std::string GetAllOutputTypes()
Definition: util.cpp:308
ParseHashV
uint256 ParseHashV(const UniValue &v, std::string strName)
Utilities: convert hex-encoded values (throws error if not hex).
Definition: util.cpp:76
extract
#define extract(n)
Extract the lowest 64 bits of (c0,c1,c2) into n, and left shift the number 64 bits.
Definition: scalar_4x64_impl.h:235
SER_NETWORK
@ SER_NETWORK
Definition: serialize.h:152
RPCSerializationFlags
int RPCSerializationFlags()
Retrieves any serialization flags requested in command line argument.
Definition: server.cpp:679
EnsureAnyNodeContext
NodeContext & EnsureAnyNodeContext(const std::any &context)
Definition: server_util.cpp:21
EnsureMemPool
CTxMemPool & EnsureMemPool(const NodeContext &node)
Definition: server_util.cpp:29
EnsureChainman
ChainstateManager & EnsureChainman(const NodeContext &node)
Definition: server_util.cpp:52
server_util.h
ProduceSignature
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:198
UpdateInput
void UpdateInput(CTxIn &input, const SignatureData &data)
Definition: sign.cpp:331
DataFromTransaction
SignatureData DataFromTransaction(const CMutableTransaction &tx, unsigned int nIn, const CTxOut &txout)
Extract signature data from a transaction input, and insert it.
Definition: sign.cpp:275
DUMMY_SIGNING_PROVIDER
const SigningProvider & DUMMY_SIGNING_PROVIDER
Definition: signingprovider.cpp:13
Amount
Definition: amount.h:19
Amount::zero
static constexpr Amount zero() noexcept
Definition: amount.h:32
BlockHash
A BlockHash is a unqiue identifier for a block.
Definition: blockhash.h:13
Currency::get
static const Currency & get()
Definition: amount.cpp:18
Currency::ticker
std::string ticker
Definition: amount.h:150
PSBTInput
A structure for PSBTs which contain per-input information.
Definition: psbt.h:44
PSBTInput::hd_keypaths
std::map< CPubKey, KeyOriginInfo > hd_keypaths
Definition: psbt.h:48
PSBTInput::partial_sigs
std::map< CKeyID, SigPair > partial_sigs
Definition: psbt.h:49
PSBTInput::sighash_type
SigHashType sighash_type
Definition: psbt.h:51
PSBTInput::unknown
std::map< std::vector< uint8_t >, std::vector< uint8_t > > unknown
Definition: psbt.h:50
PSBTInput::redeem_script
CScript redeem_script
Definition: psbt.h:46
PSBTInput::final_script_sig
CScript final_script_sig
Definition: psbt.h:47
PSBTInput::utxo
CTxOut utxo
Definition: psbt.h:45
PSBTOutput
A structure for PSBTs which contains per output information.
Definition: psbt.h:233
PSBTOutput::redeem_script
CScript redeem_script
Definition: psbt.h:234
PSBTOutput::hd_keypaths
std::map< CPubKey, KeyOriginInfo > hd_keypaths
Definition: psbt.h:235
PSBTOutput::unknown
std::map< std::vector< uint8_t >, std::vector< uint8_t > > unknown
Definition: psbt.h:236
PartiallySignedTransaction
A version of CTransaction with the PSBT format.
Definition: psbt.h:334
PartiallySignedTransaction::unknown
std::map< std::vector< uint8_t >, std::vector< uint8_t > > unknown
Definition: psbt.h:338
PartiallySignedTransaction::AddOutput
bool AddOutput(const CTxOut &txout, const PSBTOutput &psbtout)
Definition: psbt.cpp:50
PartiallySignedTransaction::inputs
std::vector< PSBTInput > inputs
Definition: psbt.h:336
PartiallySignedTransaction::tx
std::optional< CMutableTransaction > tx
Definition: psbt.h:335
PartiallySignedTransaction::AddInput
bool AddInput(const CTxIn &txin, PSBTInput &psbtin)
Definition: psbt.cpp:38
PartiallySignedTransaction::outputs
std::vector< PSBTOutput > outputs
Definition: psbt.h:337
RPCArg::Type::RANGE
@ RANGE
Special type that is a NUM or [NUM,NUM].
RPCArg::Type::OBJ_USER_KEYS
@ OBJ_USER_KEYS
Special type where the user must set the keys e.g.
RPCArg::Type::STR_HEX
@ STR_HEX
Special type that is a STR with only hex chars.
RPCArg::Type::AMOUNT
@ AMOUNT
Special type representing a floating point amount (can be either NUM or STR)
RPCArg::DefaultHint
std::string DefaultHint
Hint for default value.
Definition: util.h:206
RPCArg::Optional::OMITTED
@ OMITTED
Optional argument for which the default value is omitted from help text for one of two reasons:
RPCArg::Optional::NO
@ NO
Required arg.
RPCArgOptions::skip_type_check
bool skip_type_check
Definition: util.h:140
RPCResult::Type::ELISION
@ ELISION
Special type to denote elision (...)
RPCResult::Type::NUM_TIME
@ NUM_TIME
Special numeric to denote unix epoch time.
RPCResult::Type::OBJ_DYN
@ OBJ_DYN
Special dictionary with keys that are not literals.
RPCResult::Type::STR_HEX
@ STR_HEX
Special string with only hex chars.
RPCResult::Type::STR_AMOUNT
@ STR_AMOUNT
Special string to represent a floating point amount.
SignatureData::MergeSignatureData
void MergeSignatureData(SignatureData sigdata)
Definition: sign.cpp:335
TxId
A TxId is the identifier of a transaction.
Definition: txid.h:14
node::NodeContext
NodeContext struct containing references to chain state and connection state.
Definition: context.h:46
node::PSBTAnalysis
Holds the results of AnalyzePSBT (miscellaneous information about a PSBT)
Definition: psbt.h:35
node::PSBTAnalysis::inputs
std::vector< PSBTInputAnalysis > inputs
More information about the individual inputs of the transaction.
Definition: psbt.h:43
node::PSBTAnalysis::error
std::string error
Error message.
Definition: psbt.h:47
node::PSBTAnalysis::fee
std::optional< Amount > fee
Amount of fee being paid by the transaction.
Definition: psbt.h:41
node::PSBTAnalysis::estimated_vsize
std::optional< size_t > estimated_vsize
Estimated weight of the transaction.
Definition: psbt.h:37
node::PSBTAnalysis::estimated_feerate
std::optional< CFeeRate > estimated_feerate
Estimated feerate (fee / weight) of the transaction.
Definition: psbt.h:39
node::PSBTAnalysis::next
PSBTRole next
Which of the BIP 174 roles needs to handle the transaction next.
Definition: psbt.h:45
LOCK2
#define LOCK2(cs1, cs2)
Definition: sync.h:309
LOCK
#define LOCK(cs)
Definition: sync.h:306
WITH_LOCK
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:357
strprintf
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1202
g_txindex
std::unique_ptr< TxIndex > g_txindex
The global transaction index, used in GetTransaction. May be null.
Definition: txindex.cpp:16
HexStr
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
Definition: strencodings.cpp:543
EncodeBase64
std::string EncodeBase64(Span< const uint8_t > input)
Definition: strencodings.cpp:134
PROTOCOL_VERSION
static const int PROTOCOL_VERSION
network protocol versioning
Definition: version.h:11
Generated on Fri Apr 25 2025 17:53:15 for Bitcoin ABC by doxygen 1.9.4