Inside Bitcoin

251BasicTestingSetup::~BasicTestingSetup()
252{
253    m_node.ecc_context.reset();
254    m_node.kernel.reset();
255    if (!EnableFuzzDeterminism()) {
256        SetMockTime(0s); // Reset mocktime for following tests
257    }
258    LogInstance().DisconnectTestLogger();
259    if (m_has_custom_datadir) {
260        // Only remove the lock file, preserve the data directory.
261        UnlockDirectory(m_path_lock, ".lock");
262        fs::remove(m_path_lock / ".lock");
263    } else {
264        fs::remove_all(m_path_root);
265    }
266    // Clear all arguments except for -datadir, which GUI tests currently rely
267    // on to be set even after the testing setup is destroyed.
268    gArgs.ClearArgs();
269    gArgs.ForceSetArg("-datadir", fs::PathToString(m_path_root));
270}
271
272ChainTestingSetup::ChainTestingSetup(const ChainType chainType, TestOpts opts)
273    : BasicTestingSetup(chainType, opts)
274{
275    const CChainParams& chainparams = Params();
276
277    // A task runner is required to prevent ActivateBestChain
278    // from blocking due to queue overrun.
279    if (opts.setup_validation_interface) {
280        m_node.scheduler = std::make_unique<CScheduler>();
281        m_node.scheduler->m_service_thread = std::thread(util::TraceThread, "scheduler", [&] { m_node.scheduler->serviceQueue(); });
282        m_node.validation_signals =
283            // Use synchronous task runner while fuzzing to avoid non-determinism
284            EnableFuzzDeterminism() ?
285                std::make_unique<ValidationSignals>(std::make_unique<util::ImmediateTaskRunner>()) :
286                std::make_unique<ValidationSignals>(std::make_unique<SerialTaskRunner>(*m_node.scheduler));
287        {
288            // Ensure deterministic coverage by waiting for m_service_thread to be running
289            std::promise<void> promise;
290            m_node.scheduler->scheduleFromNow([&promise] { promise.set_value(); }, 0ms);
291            promise.get_future().wait();
292        }
293    }
294
295    bilingual_str error{};
296    m_node.mempool = std::make_unique<CTxMemPool>(MemPoolOptionsForTest(m_node), error);
297    Assert(error.empty());
298    m_node.warnings = std::make_unique<node::Warnings>();
299
300    m_node.notifications = std::make_unique<KernelNotifications>(Assert(m_node.shutdown_request), m_node.exit_status, *Assert(m_node.warnings));
301
302    m_make_chainman = [this, &chainparams, opts] {
303        Assert(!m_node.chainman);
304        ChainstateManager::Options chainman_opts{
305            .chainparams = chainparams,
306            .datadir = m_args.GetDataDirNet(),
307            .check_block_index = 1,
308            .notifications = *m_node.notifications,
309            .signals = m_node.validation_signals.get(),
310            // Use no worker threads while fuzzing to avoid racy non-determinism
311            // and dangling thread handles if AFL forks after initialization.
312            .worker_threads_num = EnableFuzzDeterminism() ? 0 : 2,
313            .prevoutfetch_threads_num = EnableFuzzDeterminism() ? 0 : 2,
314        };
315        if (opts.min_validation_cache) {
316            chainman_opts.script_execution_cache_bytes = 0;
317            chainman_opts.signature_cache_bytes = 0;
318        }
319        const BlockManager::Options blockman_opts{
320            .chainparams = chainman_opts.chainparams,
321            .blocks_dir = m_args.GetBlocksDirPath(),
322            .notifications = chainman_opts.notifications,
323            .block_tree_db_params = DBParams{
324                .path = m_args.GetDataDirNet() / "blocks" / "index",
325                .cache_bytes = m_kernel_cache_sizes.block_tree_db,
326                .memory_only = opts.block_tree_db_in_memory,
327                .wipe_data = m_args.GetBoolArg("-reindex", false),
328            },
329        };
330        m_node.chainman = std::make_unique<ChainstateManager>(*Assert(m_node.shutdown_signal), chainman_opts, blockman_opts);
331    };
332    m_make_chainman();
333}
334
335ChainTestingSetup::~ChainTestingSetup()
336{
337    if (m_node.scheduler) m_node.scheduler->stop();
338    if (m_node.validation_signals) m_node.validation_signals->FlushBackgroundCallbacks();
339    m_node.connman.reset();
340    m_node.banman.reset();
341    m_node.addrman.reset();
342    m_node.netgroupman.reset();
343    m_node.args = nullptr;
344    m_node.mempool.reset();
345    Assert(!m_node.fee_estimator_man); // Each test must create a local object, if they wish to use the fee_estimator_man
346    m_node.chainman.reset();
347    m_node.validation_signals.reset();
348    m_node.scheduler.reset();
349}
350
351void ChainTestingSetup::LoadVerifyActivateChainstate()
352{
353    auto& chainman{*Assert(m_node.chainman)};
354    node::ChainstateLoadOptions options;
355    options.mempool = Assert(m_node.mempool.get());
356    options.coins_db_in_memory = m_coins_db_in_memory;
357    options.wipe_chainstate_db = m_args.GetBoolArg("-reindex", false) || m_args.GetBoolArg("-reindex-chainstate", false);
358    options.prune = chainman.m_blockman.IsPruneMode();
359    options.check_blocks = m_args.GetIntArg("-checkblocks", DEFAULT_CHECKBLOCKS);
360    options.check_level = m_args.GetIntArg("-checklevel", DEFAULT_CHECKLEVEL);
361    options.require_full_verification = m_args.IsArgSet("-checkblocks") || m_args.IsArgSet("-checklevel");
362    auto [status, error] = LoadChainstate(chainman, m_kernel_cache_sizes, options);
363    assert(status == node::ChainstateLoadStatus::SUCCESS);
364
365    std::tie(status, error) = VerifyLoadedChainstate(chainman, options);
366    assert(status == node::ChainstateLoadStatus::SUCCESS);
367
368    m_node.notifications->setChainstateLoaded(true);
369
370    BlockValidationState state;
371    if (!chainman.ActiveChainstate().ActivateBestChain(state)) {
372        throw std::runtime_error(strprintf("ActivateBestChain failed. (%s)", state.ToString()));
373    }
374}
375
376TestingSetup::TestingSetup(
377    const ChainType chainType,
378    TestOpts opts)
379    : ChainTestingSetup(chainType, opts)
380{
381    m_coins_db_in_memory = opts.coins_db_in_memory;
382    m_block_tree_db_in_memory = opts.block_tree_db_in_memory;
383    // Ideally we'd move all the RPC tests to the functional testing framework
384    // instead of unit tests, but for now we need these here.
385    RegisterAllCoreRPCCommands(tableRPC);
386
387    LoadVerifyActivateChainstate();
388
389    if (!opts.setup_net) return;
390
391    m_node.netgroupman = std::make_unique<NetGroupManager>(NetGroupManager::NoAsmap());
392    m_node.addrman = std::make_unique<AddrMan>(*m_node.netgroupman,
393                                               /*deterministic=*/false,
394                                               m_node.args->GetIntArg("-checkaddrman", 0));
395    m_node.banman = std::make_unique<BanMan>(m_args.GetDataDirBase() / "banlist", nullptr, DEFAULT_MISBEHAVING_BANTIME);
396    m_node.connman = std::make_unique<ConnmanTestMsg>(0x1337, 0x1337, *m_node.addrman, *m_node.netgroupman, Params()); // Deterministic randomness for tests.
397    auto mining_args{node::ReadMiningArgs(*m_node.args)};
398    Assert(mining_args);
399    m_node.mining_args = std::move(*mining_args);
400    PeerManager::Options peerman_opts;
401    ApplyArgsManOptions(*m_node.args, peerman_opts);
402    peerman_opts.deterministic_rng = true;
403    m_node.peerman = PeerManager::make(*m_node.connman, *m_node.addrman,
404                                       m_node.banman.get(), *m_node.chainman,
405                                       *m_node.mempool, *m_node.warnings,
406                                       peerman_opts);
407
408    {
409        CConnman::Options options;
410        options.m_msgproc = m_node.peerman.get();
411        m_node.connman->Init(options);
412    }
413}
414
415TestChain100Setup::TestChain100Setup(
416    const ChainType chain_type,
417    TestOpts opts)
418    : TestingSetup{ChainType::REGTEST, opts}
419{
420    constexpr std::array<unsigned char, 32> vchKey = {
421        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}};
422    coinbaseKey.Set(vchKey.begin(), vchKey.end(), true);
423
424    // Generate a 100-block chain:
425    this->mineBlocks(COINBASE_MATURITY);
426
427    {
428        LOCK(::cs_main);
429        assert(
430            m_node.chainman->ActiveChain().Tip()->GetBlockHash().ToString() ==
431            "0ee6e270d6594249e548110619f7bd690695beb219b915da4a2e84e2b61ed60f");
432    }
433}
434
435void TestChain100Setup::mineBlocks(int num_blocks)
436{
437    CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
438    for (int i = 0; i < num_blocks; i++) {
439        std::vector<CMutableTransaction> noTxns;
440        CBlock b = CreateAndProcessBlock(noTxns, scriptPubKey);
441        m_clock += 1s;
442        m_coinbase_txns.push_back(b.vtx[0]);
443    }
444}
445
446CBlock TestChain100Setup::CreateBlock(
447    const std::vector<CMutableTransaction>& txns,
448    const CScript& scriptPubKey)
449{
450    auto mining{interfaces::MakeMining(m_node)};
451    auto block_template{mining->createNewBlock({
452        .use_mempool = false,
453        .coinbase_output_script = scriptPubKey,
454    }, /*cooldown=*/false)};
455    Assert(block_template);
456    CBlock block{block_template->getBlock()};
457
458    Assert(block.vtx.size() == 1);
459    for (const CMutableTransaction& tx : txns) {
460        block.vtx.push_back(MakeTransactionRef(tx));
461    }
462    RegenerateCommitments(block, *Assert(m_node.chainman));
463
464    while (!CheckProofOfWork(block.GetHash(), block.nBits, m_node.chainman->GetConsensus())) ++block.nNonce;
465
466    return block;
467}
468
469CBlock TestChain100Setup::CreateAndProcessBlock(
470    const std::vector<CMutableTransaction>& txns,
471    const CScript& scriptPubKey)
472{
473    CBlock block = this->CreateBlock(txns, scriptPubKey);
474    std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(block);
475    Assert(m_node.chainman)->ProcessNewBlock(shared_pblock, true, true, nullptr);
476
477    return block;
478}
479
480std::pair<CMutableTransaction, CAmount> TestChain100Setup::CreateValidTransaction(const std::vector<CTransactionRef>& input_transactions,
481                                                                                  const std::vector<COutPoint>& inputs,
482                                                                                  int input_height,
483                                                                                  const std::vector<CKey>& input_signing_keys,
484                                                                                  const std::vector<CTxOut>& outputs,
485                                                                                  const std::optional<CFeeRate>& feerate,
486                                                                                  const std::optional<uint32_t>& fee_output)
487{
488    CMutableTransaction mempool_txn;
489    mempool_txn.vin.reserve(inputs.size());
490    mempool_txn.vout.reserve(outputs.size());
491
492    for (const auto& outpoint : inputs) {
493        mempool_txn.vin.emplace_back(outpoint, CScript(), MAX_BIP125_RBF_SEQUENCE);
494    }
495    mempool_txn.vout = outputs;
496
497    // - Add the signing key to a keystore
498    FillableSigningProvider keystore;
499    for (const auto& input_signing_key : input_signing_keys) {
500        keystore.AddKey(input_signing_key);