Bitcoin Core 29.99.0
P2P Digital Currency
wallet_tests.cpp
Go to the documentation of this file.
1// Copyright (c) 2012-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/wallet.h>
6
7#include <cstdint>
8#include <future>
9#include <memory>
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 Assert(wallet.AddWalletDescriptor(w_desc, provider, "", false));
70}
71
72BOOST_FIXTURE_TEST_CASE(update_non_range_descriptor, TestingSetup)
73{
75 {
76 LOCK(wallet.cs_wallet);
77 wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
78 auto key{GenerateRandomKey()};
79 auto desc_str{"combo(" + EncodeSecret(key) + ")"};
80 FlatSigningProvider provider;
81 std::string error;
82 auto descs{Parse(desc_str, provider, error, /* require_checksum=*/ false)};
83 auto& desc{descs.at(0)};
84 WalletDescriptor w_desc{std::move(desc), 0, 0, 0, 0};
85 BOOST_CHECK(wallet.AddWalletDescriptor(w_desc, provider, "", false));
86 // Wallet should update the non-range descriptor successfully
87 BOOST_CHECK(wallet.AddWalletDescriptor(w_desc, provider, "", false));
88 }
89}
90
91BOOST_FIXTURE_TEST_CASE(scan_for_wallet_transactions, TestChain100Setup)
92{
93 // Cap last block file size, and mine new block in a new block file.
94 CBlockIndex* oldTip = WITH_LOCK(Assert(m_node.chainman)->GetMutex(), return m_node.chainman->ActiveChain().Tip());
95 WITH_LOCK(::cs_main, m_node.chainman->m_blockman.GetBlockFileInfo(oldTip->GetBlockPos().nFile)->nSize = MAX_BLOCKFILE_SIZE);
96 CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
97 CBlockIndex* newTip = WITH_LOCK(Assert(m_node.chainman)->GetMutex(), return m_node.chainman->ActiveChain().Tip());
98
99 // Verify ScanForWalletTransactions fails to read an unknown start block.
100 {
102 {
103 LOCK(wallet.cs_wallet);
104 LOCK(Assert(m_node.chainman)->GetMutex());
105 wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
106 wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());
107 }
108 AddKey(wallet, coinbaseKey);
110 reserver.reserve();
111 CWallet::ScanResult result = wallet.ScanForWalletTransactions(/*start_block=*/{}, /*start_height=*/0, /*max_height=*/{}, reserver, /*fUpdate=*/false, /*save_progress=*/false);
116 BOOST_CHECK_EQUAL(GetBalance(wallet).m_mine_immature, 0);
117 }
118
119 // Verify ScanForWalletTransactions picks up transactions in both the old
120 // and new block files.
121 {
123 {
124 LOCK(wallet.cs_wallet);
125 LOCK(Assert(m_node.chainman)->GetMutex());
126 wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
127 wallet.SetLastBlockProcessed(newTip->nHeight, newTip->GetBlockHash());
128 }
129 AddKey(wallet, coinbaseKey);
131 std::chrono::steady_clock::time_point fake_time;
132 reserver.setNow([&] { fake_time += 60s; return fake_time; });
133 reserver.reserve();
134
135 {
136 CBlockLocator locator;
137 BOOST_CHECK(WalletBatch{wallet.GetDatabase()}.ReadBestBlock(locator));
138 BOOST_CHECK(!locator.IsNull() && locator.vHave.front() == newTip->GetBlockHash());
139 }
140
141 CWallet::ScanResult result = wallet.ScanForWalletTransactions(/*start_block=*/oldTip->GetBlockHash(), /*start_height=*/oldTip->nHeight, /*max_height=*/{}, reserver, /*fUpdate=*/false, /*save_progress=*/true);
144 BOOST_CHECK_EQUAL(result.last_scanned_block, newTip->GetBlockHash());
145 BOOST_CHECK_EQUAL(*result.last_scanned_height, newTip->nHeight);
146 BOOST_CHECK_EQUAL(GetBalance(wallet).m_mine_immature, 100 * COIN);
147
148 {
149 CBlockLocator locator;
150 BOOST_CHECK(WalletBatch{wallet.GetDatabase()}.ReadBestBlock(locator));
151 BOOST_CHECK(!locator.IsNull() && locator.vHave.front() == newTip->GetBlockHash());
152 }
153 }
154
155 // Prune the older block file.
156 int file_number;
157 {
158 LOCK(cs_main);
159 file_number = oldTip->GetBlockPos().nFile;
160 Assert(m_node.chainman)->m_blockman.PruneOneBlockFile(file_number);
161 }
162 m_node.chainman->m_blockman.UnlinkPrunedFiles({file_number});
163
164 // Verify ScanForWalletTransactions only picks transactions in the new block
165 // file.
166 {
168 {
169 LOCK(wallet.cs_wallet);
170 LOCK(Assert(m_node.chainman)->GetMutex());
171 wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
172 wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());
173 }
174 AddKey(wallet, coinbaseKey);
176 reserver.reserve();
177 CWallet::ScanResult result = wallet.ScanForWalletTransactions(/*start_block=*/oldTip->GetBlockHash(), /*start_height=*/oldTip->nHeight, /*max_height=*/{}, reserver, /*fUpdate=*/false, /*save_progress=*/false);
180 BOOST_CHECK_EQUAL(result.last_scanned_block, newTip->GetBlockHash());
181 BOOST_CHECK_EQUAL(*result.last_scanned_height, newTip->nHeight);
182 BOOST_CHECK_EQUAL(GetBalance(wallet).m_mine_immature, 50 * COIN);
183 }
184
185 // Prune the remaining block file.
186 {
187 LOCK(cs_main);
188 file_number = newTip->GetBlockPos().nFile;
189 Assert(m_node.chainman)->m_blockman.PruneOneBlockFile(file_number);
190 }
191 m_node.chainman->m_blockman.UnlinkPrunedFiles({file_number});
192
193 // Verify ScanForWalletTransactions scans no blocks.
194 {
196 {
197 LOCK(wallet.cs_wallet);
198 LOCK(Assert(m_node.chainman)->GetMutex());
199 wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
200 wallet.SetLastBlockProcessed(m_node.chainman->ActiveChain().Height(), m_node.chainman->ActiveChain().Tip()->GetBlockHash());
201 }
202 AddKey(wallet, coinbaseKey);
204 reserver.reserve();
205 CWallet::ScanResult result = wallet.ScanForWalletTransactions(/*start_block=*/oldTip->GetBlockHash(), /*start_height=*/oldTip->nHeight, /*max_height=*/{}, reserver, /*fUpdate=*/false, /*save_progress=*/false);
207 BOOST_CHECK_EQUAL(result.last_failed_block, newTip->GetBlockHash());
210 BOOST_CHECK_EQUAL(GetBalance(wallet).m_mine_immature, 0);
211 }
212}
213
214// This test verifies that wallet settings can be added and removed
215// concurrently, ensuring no race conditions occur during either process.
216BOOST_FIXTURE_TEST_CASE(write_wallet_settings_concurrently, TestingSetup)
217{
218 auto chain = m_node.chain.get();
219 const auto NUM_WALLETS{5};
220
221 // Since we're counting the number of wallets, ensure we start without any.
222 BOOST_REQUIRE(chain->getRwSetting("wallet").isNull());
223
224 const auto& check_concurrent_wallet = [&](const auto& settings_function, int num_expected_wallets) {
225 std::vector<std::thread> threads;
226 threads.reserve(NUM_WALLETS);
227 for (auto i{0}; i < NUM_WALLETS; ++i) threads.emplace_back(settings_function, i);
228 for (auto& t : threads) t.join();
229
230 auto wallets = chain->getRwSetting("wallet");
231 BOOST_CHECK_EQUAL(wallets.getValues().size(), num_expected_wallets);
232 };
233
234 // Add NUM_WALLETS wallets concurrently, ensure we end up with NUM_WALLETS stored.
235 check_concurrent_wallet([&chain](int i) {
236 Assert(AddWalletSetting(*chain, strprintf("wallet_%d", i)));
237 },
238 /*num_expected_wallets=*/NUM_WALLETS);
239
240 // Remove NUM_WALLETS wallets concurrently, ensure we end up with 0 wallets.
241 check_concurrent_wallet([&chain](int i) {
242 Assert(RemoveWalletSetting(*chain, strprintf("wallet_%d", i)));
243 },
244 /*num_expected_wallets=*/0);
245}
246
247static int64_t AddTx(ChainstateManager& chainman, CWallet& wallet, uint32_t lockTime, int64_t mockTime, int64_t blockTime)
248{
250 TxState state = TxStateInactive{};
251 tx.nLockTime = lockTime;
252 SetMockTime(mockTime);
253 CBlockIndex* block = nullptr;
254 if (blockTime > 0) {
255 LOCK(cs_main);
256 auto inserted = chainman.BlockIndex().emplace(std::piecewise_construct, std::make_tuple(GetRandHash()), std::make_tuple());
257 assert(inserted.second);
258 const uint256& hash = inserted.first->first;
259 block = &inserted.first->second;
260 block->nTime = blockTime;
261 block->phashBlock = &hash;
262 state = TxStateConfirmed{hash, block->nHeight, /*index=*/0};
263 }
264 return wallet.AddToWallet(MakeTransactionRef(tx), state, [&](CWalletTx& wtx, bool /* new_tx */) {
265 // Assign wtx.m_state to simplify test and avoid the need to simulate
266 // reorg events. Without this, AddToWallet asserts false when the same
267 // transaction is confirmed in different blocks.
268 wtx.m_state = state;
269 return true;
270 })->nTimeSmart;
271}
272
273// Simple test to verify assignment of CWalletTx::nSmartTime value. Could be
274// expanded to cover more corner cases of smart time logic.
275BOOST_AUTO_TEST_CASE(ComputeTimeSmart)
276{
277 // New transaction should use clock time if lower than block time.
278 BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 1, 100, 120), 100);
279
280 // Test that updating existing transaction does not change smart time.
281 BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 1, 200, 220), 100);
282
283 // New transaction should use clock time if there's no block time.
284 BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 2, 300, 0), 300);
285
286 // New transaction should use block time if lower than clock time.
287 BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 3, 420, 400), 400);
288
289 // New transaction should use latest entry time if higher than
290 // min(block time, clock time).
291 BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 4, 500, 390), 400);
292
293 // If there are future entries, new transaction should use time of the
294 // newest entry that is no more than 300 seconds ahead of the clock time.
295 BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 5, 50, 600), 300);
296}
297
298void TestLoadWallet(const std::string& name, DatabaseFormat format, std::function<void(std::shared_ptr<CWallet>)> f)
299{
301 auto chain{interfaces::MakeChain(node)};
302 DatabaseOptions options;
303 options.require_format = format;
304 DatabaseStatus status;
305 bilingual_str error;
306 std::vector<bilingual_str> warnings;
307 auto database{MakeWalletDatabase(name, options, status, error)};
308 auto wallet{std::make_shared<CWallet>(chain.get(), "", std::move(database))};
310 WITH_LOCK(wallet->cs_wallet, f(wallet));
311}
312
314{
316 const std::string name{strprintf("receive-requests-%i", format)};
317 TestLoadWallet(name, format, [](std::shared_ptr<CWallet> wallet) EXCLUSIVE_LOCKS_REQUIRED(wallet->cs_wallet) {
318 BOOST_CHECK(!wallet->IsAddressPreviouslySpent(PKHash()));
319 WalletBatch batch{wallet->GetDatabase()};
320 BOOST_CHECK(batch.WriteAddressPreviouslySpent(PKHash(), true));
321 BOOST_CHECK(batch.WriteAddressPreviouslySpent(ScriptHash(), true));
322 BOOST_CHECK(wallet->SetAddressReceiveRequest(batch, PKHash(), "0", "val_rr00"));
323 BOOST_CHECK(wallet->EraseAddressReceiveRequest(batch, PKHash(), "0"));
324 BOOST_CHECK(wallet->SetAddressReceiveRequest(batch, PKHash(), "1", "val_rr10"));
325 BOOST_CHECK(wallet->SetAddressReceiveRequest(batch, PKHash(), "1", "val_rr11"));
326 BOOST_CHECK(wallet->SetAddressReceiveRequest(batch, ScriptHash(), "2", "val_rr20"));
327 });
328 TestLoadWallet(name, format, [](std::shared_ptr<CWallet> wallet) EXCLUSIVE_LOCKS_REQUIRED(wallet->cs_wallet) {
329 BOOST_CHECK(wallet->IsAddressPreviouslySpent(PKHash()));
330 BOOST_CHECK(wallet->IsAddressPreviouslySpent(ScriptHash()));
331 auto requests = wallet->GetAddressReceiveRequests();
332 auto erequests = {"val_rr11", "val_rr20"};
333 BOOST_CHECK_EQUAL_COLLECTIONS(requests.begin(), requests.end(), std::begin(erequests), std::end(erequests));
334 RunWithinTxn(wallet->GetDatabase(), /*process_desc*/"test", [](WalletBatch& batch){
335 BOOST_CHECK(batch.WriteAddressPreviouslySpent(PKHash(), false));
336 BOOST_CHECK(batch.EraseAddressData(ScriptHash()));
337 return true;
338 });
339 });
340 TestLoadWallet(name, format, [](std::shared_ptr<CWallet> wallet) EXCLUSIVE_LOCKS_REQUIRED(wallet->cs_wallet) {
341 BOOST_CHECK(!wallet->IsAddressPreviouslySpent(PKHash()));
342 BOOST_CHECK(!wallet->IsAddressPreviouslySpent(ScriptHash()));
343 auto requests = wallet->GetAddressReceiveRequests();
344 auto erequests = {"val_rr11"};
345 BOOST_CHECK_EQUAL_COLLECTIONS(requests.begin(), requests.end(), std::begin(erequests), std::end(erequests));
346 });
347 }
348}
349
351{
352public:
354 {
355 CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
356 wallet = CreateSyncedWallet(*m_node.chain, WITH_LOCK(Assert(m_node.chainman)->GetMutex(), return m_node.chainman->ActiveChain()), coinbaseKey);
357 }
358
360 {
361 wallet.reset();
362 }
363
365 {
367 CCoinControl dummy;
368 {
369 auto res = CreateTransaction(*wallet, {recipient}, /*change_pos=*/std::nullopt, dummy);
370 BOOST_CHECK(res);
371 tx = res->tx;
372 }
373 wallet->CommitTransaction(tx, {}, {});
374 CMutableTransaction blocktx;
375 {
376 LOCK(wallet->cs_wallet);
377 blocktx = CMutableTransaction(*wallet->mapWallet.at(tx->GetHash()).tx);
378 }
379 CreateAndProcessBlock({CMutableTransaction(blocktx)}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
380
381 LOCK(wallet->cs_wallet);
382 LOCK(Assert(m_node.chainman)->GetMutex());
383 wallet->SetLastBlockProcessed(wallet->GetLastBlockHeight() + 1, m_node.chainman->ActiveChain().Tip()->GetBlockHash());
384 auto it = wallet->mapWallet.find(tx->GetHash());
385 BOOST_CHECK(it != wallet->mapWallet.end());
386 it->second.m_state = TxStateConfirmed{m_node.chainman->ActiveChain().Tip()->GetBlockHash(), m_node.chainman->ActiveChain().Height(), /*index=*/1};
387 return it->second;
388 }
389
390 std::unique_ptr<CWallet> wallet;
391};
392
394{
395 std::string coinbaseAddress = coinbaseKey.GetPubKey().GetID().ToString();
396
397 // Confirm ListCoins initially returns 1 coin grouped under coinbaseKey
398 // address.
399 std::map<CTxDestination, std::vector<COutput>> list;
400 {
401 LOCK(wallet->cs_wallet);
402 list = ListCoins(*wallet);
403 }
404 BOOST_CHECK_EQUAL(list.size(), 1U);
405 BOOST_CHECK_EQUAL(std::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
406 BOOST_CHECK_EQUAL(list.begin()->second.size(), 1U);
407
408 // Check initial balance from one mature coinbase transaction.
409 BOOST_CHECK_EQUAL(50 * COIN, WITH_LOCK(wallet->cs_wallet, return AvailableCoins(*wallet).GetTotalAmount()));
410
411 // Add a transaction creating a change address, and confirm ListCoins still
412 // returns the coin associated with the change address underneath the
413 // coinbaseKey pubkey, even though the change address has a different
414 // pubkey.
415 AddTx(CRecipient{PubKeyDestination{{}}, 1 * COIN, /*subtract_fee=*/false});
416 {
417 LOCK(wallet->cs_wallet);
418 list = ListCoins(*wallet);
419 }
420 BOOST_CHECK_EQUAL(list.size(), 1U);
421 BOOST_CHECK_EQUAL(std::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
422 BOOST_CHECK_EQUAL(list.begin()->second.size(), 2U);
423
424 // Lock both coins. Confirm number of available coins drops to 0.
425 {
426 LOCK(wallet->cs_wallet);
427 BOOST_CHECK_EQUAL(AvailableCoins(*wallet).Size(), 2U);
428 }
429 for (const auto& group : list) {
430 for (const auto& coin : group.second) {
431 LOCK(wallet->cs_wallet);
432 wallet->LockCoin(coin.outpoint, /*persist=*/false);
433 }
434 }
435 {
436 LOCK(wallet->cs_wallet);
437 BOOST_CHECK_EQUAL(AvailableCoins(*wallet).Size(), 0U);
438 }
439 // Confirm ListCoins still returns same result as before, despite coins
440 // being locked.
441 {
442 LOCK(wallet->cs_wallet);
443 list = ListCoins(*wallet);
444 }
445 BOOST_CHECK_EQUAL(list.size(), 1U);
446 BOOST_CHECK_EQUAL(std::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
447 BOOST_CHECK_EQUAL(list.begin()->second.size(), 2U);
448}
449
450void TestCoinsResult(ListCoinsTest& context, OutputType out_type, CAmount amount,
451 std::map<OutputType, size_t>& expected_coins_sizes)
452{
453 LOCK(context.wallet->cs_wallet);
454 util::Result<CTxDestination> dest = Assert(context.wallet->GetNewDestination(out_type, ""));
455 CWalletTx& wtx = context.AddTx(CRecipient{*dest, amount, /*fSubtractFeeFromAmount=*/true});
456 CoinFilterParams filter;
457 filter.skip_locked = false;
458 CoinsResult available_coins = AvailableCoins(*context.wallet, nullptr, std::nullopt, filter);
459 // Lock outputs so they are not spent in follow-up transactions
460 for (uint32_t i = 0; i < wtx.tx->vout.size(); i++) context.wallet->LockCoin({wtx.GetHash(), i}, /*persist=*/false);
461 for (const auto& [type, size] : expected_coins_sizes) BOOST_CHECK_EQUAL(size, available_coins.coins[type].size());
462}
463
464BOOST_FIXTURE_TEST_CASE(BasicOutputTypesTest, ListCoinsTest)
465{
466 std::map<OutputType, size_t> expected_coins_sizes;
467 for (const auto& out_type : OUTPUT_TYPES) { expected_coins_sizes[out_type] = 0U; }
468
469 // Verify our wallet has one usable coinbase UTXO before starting
470 // This UTXO is a P2PK, so it should show up in the Other bucket
471 expected_coins_sizes[OutputType::UNKNOWN] = 1U;
472 CoinsResult available_coins = WITH_LOCK(wallet->cs_wallet, return AvailableCoins(*wallet));
473 BOOST_CHECK_EQUAL(available_coins.Size(), expected_coins_sizes[OutputType::UNKNOWN]);
474 BOOST_CHECK_EQUAL(available_coins.coins[OutputType::UNKNOWN].size(), expected_coins_sizes[OutputType::UNKNOWN]);
475
476 // We will create a self transfer for each of the OutputTypes and
477 // verify it is put in the correct bucket after running GetAvailablecoins
478 //
479 // For each OutputType, We expect 2 UTXOs in our wallet following the self transfer:
480 // 1. One UTXO as the recipient
481 // 2. One UTXO from the change, due to payment address matching logic
482
483 for (const auto& out_type : OUTPUT_TYPES) {
484 if (out_type == OutputType::UNKNOWN) continue;
485 expected_coins_sizes[out_type] = 2U;
486 TestCoinsResult(*this, out_type, 1 * COIN, expected_coins_sizes);
487 }
488}
489
491{
492 const std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), "", CreateMockableWalletDatabase());
493 LOCK(wallet->cs_wallet);
494 wallet->SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
496 BOOST_CHECK(!wallet->GetNewDestination(OutputType::BECH32, ""));
497}
498
499// Explicit calculation which is used to test the wallet constant
500// We get the same virtual size due to rounding(weight/4) for both use_max_sig values
501static size_t CalculateNestedKeyhashInputSize(bool use_max_sig)
502{
503 // Generate ephemeral valid pubkey
504 CKey key = GenerateRandomKey();
505 CPubKey pubkey = key.GetPubKey();
506
507 // Generate pubkey hash
508 uint160 key_hash(Hash160(pubkey));
509
510 // Create inner-script to enter into keystore. Key hash can't be 0...
511 CScript inner_script = CScript() << OP_0 << std::vector<unsigned char>(key_hash.begin(), key_hash.end());
512
513 // Create outer P2SH script for the output
514 uint160 script_id(Hash160(inner_script));
515 CScript script_pubkey = CScript() << OP_HASH160 << std::vector<unsigned char>(script_id.begin(), script_id.end()) << OP_EQUAL;
516
517 // Add inner-script to key store and key to watchonly
519 keystore.AddCScript(inner_script);
520 keystore.AddKeyPubKey(key, pubkey);
521
522 // Fill in dummy signatures for fee calculation.
523 SignatureData sig_data;
524
525 if (!ProduceSignature(keystore, use_max_sig ? DUMMY_MAXIMUM_SIGNATURE_CREATOR : DUMMY_SIGNATURE_CREATOR, script_pubkey, sig_data)) {
526 // We're hand-feeding it correct arguments; shouldn't happen
527 assert(false);
528 }
529
530 CTxIn tx_in;
531 UpdateInput(tx_in, sig_data);
532 return (size_t)GetVirtualTransactionInputSize(tx_in);
533}
534
536{
539}
540
541bool malformed_descriptor(std::ios_base::failure e)
542{
543 std::string s(e.what());
544 return s.find("Missing checksum") != std::string::npos;
545}
546
548{
549 std::vector<unsigned char> malformed_record;
550 VectorWriter vw{malformed_record, 0};
551 vw << std::string("notadescriptor");
552 vw << uint64_t{0};
553 vw << int32_t{0};
554 vw << int32_t{0};
555 vw << int32_t{1};
556
557 SpanReader vr{malformed_record};
558 WalletDescriptor w_desc;
559 BOOST_CHECK_EXCEPTION(vr >> w_desc, std::ios_base::failure, malformed_descriptor);
560}
561
581{
582 m_args.ForceSetArg("-unsafesqlitesync", "1");
583 // Create new wallet with known key and unload it.
584 WalletContext context;
585 context.args = &m_args;
586 context.chain = m_node.chain.get();
587 auto wallet = TestLoadWallet(context);
588 CKey key = GenerateRandomKey();
589 AddKey(*wallet, key);
590 TestUnloadWallet(std::move(wallet));
591
592
593 // Add log hook to detect AddToWallet events from rescans, blockConnected,
594 // and transactionAddedToMempool notifications
595 int addtx_count = 0;
596 DebugLogHelper addtx_counter("[default wallet] AddToWallet", [&](const std::string* s) {
597 if (s) ++addtx_count;
598 return false;
599 });
600
601
602 bool rescan_completed = false;
603 DebugLogHelper rescan_check("[default wallet] Rescan completed", [&](const std::string* s) {
604 if (s) rescan_completed = true;
605 return false;
606 });
607
608
609 // Block the queue to prevent the wallet receiving blockConnected and
610 // transactionAddedToMempool notifications, and create block and mempool
611 // transactions paying to the wallet
612 std::promise<void> promise;
613 m_node.validation_signals->CallFunctionInValidationInterfaceQueue([&promise] {
614 promise.get_future().wait();
615 });
616 std::string error;
617 m_coinbase_txns.push_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
618 auto block_tx = TestSimpleSpend(*m_coinbase_txns[0], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
619 m_coinbase_txns.push_back(CreateAndProcessBlock({block_tx}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
620 auto mempool_tx = TestSimpleSpend(*m_coinbase_txns[1], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
621 BOOST_CHECK(m_node.chain->broadcastTransaction(MakeTransactionRef(mempool_tx), DEFAULT_TRANSACTION_MAXFEE, false, error));
622
623
624 // Reload wallet and make sure new transactions are detected despite events
625 // being blocked
626 // Loading will also ask for current mempool transactions
627 wallet = TestLoadWallet(context);
628 BOOST_CHECK(rescan_completed);
629 // AddToWallet events for block_tx and mempool_tx (x2)
630 BOOST_CHECK_EQUAL(addtx_count, 3);
631 {
632 LOCK(wallet->cs_wallet);
633 BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_tx.GetHash()), 1U);
634 BOOST_CHECK_EQUAL(wallet->mapWallet.count(mempool_tx.GetHash()), 1U);
635 }
636
637
638 // Unblock notification queue and make sure stale blockConnected and
639 // transactionAddedToMempool events are processed
640 promise.set_value();
641 m_node.validation_signals->SyncWithValidationInterfaceQueue();
642 // AddToWallet events for block_tx and mempool_tx events are counted a
643 // second time as the notification queue is processed
644 BOOST_CHECK_EQUAL(addtx_count, 5);
645
646
647 TestUnloadWallet(std::move(wallet));
648
649
650 // Load wallet again, this time creating new block and mempool transactions
651 // paying to the wallet as the wallet finishes loading and syncing the
652 // queue so the events have to be handled immediately. Releasing the wallet
653 // lock during the sync is a little artificial but is needed to avoid a
654 // deadlock during the sync and simulates a new block notification happening
655 // as soon as possible.
656 addtx_count = 0;
657 auto handler = HandleLoadWallet(context, [&](std::unique_ptr<interfaces::Wallet> wallet) {
658 BOOST_CHECK(rescan_completed);
659 m_coinbase_txns.push_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
660 block_tx = TestSimpleSpend(*m_coinbase_txns[2], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
661 m_coinbase_txns.push_back(CreateAndProcessBlock({block_tx}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
662 mempool_tx = TestSimpleSpend(*m_coinbase_txns[3], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
663 BOOST_CHECK(m_node.chain->broadcastTransaction(MakeTransactionRef(mempool_tx), DEFAULT_TRANSACTION_MAXFEE, false, error));
664 m_node.validation_signals->SyncWithValidationInterfaceQueue();
665 });
666 wallet = TestLoadWallet(context);
667 // Since mempool transactions are requested at the end of loading, there will
668 // be 2 additional AddToWallet calls, one from the previous test, and a duplicate for mempool_tx
669 BOOST_CHECK_EQUAL(addtx_count, 2 + 2);
670 {
671 LOCK(wallet->cs_wallet);
672 BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_tx.GetHash()), 1U);
673 BOOST_CHECK_EQUAL(wallet->mapWallet.count(mempool_tx.GetHash()), 1U);
674 }
675
676
677 TestUnloadWallet(std::move(wallet));
678}
679
681{
682 WalletContext context;
683 context.args = &m_args;
684 auto wallet = TestLoadWallet(context);
686 WaitForDeleteWallet(std::move(wallet));
687}
688
690{
691 m_args.ForceSetArg("-unsafesqlitesync", "1");
692 WalletContext context;
693 context.args = &m_args;
694 context.chain = m_node.chain.get();
695 auto wallet = TestLoadWallet(context);
696 CKey key = GenerateRandomKey();
697 AddKey(*wallet, key);
698
699 std::string error;
700 m_coinbase_txns.push_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
701 auto block_tx = TestSimpleSpend(*m_coinbase_txns[0], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
702 CreateAndProcessBlock({block_tx}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
703
704 m_node.validation_signals->SyncWithValidationInterfaceQueue();
705
706 {
707 auto block_hash = block_tx.GetHash();
708 auto prev_tx = m_coinbase_txns[0];
709
710 LOCK(wallet->cs_wallet);
711 BOOST_CHECK(wallet->HasWalletSpend(prev_tx));
712 BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_hash), 1u);
713
714 std::vector<Txid> vHashIn{ block_hash };
715 BOOST_CHECK(wallet->RemoveTxs(vHashIn));
716
717 BOOST_CHECK(!wallet->HasWalletSpend(prev_tx));
718 BOOST_CHECK_EQUAL(wallet->mapWallet.count(block_hash), 0u);
719 }
720
721 TestUnloadWallet(std::move(wallet));
722}
723
725} // namespace wallet
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:413
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:898
node::BlockMap & BlockIndex() EXCLUSIVE_LOCKS_REQUIRED(
Definition: validation.h:1137
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)
Minimal stream for reading from an existing byte array by std::span.
Definition: streams.h:83
constexpr bool IsNull() const
Definition: uint256.h:48
constexpr unsigned char * end()
Definition: uint256.h:102
constexpr unsigned char * begin()
Definition: uint256.h:101
160-bit opaque blob.
Definition: uint256.h:184
256-bit opaque blob.
Definition: uint256.h:196
Coin Control Features.
Definition: coincontrol.h:83
A CWallet maintains a set of transactions and balances, and provides the ability to create new transa...
Definition: wallet.h:311
A transaction with a bunch of additional info that only the owner cares about.
Definition: transaction.h:195
CTransactionRef tx
Definition: transaction.h:267
CWalletTx & AddTx(CRecipient recipient)
std::unique_ptr< CWallet > wallet
Access to the wallet database.
Definition: walletdb.h:190
Descriptor with some wallet metadata.
Definition: walletutil.h:64
RAII object to check and reserve a wallet rescan.
Definition: wallet.h:1075
void setNow(NowFn now)
Definition: wallet.h:1105
bool reserve(bool with_passphrase=false)
Definition: wallet.h:1085
static UniValue Parse(std::string_view raw)
Parse string to UniValue or throw runtime_error if string contains invalid JSON.
Definition: client.cpp:321
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: interfaces.cpp:989
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:144
static CMutableTransaction TestSimpleSpend(const CTransaction &from, uint32_t index, const CKey &key, const CScript &pubkey)
Balance GetBalance(const CWallet &wallet, const int min_depth, bool avoid_reuse)
Definition: receive.cpp:242
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:1406
constexpr CAmount DEFAULT_TRANSACTION_MAXFEE
-maxtxfee default
Definition: wallet.h:138
static bool RunWithinTxn(WalletBatch &batch, std::string_view process_desc, const std::function< bool(WalletBatch &)> &func)
Definition: walletdb.cpp:1203
std::variant< TxStateConfirmed, TxStateInMempool, TxStateBlockConflicted, TxStateInactive, TxStateUnrecognized > TxState
All possible CWalletTx states.
Definition: transaction.h:79
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:50
DatabaseFormat
Definition: db.h:167
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:95
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:108
std::unique_ptr< interfaces::Handler > HandleLoadWallet(WalletContext &context, LoadWalletFn load_wallet)
Definition: wallet.cpp:215
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:111
void TestUnloadWallet(std::shared_ptr< CWallet > &&wallet)
Definition: util.cpp:73
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:2828
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:544
std::unique_ptr< WalletDatabase > CreateMockableWalletDatabase(MockableData records)
Definition: util.cpp:186
BOOST_AUTO_TEST_CASE(bnb_test)
static void AddKey(CWallet &wallet, const CKey &key)
static const CAmount WALLET_INCREMENTAL_RELAY_FEE
minimum recommended increment for replacement txs
Definition: wallet.h:125
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:376
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:53
@ WALLET_FLAG_DISABLE_PRIVATE_KEYS
Definition: walletutil.h:30
void WaitForDeleteWallet(std::shared_ptr< CWallet > &&wallet)
Explicitly delete the wallet.
Definition: wallet.cpp:253
static size_t CalculateNestedKeyhashInputSize(bool use_max_sig)
BOOST_FIXTURE_TEST_CASE(RemoveTxs, TestChain100Setup)
DatabaseStatus
Definition: db.h:186
#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:386
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:44
static constexpr unsigned int DEFAULT_MIN_RELAY_TX_FEE
Default for -minrelaytxfee, minimum relay fee for transactions.
Definition: policy.h:66
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:463
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:1118
const char * name
Definition: rest.cpp:50
@ 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
std::vector< uint256 > vHave
Definition: block.h:134
bool IsNull() const
Definition: block.h:152
A mutable version of CTransaction.
Definition: transaction.h:378
std::vector< CTxOut > vout
Definition: transaction.h:380
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:643
enum wallet::CWallet::ScanResult::@19 status
uint256 last_scanned_block
Hash and height of most recent block that was successfully scanned.
Definition: wallet.h:642
uint256 last_failed_block
Height of the most recent block that could not be scanned due to read errors or pruning.
Definition: wallet.h:649
COutputs available for spending, stored by OutputType.
Definition: spend.h:45
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:194
std::map< OutputType, std::vector< COutput > > coins
Definition: spend.h:46
std::optional< DatabaseFormat > require_format
Definition: db.h:175
State of transaction confirmed in a block.
Definition: transaction.h:32
State of transaction not confirmed or conflicting with a known block and not in the mempool.
Definition: transaction.h:59
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:259
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:290
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:51
#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:533
static void AvailableCoins(benchmark::Bench &bench, const std::vector< OutputType > &output_type)