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 <bitcoin-build-config.h> // IWYU pragma: keep
6
7#include <core_io.h>
8#include <key_io.h>
9#include <rpc/util.h>
10#include <script/script.h>
11#include <script/solver.h>
12#include <util/bip32.h>
13#include <util/translation.h>
14#include <wallet/receive.h>
15#include <wallet/rpc/util.h>
16#include <wallet/wallet.h>
17
18#include <univalue.h>
19
20namespace wallet {
21RPCMethod getnewaddress()
22{
23    return RPCMethod{
24        "getnewaddress",
25        "Returns a new Bitcoin address for receiving payments.\n"
26                "If 'label' is specified, it is added to the address book \n"
27                "so payments received with the address will be associated with 'label'.\n",
28                {
29                    {"label", RPCArg::Type::STR, RPCArg::Default{""}, "The label name for the address to be linked to. It can also be set to the empty string \"\" to represent the default label. The label does not need to exist, it will be created if there is no label by the given name."},
30                    {"address_type", RPCArg::Type::STR, RPCArg::DefaultHint{"set by -addresstype"}, "The address type to use. Options are " + FormatAllOutputTypes() + "."},
31                },
32                RPCResult{
33                    RPCResult::Type::STR, "address", "The new bitcoin address"
34                },
35                RPCExamples{
36                    HelpExampleCli("getnewaddress", "")
37            + HelpExampleRpc("getnewaddress", "")
38                },
39        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
40{
41    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
42    if (!pwallet) return UniValue::VNULL;
43
44    LOCK(pwallet->cs_wallet);
45
46    if (!pwallet->CanGetAddresses()) {
47        throw JSONRPCError(RPC_WALLET_ERROR, "Error: This wallet has no available keys");
48    }
49
50    // Parse the label first so we don't generate a key if there's an error
51    const std::string label{LabelFromValue(request.params[0])};
52
53    OutputType output_type = pwallet->m_default_address_type;
54    if (!request.params[1].isNull()) {
55        std::optional<OutputType> parsed = ParseOutputType(request.params[1].get_str());
56        if (!parsed) {
57            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("Unknown address type '%s'", request.params[1].get_str()));
58        }
59        output_type = parsed.value();
60    }
61
62    auto op_dest = pwallet->GetNewDestination(output_type, label);
63    if (!op_dest) {
64        throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, util::ErrorString(op_dest).original);
65    }
66
67    return EncodeDestination(*op_dest);
68},
69    };
70}
71
72RPCMethod getrawchangeaddress()
73{
74    return RPCMethod{
75        "getrawchangeaddress",
76        "Returns a new Bitcoin address, for receiving change.\n"
77                "This is for use with raw transactions, NOT normal use.\n",
78                {
79                    {"address_type", RPCArg::Type::STR, RPCArg::DefaultHint{"set by -changetype"}, "The address type to use. Options are " + FormatAllOutputTypes() + "."},
80                },
81                RPCResult{
82                    RPCResult::Type::STR, "address", "The address"
83                },
84                RPCExamples{
85                    HelpExampleCli("getrawchangeaddress", "")
86            + HelpExampleRpc("getrawchangeaddress", "")
87                },
88        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
89{
90    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
91    if (!pwallet) return UniValue::VNULL;
92
93    LOCK(pwallet->cs_wallet);
94
95    if (!pwallet->CanGetAddresses(true)) {
96        throw JSONRPCError(RPC_WALLET_ERROR, "Error: This wallet has no available keys");
97    }
98
99    OutputType output_type = pwallet->m_default_change_type.value_or(pwallet->m_default_address_type);
100    if (!request.params[0].isNull()) {
101        std::optional<OutputType> parsed = ParseOutputType(request.params[0].get_str());
102        if (!parsed) {
103            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("Unknown address type '%s'", request.params[0].get_str()));
104        }
105        output_type = parsed.value();
106    }
107
108    auto op_dest = pwallet->GetNewChangeDestination(output_type);
109    if (!op_dest) {
110        throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, util::ErrorString(op_dest).original);
111    }
112    return EncodeDestination(*op_dest);
113},
114    };
115}
116
117
118RPCMethod setlabel()
119{
120    return RPCMethod{
121        "setlabel",
122        "Sets the label associated with the given address.\n",
123                {
124                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The bitcoin address to be associated with a label."},
125                    {"label", RPCArg::Type::STR, RPCArg::Optional::NO, "The label to assign to the address."},
126                },
127                RPCResult{RPCResult::Type::NONE, "", ""},
128                RPCExamples{
129                    HelpExampleCli("setlabel", "\"" + EXAMPLE_ADDRESS[0] + "\" \"tabby\"")
130            + HelpExampleRpc("setlabel", "\"" + EXAMPLE_ADDRESS[0] + "\", \"tabby\"")
131                },
132        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
133{
134    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
135    if (!pwallet) return UniValue::VNULL;
136
137    LOCK(pwallet->cs_wallet);
138
139    CTxDestination dest = DecodeDestination(request.params[0].get_str());
140    if (!IsValidDestination(dest)) {
141        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");
142    }
143
144    const std::string label{LabelFromValue(request.params[1])};
145
146    if (pwallet->IsMine(dest)) {
147        pwallet->SetAddressBook(dest, label, AddressPurpose::RECEIVE);
148    } else {
149        pwallet->SetAddressBook(dest, label, AddressPurpose::SEND);
150    }
151
152    return UniValue::VNULL;
153},
154    };
155}
156
157RPCMethod listaddressgroupings()
158{
159    return RPCMethod{
160        "listaddressgroupings",
161        "Lists groups of addresses which have had their common ownership\n"
162                "made public by common use as inputs or as the resulting change\n"
163                "in past transactions\n",
164                {},
165                RPCResult{
166                    RPCResult::Type::ARR, "", "",
167                    {
168                        {RPCResult::Type::ARR, "", "",
169                        {
170                            {RPCResult::Type::ARR_FIXED, "", "",
171                            {
172                                {RPCResult::Type::STR, "address", "The bitcoin address"},
173                                {RPCResult::Type::STR_AMOUNT, "amount", "The amount in " + CURRENCY_UNIT},
174                                {RPCResult::Type::STR, "label", /*optional=*/true, "The label"},
175                            }},
176                        }},
177                    }
178                },
179                RPCExamples{
180                    HelpExampleCli("listaddressgroupings", "")
181            + HelpExampleRpc("listaddressgroupings", "")
182                },
183        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
184{
185    const std::shared_ptr<const CWallet> pwallet = GetWalletForJSONRPCRequest(request);
186    if (!pwallet) return UniValue::VNULL;
187
188    // Make sure the results are valid at least up to the most recent block
189    // the user could have gotten from another RPC command prior to now
190    pwallet->BlockUntilSyncedToCurrentChain();
191
192    LOCK(pwallet->cs_wallet);
193
194    UniValue jsonGroupings(UniValue::VARR);
195    std::map<CTxDestination, CAmount> balances = GetAddressBalances(*pwallet);
196    for (const std::set<CTxDestination>& grouping : GetAddressGroupings(*pwallet)) {
197        UniValue jsonGrouping(UniValue::VARR);
198        for (const CTxDestination& address : grouping)
199        {
200            UniValue addressInfo(UniValue::VARR);
201            addressInfo.push_back(EncodeDestination(address));
202            addressInfo.push_back(ValueFromAmount(balances[address]));
203            {
204                const auto* address_book_entry = pwallet->FindAddressBookEntry(address);
205                if (address_book_entry) {
206                    addressInfo.push_back(address_book_entry->GetLabel());
207                }
208            }
209            jsonGrouping.push_back(std::move(addressInfo));
210        }
211        jsonGroupings.push_back(std::move(jsonGrouping));
212    }
213    return jsonGroupings;
214},
215    };
216}
217
218RPCMethod keypoolrefill()
219{
220    return RPCMethod{"keypoolrefill",
221                "Refills each descriptor keypool in the wallet up to the specified number of new keys.\n"
222                "By default, descriptor wallets have 4 active ranged descriptors (" + FormatAllOutputTypes() + "), each with " + util::ToString(DEFAULT_KEYPOOL_SIZE) + " entries.\n" +
223        HELP_REQUIRING_PASSPHRASE,
224                {
225                    {"newsize", RPCArg::Type::NUM, RPCArg::DefaultHint{strprintf("%u, or as set by -keypool", DEFAULT_KEYPOOL_SIZE)}, "The new keypool size"},
226                },
227                RPCResult{RPCResult::Type::NONE, "", ""},
228                RPCExamples{
229                    HelpExampleCli("keypoolrefill", "")
230            + HelpExampleRpc("keypoolrefill", "")
231                },
232        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
233{
234    std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
235    if (!pwallet) return UniValue::VNULL;
236
237    LOCK(pwallet->cs_wallet);
238
239    // 0 is interpreted by TopUpKeyPool() as the default keypool size given by -keypool
240    unsigned int kpSize = 0;
241    if (!request.params[0].isNull()) {
242        if (request.params[0].getInt<int>() < 0)
243            throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, expected valid size.");
244        kpSize = (unsigned int)request.params[0].getInt<int>();
245    }
246
247    EnsureWalletIsUnlocked(*pwallet);
248    pwallet->TopUpKeyPool(kpSize);
249
250    if (pwallet->GetKeyPoolSize() < kpSize) {