1// Copyright (c) 2010 Satoshi Nakamoto
2// Copyright (c) 2009-present The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#include <bitcoin-build-config.h> // IWYU pragma: keep
7
8#include <wallet/rpc/wallet.h>
9
10#include <coins.h>
11#include <core_io.h>
12#include <key.h>
13#include <key_io.h>
14#include <rpc/server.h>
15#include <rpc/util.h>
16#include <univalue.h>
17#include <util/bip32.h>
18#include <util/translation.h>
19#include <wallet/context.h>
20#include <wallet/export.h>
21#include <wallet/receive.h>
22#include <wallet/rpc/util.h>
23#include <wallet/wallet.h>
24#include <wallet/walletutil.h>
25
26#include <algorithm>
27#include <optional>
28#include <string_view>
29
30
31namespace wallet {
32
33using HDPubKeyMap = CWallet::HDPubKeyMap;
34using HDKeyFilter = CWallet::HDKeyFilter;
35
36static const std::map<uint64_t, std::string> WALLET_FLAG_CAVEATS{
37    {WALLET_FLAG_AVOID_REUSE,
38     "You need to rescan the blockchain in order to correctly mark used "
39     "destinations in the past. Until this is done, some destinations may "
40     "be considered unused, even if the opposite is the case."},
41};
42
43static RPCMethod getwalletinfo()
44{
45    return RPCMethod{"getwalletinfo",
46                "Returns an object containing various wallet state info.\n",
47                {},
48                RPCResult{
49                    RPCResult::Type::OBJ, "", "",
50                    {
51                        {
52                        {RPCResult::Type::STR, "walletname", "the wallet name"},
53                        {RPCResult::Type::NUM, "walletversion", "(DEPRECATED) only related to unsupported legacy wallet, returns the latest version 169900 for backwards compatibility"},
54                        {RPCResult::Type::STR, "format", "the database format (only sqlite)"},
55                        {RPCResult::Type::NUM, "txcount", "the total number of transactions in the wallet"},
56                        {RPCResult::Type::NUM, "keypoolsize", "how many new keys are pre-generated (only counts external keys)"},
57                        {RPCResult::Type::NUM, "keypoolsize_hd_internal", "how many new keys are pre-generated for internal use (used for change outputs; 0 if external keys are used for change)"},
58                        {RPCResult::Type::NUM_TIME, "unlocked_until", /*optional=*/true, "the " + UNIX_EPOCH_TIME + " until which the wallet is unlocked for transfers, or 0 if the wallet is locked (only present for passphrase-encrypted wallets)"},
59                        {RPCResult::Type::BOOL, "private_keys_enabled", "false if privatekeys are disabled for this wallet (enforced watch-only wallet)"},
60                        {RPCResult::Type::BOOL, "avoid_reuse", "whether this wallet tracks clean/dirty coins in terms of reuse"},
61                        {RPCResult::Type::OBJ, "scanning", "current scanning details, or false if no scan is in progress",
62                        {
63                            {RPCResult::Type::NUM, "duration", "elapsed seconds since scan start"},
64                            {RPCResult::Type::NUM, "progress", "scanning progress percentage [0.0, 1.0]"},
65                        }, {.skip_type_check=true}, },
66                        {RPCResult::Type::BOOL, "descriptors", "whether this wallet uses descriptors for output script management"},
67                        {RPCResult::Type::BOOL, "external_signer", "whether this wallet is configured to use an external signer such as a hardware wallet"},
68                        {RPCResult::Type::BOOL, "blank", "Whether this wallet intentionally does not contain any keys, scripts, or descriptors"},
69                        {RPCResult::Type::NUM_TIME, "birthtime", /*optional=*/true, "The start time for blocks scanning. It could be modified by (re)importing any descriptor with an earlier timestamp."},
70                        {RPCResult::Type::ARR, "flags", "The flags currently set on the wallet",
71                        {
72                            {RPCResult::Type::STR, "flag", "The name of the flag"},
73                        }},
74                        RESULT_LAST_PROCESSED_BLOCK,
75                    }},
76                },
77                RPCExamples{
78                    HelpExampleCli("getwalletinfo", "")
79            + HelpExampleRpc("getwalletinfo", "")
80                },
81        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
82{
83    const std::shared_ptr<const CWallet> pwallet = GetWalletForJSONRPCRequest(request);
84    if (!pwallet) return UniValue::VNULL;
85
86    // Make sure the results are valid at least up to the most recent block
87    // the user could have gotten from another RPC command prior to now
88    pwallet->BlockUntilSyncedToCurrentChain();
89
90    LOCK(pwallet->cs_wallet);
91
92    UniValue obj(UniValue::VOBJ);
93
94    const int latest_legacy_wallet_minversion{169900};
95
96    size_t kpExternalSize = pwallet->KeypoolCountExternalKeys();
97    obj.pushKV("walletname", pwallet->GetName());
98    obj.pushKV("walletversion", latest_legacy_wallet_minversion);
99    obj.pushKV("format", pwallet->GetDatabase().Format());
100    obj.pushKV("txcount", pwallet->mapWallet.size());
101    obj.pushKV("keypoolsize", kpExternalSize);
102    obj.pushKV("keypoolsize_hd_internal", pwallet->GetKeyPoolSize() - kpExternalSize);
103
104    if (pwallet->HasEncryptionKeys()) {
105        obj.pushKV("unlocked_until", pwallet->nRelockTime);
106    }
107    obj.pushKV("private_keys_enabled", !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
108    obj.pushKV("avoid_reuse", pwallet->IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE));
109    if (pwallet->IsScanning()) {
110        UniValue scanning(UniValue::VOBJ);
111        scanning.pushKV("duration", Ticks<std::chrono::seconds>(pwallet->ScanningDuration()));
112        scanning.pushKV("progress", pwallet->ScanningProgress());
113        obj.pushKV("scanning", std::move(scanning));
114    } else {
115        obj.pushKV("scanning", false);
116    }
117    obj.pushKV("descriptors", pwallet->IsWalletFlagSet(WALLET_FLAG_DESCRIPTORS));
118    obj.pushKV("external_signer", pwallet->IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER));
119    obj.pushKV("blank", pwallet->IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET));
120    if (int64_t birthtime = pwallet->GetBirthTime(); birthtime != UNKNOWN_TIME) {
121        obj.pushKV("birthtime", birthtime);
122    }
123
124    // Push known flags
125    UniValue flags(UniValue::VARR);
126    uint64_t wallet_flags = pwallet->GetWalletFlags();
127    for (uint64_t i = 0; i < 64; ++i) {
128        uint64_t flag = uint64_t{1} << i;
129        if (flag & wallet_flags) {
130            if (flag & KNOWN_WALLET_FLAGS) {
131                flags.push_back(WALLET_FLAG_TO_STRING.at(WalletFlags{flag}));
132            } else {
133                flags.push_back(strprintf("unknown_flag_%u", i));
134            }
135        }
136    }
137    obj.pushKV("flags", flags);
138
139    AppendLastProcessedBlock(obj, *pwallet);
140    return obj;
141},
142    };
143}
144
145static RPCMethod listwalletdir()
146{
147    return RPCMethod{"listwalletdir",
148                "Returns a list of wallets in the wallet directory.\n",
149                {},
150                RPCResult{
151                    RPCResult::Type::OBJ, "", "",
152                    {
153                        {RPCResult::Type::ARR, "wallets", "",
154                        {
155                            {RPCResult::Type::OBJ, "", "",
156                            {
157                                {RPCResult::Type::STR, "name", "The wallet name"},
158                                {RPCResult::Type::ARR, "warnings", "Warning messages related to loading the wallet (may be empty).",
159                                {
160                                    {RPCResult::Type::STR, "", ""},
161                                }},
162                            }},
163                        }},
164                    }
165                },
166                RPCExamples{
167                    HelpExampleCli("listwalletdir", "")
168            + HelpExampleRpc("listwalletdir", "")
169                },
170        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
171{
172    UniValue wallets(UniValue::VARR);
173    for (const auto& [path, db_type] : ListDatabases(GetWalletDir())) {
174        UniValue wallet(UniValue::VOBJ);
175        wallet.pushKV("name", path.utf8string());
176                UniValue warnings(UniValue::VARR);
177        if (db_type == "bdb") {
178            warnings.push_back("This wallet is a legacy wallet and will need to be migrated with migratewallet before it can be loaded");
179        }
180        wallet.pushKV("warnings", warnings);
181        wallets.push_back(std::move(wallet));
182    }
183
184    UniValue result(UniValue::VOBJ);
185    result.pushKV("wallets", std::move(wallets));
186    return result;
187},
188    };
189}
190
191static RPCMethod listwallets()
192{
193    return RPCMethod{"listwallets",
194                "Returns a list of currently loaded wallets.\n"
195                "For full information on the wallet, use \"getwalletinfo\"\n",
196                {},
197                RPCResult{
198                    RPCResult::Type::ARR, "", "",
199                    {
200                        {RPCResult::Type::STR, "walletname", "the wallet name"},
201                    }
202                },
203                RPCExamples{
204                    HelpExampleCli("listwallets", "")
205            + HelpExampleRpc("listwallets", "")
206                },
207        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
208{
209    UniValue obj(UniValue::VARR);
210
211    WalletContext& context = EnsureWalletContext(request.context);
212    for (const std::shared_ptr<CWallet>& wallet : GetWallets(context)) {
213        LOCK(wallet->cs_wallet);
214        obj.push_back(wallet->GetName());
215    }
216
217    return obj;
218},
219    };
220}
221
222static RPCMethod loadwallet()
223{
224    return RPCMethod{
225        "loadwallet",
226        "Loads a wallet from a wallet file or directory."
227                "\nNote that all wallet command-line options used when starting bitcoind will be"
228                "\napplied to the new wallet.\n",
229                {
230                    {"filename", RPCArg::Type::STR, RPCArg::Optional::NO, "The path to the directory of the wallet to be loaded, either absolute or relative to the \"wallets\" directory. The \"wallets\" directory is set by the -walletdir option and defaults to the \"wallets\" folder within the data directory."},
231                    {"load_on_startup", RPCArg::Type::BOOL, RPCArg::Optional::OMITTED, "Save wallet name to persistent settings and load on startup. True to add wallet to startup list, false to remove, null to leave unchanged."},
232                },
233                RPCResult{
234                    RPCResult::Type::OBJ, "", "",
235                    {
236                        {RPCResult::Type::STR, "name", "The wallet name if loaded successfully."},
237                        {RPCResult::Type::ARR, "warnings", /*optional=*/true, "Warning messages, if any, related to loading the wallet.",
238                        {
239                            {RPCResult::Type::STR, "", ""},
240                        }},
241                    }
242                },
243                RPCExamples{
244                    "\nLoad wallet from the wallet dir:\n"
245                    + HelpExampleCli("loadwallet", "\"walletname\"")
246                    + HelpExampleRpc("loadwallet", "\"walletname\"")
247                    + "\nLoad wallet using absolute path (Unix):\n"
248                    + HelpExampleCli("loadwallet", "\"/path/to/walletname/\"")
249                    + HelpExampleRpc("loadwallet", "\"/path/to/walletname/\"")
250                    + "\nLoad wallet using absolute path (Windows):\n"