Inside Bitcoin

251{
252    auto chain = m_node.chain.get();
253    const auto NUM_WALLETS{5};
254
255    // Since we're counting the number of wallets, ensure we start without any.
256    BOOST_REQUIRE(chain->getRwSetting("wallet").isNull());
257
258    const auto& check_concurrent_wallet = [&](const auto& settings_function, int num_expected_wallets) {
259        std::vector<std::thread> threads;
260        threads.reserve(NUM_WALLETS);
261        for (auto i{0}; i < NUM_WALLETS; ++i) threads.emplace_back(settings_function, i);
262        for (auto& t : threads) t.join();
263
264        auto wallets = chain->getRwSetting("wallet");
265        BOOST_CHECK_EQUAL(wallets.getValues().size(), num_expected_wallets);
266    };
267
268    // Add NUM_WALLETS wallets concurrently, ensure we end up with NUM_WALLETS stored.
269    check_concurrent_wallet([&chain](int i) {
270        Assert(AddWalletSetting(*chain, strprintf("wallet_%d", i)));
271    },
272                            /*num_expected_wallets=*/NUM_WALLETS);
273
274    // Remove NUM_WALLETS wallets concurrently, ensure we end up with 0 wallets.
275    check_concurrent_wallet([&chain](int i) {
276        Assert(RemoveWalletSetting(*chain, strprintf("wallet_%d", i)));
277    },
278                            /*num_expected_wallets=*/0);
279}
280
281static int64_t AddTx(ChainstateManager& chainman, CWallet& wallet, uint32_t lockTime, std::chrono::seconds mock_time, int64_t blockTime)
282{
283    CMutableTransaction tx;
284    TxState state = TxStateInactive{};
285    tx.nLockTime = lockTime;
286    FakeNodeClock clock{mock_time};
287    CBlockIndex* block = nullptr;
288    if (blockTime > 0) {
289        LOCK(cs_main);
290        auto inserted = chainman.BlockIndex().emplace(std::piecewise_construct, std::make_tuple(GetRandHash()), std::make_tuple());
291        assert(inserted.second);
292        const uint256& hash = inserted.first->first;
293        block = &inserted.first->second;
294        block->nTime = blockTime;
295        block->phashBlock = &hash;
296        state = TxStateConfirmed{hash, block->nHeight, /*index=*/0};
297    }
298    return wallet.AddToWallet(MakeTransactionRef(tx), state, [&](CWalletTx& wtx, bool /* new_tx */) {
299        // Assign wtx.m_state to simplify test and avoid the need to simulate
300        // reorg events. Without this, AddToWallet asserts false when the same
301        // transaction is confirmed in different blocks.
302        wtx.m_state = state;
303        return true;
304    })->nTimeSmart;
305}
306
307// Simple test to verify assignment of CWalletTx::nSmartTime value. Could be
308// expanded to cover more corner cases of smart time logic.
309BOOST_AUTO_TEST_CASE(ComputeTimeSmart)
310{
311    // New transaction should use clock time if lower than block time.
312    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 1, 100s, 120), 100);
313
314    // Test that updating existing transaction does not change smart time.
315    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 1, 200s, 220), 100);
316
317    // New transaction should use clock time if there's no block time.
318    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 2, 300s, 0), 300);
319
320    // New transaction should use block time if lower than clock time.
321    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 3, 420s, 400), 400);
322
323    // New transaction should use latest entry time if higher than
324    // min(block time, clock time).
325    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 4, 500s, 390), 400);
326
327    // If there are future entries, new transaction should use time of the
328    // newest entry that is no more than 300 seconds ahead of the clock time.
329    BOOST_CHECK_EQUAL(AddTx(*m_node.chainman, m_wallet, 5, 50s, 600), 300);
330}
331
332void TestLoadWallet(const std::string& name, DatabaseFormat format, std::function<void(std::shared_ptr<CWallet>)> f)
333{
334    node::NodeContext node;
335    auto chain{interfaces::MakeChain(node)};
336    DatabaseOptions options;
337    options.require_format = format;
338    DatabaseStatus status;
339    bilingual_str error;
340    std::vector<bilingual_str> warnings;
341    auto database{MakeWalletDatabase(name, options, status, error)};
342    auto wallet{std::make_shared<CWallet>(chain.get(), "", std::move(database))};
343    BOOST_CHECK_EQUAL(wallet->PopulateWalletFromDB(error, warnings), DBErrors::LOAD_OK);
344    WITH_LOCK(wallet->cs_wallet, f(wallet));
345}
346
347BOOST_FIXTURE_TEST_CASE(LoadReceiveRequests, TestingSetup)
348{
349    for (DatabaseFormat format : DATABASE_FORMATS) {
350        const std::string name{strprintf("receive-requests-%i", format)};
351        TestLoadWallet(name, format, [](std::shared_ptr<CWallet> wallet) EXCLUSIVE_LOCKS_REQUIRED(wallet->cs_wallet) {
352            BOOST_CHECK(!wallet->IsAddressPreviouslySpent(PKHash()));
353            WalletBatch batch{wallet->GetDatabase()};
354            BOOST_CHECK(batch.WriteAddressPreviouslySpent(PKHash(), true));
355            BOOST_CHECK(batch.WriteAddressPreviouslySpent(ScriptHash(), true));
356            BOOST_CHECK(wallet->SetAddressReceiveRequest(batch, PKHash(), "0", "val_rr00"));
357            BOOST_CHECK(wallet->EraseAddressReceiveRequest(batch, PKHash(), "0"));
358            BOOST_CHECK(wallet->SetAddressReceiveRequest(batch, PKHash(), "1", "val_rr10"));
359            BOOST_CHECK(wallet->SetAddressReceiveRequest(batch, PKHash(), "1", "val_rr11"));
360            BOOST_CHECK(wallet->SetAddressReceiveRequest(batch, ScriptHash(), "2", "val_rr20"));
361        });
362        TestLoadWallet(name, format, [](std::shared_ptr<CWallet> wallet) EXCLUSIVE_LOCKS_REQUIRED(wallet->cs_wallet) {
363            BOOST_CHECK(wallet->IsAddressPreviouslySpent(PKHash()));
364            BOOST_CHECK(wallet->IsAddressPreviouslySpent(ScriptHash()));
365            auto requests = wallet->GetAddressReceiveRequests();
366            auto erequests = {"val_rr11", "val_rr20"};
367            BOOST_CHECK_EQUAL_COLLECTIONS(requests.begin(), requests.end(), std::begin(erequests), std::end(erequests));
368            RunWithinTxn(wallet->GetDatabase(), /*process_desc=*/"test", [](WalletBatch& batch){
369                BOOST_CHECK(batch.WriteAddressPreviouslySpent(PKHash(), false));
370                BOOST_CHECK(batch.EraseAddressData(ScriptHash()));
371                return true;
372            });
373        });
374        TestLoadWallet(name, format, [](std::shared_ptr<CWallet> wallet) EXCLUSIVE_LOCKS_REQUIRED(wallet->cs_wallet) {
375            BOOST_CHECK(!wallet->IsAddressPreviouslySpent(PKHash()));
376            BOOST_CHECK(!wallet->IsAddressPreviouslySpent(ScriptHash()));
377            auto requests = wallet->GetAddressReceiveRequests();
378            auto erequests = {"val_rr11"};
379            BOOST_CHECK_EQUAL_COLLECTIONS(requests.begin(), requests.end(), std::begin(erequests), std::end(erequests));
380        });
381    }
382}
383
384class ListCoinsTestingSetup : public TestChain100Setup
385{
386public:
387    ListCoinsTestingSetup()
388    {
389        CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
390        wallet = CreateSyncedWallet(*m_node.chain, WITH_LOCK(Assert(m_node.chainman)->GetMutex(), return m_node.chainman->ActiveChain()), coinbaseKey);
391    }
392
393    ~ListCoinsTestingSetup()
394    {
395        wallet.reset();
396    }
397
398    CWalletTx& AddTx(CRecipient recipient)
399    {
400        CTransactionRef tx;
401        CCoinControl dummy;
402        {
403            auto res = CreateTransaction(*wallet, {recipient}, /*change_pos=*/std::nullopt, dummy);
404            BOOST_CHECK(res);
405            tx = res->tx;
406        }
407        wallet->CommitTransaction(tx);
408        CMutableTransaction blocktx;
409        {
410            LOCK(wallet->cs_wallet);
411            blocktx = CMutableTransaction(*wallet->mapWallet.at(tx->GetHash()).GetTx());
412        }
413        CreateAndProcessBlock({CMutableTransaction(blocktx)}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
414
415        LOCK(wallet->cs_wallet);
416        LOCK(Assert(m_node.chainman)->GetMutex());
417        wallet->SetLastBlockProcessed(wallet->GetLastBlockHeight() + 1, m_node.chainman->ActiveChain().Tip()->GetBlockHash());
418        auto it = wallet->mapWallet.find(tx->GetHash());
419        BOOST_CHECK(it != wallet->mapWallet.end());
420        it->second.m_state = TxStateConfirmed{m_node.chainman->ActiveChain().Tip()->GetBlockHash(), m_node.chainman->ActiveChain().Height(), /*index=*/1};
421        return it->second;
422    }
423
424    std::unique_ptr<CWallet> wallet;
425};
426
427BOOST_FIXTURE_TEST_CASE(ListCoinsTest, ListCoinsTestingSetup)
428{
429    std::string coinbaseAddress = coinbaseKey.GetPubKey().GetID().ToString();
430
431    // Confirm ListCoins initially returns 1 coin grouped under coinbaseKey
432    // address.
433    std::map<CTxDestination, std::vector<COutput>> list;
434    {
435        LOCK(wallet->cs_wallet);
436        list = ListCoins(*wallet);
437    }
438    BOOST_CHECK_EQUAL(list.size(), 1U);
439    BOOST_CHECK_EQUAL(std::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
440    BOOST_CHECK_EQUAL(list.begin()->second.size(), 1U);
441
442    // Check initial balance from one mature coinbase transaction.
443    BOOST_CHECK_EQUAL(50 * COIN, WITH_LOCK(wallet->cs_wallet, return AvailableCoins(*wallet).GetTotalAmount()));
444
445    // Add a transaction creating a change address, and confirm ListCoins still
446    // returns the coin associated with the change address underneath the
447    // coinbaseKey pubkey, even though the change address has a different
448    // pubkey.
449    AddTx(CRecipient{PubKeyDestination{{}}, 1 * COIN, /*subtract_fee=*/false});
450    {
451        LOCK(wallet->cs_wallet);
452        list = ListCoins(*wallet);
453    }
454    BOOST_CHECK_EQUAL(list.size(), 1U);
455    BOOST_CHECK_EQUAL(std::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
456    BOOST_CHECK_EQUAL(list.begin()->second.size(), 2U);
457
458    // Lock both coins. Confirm number of available coins drops to 0.
459    {
460        LOCK(wallet->cs_wallet);
461        BOOST_CHECK_EQUAL(AvailableCoins(*wallet).Size(), 2U);
462    }
463    for (const auto& group : list) {
464        for (const auto& coin : group.second) {
465            LOCK(wallet->cs_wallet);
466            wallet->LockCoin(coin.outpoint, /*persist=*/false);
467        }
468    }
469    {
470        LOCK(wallet->cs_wallet);
471        BOOST_CHECK_EQUAL(AvailableCoins(*wallet).Size(), 0U);
472    }
473    // Confirm ListCoins still returns same result as before, despite coins
474    // being locked.
475    {
476        LOCK(wallet->cs_wallet);
477        list = ListCoins(*wallet);
478    }
479    BOOST_CHECK_EQUAL(list.size(), 1U);
480    BOOST_CHECK_EQUAL(std::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
481    BOOST_CHECK_EQUAL(list.begin()->second.size(), 2U);
482}
483
484void TestCoinsResult(ListCoinsTest& context, OutputType out_type, CAmount amount,
485                     std::map<OutputType, size_t>& expected_coins_sizes)
486{
487    LOCK(context.wallet->cs_wallet);
488    util::Result<CTxDestination> dest = Assert(context.wallet->GetNewDestination(out_type, ""));
489    CWalletTx& wtx = context.AddTx(CRecipient{*dest, amount, /*fSubtractFeeFromAmount=*/true});
490    CoinFilterParams filter;
491    filter.skip_locked = false;
492    CoinsResult available_coins = AvailableCoins(*context.wallet, nullptr, std::nullopt, filter);
493    // Lock outputs so they are not spent in follow-up transactions
494    for (uint32_t i = 0; i < wtx.GetTx()->vout.size(); i++) context.wallet->LockCoin({wtx.GetHash(), i}, /*persist=*/false);
495    for (const auto& [type, size] : expected_coins_sizes) BOOST_CHECK_EQUAL(size, available_coins.coins[type].size());
496}
497
498BOOST_FIXTURE_TEST_CASE(BasicOutputTypesTest, ListCoinsTest)
499{
500    std::map<OutputType, size_t> expected_coins_sizes;