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