Inside Bitcoin

1// Copyright (c) 2021-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 <wallet/test/util.h>
6
7#include <chain.h>
8#include <key.h>
9#include <key_io.h>
10#include <test/util/setup_common.h>
11#include <validationinterface.h>
12#include <wallet/context.h>
13#include <wallet/wallet.h>
14#include <wallet/walletdb.h>
15
16#include <sqlite3.h>
17
18#include <memory>
19
20namespace wallet {
21std::unique_ptr<CWallet> CreateSyncedWallet(interfaces::Chain& chain, CChain& cchain, const CKey& key)
22{
23    auto wallet = std::make_unique<CWallet>(&chain, "", CreateMockableWalletDatabase());
24    {
25        LOCK2(wallet->cs_wallet, ::cs_main);
26        wallet->SetLastBlockProcessed(cchain.Height(), cchain.Tip()->GetBlockHash());
27    }
28    {
29        LOCK(wallet->cs_wallet);
30        wallet->SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
31        wallet->SetupDescriptorScriptPubKeyMans();
32
33        FlatSigningProvider provider;
34        std::string error;
35        auto descs = Parse("combo(" + EncodeSecret(key) + ")", provider, error, /* require_checksum=*/ false);
36        assert(descs.size() == 1);
37        auto& desc = descs.at(0);
38        WalletDescriptor w_desc(std::move(desc), 0, 0, 1, 1);
39        Assert(wallet->AddWalletDescriptor(w_desc, provider, "", false));
40    }
41    WalletRescanReserver reserver(*wallet);
42    reserver.reserve();
43    CWallet::ScanResult result = wallet->ScanForWalletTransactions(cchain.Genesis()->GetBlockHash(), /*start_height=*/0, /*max_height=*/{}, reserver, /*save_progress=*/false);
44    assert(result.status == CWallet::ScanResult::SUCCESS);
45    assert(result.last_scanned_block == cchain.Tip()->GetBlockHash());
46    assert(*result.last_scanned_height == cchain.Height());
47    assert(result.last_failed_block.IsNull());
48    return wallet;
49}
50
51std::shared_ptr<CWallet> TestCreateWallet(std::unique_ptr<WalletDatabase> database, WalletContext& context, uint64_t create_flags)
52{
53    bilingual_str _error;
54    std::vector<bilingual_str> _warnings;
55    auto wallet = CWallet::CreateNew(context, "", std::move(database), create_flags, /*born_encrypted=*/false, _error, _warnings);
56    NotifyWalletLoaded(context, wallet);
57    if (context.chain) {
58        wallet->postInitProcess();
59    }
60    return wallet;
61}
62
63std::shared_ptr<CWallet> TestCreateWallet(WalletContext& context)
64{
65    DatabaseOptions options;
66    options.require_create = true;
67    options.create_flags = WALLET_FLAG_DESCRIPTORS;
68    DatabaseStatus status;
69    bilingual_str error;
70    auto database = MakeWalletDatabase("", options, status, error);
71    return TestCreateWallet(std::move(database), context, options.create_flags);
72}
73
74
75std::shared_ptr<CWallet> TestLoadWallet(std::unique_ptr<WalletDatabase> database, WalletContext& context)
76{
77    bilingual_str error;
78    std::vector<bilingual_str> warnings;
79    auto wallet = CWallet::LoadExisting(context, "", std::move(database), error, warnings);
80    NotifyWalletLoaded(context, wallet);
81    if (context.chain) {
82        wallet->postInitProcess();
83    }
84    return wallet;
85}
86
87std::shared_ptr<CWallet> TestLoadWallet(WalletContext& context)
88{
89    DatabaseOptions options;
90    options.require_existing = true;
91    DatabaseStatus status;
92    bilingual_str error;
93    auto database = MakeWalletDatabase("", options, status, error);
94    return TestLoadWallet(std::move(database), context);
95}
96
97void TestUnloadWallet(std::shared_ptr<CWallet>&& wallet)
98{
99    // Calls SyncWithValidationInterfaceQueue
100    wallet->chain().waitForNotificationsIfTipChanged({});
101    wallet->m_chain_notifications_handler.reset();
102    WaitForDeleteWallet(std::move(wallet));
103}
104
105std::string getnewaddress(CWallet& w)
106{
107    constexpr auto output_type = OutputType::BECH32;
108    return EncodeDestination(getNewDestination(w, output_type));
109}
110
111CTxDestination getNewDestination(CWallet& w, OutputType output_type)
112{
113    return *Assert(w.GetNewDestination(output_type, ""));
114}
115
116MockableSQLiteDatabase::MockableSQLiteDatabase()
117    : InMemoryWalletDatabase()
118{}
119
120std::unique_ptr<WalletDatabase> CreateMockableWalletDatabase()
121{
122    return std::make_unique<MockableSQLiteDatabase>();
123}
124
125wallet::DescriptorScriptPubKeyMan* CreateDescriptor(CWallet& keystore, const std::string& desc_str, const bool success)
126{
127    keystore.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
128
129    FlatSigningProvider keys;
130    std::string error;
131    auto parsed_descs = Parse(desc_str, keys, error, false);
132    Assert(success == (!parsed_descs.empty()));
133    if (!success) return nullptr;
134    auto& desc = parsed_descs.at(0);
135
136    const int64_t range_start = 0, range_end = 1, next_index = 0, timestamp = 1;
137
138    WalletDescriptor w_desc(std::move(desc), timestamp, range_start, range_end, next_index);
139
140    LOCK(keystore.cs_wallet);
141    auto spkm = Assert(keystore.AddWalletDescriptor(w_desc, keys,/*label=*/"", /*internal=*/false));
142    return &spkm.value().get();
143};
144} // namespace wallet
145