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