Branch data Line data Source code
1 : : // Copyright (c) 2021-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 <wallet/test/util.h>
6 : :
7 : : #include <chain.h>
8 : : #include <key.h>
9 : : #include <key_io.h>
10 : : #include <streams.h>
11 : : #include <test/util/setup_common.h>
12 : : #include <validationinterface.h>
13 : : #include <wallet/context.h>
14 : : #include <wallet/wallet.h>
15 : : #include <wallet/walletdb.h>
16 : :
17 : : #include <memory>
18 : :
19 : : namespace wallet {
20 : 4 : std::unique_ptr<CWallet> CreateSyncedWallet(interfaces::Chain& chain, CChain& cchain, const CKey& key)
21 : : {
22 [ + - + - ]: 4 : auto wallet = std::make_unique<CWallet>(&chain, "", CreateMockableWalletDatabase());
23 : 4 : {
24 [ + - + - ]: 4 : LOCK2(wallet->cs_wallet, ::cs_main);
25 [ + - + - ]: 8 : wallet->SetLastBlockProcessed(cchain.Height(), cchain.Tip()->GetBlockHash());
26 [ + - ]: 4 : }
27 : 4 : {
28 [ + - ]: 4 : LOCK(wallet->cs_wallet);
29 [ + - ]: 4 : wallet->SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
30 [ + - ]: 4 : wallet->SetupDescriptorScriptPubKeyMans();
31 : :
32 : 4 : FlatSigningProvider provider;
33 [ + - ]: 4 : std::string error;
34 [ + - + - : 12 : auto descs = Parse("combo(" + EncodeSecret(key) + ")", provider, error, /* require_checksum=*/ false);
+ - ]
35 [ - + ]: 4 : assert(descs.size() == 1);
36 [ + - ]: 4 : auto& desc = descs.at(0);
37 [ + - + - ]: 4 : WalletDescriptor w_desc(std::move(desc), 0, 0, 1, 1);
38 [ + - + - : 4 : if (!wallet->AddWalletDescriptor(w_desc, provider, "", false)) assert(false);
- + ]
39 [ + - ]: 4 : }
40 : 4 : WalletRescanReserver reserver(*wallet);
41 : 4 : reserver.reserve();
42 [ + - + - ]: 8 : CWallet::ScanResult result = wallet->ScanForWalletTransactions(cchain.Genesis()->GetBlockHash(), /*start_height=*/0, /*max_height=*/{}, reserver, /*fUpdate=*/false, /*save_progress=*/false);
43 [ - + ]: 4 : assert(result.status == CWallet::ScanResult::SUCCESS);
44 [ + - - + ]: 8 : assert(result.last_scanned_block == cchain.Tip()->GetBlockHash());
45 [ - + ]: 4 : assert(*result.last_scanned_height == cchain.Height());
46 [ - + ]: 4 : assert(result.last_failed_block.IsNull());
47 : 4 : return wallet;
48 : 4 : }
49 : :
50 : 5 : std::shared_ptr<CWallet> TestLoadWallet(std::unique_ptr<WalletDatabase> database, WalletContext& context, uint64_t create_flags)
51 : : {
52 [ + - ]: 5 : bilingual_str error;
53 : 5 : std::vector<bilingual_str> warnings;
54 [ + - + - ]: 10 : auto wallet = CWallet::Create(context, "", std::move(database), create_flags, error, warnings);
55 [ + - ]: 5 : NotifyWalletLoaded(context, wallet);
56 [ + + ]: 5 : if (context.chain) {
57 [ + - ]: 4 : wallet->postInitProcess();
58 : : }
59 : 10 : return wallet;
60 : 10 : }
61 : :
62 : 5 : std::shared_ptr<CWallet> TestLoadWallet(WalletContext& context)
63 : : {
64 [ + - ]: 5 : DatabaseOptions options;
65 : 5 : options.create_flags = WALLET_FLAG_DESCRIPTORS;
66 : 5 : DatabaseStatus status;
67 [ + - ]: 5 : bilingual_str error;
68 : 5 : std::vector<bilingual_str> warnings;
69 [ + - + - ]: 5 : auto database = MakeWalletDatabase("", options, status, error);
70 [ + - ]: 5 : return TestLoadWallet(std::move(database), context, options.create_flags);
71 : 10 : }
72 : :
73 : 4 : void TestUnloadWallet(std::shared_ptr<CWallet>&& wallet)
74 : : {
75 : : // Calls SyncWithValidationInterfaceQueue
76 : 4 : wallet->chain().waitForNotificationsIfTipChanged({});
77 [ + - ]: 4 : wallet->m_chain_notifications_handler.reset();
78 : 4 : WaitForDeleteWallet(std::move(wallet));
79 : 4 : }
80 : :
81 : 0 : std::unique_ptr<WalletDatabase> DuplicateMockDatabase(WalletDatabase& database)
82 : : {
83 [ # # ]: 0 : return std::make_unique<MockableDatabase>(dynamic_cast<MockableDatabase&>(database).m_records);
84 : : }
85 : :
86 : 0 : std::string getnewaddress(CWallet& w)
87 : : {
88 : 0 : constexpr auto output_type = OutputType::BECH32;
89 [ # # ]: 0 : return EncodeDestination(getNewDestination(w, output_type));
90 : : }
91 : :
92 : 0 : CTxDestination getNewDestination(CWallet& w, OutputType output_type)
93 : : {
94 [ # # # # : 0 : return *Assert(w.GetNewDestination(output_type, ""));
# # ]
95 : : }
96 : :
97 [ + - ]: 971 : MockableCursor::MockableCursor(const MockableData& records, bool pass, Span<const std::byte> prefix)
98 : : {
99 : 971 : m_pass = pass;
100 [ + - ]: 971 : std::tie(m_cursor, m_cursor_end) = records.equal_range(BytePrefix{prefix});
101 : 971 : }
102 : :
103 : 21013 : DatabaseCursor::Status MockableCursor::Next(DataStream& key, DataStream& value)
104 : : {
105 [ + - ]: 21013 : if (!m_pass) {
106 : : return Status::FAIL;
107 : : }
108 [ + + ]: 21013 : if (m_cursor == m_cursor_end) {
109 : : return Status::DONE;
110 : : }
111 [ - + ]: 20039 : key.clear();
112 [ + + ]: 20039 : value.clear();
113 : 20039 : const auto& [key_data, value_data] = *m_cursor;
114 : 20039 : key.write(key_data);
115 : 20039 : value.write(value_data);
116 : 20039 : m_cursor++;
117 : 20039 : return Status::MORE;
118 : : }
119 : :
120 : 152 : bool MockableBatch::ReadKey(DataStream&& key, DataStream& value)
121 : : {
122 [ + - ]: 152 : if (!m_pass) {
123 : : return false;
124 : : }
125 : 152 : SerializeData key_data{key.begin(), key.end()};
126 : 152 : const auto& it = m_records.find(key_data);
127 [ + + ]: 152 : if (it == m_records.end()) {
128 : : return false;
129 : : }
130 [ - + ]: 7 : value.clear();
131 [ + - ]: 7 : value.write(it->second);
132 : : return true;
133 : 152 : }
134 : :
135 : 45140 : bool MockableBatch::WriteKey(DataStream&& key, DataStream&& value, bool overwrite)
136 : : {
137 [ + + ]: 45140 : if (!m_pass) {
138 : : return false;
139 : : }
140 : 45138 : SerializeData key_data{key.begin(), key.end()};
141 [ + - ]: 45138 : SerializeData value_data{value.begin(), value.end()};
142 [ + - ]: 45138 : auto [it, inserted] = m_records.emplace(key_data, value_data);
143 [ + + + - ]: 45138 : if (!inserted && overwrite) { // Overwrite if requested
144 [ + - ]: 18757 : it->second = value_data;
145 : 18757 : inserted = true;
146 : : }
147 : 45138 : return inserted;
148 : 45138 : }
149 : :
150 : 5014 : bool MockableBatch::EraseKey(DataStream&& key)
151 : : {
152 [ + - ]: 5014 : if (!m_pass) {
153 : : return false;
154 : : }
155 : 5014 : SerializeData key_data{key.begin(), key.end()};
156 : 5014 : m_records.erase(key_data);
157 : 5014 : return true;
158 : 5014 : }
159 : :
160 : 0 : bool MockableBatch::HasKey(DataStream&& key)
161 : : {
162 [ # # ]: 0 : if (!m_pass) {
163 : : return false;
164 : : }
165 : 0 : SerializeData key_data{key.begin(), key.end()};
166 : 0 : return m_records.count(key_data) > 0;
167 : 0 : }
168 : :
169 : 20 : bool MockableBatch::ErasePrefix(Span<const std::byte> prefix)
170 : : {
171 [ + - ]: 20 : if (!m_pass) {
172 : : return false;
173 : : }
174 : 20 : auto it = m_records.begin();
175 [ + + ]: 84162 : while (it != m_records.end()) {
176 [ + + ]: 84142 : auto& key = it->first;
177 [ + + + + ]: 84142 : if (key.size() < prefix.size() || std::search(key.begin(), key.end(), prefix.begin(), prefix.end()) != key.begin()) {
178 : 74132 : it++;
179 : 74132 : continue;
180 : : }
181 : 10010 : it = m_records.erase(it);
182 : : }
183 : : return true;
184 : : }
185 : :
186 : 104 : std::unique_ptr<WalletDatabase> CreateMockableWalletDatabase(MockableData records)
187 : : {
188 : 104 : return std::make_unique<MockableDatabase>(records);
189 : : }
190 : :
191 : 2 : MockableDatabase& GetMockableDatabase(CWallet& wallet)
192 : : {
193 [ + - ]: 2 : return dynamic_cast<MockableDatabase&>(wallet.GetDatabase());
194 : : }
195 : : } // namespace wallet
|
