Bitcoin Core 29.99.0
P2P Digital Currency
wallet_tests.cpp
Go to the documentation of this file.
1// Copyright (c) 2012-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/wallet.h>
6
7#include <future>
8#include <memory>
9#include <stdint.h>
10#include <vector>
11
12#include <addresstype.h>
13#include <interfaces/chain.h>
14#include <key_io.h>
15#include <node/blockstorage.h>
16#include <policy/policy.h>
17#include <rpc/server.h>
18#include <script/solver.h>
19#include <test/util/logging.h>
20#include <test/util/random.h>
22#include <util/translation.h>
23#include <validation.h>
24#include <validationinterface.h>
25#include <wallet/coincontrol.h>
26#include <wallet/context.h>
27#include <wallet/receive.h>
28#include <wallet/spend.h>
29#include <wallet/test/util.h>
31
32#include <boost/test/unit_test.hpp>
33#include <univalue.h>
34
36
37namespace wallet {
38
39// Ensure that fee levels defined in the wallet are at least as high
40// as the default levels for node policy.
41static_assert(DEFAULT_TRANSACTION_MINFEE >= DEFAULT_MIN_RELAY_TX_FEE, "wallet minimum fee is smaller than default relay fee");
42static_assert(WALLET_INCREMENTAL_RELAY_FEE >= DEFAULT_INCREMENTAL_RELAY_FEE, "wallet incremental fee is smaller than default incremental relay fee");
43
44BOOST_FIXTURE_TEST_SUITE(wallet_tests, WalletTestingSetup)
45
46static CMutableTransaction TestSimpleSpend(const CTransaction& from, uint32_t index, const CKey& key, const CScript& pubkey)
47{
49 mtx.vout.emplace_back(from.vout[index].nValue - DEFAULT_TRANSACTION_MAXFEE, pubkey);
50 mtx.vin.push_back({CTxIn{from.GetHash(), index}});
52 keystore.AddKey(key);
53 std::map<COutPoint, Coin> coins;
54 coins[mtx.vin[0].prevout].out = from.vout[index];
55 std::map<int, bilingual_str> input_errors;
56 BOOST_CHECK(SignTransaction(mtx, &keystore, coins, SIGHASH_ALL, input_errors));
57 return mtx;
58}
59
60static void AddKey(CWallet& wallet, const CKey& key)
61{
62 LOCK(wallet.cs_wallet);
63 FlatSigningProvider provider;
64 std::string error;
65 auto descs = Parse("combo(" + EncodeSecret(key) + ")", provider, error, /* require_checksum=*/ false);
66 assert(descs.size() == 1);
67 auto& desc = descs.at(0);
68 WalletDescriptor w_desc(std::move(desc), 0, 0, 1, 1);
69 auto spk_manager = *Assert(wallet.AddWalletDescriptor(w_desc, provider, "", false));
70 assert(spk_manager);
71}
72
73BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
74{
75 // Cap last block file size, and mine new block in a new block file.
76 CBlockIndex* oldTip = WITH_LOCK(Assert(m_node.chainman)->GetMutex(), return m_node.chainman->ActiveChain().Tip());
77 WITH_LOCK(::cs_main, m_node.chainman->m_blockman.GetBlockFileInfo(oldTip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE);
78 CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
79 CBlockIndex* newTip = WITH_LOCK(Assert(m_node.chainman)->GetMutex(), return m_node.chainman->ActiveChain().Tip());
80
81 // Verify ScanForWalletTransactions fails to read an unknown start block.
82 {
84 {
85 LOCK(wallet.cs_wallet);
86 LOCK(Assert(m_node.chainman)->GetMutex());
87 wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
88 wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());
89 }
90 AddKey(wallet, coinbaseKey);
92 reserver.reserve();
93 CWallet::ScanResult result = wallet.ScanForWalletTransactions(/*start_block=*/{}, /*start_height=*/0, /*max_height=*/{}, reserver, /*fUpdate=*/false, /*save_progress=*/false);
98 BOOST_CHECK_EQUAL(GetBalance(wallet).m_mine_immature, 0);
99 }
100
101 // Verify ScanForWalletTransactions picks up transactions in both the old
102 // and new block files.
103 {
105 {
106 LOCK(wallet.cs_wallet);
107 LOCK(Assert(m_node.chainman)->GetMutex());
108 wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
109 wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());
110 }
111 AddKey(wallet, coinbaseKey);
113 std::chrono::steady_clock::time_point fake_time;
114 reserver.setNow([&] { fake_time += 60s; return fake_time; });
115 reserver.reserve();
116
117 {
118 CBlockLocator locator;
119 BOOST_CHECK(!WalletBatch{wallet.GetDatabase()}.ReadBestBlock(locator));
120 BOOST_CHECK(locator.IsNull());
121 }
122
123 CWallet::ScanResult result = wallet.ScanForWalletTransactions(/*start_block=*/oldTip->GetBlockHash(), /*start_height=*/oldTip->nHeight, /*max_height=*/{}, reserver, /*fUpdate=*/false, /*save_progress=*/true);
126 BOOST_CHECK_EQUAL(result.last_scanned_block, newTip->GetBlockHash());
127 BOOST_CHECK_EQUAL(*result.last_scanned_height, newTip->nHeight);
128 BOOST_CHECK_EQUAL(GetBalance(wallet).m_mine_immature, 100 * COIN);
129
130 {
131 CBlockLocator locator;
132 BOOST_CHECK(WalletBatch{wallet.GetDatabase()}.ReadBestBlock(locator));
133 BOOST_CHECK(!locator.IsNull());
134 }
135 }
136
137 // Prune the older block file.
138 int file_number;
139 {
140 LOCK(cs_main);
141 file_number = oldTip->GetBlockPos().nFile;
142 Assert(m_node.chainman)->m_blockman.PruneOneBlockFile(file_number);
143 }
144 m_node.chainman->m_blockman.UnlinkPrunedFiles({file_number});
145
146 // Verify ScanForWalletTransactions only picks transactions in the new block
147 // file.
148 {
150 {
151 LOCK(wallet.cs_wallet);
152 LOCK(Assert(m_node.chainman)->GetMutex());
153 wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
154 wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());
155 }
156 AddKey(wallet, coinbaseKey);
158 reserver.reserve();
159 CWallet::ScanResult result = wallet.ScanForWalletTransactions(/*start_block=*/oldTip->GetBlockHash(), /*start_height=*/oldTip->nHeight, /*max_height=*/{}, reserver, /*fUpdate=*/false, /*save_progress=*/false);
162 BOOST_CHECK_EQUAL(result.last_scanned_block, newTip->GetBlockHash());
163 BOOST_CHECK_EQUAL(*result.last_scanned_height, newTip->nHeight);
164 BOOST_CHECK_EQUAL(GetBalance(wallet).m_mine_immature, 50 * COIN);
165 }
166
167 // Prune the remaining block file.
168 {
169 LOCK(cs_main);
170 file_number = newTip->GetBlockPos().nFile;
171 Assert(m_node.chainman)->m_blockman.PruneOneBlockFile(file_number);
172 }
173 m_node.chainman->m_blockman.UnlinkPrunedFiles({file_number});
174
175 // Verify ScanForWalletTransactions scans no blocks.
176 {
178 {
179 LOCK(wallet.cs_wallet);
180 LOCK(Assert(m_node.chainman)->GetMutex());
181 wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
182 wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());
183 }
184 AddKey(wallet, coinbaseKey);
186 reserver.reserve();
187 CWallet::ScanResult result = wallet.ScanForWalletTransactions(/*start_block=*/oldTip->GetBlockHash(), /*start_height=*/oldTip->nHeight, /*max_height=*/{}, reserver, /*fUpdate=*/false, /*save_progress=*/false);
189 BOOST_CHECK_EQUAL(result.last_failed_block, newTip->GetBlockHash());
192 BOOST_CHECK_EQUAL(GetBalance(wallet).m_mine_immature, 0);
193 }
194}
195
196// This test verifies that wallet settings can be added and removed
197// concurrently, ensuring no race conditions occur during either process.
198BOOST_FIXTURE_TEST_CASE(write_wallet_settings_concurrently, TestingSetup)
199{
200 auto chain = m_node.chain.get();
201 const auto NUM_WALLETS{5};
202
203 // Since we're counting the number of wallets, ensure we start without any.
204 BOOST_REQUIRE(chain->getRwSetting("wallet").isNull());
205
206 const auto& check_concurrent_wallet = [&](const auto& settings_function, int num_expected_wallets) {
207 std::vector<std::thread> threads;
208 threads.reserve(NUM_WALLETS);
209 for (auto i{0}; i < NUM_WALLETS; ++i) threads.emplace_back(settings_function, i);
210 for (auto& t : threads) t.join();
211
212 auto wallets = chain->getRwSetting("wallet");
213 BOOST_CHECK_EQUAL(wallets.getValues().size(), num_expected_wallets);
214 };
215
216 // Add NUM_WALLETS wallets concurrently, ensure we end up with NUM_WALLETS stored.
217 check_concurrent_wallet([&chain](int i) {
218 Assert(AddWalletSetting(*chain, strprintf("wallet_%d", i)));
219 },
220 /*num_expected_wallets=*/NUM_WALLETS);
221
222 // Remove NUM_WALLETS wallets concurrently, ensure we end up with 0 wallets.
223 check_concurrent_wallet([&chain](int i) {
224 Assert(RemoveWalletSetting(*chain, strprintf("wallet_%d", i)));
225 },
226 /*num_expected_wallets=*/0);
227}
228
229// Check that GetImmatureCredit() returns a newly calculated value instead of
230// the cached value after a MarkDirty() call.
231//
232// This is a regression test written to verify a bugfix for the immature credit
233// function. Similar tests probably should be written for the other credit and
234// debit functions.
235BOOST_FIXTURE_TEST_CASE(coin_mark_dirty_immature_credit, TestChain100Setup)
236{
238
239 LOCK(wallet.cs_wallet);
240 LOCK(Assert(m_node.chainman)->GetMutex());
241 CWalletTx wtx{m_coinbase_txns.back(), TxStateConfirmed{m_node.chainman->ActiveChain().Tip()->GetBlockHash(), m_node.chainman->ActiveChain().Height(), /*index=*/0}};
242 wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
243 wallet.SetupDescriptorScriptPubKeyMans();
244
245 wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());
246
247 // Call GetImmatureCredit() once before adding the key to the wallet to
248 // cache the current immature credit amount, which is 0.
250
251 // Invalidate the cached value, add the key, and make sure a new immature
252 // credit amount is calculated.
253 wtx.MarkDirty();
254 AddKey(wallet, coinbaseKey);
256}
257
258static int64_t AddTx(ChainstateManager& chainman, CWallet& wallet, uint32_t lockTime, int64_t mockTime, int64_t blockTime)
259{
261 TxState state = TxStateInactive{};
262 tx.nLockTime = lockTime;
263 SetMockTime(mockTime);
264 CBlockIndex* block = nullptr;
265 if (blockTime > 0) {
266 LOCK(cs_main);
267 auto inserted = chainman.BlockIndex().emplace(std::piecewise_construct, std::make_tuple(GetRandHash()), std::make_tuple());
268 assert(inserted.second);
269 const uint256& hash = inserted.first->first;
270 block = &inserted.first->second;
271 block->nTime = blockTime;
272 block->phashBlock = &hash;
273 state = TxStateConfirmed{hash, block->nHeight, /*index=*/0};
274 }
275 return wallet.AddToWallet(MakeTransactionRef(tx), state, [&](CWalletTx& wtx, bool /* new_tx */) {
276 // Assign wtx.m_state to simplify test and avoid the need to simulate
277 // reorg events. Without this, AddToWallet asserts false when the same
278 // transaction is confirmed in different blocks.
279 wtx.m_state = state;
280 return true;
281 })->nTimeSmart;
282}
283
284// Simple test to verify assignment of CWalletTx::nSmartTime value. Could be
285// expanded to cover more corner cases of smart time logic.
286BOOST_AUTO_TEST_CASE(ComputeTimeSmart)
287{
288 // New transaction should use clock time if lower than block time.
289 BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 1, 100, 120), 100);
290
291 // Test that updating existing transaction does not change smart time.
292 BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 1, 200, 220), 100);
293
294 // New transaction should use clock time if there's no block time.
295 BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 2, 300, 0), 300);
296
297 // New transaction should use block time if lower than clock time.
298 BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 3, 420, 400), 400);
299
300 // New transaction should use latest entry time if higher than
301 // min(block time, clock time).
302 BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 4, 500, 390), 400);
303
304 // If there are future entries, new transaction should use time of the
305 // newest entry that is no more than 300 seconds ahead of the clock time.
306 BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 5, 50, 600), 300);
307}
308
309void TestLoadWallet(const std::string& name, DatabaseFormat format, std::function<void(std::shared_ptr<CWallet>)> f)
310{
312 auto chain{interfaces::MakeChain(node)};
313 DatabaseOptions options;
314 options.require_format = format;
315 DatabaseStatus status;
316 bilingual_str error;
317 std::vector<bilingual_str> warnings;
318 auto database{MakeWalletDatabase(name, options, status, error)};
319 auto wallet{std::make_shared<CWallet>(chain.get(), "", std::move(database))};
321 WITH_LOCK(wallet->cs_wallet, f(wallet));
322}
323
325{
327 const std::string name{strprintf("receive-requests-%i", format)};
328 TestLoadWallet(name, format, [](std::shared_ptr<CWallet> wallet) EXCLUSIVE_LOCKS_REQUIRED(wallet->cs_wallet) {
329 BOOST_CHECK(!wallet->IsAddressPreviouslySpent(PKHash()));
330 WalletBatch batch{wallet->GetDatabase()};
331 BOOST_CHECK(batch.WriteAddressPreviouslySpent(PKHash(), true));
332 BOOST_CHECK(batch.WriteAddressPreviouslySpent(ScriptHash(), true));
333 BOOST_CHECK(wallet->SetAddressReceiveRequest(batch, PKHash(), "0", "val_rr00"));
334 BOOST_CHECK(wallet->EraseAddressReceiveRequest(batch, PKHash(), "0"));
335 BOOST_CHECK(wallet->SetAddressReceiveRequest(batch, PKHash(), "1", "val_rr10"));
336 BOOST_CHECK(wallet->SetAddressReceiveRequest(batch, PKHash(), "1", "val_rr11"));
337 BOOST_CHECK(wallet->SetAddressReceiveRequest(batch, ScriptHash(), "2", "val_rr20"));
338 });
339 TestLoadWallet(name, format, [](std::shared_ptr<CWallet> wallet) EXCLUSIVE_LOCKS_REQUIRED(wallet->cs_wallet) {
340 BOOST_CHECK(wallet->IsAddressPreviouslySpent(PKHash()));
341 BOOST_CHECK(wallet->IsAddressPreviouslySpent(ScriptHash()));
342 auto requests = wallet->GetAddressReceiveRequests();
343 auto erequests = {"val_rr11", "val_rr20"};
344 BOOST_CHECK_EQUAL_COLLECTIONS(requests.begin(), requests.end(), std::begin(erequests), std::end(erequests));
345 RunWithinTxn(wallet->GetDatabase(), /*process_desc*/"test", [](WalletBatch& batch){
346 BOOST_CHECK(batch.WriteAddressPreviouslySpent(PKHash(), false));
347 BOOST_CHECK(batch.EraseAddressData(ScriptHash()));
348 return true;
349 });
350 });
351 TestLoadWallet(name, format, [](std::shared_ptr<CWallet> wallet) EXCLUSIVE_LOCKS_REQUIRED(wallet->cs_wallet) {
352 BOOST_CHECK(!wallet->IsAddressPreviouslySpent(PKHash()));
353 BOOST_CHECK(!wallet->IsAddressPreviouslySpent(ScriptHash()));
354 auto requests = wallet->GetAddressReceiveRequests();
355 auto erequests = {"val_rr11"};
356 BOOST_CHECK_EQUAL_COLLECTIONS(requests.begin(), requests.end(), std::begin(erequests), std::end(erequests));
357 });
358 }
359}
360
362{
363public:
365 {
366 CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
367 wallet = CreateSyncedWallet(*m_node.chain, WITH_LOCK(Assert(m_node.chainman)->GetMutex(), return m_node.chainman->ActiveChain()), coinbaseKey);
368 }
369
371 {
372 wallet.reset();
373 }
374
376 {
378 CCoinControl dummy;
379 {
380 auto res = CreateTransaction(*wallet, {recipient}, /*change_pos=*/std::nullopt, dummy);
381 BOOST_CHECK(res);
382 tx = res->tx;
383 }
384 wallet->CommitTransaction(tx, {}, {});
385 CMutableTransaction blocktx;
386 {
387 LOCK(wallet->cs_wallet);
388 blocktx = CMutableTransaction(*wallet->mapWallet.at(tx->GetHash()).tx);
389 }
390 CreateAndProcessBlock({CMutableTransaction(blocktx)}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
391
392 LOCK(wallet->cs_wallet);
393 LOCK(Assert(m_node.chainman)->GetMutex());
394 wallet->SetLastBlockProcessed(wallet->GetLastBlockHeight() + 1, m_node.chainman->ActiveChain().Tip()->GetBlockHash());
395 auto it = wallet->mapWallet.find(tx->GetHash());
396 BOOST_CHECK(it != wallet->mapWallet.end());
397 it->second.m_state = TxStateConfirmed{m_node.chainman->ActiveChain().Tip()->GetBlockHash(), m_node.chainman->ActiveChain().Height(), /*index=*/1};
398 return it->second;
399 }
400
401 std::unique_ptr<CWallet> wallet;
402};
403
405{
406 std::string coinbaseAddress = coinbaseKey.GetPubKey().GetID().ToString();
407
408 // Confirm ListCoins initially returns 1 coin grouped under coinbaseKey
409 // address.
410 std::map<CTxDestination, std::vector<COutput>> list;
411 {
412 LOCK(wallet->cs_wallet);
413 list = ListCoins(*wallet);
414 }
415 BOOST_CHECK_EQUAL(list.size(), 1U);
416 BOOST_CHECK_EQUAL(std::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
417 BOOST_CHECK_EQUAL(list.begin()->second.size(), 1U);
418
419 // Check initial balance from one mature coinbase transaction.
420 BOOST_CHECK_EQUAL(50 * COIN, WITH_LOCK(wallet->cs_wallet, return AvailableCoins(*wallet).GetTotalAmount()));
421
422 // Add a transaction creating a change address, and confirm ListCoins still
423 // returns the coin associated with the change address underneath the
424 // coinbaseKey pubkey, even though the change address has a different
425 // pubkey.
426 AddTx(CRecipient{PubKeyDestination{{}}, 1 * COIN, /*subtract_fee=*/false});
427 {
428 LOCK(wallet->cs_wallet);
429 list = ListCoins(*wallet);
430 }
431 BOOST_CHECK_EQUAL(list.size(), 1U);
432 BOOST_CHECK_EQUAL(std::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
433 BOOST_CHECK_EQUAL(list.begin()->second.size(), 2U);
434
435 // Lock both coins. Confirm number of available coins drops to 0.
436 {
437 LOCK(wallet->cs_wallet);
439 }
440 for (const auto& group : list) {
441 for (const auto& coin : group.second) {
442 LOCK(wallet->cs_wallet);
443 wallet->LockCoin(coin.outpoint);
444 }
445 }
446 {
447 LOCK(wallet->cs_wallet);
449 }
450 // Confirm ListCoins still returns same result as before, despite coins
451 // being locked.
452 {
453 LOCK(wallet->cs_wallet);
454 list = ListCoins(*wallet);
455 }
456 BOOST_CHECK_EQUAL(list.size(), 1U);
457 BOOST_CHECK_EQUAL(std::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
458 BOOST_CHECK_EQUAL(list.begin()->second.size(), 2U);
459}
460
461void TestCoinsResult(ListCoinsTest& context, OutputType out_type, CAmount amount,
462 std::map<OutputType, size_t>& expected_coins_sizes)
463{
464 LOCK(context.wallet->cs_wallet);
465 util::Result<CTxDestination> dest = Assert(context.wallet->GetNewDestination(out_type, ""));
466 CWalletTx& wtx = context.AddTx(CRecipient{*dest, amount, /*fSubtractFeeFromAmount=*/true});
467 CoinFilterParams filter;
468 filter.skip_locked = false;
469 CoinsResult available_coins = AvailableCoins(*context.wallet, nullptr, std::nullopt, filter);
470 // Lock outputs so they are not spent in follow-up transactions
471 for (uint32_t i = 0; i < wtx.tx->vout.size(); i++) context.wallet->LockCoin({wtx.GetHash(), i});
472 for (const auto& [type, size] : expected_coins_sizes) BOOST_CHECK_EQUAL(size, available_coins.coins[type].size());
473}
474
475BOOST_FIXTURE_TEST_CASE(BasicOutputTypesTest, ListCoinsTest)
476{
477 std::map<OutputType, size_t> expected_coins_sizes;
478 for (const auto& out_type : OUTPUT_TYPES) { expected_coins_sizes[out_type] = 0U; }
479
480 // Verify our wallet has one usable coinbase UTXO before starting
481 // This UTXO is a P2PK, so it should show up in the Other bucket
482 expected_coins_sizes[OutputType::UNKNOWN] = 1U;
483 CoinsResult available_coins = WITH_LOCK(wallet->cs_wallet, return AvailableCoins(*wallet));
484 BOOST_CHECK_EQUAL(available_coins.Size(), expected_coins_sizes[OutputType::UNKNOWN]);
485 BOOST_CHECK_EQUAL(available_coins.coins[OutputType::UNKNOWN].size(), expected_coins_sizes[OutputType::UNKNOWN]);
486
487 // We will create a self transfer for each of the OutputTypes and
488 // verify it is put in the correct bucket after running GetAvailablecoins
489 //
490 // For each OutputType, We expect 2 UTXOs in our wallet following the self transfer:
491 // 1. One UTXO as the recipient
492 // 2. One UTXO from the change, due to payment address matching logic
493
494 for (const auto& out_type : OUTPUT_TYPES) {
495 if (out_type == OutputType::UNKNOWN) continue;
496 expected_coins_sizes[out_type] = 2U;
497 TestCoinsResult(*this, out_type, 1 * COIN, expected_coins_sizes);
498 }
499}
500
502{
503 const std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), "", CreateMockableWalletDatabase());
504 LOCK(wallet->cs_wallet);
505 wallet->SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
506 wallet->SetMinVersion(FEATURE_LATEST);
508 BOOST_CHECK(!wallet->GetNewDestination(OutputType::BECH32, ""));
509}
510
511// Explicit calculation which is used to test the wallet constant
512// We get the same virtual size due to rounding(weight/4) for both use_max_sig values
513static size_t CalculateNestedKeyhashInputSize(bool use_max_sig)
514{
515 // Generate ephemeral valid pubkey
516 CKey key = GenerateRandomKey();
517 CPubKey pubkey = key.GetPubKey();
518
519 // Generate pubkey hash
520 uint160 key_hash(Hash160(pubkey));
521
522 // Create inner-script to enter into keystore. Key hash can't be 0...
523 CScript inner_script = CScript() << OP_0 << std::vector<unsigned char>(key_hash.begin(), key_hash.end());
524
525 // Create outer P2SH script for the output
526 uint160 script_id(Hash160(inner_script));
527 CScript script_pubkey = CScript() << OP_HASH160 << std::vector<unsigned char>(script_id.begin(), script_id.end()) << OP_EQUAL;
528
529 // Add inner-script to key store and key to watchonly
531 keystore.AddCScript(inner_script);
532 keystore.AddKeyPubKey(key, pubkey);
533
534 // Fill in dummy signatures for fee calculation.
535 SignatureData sig_data;
536
537 if (!ProduceSignature(keystore, use_max_sig ? DUMMY_MAXIMUM_SIGNATURE_CREATOR : DUMMY_SIGNATURE_CREATOR, script_pubkey, sig_data)) {
538 // We're hand-feeding it correct arguments; shouldn't happen
539 assert(false);
540 }
541
542 CTxIn tx_in;
543 UpdateInput(tx_in, sig_data);
544 return (size_t)GetVirtualTransactionInputSize(tx_in);
545}
546
548{
551}
552
553bool malformed_descriptor(std::ios_base::failure e)
554{
555 std::string s(e.what());
556 return s.find("Missing checksum") != std::string::npos;
557}
558
560{
561 std::vector<unsigned char> malformed_record;
562 VectorWriter vw{malformed_record, 0};
563 vw << std::string("notadescriptor");
564 vw << uint64_t{0};
565 vw << int32_t{0};
566 vw << int32_t{0};
567 vw << int32_t{1};
568
569 SpanReader vr{malformed_record};
570 WalletDescriptor w_desc;
571 BOOST_CHECK_EXCEPTION(vr >> w_desc, std::ios_base::failure, malformed_descriptor);
572}
573
593{
594 m_args.ForceSetArg("-unsafesqlitesync", "1");
595 // Create new wallet with known key and unload it.
596 WalletContext context;
597 context.args = &m_args;
598 context.chain = m_node.chain.get();
599 auto wallet = TestLoadWallet(context);
600 CKey key = GenerateRandomKey();
601 AddKey(*wallet, key);
602 TestUnloadWallet(std::move(wallet));
603
604
605 // Add log hook to detect AddToWallet events from rescans, blockConnected,
606 // and transactionAddedToMempool notifications
607 int addtx_count = 0;
608 DebugLogHelper addtx_counter("[default wallet] AddToWallet", [&](const std::string* s) {
609 if (s) ++addtx_count;
610 return false;
611 });
612
613
614 bool rescan_completed = false;
615 DebugLogHelper rescan_check("[default wallet] Rescan completed", [&](const std::string* s) {
616 if (s) rescan_completed = true;
617 return false;
618 });
619
620
621 // Block the queue to prevent the wallet receiving blockConnected and
622 // transactionAddedToMempool notifications, and create block and mempool
623 // transactions paying to the wallet
624 std::promise<void> promise;
625 m_node.validation_signals->CallFunctionInValidationInterfaceQueue([&promise] {
626 promise.get_future().wait();
627 });
628 std::string error;
629 m_coinbase_txns.push_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
630 auto block_tx = TestSimpleSpend(*m_coinbase_txns[0], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
631 m_coinbase_txns.push_back(CreateAndProcessBlock({block_tx}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
632 auto mempool_tx = TestSimpleSpend(*m_coinbase_txns[1], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
633 BOOST_CHECK(m_node.chain->broadcastTransaction(MakeTransactionRef(mempool_tx), DEFAULT_TRANSACTION_MAXFEE, false, error));
634
635
636 // Reload wallet and make sure new transactions are detected despite events
637 // being blocked
638 // Loading will also ask for current mempool transactions
639 wallet = TestLoadWallet(context);
640 BOOST_CHECK(rescan_completed);
641 // AddToWallet events for block_tx and mempool_tx (x2)
642 BOOST_CHECK_EQUAL(addtx_count, 3);
643 {
644 LOCK(wallet->cs_wallet);
645 BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_tx.GetHash()), 1U);
646 BOOST_CHECK_EQUAL(wallet->mapWallet.count(mempool_tx.GetHash()), 1U);
647 }
648
649
650 // Unblock notification queue and make sure stale blockConnected and
651 // transactionAddedToMempool events are processed
652 promise.set_value();
653 m_node.validation_signals->SyncWithValidationInterfaceQueue();
654 // AddToWallet events for block_tx and mempool_tx events are counted a
655 // second time as the notification queue is processed
656 BOOST_CHECK_EQUAL(addtx_count, 5);
657
658
659 TestUnloadWallet(std::move(wallet));
660
661
662 // Load wallet again, this time creating new block and mempool transactions
663 // paying to the wallet as the wallet finishes loading and syncing the
664 // queue so the events have to be handled immediately. Releasing the wallet
665 // lock during the sync is a little artificial but is needed to avoid a
666 // deadlock during the sync and simulates a new block notification happening
667 // as soon as possible.
668 addtx_count = 0;
669 auto handler = HandleLoadWallet(context, [&](std::unique_ptr<interfaces::Wallet> wallet) {
670 BOOST_CHECK(rescan_completed);
671 m_coinbase_txns.push_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
672 block_tx = TestSimpleSpend(*m_coinbase_txns[2], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
673 m_coinbase_txns.push_back(CreateAndProcessBlock({block_tx}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
674 mempool_tx = TestSimpleSpend(*m_coinbase_txns[3], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
675 BOOST_CHECK(m_node.chain->broadcastTransaction(MakeTransactionRef(mempool_tx), DEFAULT_TRANSACTION_MAXFEE, false, error));
676 m_node.validation_signals->SyncWithValidationInterfaceQueue();
677 });
678 wallet = TestLoadWallet(context);
679 // Since mempool transactions are requested at the end of loading, there will
680 // be 2 additional AddToWallet calls, one from the previous test, and a duplicate for mempool_tx
681 BOOST_CHECK_EQUAL(addtx_count, 2 + 2);
682 {
683 LOCK(wallet->cs_wallet);
684 BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_tx.GetHash()), 1U);
685 BOOST_CHECK_EQUAL(wallet->mapWallet.count(mempool_tx.GetHash()), 1U);
686 }
687
688
689 TestUnloadWallet(std::move(wallet));
690}
691
693{
694 WalletContext context;
695 context.args = &m_args;
696 auto wallet = TestLoadWallet(context);
698 WaitForDeleteWallet(std::move(wallet));
699}
700
702{
703 m_args.ForceSetArg("-unsafesqlitesync", "1");
704 WalletContext context;
705 context.args = &m_args;
706 context.chain = m_node.chain.get();
707 auto wallet = TestLoadWallet(context);
708 CKey key = GenerateRandomKey();
709 AddKey(*wallet, key);
710
711 std::string error;
712 m_coinbase_txns.push_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
713 auto block_tx = TestSimpleSpend(*m_coinbase_txns[0], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
714 CreateAndProcessBlock({block_tx}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
715
716 m_node.validation_signals->SyncWithValidationInterfaceQueue();
717
718 {
719 auto block_hash = block_tx.GetHash();
720 auto prev_tx = m_coinbase_txns[0];
721
722 LOCK(wallet->cs_wallet);
723 BOOST_CHECK(wallet->HasWalletSpend(prev_tx));
724 BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_hash), 1u);
725
726 std::vector<uint256> vHashIn{ block_hash };
727 BOOST_CHECK(wallet->RemoveTxs(vHashIn));
728
729 BOOST_CHECK(!wallet->HasWalletSpend(prev_tx));
730 BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_hash), 0u);
731 }
732
733 TestUnloadWallet(std::move(wallet));
734}
735
740BOOST_FIXTURE_TEST_CASE(wallet_sync_tx_invalid_state_test, TestingSetup)
741{
743 {
744 LOCK(wallet.cs_wallet);
745 wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
746 wallet.SetupDescriptorScriptPubKeyMans();
747 }
748
749 // Add tx to wallet
750 const auto op_dest{*Assert(wallet.GetNewDestination(OutputType::BECH32M, ""))};
751
753 mtx.vout.emplace_back(COIN, GetScriptForDestination(op_dest));
754 mtx.vin.emplace_back(Txid::FromUint256(m_rng.rand256()), 0);
755 const auto& tx_id_to_spend = wallet.AddToWallet(MakeTransactionRef(mtx), TxStateInMempool{})->GetHash();
756
757 {
758 // Cache and verify available balance for the wtx
759 LOCK(wallet.cs_wallet);
760 const CWalletTx* wtx_to_spend = wallet.GetWalletTx(tx_id_to_spend);
762 }
763
764 // Now the good case:
765 // 1) Add a transaction that spends the previously created transaction
766 // 2) Verify that the available balance of this new tx and the old one is updated (prev tx is marked dirty)
767
768 mtx.vin.clear();
769 mtx.vin.emplace_back(tx_id_to_spend, 0);
770 wallet.transactionAddedToMempool(MakeTransactionRef(mtx));
771 const auto good_tx_id{mtx.GetHash()};
772
773 {
774 // Verify balance update for the new tx and the old one
775 LOCK(wallet.cs_wallet);
776 const CWalletTx* new_wtx = wallet.GetWalletTx(good_tx_id.ToUint256());
778
779 // Now the old wtx
780 const CWalletTx* wtx_to_spend = wallet.GetWalletTx(tx_id_to_spend);
782 }
783
784 // Now the bad case:
785 // 1) Make db always fail
786 // 2) Try to add a transaction that spends the previously created transaction and
787 // verify that we are not moving forward if the wallet cannot store it
789 mtx.vin.clear();
790 mtx.vin.emplace_back(good_tx_id, 0);
791 BOOST_CHECK_EXCEPTION(wallet.transactionAddedToMempool(MakeTransactionRef(mtx)),
792 std::runtime_error,
793 HasReason("DB error adding transaction to wallet, write failed"));
794}
795
797} // namespace wallet
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
static constexpr CAmount COIN
The amount of satoshis in one BTC.
Definition: amount.h:15
node::NodeContext m_node
Definition: bitcoin-gui.cpp:42
#define Assert(val)
Identity function.
Definition: check.h:106
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: chain.h:141
uint32_t nTime
Definition: chain.h:189
uint256 GetBlockHash() const
Definition: chain.h:243
int nHeight
height of the entry in the chain. The genesis block has height 0
Definition: chain.h:153
FlatFilePos GetBlockPos() const EXCLUSIVE_LOCKS_REQUIRED(
Definition: chain.h:208
const uint256 * phashBlock
pointer to the hash of the block, if any. Memory is owned by this CBlockIndex
Definition: chain.h:144
An encapsulated private key.
Definition: key.h:35
CPubKey GetPubKey() const
Compute the public key from a private key.
Definition: key.cpp:182
An encapsulated public key.
Definition: pubkey.h:34
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:415
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:296
An input of a transaction.
Definition: transaction.h:67
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Definition: validation.h:866
node::BlockMap & BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(
Definition: validation.h:1123
Fillable signing provider that keeps keys in an address->secret map.
virtual bool AddKeyPubKey(const CKey &key, const CPubKey &pubkey)
virtual bool AddCScript(const CScript &redeemScript)
virtual bool AddKey(const CKey &key)
BOOST_CHECK_EXCEPTION predicates to check the specific validation error.
Definition: setup_common.h:302
Minimal stream for reading from an existing byte array by std::span.
Definition: streams.h:101
constexpr bool IsNull() const
Definition: uint256.h:48
constexpr unsigned char * end()
Definition: uint256.h:102
constexpr unsigned char * begin()
Definition: uint256.h:101
static transaction_identifier FromUint256(const uint256 &id)
160-bit opaque blob.
Definition: uint256.h:184
256-bit opaque blob.
Definition: uint256.h:196
Coin Control Features.
Definition: coincontrol.h:81
A CWallet maintains a set of transactions and balances, and provides the ability to create new transa...
Definition: wallet.h:300
A transaction with a bunch of additional info that only the owner cares about.
Definition: transaction.h:177
CTransactionRef tx
Definition: transaction.h:258
CWalletTx & AddTx(CRecipient recipient)
std::unique_ptr< CWallet > wallet
Access to the wallet database.
Definition: walletdb.h:189
Descriptor with some wallet metadata.
Definition: walletutil.h:85
RAII object to check and reserve a wallet rescan.
Definition: wallet.h:1067
void setNow(NowFn now)
Definition: wallet.h:1097
bool reserve(bool with_passphrase=false)
Definition: wallet.h:1077
static UniValue Parse(std::string_view raw)
Parse string to UniValue or throw runtime_error if string contains invalid JSON.
Definition: client.cpp:317
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:8
BOOST_FIXTURE_TEST_SUITE(cuckoocache_tests, BasicTestingSetup)
Test Suite for CuckooCache.
BOOST_AUTO_TEST_SUITE_END()
uint160 Hash160(const T1 &in1)
Compute the 160-bit hash an object.
Definition: hash.h:92
@ SIGHASH_ALL
Definition: interpreter.h:30
CKey GenerateRandomKey(bool compressed) noexcept
Definition: key.cpp:352
std::string EncodeSecret(const CKey &key)
Definition: key_io.cpp:231
std::unique_ptr< Chain > MakeChain(node::NodeContext &node)
Return implementation of Chain interface.
Definition: messages.h:20
static const unsigned int MAX_BLOCKFILE_SIZE
The maximum size of a blk?????.dat file (since 0.8)
Definition: blockstorage.h:75
void format(std::ostream &out, FormatStringCheck< sizeof...(Args)> fmt, const Args &... args)
Format list of arguments to the stream according to given format string.
Definition: tinyformat.h:1079
static constexpr size_t DUMMY_NESTED_P2WPKH_INPUT_SIZE
Pre-calculated constants for input size estimation in virtual size
Definition: wallet.h:143
static CMutableTransaction TestSimpleSpend(const CTransaction &from, uint32_t index, const CKey &key, const CScript &pubkey)
CAmount CachedTxGetAvailableCredit(const CWallet &wallet, const CWalletTx &wtx, const isminefilter &filter)
Definition: receive.cpp:159
Balance GetBalance(const CWallet &wallet, const int min_depth, bool avoid_reuse)
Definition: receive.cpp:293
void TestLoadWallet(const std::string &name, DatabaseFormat format, std::function< void(std::shared_ptr< CWallet >)> f)
util::Result< CreatedTransactionResult > CreateTransaction(CWallet &wallet, const std::vector< CRecipient > &vecSend, std::optional< unsigned int > change_pos, const CCoinControl &coin_control, bool sign)
Create a new transaction paying the recipients with a set of coins selected by SelectCoins(); Also cr...
Definition: spend.cpp:1368
constexpr CAmount DEFAULT_TRANSACTION_MAXFEE
-maxtxfee default
Definition: wallet.h:137
static bool RunWithinTxn(WalletBatch &batch, std::string_view process_desc, const std::function< bool(WalletBatch &)> &func)
Definition: walletdb.cpp:1241
std::variant< TxStateConfirmed, TxStateInMempool, TxStateBlockConflicted, TxStateInactive, TxStateUnrecognized > TxState
All possible CWalletTx states.
Definition: transaction.h:78
BOOST_FIXTURE_TEST_CASE(wallet_coinsresult_test, BasicTestingSetup)
std::shared_ptr< CWallet > TestLoadWallet(std::unique_ptr< WalletDatabase > database, WalletContext &context, uint64_t create_flags)
Definition: util.cpp:51
DatabaseFormat
Definition: db.h:164
bool AddWalletSetting(interfaces::Chain &chain, const std::string &wallet_name)
Add wallet name to persistent configuration so it will be loaded on startup.
Definition: wallet.cpp:94
static const DatabaseFormat DATABASE_FORMATS[]
Definition: util.h:27
bool RemoveWalletSetting(interfaces::Chain &chain, const std::string &wallet_name)
Remove wallet name from persistent configuration so it will not be loaded on startup.
Definition: wallet.cpp:107
std::unique_ptr< interfaces::Handler > HandleLoadWallet(WalletContext &context, LoadWalletFn load_wallet)
Definition: wallet.cpp:213
std::unique_ptr< CWallet > CreateSyncedWallet(interfaces::Chain &chain, CChain &cchain, const CKey &key)
Definition: util.cpp:20
static const CAmount DEFAULT_TRANSACTION_MINFEE
-mintxfee default
Definition: wallet.h:110
void TestUnloadWallet(std::shared_ptr< CWallet > &&wallet)
Definition: util.cpp:74
static void AddTx(CWallet &wallet)
std::unique_ptr< WalletDatabase > MakeWalletDatabase(const std::string &name, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error_string)
Definition: wallet.cpp:2813
MockableDatabase & GetMockableDatabase(CWallet &wallet)
Definition: util.cpp:192
static int64_t AddTx(ChainstateManager &chainman, CWallet &wallet, uint32_t lockTime, int64_t mockTime, int64_t blockTime)
std::map< CTxDestination, std::vector< COutput > > ListCoins(const CWallet &wallet)
Return list of available coins and locked coins grouped by non-change output address.
Definition: spend.cpp:504
std::unique_ptr< WalletDatabase > CreateMockableWalletDatabase(MockableData records)
Definition: util.cpp:187
BOOST_AUTO_TEST_CASE(bnb_test)
@ ISMINE_SPENDABLE
Definition: types.h:44
CoinsResult AvailableCoinsListUnspent(const CWallet &wallet, const CCoinControl *coinControl, CoinFilterParams params)
Wrapper function for AvailableCoins which skips the feerate and CoinFilterParams::only_spendable para...
Definition: spend.cpp:478
static void AddKey(CWallet &wallet, const CKey &key)
static const CAmount WALLET_INCREMENTAL_RELAY_FEE
minimum recommended increment for replacement txs
Definition: wallet.h:124
@ FEATURE_LATEST
Definition: walletutil.h:30
BOOST_FIXTURE_TEST_CASE(wallet_sync_tx_invalid_state_test, TestingSetup)
Checks a wallet invalid state where the inputs (prev-txs) of a new arriving transaction are not marke...
CAmount CachedTxGetImmatureCredit(const CWallet &wallet, const CWalletTx &wtx, const isminefilter &filter)
Definition: receive.cpp:148
bool malformed_descriptor(std::ios_base::failure e)
std::shared_ptr< CWallet > CreateWallet(WalletContext &context, const std::string &name, std::optional< bool > load_on_start, DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error, std::vector< bilingual_str > &warnings)
Definition: wallet.cpp:379
void TestCoinsResult(ListCoinsTest &context, OutputType out_type, CAmount amount, std::map< OutputType, size_t > &expected_coins_sizes)
@ WALLET_FLAG_DESCRIPTORS
Indicate that this wallet supports DescriptorScriptPubKeyMan.
Definition: walletutil.h:74
@ WALLET_FLAG_DISABLE_PRIVATE_KEYS
Definition: walletutil.h:51
void WaitForDeleteWallet(std::shared_ptr< CWallet > &&wallet)
Explicitly delete the wallet.
Definition: wallet.cpp:251
static size_t CalculateNestedKeyhashInputSize(bool use_max_sig)
DatabaseStatus
Definition: db.h:183
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18
#define BOOST_CHECK(expr)
Definition: object.cpp:17
OutputType
Definition: outputtype.h:17
static constexpr auto OUTPUT_TYPES
Definition: outputtype.h:25
int64_t GetVirtualTransactionInputSize(const CTxIn &txin, int64_t nSigOpCost, unsigned int bytes_per_sigop)
Definition: policy.cpp:320
static constexpr unsigned int DEFAULT_INCREMENTAL_RELAY_FEE
Default for -incrementalrelayfee, which sets the minimum feerate increase for mempool limiting or rep...
Definition: policy.h:42
static constexpr unsigned int DEFAULT_MIN_RELAY_TX_FEE
Default for -minrelaytxfee, minimum relay fee for transactions.
Definition: policy.h:64
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:424
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:423
uint256 GetRandHash() noexcept
Generate a random uint256.
Definition: random.h:454
void SignTransaction(CMutableTransaction &mtx, const SigningProvider *keystore, const std::map< COutPoint, Coin > &coins, const UniValue &hashType, UniValue &result)
Sign a transaction with the given keystore and previous transactions.
bool(* handler)(const std::any &context, HTTPRequest *req, const std::string &strReq)
Definition: rest.cpp:1010
const char * name
Definition: rest.cpp:49
@ OP_EQUAL
Definition: script.h:146
bool ProduceSignature(const SigningProvider &provider, const BaseSignatureCreator &creator, const CScript &fromPubKey, SignatureData &sigdata)
Produce a script signature using a generic signature creator.
Definition: sign.cpp:502
void UpdateInput(CTxIn &input, const SignatureData &data)
Definition: sign.cpp:675
const BaseSignatureCreator & DUMMY_MAXIMUM_SIGNATURE_CREATOR
A signature creator that just produces 72-byte empty signatures.
Definition: sign.cpp:745
const BaseSignatureCreator & DUMMY_SIGNATURE_CREATOR
A signature creator that just produces 71-byte empty signatures.
Definition: sign.cpp:744
CScript GetScriptForRawPubKey(const CPubKey &pubKey)
Generate a P2PK script for the given pubkey.
Definition: solver.cpp:213
Basic testing setup.
Definition: setup_common.h:64
Describes a place in the block chain to another node such that if the other node doesn't have the sam...
Definition: block.h:124
bool IsNull() const
Definition: block.h:152
A mutable version of CTransaction.
Definition: transaction.h:378
std::vector< CTxOut > vout
Definition: transaction.h:380
Txid GetHash() const
Compute the hash of this CMutableTransaction.
Definition: transaction.cpp:69
std::vector< CTxIn > vin
Definition: transaction.h:379
int nFile
Definition: flatfile.h:16
Testing fixture that pre-creates a 100-block REGTEST-mode block chain.
Definition: setup_common.h:146
Testing setup that configures a complete environment.
Definition: setup_common.h:121
Bilingual messages:
Definition: translation.h:24
NodeContext struct containing references to chain state and connection state.
Definition: context.h:56
std::unique_ptr< ValidationSignals > validation_signals
Issues calls about blocks and transactions.
Definition: context.h:88
std::unique_ptr< ChainstateManager > chainman
Definition: context.h:72
std::unique_ptr< interfaces::Chain > chain
Definition: context.h:76
std::optional< int > last_scanned_height
Definition: wallet.h:621
enum wallet::CWallet::ScanResult::@19 status
uint256 last_scanned_block
Hash and height of most recent block that was successfully scanned.
Definition: wallet.h:620
uint256 last_failed_block
Height of the most recent block that could not be scanned due to read errors or pruning.
Definition: wallet.h:627
COutputs available for spending, stored by OutputType.
Definition: spend.h:40
size_t Size() const
The following methods are provided so that CoinsResult can mimic a vector, i.e., methods can work wit...
Definition: spend.cpp:192
std::map< OutputType, std::vector< COutput > > coins
Definition: spend.h:41
std::optional< DatabaseFormat > require_format
Definition: db.h:172
State of transaction confirmed in a block.
Definition: transaction.h:31
State of transaction added to mempool.
Definition: transaction.h:41
State of transaction not confirmed or conflicting with a known block and not in the mempool.
Definition: transaction.h:58
WalletContext struct containing references to state shared between CWallet instances,...
Definition: context.h:36
interfaces::Chain * chain
Definition: context.h:37
ArgsManager * args
Definition: context.h:39
#define LOCK(cs)
Definition: sync.h:257
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:301
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:49
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1172
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
Definition: time.cpp:40
assert(!tx.IsCoinBase())
std::shared_ptr< CWallet > m_wallet
Definition: interfaces.cpp:545
static void AvailableCoins(benchmark::Bench &bench, const std::vector< OutputType > &output_type)