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