1// Copyright (c) 2011-present The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#include <common/messages.h>
6#include <consensus/validation.h>
7#include <core_io.h>
8#include <key_io.h>
9#include <node/types.h>
10#include <policy/policy.h>
11#include <policy/truc_policy.h>
12#include <rpc/rawtransaction_util.h>
13#include <rpc/util.h>
14#include <script/script.h>
15#include <util/rbf.h>
16#include <util/translation.h>
17#include <util/vector.h>
18#include <wallet/coincontrol.h>
19#include <wallet/feebumper.h>
20#include <wallet/fees.h>
21#include <wallet/rpc/util.h>
22#include <wallet/spend.h>
23#include <wallet/wallet.h>
24
25#include <univalue.h>
26
27using common::FeeModeFromString;
28using common::FeeModesDetail;
29using common::InvalidEstimateModeErrorMessage;
30using common::StringForFeeReason;
31using common::TransactionErrorString;
32using node::TransactionError;
33
34namespace wallet {
35std::vector<CRecipient> CreateRecipients(const std::vector<std::pair<CTxDestination, CAmount>>& outputs, const std::set<int>& subtract_fee_outputs)
36{
37    std::vector<CRecipient> recipients;
38    for (size_t i = 0; i < outputs.size(); ++i) {
39        const auto& [destination, amount] = outputs.at(i);
40        CRecipient recipient{destination, amount, subtract_fee_outputs.contains(i)};
41        recipients.push_back(recipient);
42    }
43    return recipients;
44}
45
46static void InterpretFeeEstimationInstructions(const UniValue& conf_target, const UniValue& estimate_mode, const UniValue& fee_rate, UniValue& options)
47{
48    if (options.exists("conf_target") || options.exists("estimate_mode")) {
49        if (!conf_target.isNull() || !estimate_mode.isNull()) {
50            throw JSONRPCError(RPC_INVALID_PARAMETER, "Pass conf_target and estimate_mode either as arguments or in the options object, but not both");
51        }
52    } else {
53        options.pushKV("conf_target", conf_target);
54        options.pushKV("estimate_mode", estimate_mode);
55    }
56    if (options.exists("fee_rate")) {
57        if (!fee_rate.isNull()) {
58            throw JSONRPCError(RPC_INVALID_PARAMETER, "Pass the fee_rate either as an argument, or in the options object, but not both");
59        }
60    } else {
61        options.pushKV("fee_rate", fee_rate);
62    }
63    if (!options["conf_target"].isNull() && (options["estimate_mode"].isNull() || (options["estimate_mode"].get_str() == "unset"))) {
64        throw JSONRPCError(RPC_INVALID_PARAMETER, "Specify estimate_mode");
65    }
66}
67
68std::set<int> InterpretSubtractFeeFromOutputInstructions(const UniValue& sffo_instructions, const std::vector<std::string>& destinations)
69{
70    std::set<int> sffo_set;
71    if (sffo_instructions.isNull()) return sffo_set;
72
73    for (const auto& sffo : sffo_instructions.getValues()) {
74        int pos{-1};
75        if (sffo.isStr()) {
76            auto it = find(destinations.begin(), destinations.end(), sffo.get_str());
77            if (it == destinations.end()) throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid parameter 'subtract fee from output', destination %s not found in tx outputs", sffo.get_str()));
78            pos = it - destinations.begin();
79        } else if (sffo.isNum()) {
80            pos = sffo.getInt<int>();
81        } else {
82            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid parameter 'subtract fee from output', invalid value type: %s", uvTypeName(sffo.type())));
83        }
84
85        if (sffo_set.contains(pos))
86            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid parameter 'subtract fee from output', duplicated position: %d", pos));
87        if (pos < 0)
88            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid parameter 'subtract fee from output', negative position: %d", pos));
89        if (pos >= int(destinations.size()))
90            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid parameter 'subtract fee from output', position too large: %d", pos));
91        sffo_set.insert(pos);
92    }
93    return sffo_set;
94}
95
96static UniValue FinishTransaction(const std::shared_ptr<CWallet> pwallet, const UniValue& options, CMutableTransaction& rawTx)
97{
98    bool can_anti_fee_snipe = !options.exists("locktime");
99
100    for (const CTxIn& tx_in : rawTx.vin) {
101        // Checks sequence values consistent with DiscourageFeeSniping
102        can_anti_fee_snipe = can_anti_fee_snipe && (tx_in.nSequence == CTxIn::MAX_SEQUENCE_NONFINAL || tx_in.nSequence == MAX_BIP125_RBF_SEQUENCE);
103    }
104
105    if (can_anti_fee_snipe) {
106        LOCK(pwallet->cs_wallet);
107        FastRandomContext rng_fast;
108        DiscourageFeeSniping(rawTx, rng_fast, pwallet->chain(), pwallet->GetLastBlockHash(), pwallet->GetLastBlockHeight());
109    }
110
111    // Make a blank psbt
112    PartiallySignedTransaction psbtx(rawTx, /*version=*/2);
113
114    // First fill transaction with our data without signing,
115    // so external signers are not asked to sign more than once.
116    bool complete;
117    pwallet->FillPSBT(psbtx, {.sign = false, .bip32_derivs = true}, complete);
118    const auto err{pwallet->FillPSBT(psbtx, {.sign = true, .bip32_derivs = false}, complete)};
119    if (err) {
120        throw JSONRPCPSBTError(*err);
121    }
122
123    CMutableTransaction mtx;
124    complete = FinalizeAndExtractPSBT(psbtx, mtx);
125
126    UniValue result(UniValue::VOBJ);
127
128    const bool psbt_opt_in{options.exists("psbt") && options["psbt"].get_bool()};
129    bool add_to_wallet{options.exists("add_to_wallet") ? options["add_to_wallet"].get_bool() : true};
130    if (psbt_opt_in || !complete || !add_to_wallet) {
131        // Serialize the PSBT
132        DataStream ssTx{};
133        ssTx << psbtx;
134        result.pushKV("psbt", EncodeBase64(ssTx.str()));
135    }
136
137    if (complete) {
138        std::string hex{EncodeHexTx(CTransaction(mtx))};
139        CTransactionRef tx(MakeTransactionRef(std::move(mtx)));
140        result.pushKV("txid", tx->GetHash().GetHex());
141        if (add_to_wallet && !psbt_opt_in) {
142            pwallet->CommitTransaction(tx);
143        } else {
144            result.pushKV("hex", hex);
145        }
146    }
147    result.pushKV("complete", complete);
148
149    return result;
150}
151
152static void PreventOutdatedOptions(const UniValue& options)
153{
154    if (options.exists("feeRate")) {
155        throw JSONRPCError(RPC_INVALID_PARAMETER, "Use fee_rate (" + CURRENCY_ATOM + "/vB) instead of feeRate");
156    }
157    if (options.exists("changeAddress")) {
158        throw JSONRPCError(RPC_INVALID_PARAMETER, "Use change_address instead of changeAddress");
159    }
160    if (options.exists("changePosition")) {
161        throw JSONRPCError(RPC_INVALID_PARAMETER, "Use change_position instead of changePosition");
162    }
163    if (options.exists("lockUnspents")) {
164        throw JSONRPCError(RPC_INVALID_PARAMETER, "Use lock_unspents instead of lockUnspents");
165    }
166    if (options.exists("subtractFeeFromOutputs")) {
167        throw JSONRPCError(RPC_INVALID_PARAMETER, "Use subtract_fee_from_outputs instead of subtractFeeFromOutputs");
168    }
169}
170
171UniValue SendMoney(CWallet& wallet, const CCoinControl &coin_control, std::vector<CRecipient> &recipients, std::optional<std::string> comment, std::optional<std::string> comment_to, bool verbose)
172{
173    EnsureWalletIsUnlocked(wallet);
174
175    // This function is only used by sendtoaddress and sendmany.
176    // This should always try to sign, if we don't have (all) private keys, don't
177    // try to do anything here.
178    if (wallet.IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER)) {
179        throw JSONRPCError(RPC_WALLET_ERROR, "Error: sendtoaddress and sendmany are not supported for wallets with external signers; use send instead");
180    }
181    if (wallet.IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
182        throw JSONRPCError(RPC_WALLET_ERROR, "Error: Private keys are disabled for this wallet");
183    }
184
185    // Shuffle recipient list
186    std::shuffle(recipients.begin(), recipients.end(), FastRandomContext());
187
188    // Send
189    auto res = CreateTransaction(wallet, recipients, /*change_pos=*/std::nullopt, coin_control, true);
190    if (!res) {
191        throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, util::ErrorString(res).original);
192    }
193    const CTransactionRef& tx = res->tx;
194    wallet.CommitTransaction(tx, /*replaces_txid=*/std::nullopt, comment, comment_to);
195    if (verbose) {
196        UniValue entry(UniValue::VOBJ);
197        entry.pushKV("txid", tx->GetHash().GetHex());
198        entry.pushKV("fee_reason", StringForFeeReason(res->fee_reason));
199        return entry;
200    }
201    return tx->GetHash().GetHex();
202}
203
204
205/**
206 * Update coin control with fee estimation based on the given parameters
207 *
208 * @param[in]     wallet            Wallet reference
209 * @param[in,out] cc                Coin control to be updated
210 * @param[in]     conf_target       UniValue integer; confirmation target in blocks, values between 1 and 1008 are valid per policy/fees/block_policy_estimator.h;
211 * @param[in]     estimate_mode     UniValue string; fee estimation mode, valid values are "unset", "economical" or "conservative";
212 * @param[in]     fee_rate          UniValue real; fee rate in sat/vB;
213 *                                      if present, both conf_target and estimate_mode must either be null, or "unset"
214 * @param[in]     override_min_fee  bool; whether to set fOverrideFeeRate to true to disable minimum fee rate checks and instead
215 *                                      verify only that fee_rate is greater than 0
216 * @throws a JSONRPCError if conf_target, estimate_mode, or fee_rate contain invalid values or are in conflict
217 */
218static void SetFeeEstimateMode(const CWallet& wallet, CCoinControl& cc, const UniValue& conf_target, const UniValue& estimate_mode, const UniValue& fee_rate, bool override_min_fee)
219{
220    if (!fee_rate.isNull()) {
221        if (!conf_target.isNull()) {
222            throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot specify both conf_target and fee_rate. Please provide either a confirmation target in blocks for automatic fee estimation, or an explicit fee rate.");
223        }
224        if (!estimate_mode.isNull() && estimate_mode.get_str() != "unset") {
225            throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot specify both estimate_mode and fee_rate");
226        }
227        // Fee rates in sat/vB cannot represent more than 3 significant digits.
228        cc.m_feerate = CFeeRate{AmountFromValue(fee_rate, /*decimals=*/3)};
229        if (override_min_fee) cc.fOverrideFeeRate = true;
230        // Default RBF to true for explicit fee_rate, if unset.
231        if (!cc.m_signal_bip125_rbf) cc.m_signal_bip125_rbf = true;
232        return;
233    }
234    if (!estimate_mode.isNull() && !FeeModeFromString(estimate_mode.get_str(), cc.m_fee_mode)) {
235        throw JSONRPCError(RPC_INVALID_PARAMETER, InvalidEstimateModeErrorMessage());
236    }
237    if (!conf_target.isNull()) {
238        cc.m_confirm_target = ParseConfirmTarget(conf_target, wallet.chain().maximumFeeEstimationTargetBlocks());
239    }
240}
241
242RPCMethod sendtoaddress()
243{
244    return RPCMethod{
245        "sendtoaddress",
246        "Send an amount to a given address." +
247        HELP_REQUIRING_PASSPHRASE,
248                {
249                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address to send to."},
250                    {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::NO, "The amount in " + CURRENCY_UNIT + " to send. eg 0.1"},