Inside Bitcoin

501    for (const auto& out_type : OUTPUT_TYPES) { expected_coins_sizes[out_type] = 0U; }
502
503    // Verify our wallet has one usable coinbase UTXO before starting
504    // This UTXO is a P2PK, so it should show up in the Other bucket
505    expected_coins_sizes[OutputType::UNKNOWN] = 1U;
506    CoinsResult available_coins = WITH_LOCK(wallet->cs_wallet, return AvailableCoins(*wallet));
507    BOOST_CHECK_EQUAL(available_coins.Size(), expected_coins_sizes[OutputType::UNKNOWN]);
508    BOOST_CHECK_EQUAL(available_coins.coins[OutputType::UNKNOWN].size(), expected_coins_sizes[OutputType::UNKNOWN]);
509
510    // We will create a self transfer for each of the OutputTypes and
511    // verify it is put in the correct bucket after running GetAvailablecoins
512    //
513    // For each OutputType, We expect 2 UTXOs in our wallet following the self transfer:
514    //   1. One UTXO as the recipient
515    //   2. One UTXO from the change, due to payment address matching logic
516
517    for (const auto& out_type : OUTPUT_TYPES) {
518        if (out_type == OutputType::UNKNOWN) continue;
519        expected_coins_sizes[out_type] = 2U;
520        TestCoinsResult(*this, out_type, 1 * COIN, expected_coins_sizes);
521    }
522}
523
524BOOST_FIXTURE_TEST_CASE(wallet_disableprivkeys, TestChain100Setup)
525{
526    const std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), "", CreateMockableWalletDatabase());
527    LOCK(wallet->cs_wallet);
528    wallet->SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
529    wallet->SetWalletFlag(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
530    BOOST_CHECK(!wallet->GetNewDestination(OutputType::BECH32, ""));
531}
532
533// Explicit calculation which is used to test the wallet constant
534// We get the same virtual size due to rounding(weight/4) for both use_max_sig values
535static size_t CalculateNestedKeyhashInputSize(bool use_max_sig)
536{
537    // Generate ephemeral valid pubkey
538    CKey key = GenerateRandomKey();
539    CPubKey pubkey = key.GetPubKey();
540
541    // Generate pubkey hash
542    uint160 key_hash(Hash160(pubkey));
543
544    // Create inner-script to enter into keystore. Key hash can't be 0...
545    CScript inner_script = CScript() << OP_0 << std::vector<unsigned char>(key_hash.begin(), key_hash.end());
546
547    // Create outer P2SH script for the output
548    uint160 script_id(Hash160(inner_script));
549    CScript script_pubkey = CScript() << OP_HASH160 << std::vector<unsigned char>(script_id.begin(), script_id.end()) << OP_EQUAL;
550
551    // Add inner-script to key store and key to watchonly
552    FillableSigningProvider keystore;
553    keystore.AddCScript(inner_script);
554    keystore.AddKeyPubKey(key, pubkey);
555
556    // Fill in dummy signatures for fee calculation.
557    SignatureData sig_data;
558
559    if (!ProduceSignature(keystore, use_max_sig ? DUMMY_MAXIMUM_SIGNATURE_CREATOR : DUMMY_SIGNATURE_CREATOR, script_pubkey, sig_data)) {
560        // We're hand-feeding it correct arguments; shouldn't happen
561        assert(false);
562    }
563
564    CTxIn tx_in;
565    UpdateInput(tx_in, sig_data);
566    return (size_t)GetVirtualTransactionInputSize(tx_in);
567}
568
569BOOST_FIXTURE_TEST_CASE(dummy_input_size_test, TestChain100Setup)
570{
571    BOOST_CHECK_EQUAL(CalculateNestedKeyhashInputSize(false), DUMMY_NESTED_P2WPKH_INPUT_SIZE);
572    BOOST_CHECK_EQUAL(CalculateNestedKeyhashInputSize(true), DUMMY_NESTED_P2WPKH_INPUT_SIZE);
573}
574
575bool malformed_descriptor(std::ios_base::failure e)
576{
577    std::string s(e.what());
578    return s.find("Missing checksum") != std::string::npos;
579}
580
581BOOST_FIXTURE_TEST_CASE(wallet_descriptor_test, BasicTestingSetup)
582{
583    std::vector<unsigned char> malformed_record;
584    VectorWriter vw{malformed_record, 0};
585    vw << std::string("notadescriptor");
586    vw << uint64_t{0};
587    vw << int32_t{0};
588    vw << int32_t{0};
589    vw << int32_t{1};
590
591    SpanReader vr{malformed_record};
592    std::optional<WalletDescriptor> w_desc;
593    BOOST_CHECK_EXCEPTION(w_desc.emplace(WalletDescriptor::FromStream(deserialize, vr)), std::ios_base::failure, malformed_descriptor);
594}
595
596//! Test CWallet::CreateNew() and its behavior handling potential race
597//! conditions if it's called the same time an incoming transaction shows up in
598//! the mempool or a new block.
599//!
600//! It isn't possible to verify there aren't race condition in every case, so
601//! this test just checks two specific cases and ensures that timing of
602//! notifications in these cases doesn't prevent the wallet from detecting
603//! transactions.
604//!
605//! In the first case, block and mempool transactions are created before the
606//! wallet is loaded, but notifications about these transactions are delayed
607//! until after it is loaded. The notifications are superfluous in this case, so
608//! the test verifies the transactions are detected before they arrive.
609//!
610//! In the second case, block and mempool transactions are created after the
611//! wallet rescan and notifications are immediately synced, to verify the wallet
612//! must already have a handler in place for them, and there's no gap after
613//! rescanning where new transactions in new blocks could be lost.
614BOOST_FIXTURE_TEST_CASE(CreateWallet, TestChain100Setup)
615{
616    m_args.ForceSetArg("-unsafesqlitesync", "1");
617    // Create new wallet with known key and unload it.
618    WalletContext context;
619    context.args = &m_args;
620    context.chain = m_node.chain.get();
621    auto wallet = TestCreateWallet(context);
622    CKey key = GenerateRandomKey();
623    AddKey(*wallet, key);
624    TestUnloadWallet(std::move(wallet));
625
626
627    // Add log hook to detect AddToWallet events from rescans, blockConnected,
628    // and transactionAddedToMempool notifications
629    int addtx_count = 0;
630    DebugLogHelper addtx_counter("[default wallet] AddToWallet", [&](const std::string* s) {
631        if (s) ++addtx_count;
632        return false;
633    });
634
635
636    bool rescan_completed = false;
637    DebugLogHelper rescan_check("[default wallet] Rescan completed", [&](const std::string* s) {
638        if (s) rescan_completed = true;
639        return false;
640    });
641
642
643    // Block the queue to prevent the wallet receiving blockConnected and
644    // transactionAddedToMempool notifications, and create block and mempool
645    // transactions paying to the wallet
646    std::promise<void> promise;
647    m_node.validation_signals->CallFunctionInValidationInterfaceQueue([&promise] {
648        promise.get_future().wait();
649    });
650    std::string error;
651    m_coinbase_txns.push_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
652    auto block_tx = TestSimpleSpend(*m_coinbase_txns[0], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
653    m_coinbase_txns.push_back(CreateAndProcessBlock({block_tx}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
654    auto mempool_tx = TestSimpleSpend(*m_coinbase_txns[1], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
655    BOOST_CHECK(m_node.chain->broadcastTransaction(MakeTransactionRef(mempool_tx), DEFAULT_TRANSACTION_MAXFEE, node::TxBroadcast::MEMPOOL_NO_BROADCAST, error));
656
657
658    // Reload wallet and make sure new transactions are detected despite events
659    // being blocked
660    // Loading will also ask for current mempool transactions
661    wallet = TestLoadWallet(context);
662    BOOST_CHECK(rescan_completed);
663    // AddToWallet events for block_tx and mempool_tx (x2)
664    BOOST_CHECK_EQUAL(addtx_count, 3);
665    {
666        LOCK(wallet->cs_wallet);
667        BOOST_CHECK(wallet->mapWallet.contains(block_tx.GetHash()));
668        BOOST_CHECK(wallet->mapWallet.contains(mempool_tx.GetHash()));
669    }
670
671
672    // Unblock notification queue and make sure stale blockConnected and
673    // transactionAddedToMempool events are processed
674    promise.set_value();
675    m_node.validation_signals->SyncWithValidationInterfaceQueue();
676    // AddToWallet events for block_tx and mempool_tx events are counted a
677    // second time as the notification queue is processed
678    BOOST_CHECK_EQUAL(addtx_count, 5);
679
680
681    TestUnloadWallet(std::move(wallet));
682
683
684    // Load wallet again, this time creating new block and mempool transactions
685    // paying to the wallet as the wallet finishes loading and syncing the
686    // queue so the events have to be handled immediately. Releasing the wallet
687    // lock during the sync is a little artificial but is needed to avoid a
688    // deadlock during the sync and simulates a new block notification happening
689    // as soon as possible.
690    addtx_count = 0;
691    auto handler = HandleLoadWallet(context, [&](std::unique_ptr<interfaces::Wallet> wallet) {
692            BOOST_CHECK(rescan_completed);
693            m_coinbase_txns.push_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
694            block_tx = TestSimpleSpend(*m_coinbase_txns[2], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
695            m_coinbase_txns.push_back(CreateAndProcessBlock({block_tx}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
696            mempool_tx = TestSimpleSpend(*m_coinbase_txns[3], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
697            BOOST_CHECK(m_node.chain->broadcastTransaction(MakeTransactionRef(mempool_tx), DEFAULT_TRANSACTION_MAXFEE, node::TxBroadcast::MEMPOOL_NO_BROADCAST, error));
698            m_node.validation_signals->SyncWithValidationInterfaceQueue();
699        });
700    wallet = TestLoadWallet(context);
701    // Since mempool transactions are requested at the end of loading, there will
702    // be 2 additional AddToWallet calls, one from the previous test, and a duplicate for mempool_tx
703    BOOST_CHECK_EQUAL(addtx_count, 2 + 2);
704    {
705        LOCK(wallet->cs_wallet);
706        BOOST_CHECK(wallet->mapWallet.contains(block_tx.GetHash()));
707        BOOST_CHECK(wallet->mapWallet.contains(mempool_tx.GetHash()));
708    }
709
710
711    TestUnloadWallet(std::move(wallet));
712}
713
714BOOST_FIXTURE_TEST_CASE(CreateWalletWithoutChain, BasicTestingSetup)
715{
716    WalletContext context;
717    context.args = &m_args;
718    auto wallet = TestCreateWallet(context);
719    BOOST_CHECK(wallet);
720    WaitForDeleteWallet(std::move(wallet));
721}
722
723BOOST_FIXTURE_TEST_CASE(RemoveTxs, TestChain100Setup)
724{
725    m_args.ForceSetArg("-unsafesqlitesync", "1");
726    WalletContext context;
727    context.args = &m_args;
728    context.chain = m_node.chain.get();
729    auto wallet = TestCreateWallet(context);
730    CKey key = GenerateRandomKey();
731    AddKey(*wallet, key);
732
733    m_coinbase_txns.push_back(CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())).vtx[0]);
734    auto block_tx = TestSimpleSpend(*m_coinbase_txns[0], 0, coinbaseKey, GetScriptForRawPubKey(key.GetPubKey()));
735    CreateAndProcessBlock({block_tx}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
736
737    m_node.validation_signals->SyncWithValidationInterfaceQueue();
738
739    {
740        auto block_hash = block_tx.GetHash();
741        auto prev_tx = m_coinbase_txns[0];
742
743        LOCK(wallet->cs_wallet);
744        BOOST_CHECK(wallet->HasWalletSpend(prev_tx));
745        BOOST_CHECK(wallet->mapWallet.contains(block_hash));
746
747        std::vector<Txid> vHashIn{ block_hash };
748        BOOST_CHECK(wallet->RemoveTxs(vHashIn));
749
750        BOOST_CHECK(!wallet->HasWalletSpend(prev_tx));