Bitcoin Core 28.99.0
P2P Digital Currency
spend.cpp
Go to the documentation of this file.
1// Copyright (c) 2011-2022 The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#include <common/messages.h>
7#include <core_io.h>
8#include <key_io.h>
9#include <node/types.h>
10#include <policy/policy.h>
12#include <rpc/util.h>
13#include <script/script.h>
14#include <util/rbf.h>
15#include <util/translation.h>
16#include <util/vector.h>
17#include <wallet/coincontrol.h>
18#include <wallet/feebumper.h>
19#include <wallet/fees.h>
20#include <wallet/rpc/util.h>
21#include <wallet/spend.h>
22#include <wallet/wallet.h>
23
24#include <univalue.h>
25
32
33namespace wallet {
34std::vector<CRecipient> CreateRecipients(const std::vector<std::pair<CTxDestination, CAmount>>& outputs, const std::set<int>& subtract_fee_outputs)
35{
36 std::vector<CRecipient> recipients;
37 for (size_t i = 0; i < outputs.size(); ++i) {
38 const auto& [destination, amount] = outputs.at(i);
39 CRecipient recipient{destination, amount, subtract_fee_outputs.contains(i)};
40 recipients.push_back(recipient);
41 }
42 return recipients;
43}
44
45static void InterpretFeeEstimationInstructions(const UniValue& conf_target, const UniValue& estimate_mode, const UniValue& fee_rate, UniValue& options)
46{
47 if (options.exists("conf_target") || options.exists("estimate_mode")) {
48 if (!conf_target.isNull() || !estimate_mode.isNull()) {
49 throw JSONRPCError(RPC_INVALID_PARAMETER, "Pass conf_target and estimate_mode either as arguments or in the options object, but not both");
50 }
51 } else {
52 options.pushKV("conf_target", conf_target);
53 options.pushKV("estimate_mode", estimate_mode);
54 }
55 if (options.exists("fee_rate")) {
56 if (!fee_rate.isNull()) {
57 throw JSONRPCError(RPC_INVALID_PARAMETER, "Pass the fee_rate either as an argument, or in the options object, but not both");
58 }
59 } else {
60 options.pushKV("fee_rate", fee_rate);
61 }
62 if (!options["conf_target"].isNull() && (options["estimate_mode"].isNull() || (options["estimate_mode"].get_str() == "unset"))) {
63 throw JSONRPCError(RPC_INVALID_PARAMETER, "Specify estimate_mode");
64 }
65}
66
67std::set<int> InterpretSubtractFeeFromOutputInstructions(const UniValue& sffo_instructions, const std::vector<std::string>& destinations)
68{
69 std::set<int> sffo_set;
70 if (sffo_instructions.isNull()) return sffo_set;
71 if (sffo_instructions.isBool()) {
72 if (sffo_instructions.get_bool()) sffo_set.insert(0);
73 return sffo_set;
74 }
75 for (const auto& sffo : sffo_instructions.getValues()) {
76 if (sffo.isStr()) {
77 for (size_t i = 0; i < destinations.size(); ++i) {
78 if (sffo.get_str() == destinations.at(i)) {
79 sffo_set.insert(i);
80 break;
81 }
82 }
83 }
84 if (sffo.isNum()) {
85 int pos = sffo.getInt<int>();
86 if (sffo_set.contains(pos))
87 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid parameter, duplicated position: %d", pos));
88 if (pos < 0)
89 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid parameter, negative position: %d", pos));
90 if (pos >= int(destinations.size()))
91 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid parameter, position too large: %d", pos));
92 sffo_set.insert(pos);
93 }
94 }
95 return sffo_set;
96}
97
98static UniValue FinishTransaction(const std::shared_ptr<CWallet> pwallet, const UniValue& options, const CMutableTransaction& rawTx)
99{
100 // Make a blank psbt
101 PartiallySignedTransaction psbtx(rawTx);
102
103 // First fill transaction with our data without signing,
104 // so external signers are not asked to sign more than once.
105 bool complete;
106 pwallet->FillPSBT(psbtx, complete, SIGHASH_DEFAULT, /*sign=*/false, /*bip32derivs=*/true);
107 const auto err{pwallet->FillPSBT(psbtx, complete, SIGHASH_DEFAULT, /*sign=*/true, /*bip32derivs=*/false)};
108 if (err) {
109 throw JSONRPCPSBTError(*err);
110 }
111
113 complete = FinalizeAndExtractPSBT(psbtx, mtx);
114
115 UniValue result(UniValue::VOBJ);
116
117 const bool psbt_opt_in{options.exists("psbt") && options["psbt"].get_bool()};
118 bool add_to_wallet{options.exists("add_to_wallet") ? options["add_to_wallet"].get_bool() : true};
119 if (psbt_opt_in || !complete || !add_to_wallet) {
120 // Serialize the PSBT
121 DataStream ssTx{};
122 ssTx << psbtx;
123 result.pushKV("psbt", EncodeBase64(ssTx.str()));
124 }
125
126 if (complete) {
127 std::string hex{EncodeHexTx(CTransaction(mtx))};
128 CTransactionRef tx(MakeTransactionRef(std::move(mtx)));
129 result.pushKV("txid", tx->GetHash().GetHex());
130 if (add_to_wallet && !psbt_opt_in) {
131 pwallet->CommitTransaction(tx, {}, /*orderForm=*/{});
132 } else {
133 result.pushKV("hex", hex);
134 }
135 }
136 result.pushKV("complete", complete);
137
138 return result;
139}
140
141static void PreventOutdatedOptions(const UniValue& options)
142{
143 if (options.exists("feeRate")) {
144 throw JSONRPCError(RPC_INVALID_PARAMETER, "Use fee_rate (" + CURRENCY_ATOM + "/vB) instead of feeRate");
145 }
146 if (options.exists("changeAddress")) {
147 throw JSONRPCError(RPC_INVALID_PARAMETER, "Use change_address instead of changeAddress");
148 }
149 if (options.exists("changePosition")) {
150 throw JSONRPCError(RPC_INVALID_PARAMETER, "Use change_position instead of changePosition");
151 }
152 if (options.exists("includeWatching")) {
153 throw JSONRPCError(RPC_INVALID_PARAMETER, "Use include_watching instead of includeWatching");
154 }
155 if (options.exists("lockUnspents")) {
156 throw JSONRPCError(RPC_INVALID_PARAMETER, "Use lock_unspents instead of lockUnspents");
157 }
158 if (options.exists("subtractFeeFromOutputs")) {
159 throw JSONRPCError(RPC_INVALID_PARAMETER, "Use subtract_fee_from_outputs instead of subtractFeeFromOutputs");
160 }
161}
162
163UniValue SendMoney(CWallet& wallet, const CCoinControl &coin_control, std::vector<CRecipient> &recipients, mapValue_t map_value, bool verbose)
164{
166
167 // This function is only used by sendtoaddress and sendmany.
168 // This should always try to sign, if we don't have private keys, don't try to do anything here.
169 if (wallet.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
170 throw JSONRPCError(RPC_WALLET_ERROR, "Error: Private keys are disabled for this wallet");
171 }
172
173 // Shuffle recipient list
174 std::shuffle(recipients.begin(), recipients.end(), FastRandomContext());
175
176 // Send
177 auto res = CreateTransaction(wallet, recipients, /*change_pos=*/std::nullopt, coin_control, true);
178 if (!res) {
180 }
181 const CTransactionRef& tx = res->tx;
182 wallet.CommitTransaction(tx, std::move(map_value), /*orderForm=*/{});
183 if (verbose) {
185 entry.pushKV("txid", tx->GetHash().GetHex());
186 entry.pushKV("fee_reason", StringForFeeReason(res->fee_calc.reason));
187 return entry;
188 }
189 return tx->GetHash().GetHex();
190}
191
192
206static void SetFeeEstimateMode(const CWallet& wallet, CCoinControl& cc, const UniValue& conf_target, const UniValue& estimate_mode, const UniValue& fee_rate, bool override_min_fee)
207{
208 if (!fee_rate.isNull()) {
209 if (!conf_target.isNull()) {
210 throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot specify both conf_target and fee_rate. Please provide either a confirmation target in blocks for automatic fee estimation, or an explicit fee rate.");
211 }
212 if (!estimate_mode.isNull() && estimate_mode.get_str() != "unset") {
213 throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot specify both estimate_mode and fee_rate");
214 }
215 // Fee rates in sat/vB cannot represent more than 3 significant digits.
216 cc.m_feerate = CFeeRate{AmountFromValue(fee_rate, /*decimals=*/3)};
217 if (override_min_fee) cc.fOverrideFeeRate = true;
218 // Default RBF to true for explicit fee_rate, if unset.
219 if (!cc.m_signal_bip125_rbf) cc.m_signal_bip125_rbf = true;
220 return;
221 }
222 if (!estimate_mode.isNull() && !FeeModeFromString(estimate_mode.get_str(), cc.m_fee_mode)) {
224 }
225 if (!conf_target.isNull()) {
226 cc.m_confirm_target = ParseConfirmTarget(conf_target, wallet.chain().estimateMaxBlocks());
227 }
228}
229
231{
232 return RPCHelpMan{"sendtoaddress",
233 "\nSend an amount to a given address." +
235 {
236 {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address to send to."},
237 {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "The amount in " + CURRENCY_UNIT + " to send. eg 0.1"},
238 {"comment", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "A comment used to store what the transaction is for.\n"
239 "This is not part of the transaction, just kept in your wallet."},
240 {"comment_to", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "A comment to store the name of the person or organization\n"
241 "to which you're sending the transaction. This is not part of the \n"
242 "transaction, just kept in your wallet."},
243 {"subtractfeefromamount", RPCArg::Type::BOOL, RPCArg::Default{false}, "The fee will be deducted from the amount being sent.\n"
244 "The recipient will receive less bitcoins than you enter in the amount field."},
245 {"replaceable", RPCArg::Type::BOOL, RPCArg::DefaultHint{"wallet default"}, "Signal that this transaction can be replaced by a transaction (BIP 125)"},
246 {"conf_target", RPCArg::Type::NUM, RPCArg::DefaultHint{"wallet -txconfirmtarget"}, "Confirmation target in blocks"},
247 {"estimate_mode", RPCArg::Type::STR, RPCArg::Default{"unset"}, "The fee estimate mode, must be one of (case insensitive):\n"
248 + FeeModesDetail(std::string("economical mode is used if the transaction is replaceable;\notherwise, conservative mode is used"))},
249 {"avoid_reuse", RPCArg::Type::BOOL, RPCArg::Default{true}, "(only available if avoid_reuse wallet flag is set) Avoid spending from dirty addresses; addresses are considered\n"
250 "dirty if they have previously been used in a transaction. If true, this also activates avoidpartialspends, grouping outputs by their addresses."},
251 {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"not set, fall back to wallet fee estimation"}, "Specify a fee rate in " + CURRENCY_ATOM + "/vB."},
252 {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "If true, return extra information about the transaction."},
253 },
254 {
255 RPCResult{"if verbose is not set or set to false",
256 RPCResult::Type::STR_HEX, "txid", "The transaction id."
257 },
258 RPCResult{"if verbose is set to true",
259 RPCResult::Type::OBJ, "", "",
260 {
261 {RPCResult::Type::STR_HEX, "txid", "The transaction id."},
262 {RPCResult::Type::STR, "fee_reason", "The transaction fee reason."}
263 },
264 },
265 },
267 "\nSend 0.1 BTC\n"
268 + HelpExampleCli("sendtoaddress", "\"" + EXAMPLE_ADDRESS[0] + "\" 0.1") +
269 "\nSend 0.1 BTC with a confirmation target of 6 blocks in economical fee estimate mode using positional arguments\n"
270 + HelpExampleCli("sendtoaddress", "\"" + EXAMPLE_ADDRESS[0] + "\" 0.1 \"donation\" \"sean's outpost\" false true 6 economical") +
271 "\nSend 0.1 BTC with a fee rate of 1.1 " + CURRENCY_ATOM + "/vB, subtract fee from amount, BIP125-replaceable, using positional arguments\n"
272 + HelpExampleCli("sendtoaddress", "\"" + EXAMPLE_ADDRESS[0] + "\" 0.1 \"drinks\" \"room77\" true true null \"unset\" null 1.1") +
273 "\nSend 0.2 BTC with a confirmation target of 6 blocks in economical fee estimate mode using named arguments\n"
274 + HelpExampleCli("-named sendtoaddress", "address=\"" + EXAMPLE_ADDRESS[0] + "\" amount=0.2 conf_target=6 estimate_mode=\"economical\"") +
275 "\nSend 0.5 BTC with a fee rate of 25 " + CURRENCY_ATOM + "/vB using named arguments\n"
276 + HelpExampleCli("-named sendtoaddress", "address=\"" + EXAMPLE_ADDRESS[0] + "\" amount=0.5 fee_rate=25")
277 + HelpExampleCli("-named sendtoaddress", "address=\"" + EXAMPLE_ADDRESS[0] + "\" amount=0.5 fee_rate=25 subtractfeefromamount=false replaceable=true avoid_reuse=true comment=\"2 pizzas\" comment_to=\"jeremy\" verbose=true")
278 },
279 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
280{
281 std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
282 if (!pwallet) return UniValue::VNULL;
283
284 // Make sure the results are valid at least up to the most recent block
285 // the user could have gotten from another RPC command prior to now
286 pwallet->BlockUntilSyncedToCurrentChain();
287
288 LOCK(pwallet->cs_wallet);
289
290 // Wallet comments
291 mapValue_t mapValue;
292 if (!request.params[2].isNull() && !request.params[2].get_str().empty())
293 mapValue["comment"] = request.params[2].get_str();
294 if (!request.params[3].isNull() && !request.params[3].get_str().empty())
295 mapValue["to"] = request.params[3].get_str();
296
297 CCoinControl coin_control;
298 if (!request.params[5].isNull()) {
299 coin_control.m_signal_bip125_rbf = request.params[5].get_bool();
300 }
301
302 coin_control.m_avoid_address_reuse = GetAvoidReuseFlag(*pwallet, request.params[8]);
303 // We also enable partial spend avoidance if reuse avoidance is set.
304 coin_control.m_avoid_partial_spends |= coin_control.m_avoid_address_reuse;
305
306 SetFeeEstimateMode(*pwallet, coin_control, /*conf_target=*/request.params[6], /*estimate_mode=*/request.params[7], /*fee_rate=*/request.params[9], /*override_min_fee=*/false);
307
308 EnsureWalletIsUnlocked(*pwallet);
309
310 UniValue address_amounts(UniValue::VOBJ);
311 const std::string address = request.params[0].get_str();
312 address_amounts.pushKV(address, request.params[1]);
313 std::vector<CRecipient> recipients = CreateRecipients(
314 ParseOutputs(address_amounts),
315 InterpretSubtractFeeFromOutputInstructions(request.params[4], address_amounts.getKeys())
316 );
317 const bool verbose{request.params[10].isNull() ? false : request.params[10].get_bool()};
318
319 return SendMoney(*pwallet, coin_control, recipients, mapValue, verbose);
320},
321 };
322}
323
325{
326 return RPCHelpMan{"sendmany",
327 "Send multiple times. Amounts are double-precision floating point numbers." +
329 {
330 {"dummy", RPCArg::Type::STR, RPCArg::Default{"\"\""}, "Must be set to \"\" for backwards compatibility.",
332 .oneline_description = "\"\"",
333 }},
334 {"amounts", RPCArg::Type::OBJ_USER_KEYS, RPCArg::Optional::NO, "The addresses and amounts",
335 {
336 {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "The bitcoin address is the key, the numeric amount (can be string) in " + CURRENCY_UNIT + " is the value"},
337 },
338 },
339 {"minconf", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "Ignored dummy value"},
340 {"comment", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "A comment"},
341 {"subtractfeefrom", RPCArg::Type::ARR, RPCArg::Optional::OMITTED, "The addresses.\n"
342 "The fee will be equally deducted from the amount of each selected address.\n"
343 "Those recipients will receive less bitcoins than you enter in their corresponding amount field.\n"
344 "If no addresses are specified here, the sender pays the fee.",
345 {
346 {"address", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Subtract fee from this address"},
347 },
348 },
349 {"replaceable", RPCArg::Type::BOOL, RPCArg::DefaultHint{"wallet default"}, "Signal that this transaction can be replaced by a transaction (BIP 125)"},
350 {"conf_target", RPCArg::Type::NUM, RPCArg::DefaultHint{"wallet -txconfirmtarget"}, "Confirmation target in blocks"},
351 {"estimate_mode", RPCArg::Type::STR, RPCArg::Default{"unset"}, "The fee estimate mode, must be one of (case insensitive):\n"
352 + FeeModesDetail(std::string("economical mode is used if the transaction is replaceable;\notherwise, conservative mode is used"))},
353 {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"not set, fall back to wallet fee estimation"}, "Specify a fee rate in " + CURRENCY_ATOM + "/vB."},
354 {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "If true, return extra information about the transaction."},
355 },
356 {
357 RPCResult{"if verbose is not set or set to false",
358 RPCResult::Type::STR_HEX, "txid", "The transaction id for the send. Only 1 transaction is created regardless of\n"
359 "the number of addresses."
360 },
361 RPCResult{"if verbose is set to true",
362 RPCResult::Type::OBJ, "", "",
363 {
364 {RPCResult::Type::STR_HEX, "txid", "The transaction id for the send. Only 1 transaction is created regardless of\n"
365 "the number of addresses."},
366 {RPCResult::Type::STR, "fee_reason", "The transaction fee reason."}
367 },
368 },
369 },
371 "\nSend two amounts to two different addresses:\n"
372 + HelpExampleCli("sendmany", "\"\" \"{\\\"" + EXAMPLE_ADDRESS[0] + "\\\":0.01,\\\"" + EXAMPLE_ADDRESS[1] + "\\\":0.02}\"") +
373 "\nSend two amounts to two different addresses setting the confirmation and comment:\n"
374 + HelpExampleCli("sendmany", "\"\" \"{\\\"" + EXAMPLE_ADDRESS[0] + "\\\":0.01,\\\"" + EXAMPLE_ADDRESS[1] + "\\\":0.02}\" 6 \"testing\"") +
375 "\nSend two amounts to two different addresses, subtract fee from amount:\n"
376 + HelpExampleCli("sendmany", "\"\" \"{\\\"" + EXAMPLE_ADDRESS[0] + "\\\":0.01,\\\"" + EXAMPLE_ADDRESS[1] + "\\\":0.02}\" 1 \"\" \"[\\\"" + EXAMPLE_ADDRESS[0] + "\\\",\\\"" + EXAMPLE_ADDRESS[1] + "\\\"]\"") +
377 "\nAs a JSON-RPC call\n"
378 + HelpExampleRpc("sendmany", "\"\", {\"" + EXAMPLE_ADDRESS[0] + "\":0.01,\"" + EXAMPLE_ADDRESS[1] + "\":0.02}, 6, \"testing\"")
379 },
380 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
381{
382 std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
383 if (!pwallet) return UniValue::VNULL;
384
385 // Make sure the results are valid at least up to the most recent block
386 // the user could have gotten from another RPC command prior to now
387 pwallet->BlockUntilSyncedToCurrentChain();
388
389 LOCK(pwallet->cs_wallet);
390
391 if (!request.params[0].isNull() && !request.params[0].get_str().empty()) {
392 throw JSONRPCError(RPC_INVALID_PARAMETER, "Dummy value must be set to \"\"");
393 }
394 UniValue sendTo = request.params[1].get_obj();
395
396 mapValue_t mapValue;
397 if (!request.params[3].isNull() && !request.params[3].get_str().empty())
398 mapValue["comment"] = request.params[3].get_str();
399
400 CCoinControl coin_control;
401 if (!request.params[5].isNull()) {
402 coin_control.m_signal_bip125_rbf = request.params[5].get_bool();
403 }
404
405 SetFeeEstimateMode(*pwallet, coin_control, /*conf_target=*/request.params[6], /*estimate_mode=*/request.params[7], /*fee_rate=*/request.params[8], /*override_min_fee=*/false);
406
407 std::vector<CRecipient> recipients = CreateRecipients(
408 ParseOutputs(sendTo),
409 InterpretSubtractFeeFromOutputInstructions(request.params[4], sendTo.getKeys())
410 );
411 const bool verbose{request.params[9].isNull() ? false : request.params[9].get_bool()};
412
413 return SendMoney(*pwallet, coin_control, recipients, std::move(mapValue), verbose);
414},
415 };
416}
417
419{
420 return RPCHelpMan{"settxfee",
421 "\nSet the transaction fee rate in " + CURRENCY_UNIT + "/kvB for this wallet. Overrides the global -paytxfee command line parameter.\n"
422 "Can be deactivated by passing 0 as the fee. In that case automatic fee selection will be used by default.\n",
423 {
424 {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "The transaction fee rate in " + CURRENCY_UNIT + "/kvB"},
425 },
426 RPCResult{
427 RPCResult::Type::BOOL, "", "Returns true if successful"
428 },
430 HelpExampleCli("settxfee", "0.00001")
431 + HelpExampleRpc("settxfee", "0.00001")
432 },
433 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
434{
435 std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
436 if (!pwallet) return UniValue::VNULL;
437
438 LOCK(pwallet->cs_wallet);
439
440 CAmount nAmount = AmountFromValue(request.params[0]);
441 CFeeRate tx_fee_rate(nAmount, 1000);
442 CFeeRate max_tx_fee_rate(pwallet->m_default_max_tx_fee, 1000);
443 if (tx_fee_rate == CFeeRate(0)) {
444 // automatic selection
445 } else if (tx_fee_rate < pwallet->chain().relayMinFee()) {
446 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("txfee cannot be less than min relay tx fee (%s)", pwallet->chain().relayMinFee().ToString()));
447 } else if (tx_fee_rate < pwallet->m_min_fee) {
448 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("txfee cannot be less than wallet min fee (%s)", pwallet->m_min_fee.ToString()));
449 } else if (tx_fee_rate > max_tx_fee_rate) {
450 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("txfee cannot be more than wallet max tx fee (%s)", max_tx_fee_rate.ToString()));
451 }
452
453 pwallet->m_pay_tx_fee = tx_fee_rate;
454 return true;
455},
456 };
457}
458
459
460// Only includes key documentation where the key is snake_case in all RPC methods. MixedCase keys can be added later.
461static std::vector<RPCArg> FundTxDoc(bool solving_data = true)
462{
463 std::vector<RPCArg> args = {
464 {"conf_target", RPCArg::Type::NUM, RPCArg::DefaultHint{"wallet -txconfirmtarget"}, "Confirmation target in blocks", RPCArgOptions{.also_positional = true}},
465 {"estimate_mode", RPCArg::Type::STR, RPCArg::Default{"unset"}, "The fee estimate mode, must be one of (case insensitive):\n"
466 + FeeModesDetail(std::string("economical mode is used if the transaction is replaceable;\notherwise, conservative mode is used")), RPCArgOptions{.also_positional = true}},
467 {
468 "replaceable", RPCArg::Type::BOOL, RPCArg::DefaultHint{"wallet default"}, "Marks this transaction as BIP125-replaceable.\n"
469 "Allows this transaction to be replaced by a transaction with higher fees"
470 },
471 };
472 if (solving_data) {
473 args.push_back({"solving_data", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "Keys and scripts needed for producing a final transaction with a dummy signature.\n"
474 "Used for fee estimation during coin selection.",
475 {
476 {
477 "pubkeys", RPCArg::Type::ARR, RPCArg::Default{UniValue::VARR}, "Public keys involved in this transaction.",
478 {
479 {"pubkey", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "A public key"},
480 }
481 },
482 {
483 "scripts", RPCArg::Type::ARR, RPCArg::Default{UniValue::VARR}, "Scripts involved in this transaction.",
484 {
485 {"script", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "A script"},
486 }
487 },
488 {
489 "descriptors", RPCArg::Type::ARR, RPCArg::Default{UniValue::VARR}, "Descriptors that provide solving data for this transaction.",
490 {
491 {"descriptor", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "A descriptor"},
492 }
493 },
494 }
495 });
496 }
497 return args;
498}
499
500CreatedTransactionResult FundTransaction(CWallet& wallet, const CMutableTransaction& tx, const std::vector<CRecipient>& recipients, const UniValue& options, CCoinControl& coinControl, bool override_min_fee)
501{
502 // We want to make sure tx.vout is not used now that we are passing outputs as a vector of recipients.
503 // This sets us up to remove tx completely in a future PR in favor of passing the inputs directly.
504 CHECK_NONFATAL(tx.vout.empty());
505 // Make sure the results are valid at least up to the most recent block
506 // the user could have gotten from another RPC command prior to now
507 wallet.BlockUntilSyncedToCurrentChain();
508
509 std::optional<unsigned int> change_position;
510 bool lockUnspents = false;
511 if (!options.isNull()) {
512 if (options.type() == UniValue::VBOOL) {
513 // backward compatibility bool only fallback
514 coinControl.fAllowWatchOnly = options.get_bool();
515 }
516 else {
517 RPCTypeCheckObj(options,
518 {
519 {"add_inputs", UniValueType(UniValue::VBOOL)},
520 {"include_unsafe", UniValueType(UniValue::VBOOL)},
521 {"add_to_wallet", UniValueType(UniValue::VBOOL)},
522 {"changeAddress", UniValueType(UniValue::VSTR)},
523 {"change_address", UniValueType(UniValue::VSTR)},
524 {"changePosition", UniValueType(UniValue::VNUM)},
525 {"change_position", UniValueType(UniValue::VNUM)},
526 {"change_type", UniValueType(UniValue::VSTR)},
527 {"includeWatching", UniValueType(UniValue::VBOOL)},
528 {"include_watching", UniValueType(UniValue::VBOOL)},
529 {"inputs", UniValueType(UniValue::VARR)},
530 {"lockUnspents", UniValueType(UniValue::VBOOL)},
531 {"lock_unspents", UniValueType(UniValue::VBOOL)},
532 {"locktime", UniValueType(UniValue::VNUM)},
533 {"fee_rate", UniValueType()}, // will be checked by AmountFromValue() in SetFeeEstimateMode()
534 {"feeRate", UniValueType()}, // will be checked by AmountFromValue() below
535 {"psbt", UniValueType(UniValue::VBOOL)},
536 {"solving_data", UniValueType(UniValue::VOBJ)},
537 {"subtractFeeFromOutputs", UniValueType(UniValue::VARR)},
538 {"subtract_fee_from_outputs", UniValueType(UniValue::VARR)},
539 {"replaceable", UniValueType(UniValue::VBOOL)},
540 {"conf_target", UniValueType(UniValue::VNUM)},
541 {"estimate_mode", UniValueType(UniValue::VSTR)},
542 {"minconf", UniValueType(UniValue::VNUM)},
543 {"maxconf", UniValueType(UniValue::VNUM)},
544 {"input_weights", UniValueType(UniValue::VARR)},
545 {"max_tx_weight", UniValueType(UniValue::VNUM)},
546 },
547 true, true);
548
549 if (options.exists("add_inputs")) {
550 coinControl.m_allow_other_inputs = options["add_inputs"].get_bool();
551 }
552
553 if (options.exists("changeAddress") || options.exists("change_address")) {
554 const std::string change_address_str = (options.exists("change_address") ? options["change_address"] : options["changeAddress"]).get_str();
555 CTxDestination dest = DecodeDestination(change_address_str);
556
557 if (!IsValidDestination(dest)) {
558 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Change address must be a valid bitcoin address");
559 }
560
561 coinControl.destChange = dest;
562 }
563
564 if (options.exists("changePosition") || options.exists("change_position")) {
565 int pos = (options.exists("change_position") ? options["change_position"] : options["changePosition"]).getInt<int>();
566 if (pos < 0 || (unsigned int)pos > recipients.size()) {
567 throw JSONRPCError(RPC_INVALID_PARAMETER, "changePosition out of bounds");
568 }
569 change_position = (unsigned int)pos;
570 }
571
572 if (options.exists("change_type")) {
573 if (options.exists("changeAddress") || options.exists("change_address")) {
574 throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot specify both change address and address type options");
575 }
576 if (std::optional<OutputType> parsed = ParseOutputType(options["change_type"].get_str())) {
577 coinControl.m_change_type.emplace(parsed.value());
578 } else {
579 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("Unknown change type '%s'", options["change_type"].get_str()));
580 }
581 }
582
583 const UniValue include_watching_option = options.exists("include_watching") ? options["include_watching"] : options["includeWatching"];
584 coinControl.fAllowWatchOnly = ParseIncludeWatchonly(include_watching_option, wallet);
585
586 if (options.exists("lockUnspents") || options.exists("lock_unspents")) {
587 lockUnspents = (options.exists("lock_unspents") ? options["lock_unspents"] : options["lockUnspents"]).get_bool();
588 }
589
590 if (options.exists("include_unsafe")) {
591 coinControl.m_include_unsafe_inputs = options["include_unsafe"].get_bool();
592 }
593
594 if (options.exists("feeRate")) {
595 if (options.exists("fee_rate")) {
596 throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot specify both fee_rate (" + CURRENCY_ATOM + "/vB) and feeRate (" + CURRENCY_UNIT + "/kvB)");
597 }
598 if (options.exists("conf_target")) {
599 throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot specify both conf_target and feeRate. Please provide either a confirmation target in blocks for automatic fee estimation, or an explicit fee rate.");
600 }
601 if (options.exists("estimate_mode")) {
602 throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot specify both estimate_mode and feeRate");
603 }
604 coinControl.m_feerate = CFeeRate(AmountFromValue(options["feeRate"]));
605 coinControl.fOverrideFeeRate = true;
606 }
607
608 if (options.exists("replaceable")) {
609 coinControl.m_signal_bip125_rbf = options["replaceable"].get_bool();
610 }
611
612 if (options.exists("minconf")) {
613 coinControl.m_min_depth = options["minconf"].getInt<int>();
614
615 if (coinControl.m_min_depth < 0) {
616 throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative minconf");
617 }
618 }
619
620 if (options.exists("maxconf")) {
621 coinControl.m_max_depth = options["maxconf"].getInt<int>();
622
623 if (coinControl.m_max_depth < coinControl.m_min_depth) {
624 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("maxconf can't be lower than minconf: %d < %d", coinControl.m_max_depth, coinControl.m_min_depth));
625 }
626 }
627 SetFeeEstimateMode(wallet, coinControl, options["conf_target"], options["estimate_mode"], options["fee_rate"], override_min_fee);
628 }
629 } else {
630 // if options is null and not a bool
632 }
633
634 if (options.exists("solving_data")) {
635 const UniValue solving_data = options["solving_data"].get_obj();
636 if (solving_data.exists("pubkeys")) {
637 for (const UniValue& pk_univ : solving_data["pubkeys"].get_array().getValues()) {
638 const CPubKey pubkey = HexToPubKey(pk_univ.get_str());
639 coinControl.m_external_provider.pubkeys.emplace(pubkey.GetID(), pubkey);
640 // Add witness script for pubkeys
641 const CScript wit_script = GetScriptForDestination(WitnessV0KeyHash(pubkey));
642 coinControl.m_external_provider.scripts.emplace(CScriptID(wit_script), wit_script);
643 }
644 }
645
646 if (solving_data.exists("scripts")) {
647 for (const UniValue& script_univ : solving_data["scripts"].get_array().getValues()) {
648 const std::string& script_str = script_univ.get_str();
649 if (!IsHex(script_str)) {
650 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("'%s' is not hex", script_str));
651 }
652 std::vector<unsigned char> script_data(ParseHex(script_str));
653 const CScript script(script_data.begin(), script_data.end());
654 coinControl.m_external_provider.scripts.emplace(CScriptID(script), script);
655 }
656 }
657
658 if (solving_data.exists("descriptors")) {
659 for (const UniValue& desc_univ : solving_data["descriptors"].get_array().getValues()) {
660 const std::string& desc_str = desc_univ.get_str();
661 FlatSigningProvider desc_out;
662 std::string error;
663 std::vector<CScript> scripts_temp;
664 auto descs = Parse(desc_str, desc_out, error, true);
665 if (descs.empty()) {
666 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Unable to parse descriptor '%s': %s", desc_str, error));
667 }
668 for (auto& desc : descs) {
669 desc->Expand(0, desc_out, scripts_temp, desc_out);
670 }
671 coinControl.m_external_provider.Merge(std::move(desc_out));
672 }
673 }
674 }
675
676 if (options.exists("input_weights")) {
677 for (const UniValue& input : options["input_weights"].get_array().getValues()) {
678 Txid txid = Txid::FromUint256(ParseHashO(input, "txid"));
679
680 const UniValue& vout_v = input.find_value("vout");
681 if (!vout_v.isNum()) {
682 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, missing vout key");
683 }
684 int vout = vout_v.getInt<int>();
685 if (vout < 0) {
686 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout cannot be negative");
687 }
688
689 const UniValue& weight_v = input.find_value("weight");
690 if (!weight_v.isNum()) {
691 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, missing weight key");
692 }
693 int64_t weight = weight_v.getInt<int64_t>();
694 const int64_t min_input_weight = GetTransactionInputWeight(CTxIn());
695 CHECK_NONFATAL(min_input_weight == 165);
696 if (weight < min_input_weight) {
697 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, weight cannot be less than 165 (41 bytes (size of outpoint + sequence + empty scriptSig) * 4 (witness scaling factor)) + 1 (empty witness)");
698 }
699 if (weight > MAX_STANDARD_TX_WEIGHT) {
700 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid parameter, weight cannot be greater than the maximum standard tx weight of %d", MAX_STANDARD_TX_WEIGHT));
701 }
702
703 coinControl.SetInputWeight(COutPoint(txid, vout), weight);
704 }
705 }
706
707 if (options.exists("max_tx_weight")) {
708 coinControl.m_max_tx_weight = options["max_tx_weight"].getInt<int>();
709 }
710
711 if (recipients.empty())
712 throw JSONRPCError(RPC_INVALID_PARAMETER, "TX must have at least one output");
713
714 auto txr = FundTransaction(wallet, tx, recipients, change_position, lockUnspents, coinControl);
715 if (!txr) {
716 throw JSONRPCError(RPC_WALLET_ERROR, ErrorString(txr).original);
717 }
718 return *txr;
719}
720
721static void SetOptionsInputWeights(const UniValue& inputs, UniValue& options)
722{
723 if (options.exists("input_weights")) {
724 throw JSONRPCError(RPC_INVALID_PARAMETER, "Input weights should be specified in inputs rather than in options.");
725 }
726 if (inputs.size() == 0) {
727 return;
728 }
729 UniValue weights(UniValue::VARR);
730 for (const UniValue& input : inputs.getValues()) {
731 if (input.exists("weight")) {
732 weights.push_back(input);
733 }
734 }
735 options.pushKV("input_weights", std::move(weights));
736}
737
739{
740 return RPCHelpMan{"fundrawtransaction",
741 "\nIf the transaction has no inputs, they will be automatically selected to meet its out value.\n"
742 "It will add at most one change output to the outputs.\n"
743 "No existing outputs will be modified unless \"subtractFeeFromOutputs\" is specified.\n"
744 "Note that inputs which were signed may need to be resigned after completion since in/outputs have been added.\n"
745 "The inputs added will not be signed, use signrawtransactionwithkey\n"
746 "or signrawtransactionwithwallet for that.\n"
747 "All existing inputs must either have their previous output transaction be in the wallet\n"
748 "or be in the UTXO set. Solving data must be provided for non-wallet inputs.\n"
749 "Note that all inputs selected must be of standard form and P2SH scripts must be\n"
750 "in the wallet using importaddress or addmultisigaddress (to calculate fees).\n"
751 "You can see whether this is the case by checking the \"solvable\" field in the listunspent output.\n"
752 "Only pay-to-pubkey, multisig, and P2SH versions thereof are currently supported for watch-only\n",
753 {
754 {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex string of the raw transaction"},
755 {"options", RPCArg::Type::OBJ_NAMED_PARAMS, RPCArg::Optional::OMITTED, "For backward compatibility: passing in a true instead of an object will result in {\"includeWatching\":true}",
756 Cat<std::vector<RPCArg>>(
757 {
758 {"add_inputs", RPCArg::Type::BOOL, RPCArg::Default{true}, "For a transaction with existing inputs, automatically include more if they are not enough."},
759 {"include_unsafe", RPCArg::Type::BOOL, RPCArg::Default{false}, "Include inputs that are not safe to spend (unconfirmed transactions from outside keys and unconfirmed replacement transactions).\n"
760 "Warning: the resulting transaction may become invalid if one of the unsafe inputs disappears.\n"
761 "If that happens, you will need to fund the transaction with different inputs and republish it."},
762 {"minconf", RPCArg::Type::NUM, RPCArg::Default{0}, "If add_inputs is specified, require inputs with at least this many confirmations."},
763 {"maxconf", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "If add_inputs is specified, require inputs with at most this many confirmations."},
764 {"changeAddress", RPCArg::Type::STR, RPCArg::DefaultHint{"automatic"}, "The bitcoin address to receive the change"},
765 {"changePosition", RPCArg::Type::NUM, RPCArg::DefaultHint{"random"}, "The index of the change output"},
766 {"change_type", RPCArg::Type::STR, RPCArg::DefaultHint{"set by -changetype"}, "The output type to use. Only valid if changeAddress is not specified. Options are \"legacy\", \"p2sh-segwit\", \"bech32\", and \"bech32m\"."},
767 {"includeWatching", RPCArg::Type::BOOL, RPCArg::DefaultHint{"true for watch-only wallets, otherwise false"}, "Also select inputs which are watch only.\n"
768 "Only solvable inputs can be used. Watch-only destinations are solvable if the public key and/or output script was imported,\n"
769 "e.g. with 'importpubkey' or 'importmulti' with the 'pubkeys' or 'desc' field."},
770 {"lockUnspents", RPCArg::Type::BOOL, RPCArg::Default{false}, "Lock selected unspent outputs"},
771 {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"not set, fall back to wallet fee estimation"}, "Specify a fee rate in " + CURRENCY_ATOM + "/vB."},
772 {"feeRate", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"not set, fall back to wallet fee estimation"}, "Specify a fee rate in " + CURRENCY_UNIT + "/kvB."},
773 {"subtractFeeFromOutputs", RPCArg::Type::ARR, RPCArg::Default{UniValue::VARR}, "The integers.\n"
774 "The fee will be equally deducted from the amount of each specified output.\n"
775 "Those recipients will receive less bitcoins than you enter in their corresponding amount field.\n"
776 "If no outputs are specified here, the sender pays the fee.",
777 {
778 {"vout_index", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "The zero-based output index, before a change output is added."},
779 },
780 },
781 {"input_weights", RPCArg::Type::ARR, RPCArg::Optional::OMITTED, "Inputs and their corresponding weights",
782 {
784 {
785 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
786 {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output index"},
787 {"weight", RPCArg::Type::NUM, RPCArg::Optional::NO, "The maximum weight for this input, "
788 "including the weight of the outpoint and sequence number. "
789 "Note that serialized signature sizes are not guaranteed to be consistent, "
790 "so the maximum DER signatures size of 73 bytes should be used when considering ECDSA signatures."
791 "Remember to convert serialized sizes to weight units when necessary."},
792 },
793 },
794 },
795 },
796 {"max_tx_weight", RPCArg::Type::NUM, RPCArg::Default{MAX_STANDARD_TX_WEIGHT}, "The maximum acceptable transaction weight.\n"
797 "Transaction building will fail if this can not be satisfied."},
798 },
799 FundTxDoc()),
801 .skip_type_check = true,
802 .oneline_description = "options",
803 }},
804 {"iswitness", RPCArg::Type::BOOL, RPCArg::DefaultHint{"depends on heuristic tests"}, "Whether the transaction hex is a serialized witness transaction.\n"
805 "If iswitness is not present, heuristic tests will be used in decoding.\n"
806 "If true, only witness deserialization will be tried.\n"
807 "If false, only non-witness deserialization will be tried.\n"
808 "This boolean should reflect whether the transaction has inputs\n"
809 "(e.g. fully valid, or on-chain transactions), if known by the caller."
810 },
811 },
812 RPCResult{
813 RPCResult::Type::OBJ, "", "",
814 {
815 {RPCResult::Type::STR_HEX, "hex", "The resulting raw transaction (hex-encoded string)"},
816 {RPCResult::Type::STR_AMOUNT, "fee", "Fee in " + CURRENCY_UNIT + " the resulting transaction pays"},
817 {RPCResult::Type::NUM, "changepos", "The position of the added change output, or -1"},
818 }
819 },
821 "\nCreate a transaction with no inputs\n"
822 + HelpExampleCli("createrawtransaction", "\"[]\" \"{\\\"myaddress\\\":0.01}\"") +
823 "\nAdd sufficient unsigned inputs to meet the output value\n"
824 + HelpExampleCli("fundrawtransaction", "\"rawtransactionhex\"") +
825 "\nSign the transaction\n"
826 + HelpExampleCli("signrawtransactionwithwallet", "\"fundedtransactionhex\"") +
827 "\nSend the transaction\n"
828 + HelpExampleCli("sendrawtransaction", "\"signedtransactionhex\"")
829 },
830 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
831{
832 std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
833 if (!pwallet) return UniValue::VNULL;
834
835 // parse hex string from parameter
837 bool try_witness = request.params[2].isNull() ? true : request.params[2].get_bool();
838 bool try_no_witness = request.params[2].isNull() ? true : !request.params[2].get_bool();
839 if (!DecodeHexTx(tx, request.params[0].get_str(), try_no_witness, try_witness)) {
840 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
841 }
842 UniValue options = request.params[1];
843 std::vector<std::pair<CTxDestination, CAmount>> destinations;
844 for (const auto& tx_out : tx.vout) {
845 CTxDestination dest;
846 ExtractDestination(tx_out.scriptPubKey, dest);
847 destinations.emplace_back(dest, tx_out.nValue);
848 }
849 std::vector<std::string> dummy(destinations.size(), "dummy");
850 std::vector<CRecipient> recipients = CreateRecipients(
851 destinations,
852 InterpretSubtractFeeFromOutputInstructions(options["subtractFeeFromOutputs"], dummy)
853 );
854 CCoinControl coin_control;
855 // Automatically select (additional) coins. Can be overridden by options.add_inputs.
856 coin_control.m_allow_other_inputs = true;
857 // Clear tx.vout since it is not meant to be used now that we are passing outputs directly.
858 // This sets us up for a future PR to completely remove tx from the function signature in favor of passing inputs directly
859 tx.vout.clear();
860 auto txr = FundTransaction(*pwallet, tx, recipients, options, coin_control, /*override_min_fee=*/true);
861
862 UniValue result(UniValue::VOBJ);
863 result.pushKV("hex", EncodeHexTx(*txr.tx));
864 result.pushKV("fee", ValueFromAmount(txr.fee));
865 result.pushKV("changepos", txr.change_pos ? (int)*txr.change_pos : -1);
866
867 return result;
868},
869 };
870}
871
873{
874 return RPCHelpMan{"signrawtransactionwithwallet",
875 "\nSign inputs for raw transaction (serialized, hex-encoded).\n"
876 "The second optional argument (may be null) is an array of previous transaction outputs that\n"
877 "this transaction depends on but may not yet be in the block chain." +
879 {
880 {"hexstring", RPCArg::Type::STR, RPCArg::Optional::NO, "The transaction hex string"},
881 {"prevtxs", RPCArg::Type::ARR, RPCArg::Optional::OMITTED, "The previous dependent transaction outputs",
882 {
884 {
885 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
886 {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
887 {"scriptPubKey", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The output script"},
888 {"redeemScript", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "(required for P2SH) redeem script"},
889 {"witnessScript", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "(required for P2WSH or P2SH-P2WSH) witness script"},
890 {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::OMITTED, "(required for Segwit inputs) the amount spent"},
891 },
892 },
893 },
894 },
895 {"sighashtype", RPCArg::Type::STR, RPCArg::Default{"DEFAULT for Taproot, ALL otherwise"}, "The signature hash type. Must be one of\n"
896 " \"DEFAULT\"\n"
897 " \"ALL\"\n"
898 " \"NONE\"\n"
899 " \"SINGLE\"\n"
900 " \"ALL|ANYONECANPAY\"\n"
901 " \"NONE|ANYONECANPAY\"\n"
902 " \"SINGLE|ANYONECANPAY\""},
903 },
904 RPCResult{
905 RPCResult::Type::OBJ, "", "",
906 {
907 {RPCResult::Type::STR_HEX, "hex", "The hex-encoded raw transaction with signature(s)"},
908 {RPCResult::Type::BOOL, "complete", "If the transaction has a complete set of signatures"},
909 {RPCResult::Type::ARR, "errors", /*optional=*/true, "Script verification errors (if there are any)",
910 {
911 {RPCResult::Type::OBJ, "", "",
912 {
913 {RPCResult::Type::STR_HEX, "txid", "The hash of the referenced, previous transaction"},
914 {RPCResult::Type::NUM, "vout", "The index of the output to spent and used as input"},
915 {RPCResult::Type::ARR, "witness", "",
916 {
917 {RPCResult::Type::STR_HEX, "witness", ""},
918 }},
919 {RPCResult::Type::STR_HEX, "scriptSig", "The hex-encoded signature script"},
920 {RPCResult::Type::NUM, "sequence", "Script sequence number"},
921 {RPCResult::Type::STR, "error", "Verification or signing error related to the input"},
922 }},
923 }},
924 }
925 },
927 HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"")
928 + HelpExampleRpc("signrawtransactionwithwallet", "\"myhex\"")
929 },
930 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
931{
932 const std::shared_ptr<const CWallet> pwallet = GetWalletForJSONRPCRequest(request);
933 if (!pwallet) return UniValue::VNULL;
934
936 if (!DecodeHexTx(mtx, request.params[0].get_str())) {
937 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed. Make sure the tx has at least one input.");
938 }
939
940 // Sign the transaction
941 LOCK(pwallet->cs_wallet);
942 EnsureWalletIsUnlocked(*pwallet);
943
944 // Fetch previous transactions (inputs):
945 std::map<COutPoint, Coin> coins;
946 for (const CTxIn& txin : mtx.vin) {
947 coins[txin.prevout]; // Create empty map entry keyed by prevout.
948 }
949 pwallet->chain().findCoins(coins);
950
951 // Parse the prevtxs array
952 ParsePrevouts(request.params[1], nullptr, coins);
953
954 int nHashType = ParseSighashString(request.params[2]);
955
956 // Script verification errors
957 std::map<int, bilingual_str> input_errors;
958
959 bool complete = pwallet->SignTransaction(mtx, coins, nHashType, input_errors);
960 UniValue result(UniValue::VOBJ);
961 SignTransactionResultToJSON(mtx, complete, coins, input_errors, result);
962 return result;
963},
964 };
965}
966
967// Definition of allowed formats of specifying transaction outputs in
968// `bumpfee`, `psbtbumpfee`, `send` and `walletcreatefundedpsbt` RPCs.
969static std::vector<RPCArg> OutputsDoc()
970{
971 return
972 {
974 {
975 {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "A key-value pair. The key (string) is the bitcoin address,\n"
976 "the value (float or string) is the amount in " + CURRENCY_UNIT + ""},
977 },
978 },
980 {
981 {"data", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "A key-value pair. The key must be \"data\", the value is hex-encoded data"},
982 },
983 },
984 };
985}
986
987static RPCHelpMan bumpfee_helper(std::string method_name)
988{
989 const bool want_psbt = method_name == "psbtbumpfee";
990 const std::string incremental_fee{CFeeRate(DEFAULT_INCREMENTAL_RELAY_FEE).ToString(FeeEstimateMode::SAT_VB)};
991
992 return RPCHelpMan{method_name,
993 "\nBumps the fee of an opt-in-RBF transaction T, replacing it with a new transaction B.\n"
994 + std::string(want_psbt ? "Returns a PSBT instead of creating and signing a new transaction.\n" : "") +
995 "An opt-in RBF transaction with the given txid must be in the wallet.\n"
996 "The command will pay the additional fee by reducing change outputs or adding inputs when necessary.\n"
997 "It may add a new change output if one does not already exist.\n"
998 "All inputs in the original transaction will be included in the replacement transaction.\n"
999 "The command will fail if the wallet or mempool contains a transaction that spends one of T's outputs.\n"
1000 "By default, the new fee will be calculated automatically using the estimatesmartfee RPC.\n"
1001 "The user can specify a confirmation target for estimatesmartfee.\n"
1002 "Alternatively, the user can specify a fee rate in " + CURRENCY_ATOM + "/vB for the new transaction.\n"
1003 "At a minimum, the new fee rate must be high enough to pay an additional new relay fee (incrementalfee\n"
1004 "returned by getnetworkinfo) to enter the node's mempool.\n"
1005 "* WARNING: before version 0.21, fee_rate was in " + CURRENCY_UNIT + "/kvB. As of 0.21, fee_rate is in " + CURRENCY_ATOM + "/vB. *\n",
1006 {
1007 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The txid to be bumped"},
1009 {
1010 {"conf_target", RPCArg::Type::NUM, RPCArg::DefaultHint{"wallet -txconfirmtarget"}, "Confirmation target in blocks\n"},
1011 {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"not set, fall back to wallet fee estimation"},
1012 "\nSpecify a fee rate in " + CURRENCY_ATOM + "/vB instead of relying on the built-in fee estimator.\n"
1013 "Must be at least " + incremental_fee + " higher than the current transaction fee rate.\n"
1014 "WARNING: before version 0.21, fee_rate was in " + CURRENCY_UNIT + "/kvB. As of 0.21, fee_rate is in " + CURRENCY_ATOM + "/vB.\n"},
1015 {"replaceable", RPCArg::Type::BOOL, RPCArg::Default{true}, "Whether the new transaction should still be\n"
1016 "marked bip-125 replaceable. If true, the sequence numbers in the transaction will\n"
1017 "be left unchanged from the original. If false, any input sequence numbers in the\n"
1018 "original transaction that were less than 0xfffffffe will be increased to 0xfffffffe\n"
1019 "so the new transaction will not be explicitly bip-125 replaceable (though it may\n"
1020 "still be replaceable in practice, for example if it has unconfirmed ancestors which\n"
1021 "are replaceable).\n"},
1022 {"estimate_mode", RPCArg::Type::STR, RPCArg::Default{"unset"}, "The fee estimate mode, must be one of (case insensitive):\n"
1023 + FeeModesDetail(std::string("economical mode is used if the transaction is replaceable;\notherwise, conservative mode is used"))},
1024 {"outputs", RPCArg::Type::ARR, RPCArg::Default{UniValue::VARR}, "The outputs specified as key-value pairs.\n"
1025 "Each key may only appear once, i.e. there can only be one 'data' output, and no address may be duplicated.\n"
1026 "At least one output of either type must be specified.\n"
1027 "Cannot be provided if 'original_change_index' is specified.",
1028 OutputsDoc(),
1030 {"original_change_index", RPCArg::Type::NUM, RPCArg::DefaultHint{"not set, detect change automatically"}, "The 0-based index of the change output on the original transaction. "
1031 "The indicated output will be recycled into the new change output on the bumped transaction. "
1032 "The remainder after paying the recipients and fees will be sent to the output script of the "
1033 "original change output. The change output’s amount can increase if bumping the transaction "
1034 "adds new inputs, otherwise it will decrease. Cannot be used in combination with the 'outputs' option."},
1035 },
1037 },
1038 RPCResult{
1039 RPCResult::Type::OBJ, "", "", Cat(
1040 want_psbt ?
1041 std::vector<RPCResult>{{RPCResult::Type::STR, "psbt", "The base64-encoded unsigned PSBT of the new transaction."}} :
1042 std::vector<RPCResult>{{RPCResult::Type::STR_HEX, "txid", "The id of the new transaction."}},
1043 {
1044 {RPCResult::Type::STR_AMOUNT, "origfee", "The fee of the replaced transaction."},
1045 {RPCResult::Type::STR_AMOUNT, "fee", "The fee of the new transaction."},
1046 {RPCResult::Type::ARR, "errors", "Errors encountered during processing (may be empty).",
1047 {
1048 {RPCResult::Type::STR, "", ""},
1049 }},
1050 })
1051 },
1053 "\nBump the fee, get the new transaction\'s " + std::string(want_psbt ? "psbt" : "txid") + "\n" +
1054 HelpExampleCli(method_name, "<txid>")
1055 },
1056 [want_psbt](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
1057{
1058 std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
1059 if (!pwallet) return UniValue::VNULL;
1060
1061 if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) && !pwallet->IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER) && !want_psbt) {
1062 throw JSONRPCError(RPC_WALLET_ERROR, "bumpfee is not available with wallets that have private keys disabled. Use psbtbumpfee instead.");
1063 }
1064
1065 uint256 hash(ParseHashV(request.params[0], "txid"));
1066
1067 CCoinControl coin_control;
1068 coin_control.fAllowWatchOnly = pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
1069 // optional parameters
1070 coin_control.m_signal_bip125_rbf = true;
1071 std::vector<CTxOut> outputs;
1072
1073 std::optional<uint32_t> original_change_index;
1074
1075 if (!request.params[1].isNull()) {
1076 UniValue options = request.params[1];
1077 RPCTypeCheckObj(options,
1078 {
1079 {"confTarget", UniValueType(UniValue::VNUM)},
1080 {"conf_target", UniValueType(UniValue::VNUM)},
1081 {"fee_rate", UniValueType()}, // will be checked by AmountFromValue() in SetFeeEstimateMode()
1082 {"replaceable", UniValueType(UniValue::VBOOL)},
1083 {"estimate_mode", UniValueType(UniValue::VSTR)},
1084 {"outputs", UniValueType()}, // will be checked by AddOutputs()
1085 {"original_change_index", UniValueType(UniValue::VNUM)},
1086 },
1087 true, true);
1088
1089 if (options.exists("confTarget") && options.exists("conf_target")) {
1090 throw JSONRPCError(RPC_INVALID_PARAMETER, "confTarget and conf_target options should not both be set. Use conf_target (confTarget is deprecated).");
1091 }
1092
1093 auto conf_target = options.exists("confTarget") ? options["confTarget"] : options["conf_target"];
1094
1095 if (options.exists("replaceable")) {
1096 coin_control.m_signal_bip125_rbf = options["replaceable"].get_bool();
1097 }
1098 SetFeeEstimateMode(*pwallet, coin_control, conf_target, options["estimate_mode"], options["fee_rate"], /*override_min_fee=*/false);
1099
1100 // Prepare new outputs by creating a temporary tx and calling AddOutputs().
1101 if (!options["outputs"].isNull()) {
1102 if (options["outputs"].isArray() && options["outputs"].empty()) {
1103 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, output argument cannot be an empty array");
1104 }
1105 CMutableTransaction tempTx;
1106 AddOutputs(tempTx, options["outputs"]);
1107 outputs = tempTx.vout;
1108 }
1109
1110 if (options.exists("original_change_index")) {
1111 original_change_index = options["original_change_index"].getInt<uint32_t>();
1112 }
1113 }
1114
1115 // Make sure the results are valid at least up to the most recent block
1116 // the user could have gotten from another RPC command prior to now
1117 pwallet->BlockUntilSyncedToCurrentChain();
1118
1119 LOCK(pwallet->cs_wallet);
1120
1121 EnsureWalletIsUnlocked(*pwallet);
1122
1123
1124 std::vector<bilingual_str> errors;
1125 CAmount old_fee;
1126 CAmount new_fee;
1129 // Targeting feerate bump.
1130 res = feebumper::CreateRateBumpTransaction(*pwallet, hash, coin_control, errors, old_fee, new_fee, mtx, /*require_mine=*/ !want_psbt, outputs, original_change_index);
1131 if (res != feebumper::Result::OK) {
1132 switch(res) {
1134 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, errors[0].original);
1135 break;
1137 throw JSONRPCError(RPC_INVALID_REQUEST, errors[0].original);
1138 break;
1140 throw JSONRPCError(RPC_INVALID_PARAMETER, errors[0].original);
1141 break;
1143 throw JSONRPCError(RPC_WALLET_ERROR, errors[0].original);
1144 break;
1145 default:
1146 throw JSONRPCError(RPC_MISC_ERROR, errors[0].original);
1147 break;
1148 }
1149 }
1150
1151 UniValue result(UniValue::VOBJ);
1152
1153 // For bumpfee, return the new transaction id.
1154 // For psbtbumpfee, return the base64-encoded unsigned PSBT of the new transaction.
1155 if (!want_psbt) {
1156 if (!feebumper::SignTransaction(*pwallet, mtx)) {
1157 if (pwallet->IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER)) {
1158 throw JSONRPCError(RPC_WALLET_ERROR, "Transaction incomplete. Try psbtbumpfee instead.");
1159 }
1160 throw JSONRPCError(RPC_WALLET_ERROR, "Can't sign transaction.");
1161 }
1162
1163 uint256 txid;
1164 if (feebumper::CommitTransaction(*pwallet, hash, std::move(mtx), errors, txid) != feebumper::Result::OK) {
1165 throw JSONRPCError(RPC_WALLET_ERROR, errors[0].original);
1166 }
1167
1168 result.pushKV("txid", txid.GetHex());
1169 } else {
1170 PartiallySignedTransaction psbtx(mtx);
1171 bool complete = false;
1172 const auto err{pwallet->FillPSBT(psbtx, complete, SIGHASH_DEFAULT, /*sign=*/false, /*bip32derivs=*/true)};
1173 CHECK_NONFATAL(!err);
1174 CHECK_NONFATAL(!complete);
1175 DataStream ssTx{};
1176 ssTx << psbtx;
1177 result.pushKV("psbt", EncodeBase64(ssTx.str()));
1178 }
1179
1180 result.pushKV("origfee", ValueFromAmount(old_fee));
1181 result.pushKV("fee", ValueFromAmount(new_fee));
1182 UniValue result_errors(UniValue::VARR);
1183 for (const bilingual_str& error : errors) {
1184 result_errors.push_back(error.original);
1185 }
1186 result.pushKV("errors", std::move(result_errors));
1187
1188 return result;
1189},
1190 };
1191}
1192
1193RPCHelpMan bumpfee() { return bumpfee_helper("bumpfee"); }
1194RPCHelpMan psbtbumpfee() { return bumpfee_helper("psbtbumpfee"); }
1195
1197{
1198 return RPCHelpMan{"send",
1199 "\nEXPERIMENTAL warning: this call may be changed in future releases.\n"
1200 "\nSend a transaction.\n",
1201 {
1202 {"outputs", RPCArg::Type::ARR, RPCArg::Optional::NO, "The outputs specified as key-value pairs.\n"
1203 "Each key may only appear once, i.e. there can only be one 'data' output, and no address may be duplicated.\n"
1204 "At least one output of either type must be specified.\n"
1205 "For convenience, a dictionary, which holds the key-value pairs directly, is also accepted.",
1206 OutputsDoc(),
1208 {"conf_target", RPCArg::Type::NUM, RPCArg::DefaultHint{"wallet -txconfirmtarget"}, "Confirmation target in blocks"},
1209 {"estimate_mode", RPCArg::Type::STR, RPCArg::Default{"unset"}, "The fee estimate mode, must be one of (case insensitive):\n"
1210 + FeeModesDetail(std::string("economical mode is used if the transaction is replaceable;\notherwise, conservative mode is used"))},
1211 {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"not set, fall back to wallet fee estimation"}, "Specify a fee rate in " + CURRENCY_ATOM + "/vB."},
1213 Cat<std::vector<RPCArg>>(
1214 {
1215 {"add_inputs", RPCArg::Type::BOOL, RPCArg::DefaultHint{"false when \"inputs\" are specified, true otherwise"},"Automatically include coins from the wallet to cover the target amount.\n"},
1216 {"include_unsafe", RPCArg::Type::BOOL, RPCArg::Default{false}, "Include inputs that are not safe to spend (unconfirmed transactions from outside keys and unconfirmed replacement transactions).\n"
1217 "Warning: the resulting transaction may become invalid if one of the unsafe inputs disappears.\n"
1218 "If that happens, you will need to fund the transaction with different inputs and republish it."},
1219 {"minconf", RPCArg::Type::NUM, RPCArg::Default{0}, "If add_inputs is specified, require inputs with at least this many confirmations."},
1220 {"maxconf", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "If add_inputs is specified, require inputs with at most this many confirmations."},
1221 {"add_to_wallet", RPCArg::Type::BOOL, RPCArg::Default{true}, "When false, returns a serialized transaction which will not be added to the wallet or broadcast"},
1222 {"change_address", RPCArg::Type::STR, RPCArg::DefaultHint{"automatic"}, "The bitcoin address to receive the change"},
1223 {"change_position", RPCArg::Type::NUM, RPCArg::DefaultHint{"random"}, "The index of the change output"},
1224 {"change_type", RPCArg::Type::STR, RPCArg::DefaultHint{"set by -changetype"}, "The output type to use. Only valid if change_address is not specified. Options are \"legacy\", \"p2sh-segwit\", \"bech32\" and \"bech32m\"."},
1225 {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"not set, fall back to wallet fee estimation"}, "Specify a fee rate in " + CURRENCY_ATOM + "/vB.", RPCArgOptions{.also_positional = true}},
1226 {"include_watching", RPCArg::Type::BOOL, RPCArg::DefaultHint{"true for watch-only wallets, otherwise false"}, "Also select inputs which are watch only.\n"
1227 "Only solvable inputs can be used. Watch-only destinations are solvable if the public key and/or output script was imported,\n"
1228 "e.g. with 'importpubkey' or 'importmulti' with the 'pubkeys' or 'desc' field."},
1229 {"inputs", RPCArg::Type::ARR, RPCArg::Default{UniValue::VARR}, "Specify inputs instead of adding them automatically. A JSON array of JSON objects",
1230 {
1231 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
1232 {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
1233 {"sequence", RPCArg::Type::NUM, RPCArg::Optional::NO, "The sequence number"},
1234 {"weight", RPCArg::Type::NUM, RPCArg::DefaultHint{"Calculated from wallet and solving data"}, "The maximum weight for this input, "
1235 "including the weight of the outpoint and sequence number. "
1236 "Note that signature sizes are not guaranteed to be consistent, "
1237 "so the maximum DER signatures size of 73 bytes should be used when considering ECDSA signatures."
1238 "Remember to convert serialized sizes to weight units when necessary."},
1239 },
1240 },
1241 {"locktime", RPCArg::Type::NUM, RPCArg::Default{0}, "Raw locktime. Non-0 value also locktime-activates inputs"},
1242 {"lock_unspents", RPCArg::Type::BOOL, RPCArg::Default{false}, "Lock selected unspent outputs"},
1243 {"psbt", RPCArg::Type::BOOL, RPCArg::DefaultHint{"automatic"}, "Always return a PSBT, implies add_to_wallet=false."},
1244 {"subtract_fee_from_outputs", RPCArg::Type::ARR, RPCArg::Default{UniValue::VARR}, "Outputs to subtract the fee from, specified as integer indices.\n"
1245 "The fee will be equally deducted from the amount of each specified output.\n"
1246 "Those recipients will receive less bitcoins than you enter in their corresponding amount field.\n"
1247 "If no outputs are specified here, the sender pays the fee.",
1248 {
1249 {"vout_index", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "The zero-based output index, before a change output is added."},
1250 },
1251 },
1252 {"max_tx_weight", RPCArg::Type::NUM, RPCArg::Default{MAX_STANDARD_TX_WEIGHT}, "The maximum acceptable transaction weight.\n"
1253 "Transaction building will fail if this can not be satisfied."},
1254 },
1255 FundTxDoc()),
1257 },
1258 RPCResult{
1259 RPCResult::Type::OBJ, "", "",
1260 {
1261 {RPCResult::Type::BOOL, "complete", "If the transaction has a complete set of signatures"},
1262 {RPCResult::Type::STR_HEX, "txid", /*optional=*/true, "The transaction id for the send. Only 1 transaction is created regardless of the number of addresses."},
1263 {RPCResult::Type::STR_HEX, "hex", /*optional=*/true, "If add_to_wallet is false, the hex-encoded raw transaction with signature(s)"},
1264 {RPCResult::Type::STR, "psbt", /*optional=*/true, "If more signatures are needed, or if add_to_wallet is false, the base64-encoded (partially) signed transaction"}
1265 }
1266 },
1267 RPCExamples{""
1268 "\nSend 0.1 BTC with a confirmation target of 6 blocks in economical fee estimate mode\n"
1269 + HelpExampleCli("send", "'{\"" + EXAMPLE_ADDRESS[0] + "\": 0.1}' 6 economical\n") +
1270 "Send 0.2 BTC with a fee rate of 1.1 " + CURRENCY_ATOM + "/vB using positional arguments\n"
1271 + HelpExampleCli("send", "'{\"" + EXAMPLE_ADDRESS[0] + "\": 0.2}' null \"unset\" 1.1\n") +
1272 "Send 0.2 BTC with a fee rate of 1 " + CURRENCY_ATOM + "/vB using the options argument\n"
1273 + HelpExampleCli("send", "'{\"" + EXAMPLE_ADDRESS[0] + "\": 0.2}' null \"unset\" null '{\"fee_rate\": 1}'\n") +
1274 "Send 0.3 BTC with a fee rate of 25 " + CURRENCY_ATOM + "/vB using named arguments\n"
1275 + HelpExampleCli("-named send", "outputs='{\"" + EXAMPLE_ADDRESS[0] + "\": 0.3}' fee_rate=25\n") +
1276 "Create a transaction that should confirm the next block, with a specific input, and return result without adding to wallet or broadcasting to the network\n"
1277 + HelpExampleCli("send", "'{\"" + EXAMPLE_ADDRESS[0] + "\": 0.1}' 1 economical '{\"add_to_wallet\": false, \"inputs\": [{\"txid\":\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\", \"vout\":1}]}'")
1278 },
1279 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
1280 {
1281 std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
1282 if (!pwallet) return UniValue::VNULL;
1283
1284 UniValue options{request.params[4].isNull() ? UniValue::VOBJ : request.params[4]};
1285 InterpretFeeEstimationInstructions(/*conf_target=*/request.params[1], /*estimate_mode=*/request.params[2], /*fee_rate=*/request.params[3], options);
1286 PreventOutdatedOptions(options);
1287
1288
1289 bool rbf{options.exists("replaceable") ? options["replaceable"].get_bool() : pwallet->m_signal_rbf};
1290 UniValue outputs(UniValue::VOBJ);
1291 outputs = NormalizeOutputs(request.params[0]);
1292 std::vector<CRecipient> recipients = CreateRecipients(
1293 ParseOutputs(outputs),
1294 InterpretSubtractFeeFromOutputInstructions(options["subtract_fee_from_outputs"], outputs.getKeys())
1295 );
1296 CMutableTransaction rawTx = ConstructTransaction(options["inputs"], request.params[0], options["locktime"], rbf);
1297 CCoinControl coin_control;
1298 // Automatically select coins, unless at least one is manually selected. Can
1299 // be overridden by options.add_inputs.
1300 coin_control.m_allow_other_inputs = rawTx.vin.size() == 0;
1301 if (options.exists("max_tx_weight")) {
1302 coin_control.m_max_tx_weight = options["max_tx_weight"].getInt<int>();
1303 }
1304 SetOptionsInputWeights(options["inputs"], options);
1305 // Clear tx.vout since it is not meant to be used now that we are passing outputs directly.
1306 // This sets us up for a future PR to completely remove tx from the function signature in favor of passing inputs directly
1307 rawTx.vout.clear();
1308 auto txr = FundTransaction(*pwallet, rawTx, recipients, options, coin_control, /*override_min_fee=*/false);
1309
1310 return FinishTransaction(pwallet, options, CMutableTransaction(*txr.tx));
1311 }
1312 };
1313}
1314
1316{
1317 return RPCHelpMan{"sendall",
1318 "EXPERIMENTAL warning: this call may be changed in future releases.\n"
1319 "\nSpend the value of all (or specific) confirmed UTXOs and unconfirmed change in the wallet to one or more recipients.\n"
1320 "Unconfirmed inbound UTXOs and locked UTXOs will not be spent. Sendall will respect the avoid_reuse wallet flag.\n"
1321 "If your wallet contains many small inputs, either because it received tiny payments or as a result of accumulating change, consider using `send_max` to exclude inputs that are worth less than the fees needed to spend them.\n",
1322 {
1323 {"recipients", RPCArg::Type::ARR, RPCArg::Optional::NO, "The sendall destinations. Each address may only appear once.\n"
1324 "Optionally some recipients can be specified with an amount to perform payments, but at least one address must appear without a specified amount.\n",
1325 {
1326 {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "A bitcoin address which receives an equal share of the unspecified amount."},
1328 {
1329 {"address", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "A key-value pair. The key (string) is the bitcoin address, the value (float or string) is the amount in " + CURRENCY_UNIT + ""},
1330 },
1331 },
1332 },
1333 },
1334 {"conf_target", RPCArg::Type::NUM, RPCArg::DefaultHint{"wallet -txconfirmtarget"}, "Confirmation target in blocks"},
1335 {"estimate_mode", RPCArg::Type::STR, RPCArg::Default{"unset"}, "The fee estimate mode, must be one of (case insensitive):\n"
1336 + FeeModesDetail(std::string("economical mode is used if the transaction is replaceable;\notherwise, conservative mode is used"))},
1337 {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"not set, fall back to wallet fee estimation"}, "Specify a fee rate in " + CURRENCY_ATOM + "/vB."},
1338 {
1340 Cat<std::vector<RPCArg>>(
1341 {
1342 {"add_to_wallet", RPCArg::Type::BOOL, RPCArg::Default{true}, "When false, returns the serialized transaction without broadcasting or adding it to the wallet"},
1343 {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"not set, fall back to wallet fee estimation"}, "Specify a fee rate in " + CURRENCY_ATOM + "/vB.", RPCArgOptions{.also_positional = true}},
1344 {"include_watching", RPCArg::Type::BOOL, RPCArg::DefaultHint{"true for watch-only wallets, otherwise false"}, "Also select inputs which are watch-only.\n"
1345 "Only solvable inputs can be used. Watch-only destinations are solvable if the public key and/or output script was imported,\n"
1346 "e.g. with 'importpubkey' or 'importmulti' with the 'pubkeys' or 'desc' field."},
1347 {"inputs", RPCArg::Type::ARR, RPCArg::Default{UniValue::VARR}, "Use exactly the specified inputs to build the transaction. Specifying inputs is incompatible with the send_max, minconf, and maxconf options.",
1348 {
1350 {
1351 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
1352 {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
1353 {"sequence", RPCArg::Type::NUM, RPCArg::DefaultHint{"depends on the value of the 'replaceable' and 'locktime' arguments"}, "The sequence number"},
1354 },
1355 },
1356 },
1357 },
1358 {"locktime", RPCArg::Type::NUM, RPCArg::Default{0}, "Raw locktime. Non-0 value also locktime-activates inputs"},
1359 {"lock_unspents", RPCArg::Type::BOOL, RPCArg::Default{false}, "Lock selected unspent outputs"},
1360 {"psbt", RPCArg::Type::BOOL, RPCArg::DefaultHint{"automatic"}, "Always return a PSBT, implies add_to_wallet=false."},
1361 {"send_max", RPCArg::Type::BOOL, RPCArg::Default{false}, "When true, only use UTXOs that can pay for their own fees to maximize the output amount. When 'false' (default), no UTXO is left behind. send_max is incompatible with providing specific inputs."},
1362 {"minconf", RPCArg::Type::NUM, RPCArg::Default{0}, "Require inputs with at least this many confirmations."},
1363 {"maxconf", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "Require inputs with at most this many confirmations."},
1364 },
1365 FundTxDoc()
1366 ),
1368 },
1369 },
1370 RPCResult{
1371 RPCResult::Type::OBJ, "", "",
1372 {
1373 {RPCResult::Type::BOOL, "complete", "If the transaction has a complete set of signatures"},
1374 {RPCResult::Type::STR_HEX, "txid", /*optional=*/true, "The transaction id for the send. Only 1 transaction is created regardless of the number of addresses."},
1375 {RPCResult::Type::STR_HEX, "hex", /*optional=*/true, "If add_to_wallet is false, the hex-encoded raw transaction with signature(s)"},
1376 {RPCResult::Type::STR, "psbt", /*optional=*/true, "If more signatures are needed, or if add_to_wallet is false, the base64-encoded (partially) signed transaction"}
1377 }
1378 },
1379 RPCExamples{""
1380 "\nSpend all UTXOs from the wallet with a fee rate of 1 " + CURRENCY_ATOM + "/vB using named arguments\n"
1381 + HelpExampleCli("-named sendall", "recipients='[\"" + EXAMPLE_ADDRESS[0] + "\"]' fee_rate=1\n") +
1382 "Spend all UTXOs with a fee rate of 1.1 " + CURRENCY_ATOM + "/vB using positional arguments\n"
1383 + HelpExampleCli("sendall", "'[\"" + EXAMPLE_ADDRESS[0] + "\"]' null \"unset\" 1.1\n") +
1384 "Spend all UTXOs split into equal amounts to two addresses with a fee rate of 1.5 " + CURRENCY_ATOM + "/vB using the options argument\n"
1385 + HelpExampleCli("sendall", "'[\"" + EXAMPLE_ADDRESS[0] + "\", \"" + EXAMPLE_ADDRESS[1] + "\"]' null \"unset\" null '{\"fee_rate\": 1.5}'\n") +
1386 "Leave dust UTXOs in wallet, spend only UTXOs with positive effective value with a fee rate of 10 " + CURRENCY_ATOM + "/vB using the options argument\n"
1387 + HelpExampleCli("sendall", "'[\"" + EXAMPLE_ADDRESS[0] + "\"]' null \"unset\" null '{\"fee_rate\": 10, \"send_max\": true}'\n") +
1388 "Spend all UTXOs with a fee rate of 1.3 " + CURRENCY_ATOM + "/vB using named arguments and sending a 0.25 " + CURRENCY_UNIT + " to another recipient\n"
1389 + HelpExampleCli("-named sendall", "recipients='[{\"" + EXAMPLE_ADDRESS[1] + "\": 0.25}, \""+ EXAMPLE_ADDRESS[0] + "\"]' fee_rate=1.3\n")
1390 },
1391 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
1392 {
1393 std::shared_ptr<CWallet> const pwallet{GetWalletForJSONRPCRequest(request)};
1394 if (!pwallet) return UniValue::VNULL;
1395 // Make sure the results are valid at least up to the most recent block
1396 // the user could have gotten from another RPC command prior to now
1397 pwallet->BlockUntilSyncedToCurrentChain();
1398
1399 UniValue options{request.params[4].isNull() ? UniValue::VOBJ : request.params[4]};
1400 InterpretFeeEstimationInstructions(/*conf_target=*/request.params[1], /*estimate_mode=*/request.params[2], /*fee_rate=*/request.params[3], options);
1401 PreventOutdatedOptions(options);
1402
1403
1404 std::set<std::string> addresses_without_amount;
1405 UniValue recipient_key_value_pairs(UniValue::VARR);
1406 const UniValue& recipients{request.params[0]};
1407 for (unsigned int i = 0; i < recipients.size(); ++i) {
1408 const UniValue& recipient{recipients[i]};
1409 if (recipient.isStr()) {
1411 rkvp.pushKV(recipient.get_str(), 0);
1412 recipient_key_value_pairs.push_back(std::move(rkvp));
1413 addresses_without_amount.insert(recipient.get_str());
1414 } else {
1415 recipient_key_value_pairs.push_back(recipient);
1416 }
1417 }
1418
1419 if (addresses_without_amount.size() == 0) {
1420 throw JSONRPCError(RPC_INVALID_PARAMETER, "Must provide at least one address without a specified amount");
1421 }
1422
1423 CCoinControl coin_control;
1424
1425 SetFeeEstimateMode(*pwallet, coin_control, options["conf_target"], options["estimate_mode"], options["fee_rate"], /*override_min_fee=*/false);
1426
1427 coin_control.fAllowWatchOnly = ParseIncludeWatchonly(options["include_watching"], *pwallet);
1428
1429 if (options.exists("minconf")) {
1430 if (options["minconf"].getInt<int>() < 0)
1431 {
1432 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid minconf (minconf cannot be negative): %s", options["minconf"].getInt<int>()));
1433 }
1434
1435 coin_control.m_min_depth = options["minconf"].getInt<int>();
1436 }
1437
1438 if (options.exists("maxconf")) {
1439 coin_control.m_max_depth = options["maxconf"].getInt<int>();
1440
1441 if (coin_control.m_max_depth < coin_control.m_min_depth) {
1442 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("maxconf can't be lower than minconf: %d < %d", coin_control.m_max_depth, coin_control.m_min_depth));
1443 }
1444 }
1445
1446 const bool rbf{options.exists("replaceable") ? options["replaceable"].get_bool() : pwallet->m_signal_rbf};
1447
1448 FeeCalculation fee_calc_out;
1449 CFeeRate fee_rate{GetMinimumFeeRate(*pwallet, coin_control, &fee_calc_out)};
1450 // Do not, ever, assume that it's fine to change the fee rate if the user has explicitly
1451 // provided one
1452 if (coin_control.m_feerate && fee_rate > *coin_control.m_feerate) {
1453 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Fee rate (%s) is lower than the minimum fee rate setting (%s)", coin_control.m_feerate->ToString(FeeEstimateMode::SAT_VB), fee_rate.ToString(FeeEstimateMode::SAT_VB)));
1454 }
1455 if (fee_calc_out.reason == FeeReason::FALLBACK && !pwallet->m_allow_fallback_fee) {
1456 // eventually allow a fallback fee
1457 throw JSONRPCError(RPC_WALLET_ERROR, "Fee estimation failed. Fallbackfee is disabled. Wait a few blocks or enable -fallbackfee.");
1458 }
1459
1460 CMutableTransaction rawTx{ConstructTransaction(options["inputs"], recipient_key_value_pairs, options["locktime"], rbf)};
1461 LOCK(pwallet->cs_wallet);
1462
1463 CAmount total_input_value(0);
1464 bool send_max{options.exists("send_max") ? options["send_max"].get_bool() : false};
1465 if (options.exists("inputs") && options.exists("send_max")) {
1466 throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot combine send_max with specific inputs.");
1467 } else if (options.exists("inputs") && (options.exists("minconf") || options.exists("maxconf"))) {
1468 throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot combine minconf or maxconf with specific inputs.");
1469 } else if (options.exists("inputs")) {
1470 for (const CTxIn& input : rawTx.vin) {
1471 if (pwallet->IsSpent(input.prevout)) {
1472 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Input not available. UTXO (%s:%d) was already spent.", input.prevout.hash.ToString(), input.prevout.n));
1473 }
1474 const CWalletTx* tx{pwallet->GetWalletTx(input.prevout.hash)};
1475 if (!tx || input.prevout.n >= tx->tx->vout.size() || !(pwallet->IsMine(tx->tx->vout[input.prevout.n]) & (coin_control.fAllowWatchOnly ? ISMINE_ALL : ISMINE_SPENDABLE))) {
1476 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Input not found. UTXO (%s:%d) is not part of wallet.", input.prevout.hash.ToString(), input.prevout.n));
1477 }
1478 total_input_value += tx->tx->vout[input.prevout.n].nValue;
1479 }
1480 } else {
1481 CoinFilterParams coins_params;
1482 coins_params.min_amount = 0;
1483 for (const COutput& output : AvailableCoins(*pwallet, &coin_control, fee_rate, coins_params).All()) {
1484 CHECK_NONFATAL(output.input_bytes > 0);
1485 if (send_max && fee_rate.GetFee(output.input_bytes) > output.txout.nValue) {
1486 continue;
1487 }
1488 CTxIn input(output.outpoint.hash, output.outpoint.n, CScript(), rbf ? MAX_BIP125_RBF_SEQUENCE : CTxIn::SEQUENCE_FINAL);
1489 rawTx.vin.push_back(input);
1490 total_input_value += output.txout.nValue;
1491 }
1492 }
1493
1494 std::vector<COutPoint> outpoints_spent;
1495 outpoints_spent.reserve(rawTx.vin.size());
1496
1497 for (const CTxIn& tx_in : rawTx.vin) {
1498 outpoints_spent.push_back(tx_in.prevout);
1499 }
1500
1501 // estimate final size of tx
1502 const TxSize tx_size{CalculateMaximumSignedTxSize(CTransaction(rawTx), pwallet.get())};
1503 const CAmount fee_from_size{fee_rate.GetFee(tx_size.vsize)};
1504 const std::optional<CAmount> total_bump_fees{pwallet->chain().calculateCombinedBumpFee(outpoints_spent, fee_rate)};
1505 CAmount effective_value = total_input_value - fee_from_size - total_bump_fees.value_or(0);
1506
1507 if (fee_from_size > pwallet->m_default_max_tx_fee) {
1508 throw JSONRPCError(RPC_WALLET_ERROR, TransactionErrorString(TransactionError::MAX_FEE_EXCEEDED).original);
1509 }
1510
1511 if (effective_value <= 0) {
1512 if (send_max) {
1513 throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Total value of UTXO pool too low to pay for transaction, try using lower feerate.");
1514 } else {
1515 throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Total value of UTXO pool too low to pay for transaction. Try using lower feerate or excluding uneconomic UTXOs with 'send_max' option.");
1516 }
1517 }
1518
1519 // If this transaction is too large, e.g. because the wallet has many UTXOs, it will be rejected by the node's mempool.
1520 if (tx_size.weight > MAX_STANDARD_TX_WEIGHT) {
1521 throw JSONRPCError(RPC_WALLET_ERROR, "Transaction too large.");
1522 }
1523
1524 CAmount output_amounts_claimed{0};
1525 for (const CTxOut& out : rawTx.vout) {
1526 output_amounts_claimed += out.nValue;
1527 }
1528
1529 if (output_amounts_claimed > total_input_value) {
1530 throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Assigned more value to outputs than available funds.");
1531 }
1532
1533 const CAmount remainder{effective_value - output_amounts_claimed};
1534 if (remainder < 0) {
1535 throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Insufficient funds for fees after creating specified outputs.");
1536 }
1537
1538 const CAmount per_output_without_amount{remainder / (long)addresses_without_amount.size()};
1539
1540 bool gave_remaining_to_first{false};
1541 for (CTxOut& out : rawTx.vout) {
1542 CTxDestination dest;
1543 ExtractDestination(out.scriptPubKey, dest);
1544 std::string addr{EncodeDestination(dest)};
1545 if (addresses_without_amount.count(addr) > 0) {
1546 out.nValue = per_output_without_amount;
1547 if (!gave_remaining_to_first) {
1548 out.nValue += remainder % addresses_without_amount.size();
1549 gave_remaining_to_first = true;
1550 }
1551 if (IsDust(out, pwallet->chain().relayDustFee())) {
1552 // Dynamically generated output amount is dust
1553 throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Dynamically assigned remainder results in dust output.");
1554 }
1555 } else {
1556 if (IsDust(out, pwallet->chain().relayDustFee())) {
1557 // Specified output amount is dust
1558 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Specified output amount to %s is below dust threshold.", addr));
1559 }
1560 }
1561 }
1562
1563 const bool lock_unspents{options.exists("lock_unspents") ? options["lock_unspents"].get_bool() : false};
1564 if (lock_unspents) {
1565 for (const CTxIn& txin : rawTx.vin) {
1566 pwallet->LockCoin(txin.prevout);
1567 }
1568 }
1569
1570 return FinishTransaction(pwallet, options, rawTx);
1571 }
1572 };
1573}
1574
1576{
1577 return RPCHelpMan{"walletprocesspsbt",
1578 "\nUpdate a PSBT with input information from our wallet and then sign inputs\n"
1579 "that we can sign for." +
1581 {
1582 {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO, "The transaction base64 string"},
1583 {"sign", RPCArg::Type::BOOL, RPCArg::Default{true}, "Also sign the transaction when updating (requires wallet to be unlocked)"},
1584 {"sighashtype", RPCArg::Type::STR, RPCArg::Default{"DEFAULT for Taproot, ALL otherwise"}, "The signature hash type to sign with if not specified by the PSBT. Must be one of\n"
1585 " \"DEFAULT\"\n"
1586 " \"ALL\"\n"
1587 " \"NONE\"\n"
1588 " \"SINGLE\"\n"
1589 " \"ALL|ANYONECANPAY\"\n"
1590 " \"NONE|ANYONECANPAY\"\n"
1591 " \"SINGLE|ANYONECANPAY\""},
1592 {"bip32derivs", RPCArg::Type::BOOL, RPCArg::Default{true}, "Include BIP 32 derivation paths for public keys if we know them"},
1593 {"finalize", RPCArg::Type::BOOL, RPCArg::Default{true}, "Also finalize inputs if possible"},
1594 },
1595 RPCResult{
1596 RPCResult::Type::OBJ, "", "",
1597 {
1598 {RPCResult::Type::STR, "psbt", "The base64-encoded partially signed transaction"},
1599 {RPCResult::Type::BOOL, "complete", "If the transaction has a complete set of signatures"},
1600 {RPCResult::Type::STR_HEX, "hex", /*optional=*/true, "The hex-encoded network transaction if complete"},
1601 }
1602 },
1604 HelpExampleCli("walletprocesspsbt", "\"psbt\"")
1605 },
1606 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
1607{
1608 const std::shared_ptr<const CWallet> pwallet = GetWalletForJSONRPCRequest(request);
1609 if (!pwallet) return UniValue::VNULL;
1610
1611 const CWallet& wallet{*pwallet};
1612 // Make sure the results are valid at least up to the most recent block
1613 // the user could have gotten from another RPC command prior to now
1614 wallet.BlockUntilSyncedToCurrentChain();
1615
1616 // Unserialize the transaction
1618 std::string error;
1619 if (!DecodeBase64PSBT(psbtx, request.params[0].get_str(), error)) {
1620 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", error));
1621 }
1622
1623 // Get the sighash type
1624 int nHashType = ParseSighashString(request.params[2]);
1625
1626 // Fill transaction with our data and also sign
1627 bool sign = request.params[1].isNull() ? true : request.params[1].get_bool();
1628 bool bip32derivs = request.params[3].isNull() ? true : request.params[3].get_bool();
1629 bool finalize = request.params[4].isNull() ? true : request.params[4].get_bool();
1630 bool complete = true;
1631
1632 if (sign) EnsureWalletIsUnlocked(*pwallet);
1633
1634 const auto err{wallet.FillPSBT(psbtx, complete, nHashType, sign, bip32derivs, nullptr, finalize)};
1635 if (err) {
1636 throw JSONRPCPSBTError(*err);
1637 }
1638
1639 UniValue result(UniValue::VOBJ);
1640 DataStream ssTx{};
1641 ssTx << psbtx;
1642 result.pushKV("psbt", EncodeBase64(ssTx.str()));
1643 result.pushKV("complete", complete);
1644 if (complete) {
1646 // Returns true if complete, which we already think it is.
1648 DataStream ssTx_final;
1649 ssTx_final << TX_WITH_WITNESS(mtx);
1650 result.pushKV("hex", HexStr(ssTx_final));
1651 }
1652
1653 return result;
1654},
1655 };
1656}
1657
1659{
1660 return RPCHelpMan{"walletcreatefundedpsbt",
1661 "\nCreates and funds a transaction in the Partially Signed Transaction format.\n"
1662 "Implements the Creator and Updater roles.\n"
1663 "All existing inputs must either have their previous output transaction be in the wallet\n"
1664 "or be in the UTXO set. Solving data must be provided for non-wallet inputs.\n",
1665 {
1666 {"inputs", RPCArg::Type::ARR, RPCArg::Optional::OMITTED, "Leave empty to add inputs automatically. See add_inputs option.",
1667 {
1669 {
1670 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
1671 {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
1672 {"sequence", RPCArg::Type::NUM, RPCArg::DefaultHint{"depends on the value of the 'locktime' and 'options.replaceable' arguments"}, "The sequence number"},
1673 {"weight", RPCArg::Type::NUM, RPCArg::DefaultHint{"Calculated from wallet and solving data"}, "The maximum weight for this input, "
1674 "including the weight of the outpoint and sequence number. "
1675 "Note that signature sizes are not guaranteed to be consistent, "
1676 "so the maximum DER signatures size of 73 bytes should be used when considering ECDSA signatures."
1677 "Remember to convert serialized sizes to weight units when necessary."},
1678 },
1679 },
1680 },
1681 },
1682 {"outputs", RPCArg::Type::ARR, RPCArg::Optional::NO, "The outputs specified as key-value pairs.\n"
1683 "Each key may only appear once, i.e. there can only be one 'data' output, and no address may be duplicated.\n"
1684 "At least one output of either type must be specified.\n"
1685 "For compatibility reasons, a dictionary, which holds the key-value pairs directly, is also\n"
1686 "accepted as second parameter.",
1687 OutputsDoc(),
1689 {"locktime", RPCArg::Type::NUM, RPCArg::Default{0}, "Raw locktime. Non-0 value also locktime-activates inputs"},
1691 Cat<std::vector<RPCArg>>(
1692 {
1693 {"add_inputs", RPCArg::Type::BOOL, RPCArg::DefaultHint{"false when \"inputs\" are specified, true otherwise"}, "Automatically include coins from the wallet to cover the target amount.\n"},
1694 {"include_unsafe", RPCArg::Type::BOOL, RPCArg::Default{false}, "Include inputs that are not safe to spend (unconfirmed transactions from outside keys and unconfirmed replacement transactions).\n"
1695 "Warning: the resulting transaction may become invalid if one of the unsafe inputs disappears.\n"
1696 "If that happens, you will need to fund the transaction with different inputs and republish it."},
1697 {"minconf", RPCArg::Type::NUM, RPCArg::Default{0}, "If add_inputs is specified, require inputs with at least this many confirmations."},
1698 {"maxconf", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "If add_inputs is specified, require inputs with at most this many confirmations."},
1699 {"changeAddress", RPCArg::Type::STR, RPCArg::DefaultHint{"automatic"}, "The bitcoin address to receive the change"},
1700 {"changePosition", RPCArg::Type::NUM, RPCArg::DefaultHint{"random"}, "The index of the change output"},
1701 {"change_type", RPCArg::Type::STR, RPCArg::DefaultHint{"set by -changetype"}, "The output type to use. Only valid if changeAddress is not specified. Options are \"legacy\", \"p2sh-segwit\", \"bech32\", and \"bech32m\"."},
1702 {"includeWatching", RPCArg::Type::BOOL, RPCArg::DefaultHint{"true for watch-only wallets, otherwise false"}, "Also select inputs which are watch only"},
1703 {"lockUnspents", RPCArg::Type::BOOL, RPCArg::Default{false}, "Lock selected unspent outputs"},
1704 {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"not set, fall back to wallet fee estimation"}, "Specify a fee rate in " + CURRENCY_ATOM + "/vB."},
1705 {"feeRate", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"not set, fall back to wallet fee estimation"}, "Specify a fee rate in " + CURRENCY_UNIT + "/kvB."},
1706 {"subtractFeeFromOutputs", RPCArg::Type::ARR, RPCArg::Default{UniValue::VARR}, "The outputs to subtract the fee from.\n"
1707 "The fee will be equally deducted from the amount of each specified output.\n"
1708 "Those recipients will receive less bitcoins than you enter in their corresponding amount field.\n"
1709 "If no outputs are specified here, the sender pays the fee.",
1710 {
1711 {"vout_index", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "The zero-based output index, before a change output is added."},
1712 },
1713 },
1714 {"max_tx_weight", RPCArg::Type::NUM, RPCArg::Default{MAX_STANDARD_TX_WEIGHT}, "The maximum acceptable transaction weight.\n"
1715 "Transaction building will fail if this can not be satisfied."},
1716 },
1717 FundTxDoc()),
1719 {"bip32derivs", RPCArg::Type::BOOL, RPCArg::Default{true}, "Include BIP 32 derivation paths for public keys if we know them"},
1720 },
1721 RPCResult{
1722 RPCResult::Type::OBJ, "", "",
1723 {
1724 {RPCResult::Type::STR, "psbt", "The resulting raw transaction (base64-encoded string)"},
1725 {RPCResult::Type::STR_AMOUNT, "fee", "Fee in " + CURRENCY_UNIT + " the resulting transaction pays"},
1726 {RPCResult::Type::NUM, "changepos", "The position of the added change output, or -1"},
1727 }
1728 },
1730 "\nCreate a transaction with no inputs\n"
1731 + HelpExampleCli("walletcreatefundedpsbt", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"")
1732 },
1733 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
1734{
1735 std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
1736 if (!pwallet) return UniValue::VNULL;
1737
1738 CWallet& wallet{*pwallet};
1739 // Make sure the results are valid at least up to the most recent block
1740 // the user could have gotten from another RPC command prior to now
1741 wallet.BlockUntilSyncedToCurrentChain();
1742
1743 UniValue options{request.params[3].isNull() ? UniValue::VOBJ : request.params[3]};
1744
1745 const UniValue &replaceable_arg = options["replaceable"];
1746 const bool rbf{replaceable_arg.isNull() ? wallet.m_signal_rbf : replaceable_arg.get_bool()};
1747 CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2], rbf);
1748 UniValue outputs(UniValue::VOBJ);
1749 outputs = NormalizeOutputs(request.params[1]);
1750 std::vector<CRecipient> recipients = CreateRecipients(
1751 ParseOutputs(outputs),
1752 InterpretSubtractFeeFromOutputInstructions(options["subtractFeeFromOutputs"], outputs.getKeys())
1753 );
1754 CCoinControl coin_control;
1755 // Automatically select coins, unless at least one is manually selected. Can
1756 // be overridden by options.add_inputs.
1757 coin_control.m_allow_other_inputs = rawTx.vin.size() == 0;
1758 SetOptionsInputWeights(request.params[0], options);
1759 // Clear tx.vout since it is not meant to be used now that we are passing outputs directly.
1760 // This sets us up for a future PR to completely remove tx from the function signature in favor of passing inputs directly
1761 rawTx.vout.clear();
1762 auto txr = FundTransaction(wallet, rawTx, recipients, options, coin_control, /*override_min_fee=*/true);
1763
1764 // Make a blank psbt
1766
1767 // Fill transaction with out data but don't sign
1768 bool bip32derivs = request.params[4].isNull() ? true : request.params[4].get_bool();
1769 bool complete = true;
1770 const auto err{wallet.FillPSBT(psbtx, complete, 1, /*sign=*/false, /*bip32derivs=*/bip32derivs)};
1771 if (err) {
1772 throw JSONRPCPSBTError(*err);
1773 }
1774
1775 // Serialize the PSBT
1776 DataStream ssTx{};
1777 ssTx << psbtx;
1778
1779 UniValue result(UniValue::VOBJ);
1780 result.pushKV("psbt", EncodeBase64(ssTx.str()));
1781 result.pushKV("fee", ValueFromAmount(txr.fee));
1782 result.pushKV("changepos", txr.change_pos ? (int)*txr.change_pos : -1);
1783 return result;
1784},
1785 };
1786}
1787} // namespace wallet
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Parse a scriptPubKey for the destination.
Definition: addresstype.cpp:49
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination corresponds to one with an address.
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, PayToAnchor, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
Definition: addresstype.h:140
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
static CAmount AmountFromValue(const UniValue &value)
Definition: bitcoin-tx.cpp:561
ArgsManager & args
Definition: bitcoind.cpp:277
#define CHECK_NONFATAL(condition)
Identity function.
Definition: check.h:81
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
Definition: feerate.h:33
std::string ToString(const FeeEstimateMode &fee_estimate_mode=FeeEstimateMode::BTC_KVB) const
Definition: feerate.cpp:39
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:29
uint32_t n
Definition: transaction.h:32
Txid hash
Definition: transaction.h:31
An encapsulated public key.
Definition: pubkey.h:34
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
Definition: pubkey.h:164
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:415
A reference to a CScript: the Hash160 of its serialization.
Definition: script.h:602
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:296
An input of a transaction.
Definition: transaction.h:67
static const uint32_t SEQUENCE_FINAL
Setting nSequence to this value for every input in a transaction disables nLockTime/IsFinalTx().
Definition: transaction.h:81
COutPoint prevout
Definition: transaction.h:69
An output of a transaction.
Definition: transaction.h:150
Double ended buffer combining vector and stream-like interfaces.
Definition: streams.h:147
Fast randomness source.
Definition: random.h:377
void push_back(UniValue val)
Definition: univalue.cpp:104
const std::string & get_str() const
const UniValue & find_value(std::string_view key) const
Definition: univalue.cpp:233
@ VNULL
Definition: univalue.h:24
@ VOBJ
Definition: univalue.h:24
@ VSTR
Definition: univalue.h:24
@ VARR
Definition: univalue.h:24
@ VNUM
Definition: univalue.h:24
@ VBOOL
Definition: univalue.h:24
bool isNull() const
Definition: univalue.h:79
const UniValue & get_obj() const
size_t size() const
Definition: univalue.h:71
enum VType type() const
Definition: univalue.h:126
const std::vector< UniValue > & getValues() const
const std::vector< std::string > & getKeys() const
bool isBool() const
Definition: univalue.h:82
Int getInt() const
Definition: univalue.h:138
bool exists(const std::string &key) const
Definition: univalue.h:77
bool isNum() const
Definition: univalue.h:84
void pushKV(std::string key, UniValue val)
Definition: univalue.cpp:126
bool get_bool() const
std::string GetHex() const
Definition: uint256.cpp:11
std::string ToString() const
static transaction_identifier FromUint256(const uint256 &id)
256-bit opaque blob.
Definition: uint256.h:190
Coin Control Features.
Definition: coincontrol.h:81
FeeEstimateMode m_fee_mode
Fee estimation mode to control arguments to estimateSmartFee.
Definition: coincontrol.h:107
std::optional< bool > m_signal_bip125_rbf
Override the wallet's m_signal_rbf if set.
Definition: coincontrol.h:101
std::optional< unsigned int > m_confirm_target
Override the default confirmation target if set.
Definition: coincontrol.h:99
std::optional< int > m_max_tx_weight
Caps weight of resulting tx.
Definition: coincontrol.h:119
std::optional< OutputType > m_change_type
Override the default change type if set, ignored if destChange is set.
Definition: coincontrol.h:86
bool m_avoid_address_reuse
Forbids inclusion of dirty (previously used) addresses.
Definition: coincontrol.h:105
int m_min_depth
Minimum chain depth value for coin availability.
Definition: coincontrol.h:109
bool m_allow_other_inputs
If true, the selection process can add extra unselected inputs from the wallet while requires all sel...
Definition: coincontrol.h:91
int m_max_depth
Maximum chain depth value for coin availability.
Definition: coincontrol.h:111
bool fOverrideFeeRate
Override automatic min/max checks on fee, m_feerate must be set if true.
Definition: coincontrol.h:95
void SetInputWeight(const COutPoint &outpoint, int64_t weight)
Set an input's weight.
Definition: coincontrol.cpp:67
std::optional< CFeeRate > m_feerate
Override the wallet's m_pay_tx_fee if set.
Definition: coincontrol.h:97
bool m_include_unsafe_inputs
If false, only safe inputs will be used.
Definition: coincontrol.h:88
bool m_avoid_partial_spends
Avoid partial use of funds sent to a given address.
Definition: coincontrol.h:103
bool fAllowWatchOnly
Includes watch only addresses which are solvable.
Definition: coincontrol.h:93
FlatSigningProvider m_external_provider
SigningProvider that has pubkeys and scripts to do spend size estimation for external inputs.
Definition: coincontrol.h:113
CTxDestination destChange
Custom change destination, if not set an address is generated.
Definition: coincontrol.h:84
A CWallet maintains a set of transactions and balances, and provides the ability to create new transa...
Definition: wallet.h:300
A transaction with a bunch of additional info that only the owner cares about.
Definition: transaction.h:177
static UniValue Parse(std::string_view raw)
Parse string to UniValue or throw runtime_error if string contains invalid JSON.
Definition: client.cpp:327
static int64_t GetTransactionInputWeight(const CTxIn &txin)
Definition: validation.h:141
std::string EncodeHexTx(const CTransaction &tx)
Definition: core_write.cpp:143
UniValue ValueFromAmount(const CAmount amount)
Definition: core_write.cpp:26
bool DecodeHexTx(CMutableTransaction &tx, const std::string &hex_tx, bool try_no_witness=false, bool try_witness=true)
Definition: core_read.cpp:196
const std::string CURRENCY_ATOM
Definition: feerate.h:18
const std::string CURRENCY_UNIT
Definition: feerate.h:17
@ SAT_VB
Use sat/vB fee rate unit.
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
Definition: hex_base.cpp:29
@ SIGHASH_DEFAULT
Taproot only; implied when sighash byte is missing, and equivalent to SIGHASH_ALL.
Definition: interpreter.h:35
CTxDestination DecodeDestination(const std::string &str, std::string &error_msg, std::vector< int > *error_locations)
Definition: key_io.cpp:299
std::string EncodeDestination(const CTxDestination &dest)
Definition: key_io.cpp:294
is a home for simple string functions returning descriptive messages that are used in RPC and GUI int...
static int sign(const secp256k1_context *ctx, struct signer_secrets *signer_secrets, struct signer *signer, const secp256k1_musig_keyagg_cache *cache, const unsigned char *msg32, unsigned char *sig64)
Definition: musig.c:105
bool FeeModeFromString(const std::string &mode_string, FeeEstimateMode &fee_estimate_mode)
Definition: messages.cpp:94
std::string FeeModesDetail(std::string default_info)
Definition: messages.cpp:75
bilingual_str TransactionErrorString(const TransactionError err)
Definition: messages.cpp:124
std::string InvalidEstimateModeErrorMessage()
Definition: messages.cpp:89
std::string StringForFeeReason(FeeReason reason)
Definition: messages.cpp:26
TransactionError
Definition: types.h:20
bilingual_str ErrorString(const Result< T > &result)
Definition: result.h:93
Result CreateRateBumpTransaction(CWallet &wallet, const uint256 &txid, const CCoinControl &coin_control, std::vector< bilingual_str > &errors, CAmount &old_fee, CAmount &new_fee, CMutableTransaction &mtx, bool require_mine, const std::vector< CTxOut > &outputs, std::optional< uint32_t > original_change_index)
Create bumpfee transaction based on feerate estimates.
Definition: feebumper.cpp:165
Result CommitTransaction(CWallet &wallet, const uint256 &txid, CMutableTransaction &&mtx, std::vector< bilingual_str > &errors, uint256 &bumped_txid)
Commit the bumpfee transaction.
Definition: feebumper.cpp:356
bool SignTransaction(CWallet &wallet, CMutableTransaction &mtx)
Sign the new transaction,.
Definition: feebumper.cpp:336
CreatedTransactionResult FundTransaction(CWallet &wallet, const CMutableTransaction &tx, const std::vector< CRecipient > &recipients, const UniValue &options, CCoinControl &coinControl, bool override_min_fee)
Definition: spend.cpp:500
std::shared_ptr< CWallet > GetWalletForJSONRPCRequest(const JSONRPCRequest &request)
Figures out what wallet, if any, to use for a JSONRPCRequest.
Definition: util.cpp:57
util::Result< CreatedTransactionResult > CreateTransaction(CWallet &wallet, const std::vector< CRecipient > &vecSend, std::optional< unsigned int > change_pos, const CCoinControl &coin_control, bool sign)
Create a new transaction paying the recipients with a set of coins selected by SelectCoins(); Also cr...
Definition: spend.cpp:1370
std::map< std::string, std::string > mapValue_t
Definition: transaction.h:149
static RPCHelpMan bumpfee_helper(std::string method_name)
Definition: spend.cpp:987
RPCHelpMan walletprocesspsbt()
Definition: spend.cpp:1575
void EnsureWalletIsUnlocked(const CWallet &wallet)
Definition: util.cpp:81
const std::string HELP_REQUIRING_PASSPHRASE
Definition: util.cpp:19
RPCHelpMan psbtbumpfee()
Definition: spend.cpp:1194
static void SetFeeEstimateMode(const CWallet &wallet, CCoinControl &cc, const UniValue &conf_target, const UniValue &estimate_mode, const UniValue &fee_rate, bool override_min_fee)
Update coin control with fee estimation based on the given parameters.
Definition: spend.cpp:206
bool IsDust(const CRecipient &recipient, const CFeeRate &dustRelayFee)
Definition: spend.cpp:1005
RPCHelpMan walletcreatefundedpsbt()
Definition: spend.cpp:1658
static void InterpretFeeEstimationInstructions(const UniValue &conf_target, const UniValue &estimate_mode, const UniValue &fee_rate, UniValue &options)
Definition: spend.cpp:45
static void SetOptionsInputWeights(const UniValue &inputs, UniValue &options)
Definition: spend.cpp:721
RPCHelpMan settxfee()
Definition: spend.cpp:418
RPCHelpMan signrawtransactionwithwallet()
Definition: spend.cpp:872
CFeeRate GetMinimumFeeRate(const CWallet &wallet, const CCoinControl &coin_control, FeeCalculation *feeCalc)
Estimate the minimum fee rate considering user set parameters and the required fee.
Definition: fees.cpp:29
UniValue SendMoney(CWallet &wallet, const CCoinControl &coin_control, std::vector< CRecipient > &recipients, mapValue_t map_value, bool verbose)
Definition: spend.cpp:163
RPCHelpMan sendall()
Definition: spend.cpp:1315
static void PreventOutdatedOptions(const UniValue &options)
Definition: spend.cpp:141
RPCHelpMan bumpfee()
Definition: spend.cpp:1193
std::vector< CRecipient > CreateRecipients(const std::vector< std::pair< CTxDestination, CAmount > > &outputs, const std::set< int > &subtract_fee_outputs)
Definition: spend.cpp:34
@ ISMINE_SPENDABLE
Definition: types.h:44
@ ISMINE_ALL
Definition: types.h:46
static std::vector< RPCArg > FundTxDoc(bool solving_data=true)
Definition: spend.cpp:461
static UniValue FinishTransaction(const std::shared_ptr< CWallet > pwallet, const UniValue &options, const CMutableTransaction &rawTx)
Definition: spend.cpp:98
bool ParseIncludeWatchonly(const UniValue &include_watchonly, const CWallet &wallet)
Used by RPC commands that have an include_watchonly parameter.
Definition: util.cpp:36
static std::vector< RPCArg > OutputsDoc()
Definition: spend.cpp:969
RPCHelpMan sendmany()
Definition: spend.cpp:324
bool GetAvoidReuseFlag(const CWallet &wallet, const UniValue &param)
Definition: util.cpp:21
RPCHelpMan fundrawtransaction()
Definition: spend.cpp:738
TxSize CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, const std::vector< CTxOut > &txouts, const CCoinControl *coin_control)
Calculate the size of the transaction using CoinControl to determine whether to expect signature grin...
Definition: spend.cpp:142
@ WALLET_FLAG_EXTERNAL_SIGNER
Indicates that the wallet needs an external signer.
Definition: walletutil.h:77
@ WALLET_FLAG_DISABLE_PRIVATE_KEYS
Definition: walletutil.h:51
std::set< int > InterpretSubtractFeeFromOutputInstructions(const UniValue &sffo_instructions, const std::vector< std::string > &destinations)
Definition: spend.cpp:67
RPCHelpMan send()
Definition: spend.cpp:1196
RPCHelpMan sendtoaddress()
Definition: spend.cpp:230
CoinsResult AvailableCoins(const CWallet &wallet, const CCoinControl *coinControl, std::optional< CFeeRate > feerate, const CoinFilterParams &params)
Populate the CoinsResult struct with vectors of available COutputs, organized by OutputType.
Definition: spend.cpp:314
is a home for public enum and struct type definitions that are used by internally by node code,...
std::optional< OutputType > ParseOutputType(const std::string &type)
Definition: outputtype.cpp:24
static constexpr unsigned int DEFAULT_INCREMENTAL_RELAY_FEE
Default for -incrementalrelayfee, which sets the minimum feerate increase for mempool limiting or rep...
Definition: policy.h:35
static constexpr int32_t MAX_STANDARD_TX_WEIGHT
The maximum weight for transactions we're willing to relay/mine.
Definition: policy.h:27
static constexpr TransactionSerParams TX_WITH_WITNESS
Definition: transaction.h:195
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:424
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:423
bool DecodeBase64PSBT(PartiallySignedTransaction &psbt, const std::string &base64_tx, std::string &error)
Decode a base64ed PSBT into a PartiallySignedTransaction.
Definition: psbt.cpp:536
bool FinalizeAndExtractPSBT(PartiallySignedTransaction &psbtx, CMutableTransaction &result)
Finalizes a PSBT if possible, and extracts it to a CMutableTransaction if it could be finalized.
Definition: psbt.cpp:495
void SignTransactionResultToJSON(CMutableTransaction &mtx, bool complete, const std::map< COutPoint, Coin > &coins, const std::map< int, bilingual_str > &input_errors, UniValue &result)
CMutableTransaction ConstructTransaction(const UniValue &inputs_in, const UniValue &outputs_in, const UniValue &locktime, std::optional< bool > rbf)
Create a transaction from univalue parameters.
void AddOutputs(CMutableTransaction &rawTx, const UniValue &outputs_in)
Normalize, parse, and add outputs to the transaction.
std::vector< std::pair< CTxDestination, CAmount > > ParseOutputs(const UniValue &outputs)
Parse normalized outputs into destination, amount tuples.
UniValue NormalizeOutputs(const UniValue &outputs_in)
Normalize univalue-represented outputs.
void ParsePrevouts(const UniValue &prevTxsUnival, FlatSigningProvider *keystore, std::map< COutPoint, Coin > &coins)
Parse a prevtxs UniValue array and get the map of coins from it.
UniValue JSONRPCError(int code, const std::string &message)
Definition: request.cpp:70
@ RPC_MISC_ERROR
General application defined errors.
Definition: protocol.h:40
@ RPC_WALLET_INSUFFICIENT_FUNDS
Not enough funds in wallet or account.
Definition: protocol.h:72
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
Definition: protocol.h:44
@ RPC_WALLET_ERROR
Wallet errors.
Definition: protocol.h:71
@ RPC_DESERIALIZATION_ERROR
Error parsing or validating structure in raw format.
Definition: protocol.h:46
@ RPC_INVALID_REQUEST
Standard JSON-RPC 2.0 errors.
Definition: protocol.h:29
@ RPC_INVALID_ADDRESS_OR_KEY
Invalid address or key.
Definition: protocol.h:42
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
Definition: util.cpp:184
int ParseSighashString(const UniValue &sighash)
Returns a sighash value corresponding to the passed in argument.
Definition: util.cpp:379
UniValue JSONRPCPSBTError(PSBTError err)
Definition: util.cpp:425
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
Definition: util.cpp:202
CPubKey HexToPubKey(const std::string &hex_in)
Definition: util.cpp:220
const std::string EXAMPLE_ADDRESS[2]
Example bech32 addresses for the RPCExamples help documentation.
Definition: util.cpp:45
uint256 ParseHashO(const UniValue &o, std::string_view strKey)
Definition: util.cpp:127
unsigned int ParseConfirmTarget(const UniValue &value, unsigned int max_target)
Parse a confirm target option and raise an RPC error if it is invalid.
Definition: util.cpp:391
void RPCTypeCheckObj(const UniValue &o, const std::map< std::string, UniValueType > &typesExpected, bool fAllowNull, bool fStrict)
Definition: util.cpp:57
uint256 ParseHashV(const UniValue &v, std::string_view name)
Utilities: convert hex-encoded Values (throws error if not hex).
Definition: util.cpp:118
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
Definition: strencodings.h:68
A mutable version of CTransaction.
Definition: transaction.h:378
std::vector< CTxOut > vout
Definition: transaction.h:380
std::vector< CTxIn > vin
Definition: transaction.h:379
FeeReason reason
Definition: fees.h:95
FlatSigningProvider & Merge(FlatSigningProvider &&b) LIFETIMEBOUND
std::map< CKeyID, CPubKey > pubkeys
std::map< CScriptID, CScript > scripts
A version of CTransaction with the PSBT format.
Definition: psbt.h:951
@ OBJ_USER_KEYS
Special type where the user must set the keys e.g. to define multiple addresses; as opposed to e....
@ STR_HEX
Special type that is a STR with only hex chars.
@ AMOUNT
Special type representing a floating point amount (can be either NUM or STR)
@ OBJ_NAMED_PARAMS
Special type that behaves almost exactly like OBJ, defining an options object with a list of pre-defi...
std::string DefaultHint
Hint for default value.
Definition: util.h:217
@ OMITTED
Optional argument for which the default value is omitted from help text for one of two reasons:
@ NO
Required arg.
std::string oneline_description
Should be empty unless it is supposed to override the auto-generated summary line.
Definition: util.h:168
bool also_positional
If set allows a named-parameter field in an OBJ_NAMED_PARAM options object to have the same name as a...
Definition: util.h:171
bool skip_type_check
Definition: util.h:167
@ STR_HEX
Special string with only hex chars.
@ STR_AMOUNT
Special string to represent a floating point amount.
Wrapper for UniValue::VType, which includes typeAny: Used to denote don't care type.
Definition: util.h:79
Bilingual messages:
Definition: translation.h:21
A UTXO under consideration for use in funding a new transaction.
Definition: coinselection.h:28
#define LOCK(cs)
Definition: sync.h:257
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1165
const UniValue NullUniValue
Definition: univalue.cpp:16
static constexpr uint32_t MAX_BIP125_RBF_SEQUENCE
Definition: rbf.h:12
std::string EncodeBase64(Span< const unsigned char > input)
bool IsHex(std::string_view str)
V Cat(V v1, V &&v2)
Concatenate two vectors, moving elements.
Definition: vector.h:34