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