setup_common.h

Go to the documentation of this file.

// Copyright (c) 2015-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_TEST_UTIL_SETUP_COMMON_H
#define BITCOIN_TEST_UTIL_SETUP_COMMON_H
 
#include <common/args.h> // IWYU pragma: export
#include <consensus/amount.h>
#include <kernel/caches.h>
#include <key.h>
#include <node/caches.h>
#include <node/context.h> // IWYU pragma: export
#include <primitives/transaction.h>
#include <random.h>
#include <test/util/net.h>
#include <test/util/random.h>
#include <test/util/time.h>
#include <util/chaintype.h> // IWYU pragma: export
#include <util/fs.h>
#include <util/signalinterrupt.h>
#include <util/vector.h>
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
class CFeeRate;
 
extern const std::function<std::vector<const char*>()> G_TEST_COMMAND_LINE_ARGUMENTS;
 
extern const std::function<std::string()> G_TEST_GET_FULL_NAME;
 
inline constexpr CAmount CENT{1'000'000};
 
void SetupCommonTestArgs(ArgsManager& argsman);
 
struct TestOpts {
    std::vector<const char*> extra_args{};
    bool coins_db_in_memory{true};
    bool block_tree_db_in_memory{true};
    bool setup_net{true};
    bool setup_validation_interface{true};
    bool min_validation_cache{false}; // Equivalent of -maxsigcachebytes=0
};
 
struct BasicTestingSetup {
    util::SignalInterrupt m_interrupt;
    node::NodeContext m_node; // keep as first member to be destructed last
 
    FastRandomContext m_rng;
    void SeedRandomForTest(SeedRand seed)
    {
        SeedRandomStateForTest(seed);
        m_rng.Reseed(GetRandHash());
    }
 
    explicit BasicTestingSetup(ChainType chainType = ChainType::MAIN, TestOpts = {});
    ~BasicTestingSetup();
 
    fs::path m_path_root;
    fs::path m_path_lock;
    bool m_has_custom_datadir{false};
    ArgsManager m_args;
};
 
struct ChainTestingSetup : public BasicTestingSetup {
    kernel::CacheSizes m_kernel_cache_sizes{node::CalculateCacheSizes(m_args).kernel};
    bool m_coins_db_in_memory{true};
    bool m_block_tree_db_in_memory{true};
    std::function<void()> m_make_chainman{};
 
    explicit ChainTestingSetup(ChainType chainType = ChainType::MAIN, TestOpts = {});
    ~ChainTestingSetup();
 
    void CreateBlockTemplateManager();
 
    // Supplies a chainstate, if one is needed
    void LoadVerifyActivateChainstate();
};
 
struct TestingSetup : public ChainTestingSetup {
    explicit TestingSetup(
        ChainType chainType = ChainType::MAIN,
        TestOpts = {});
};
 
struct RegTestingSetup : public TestingSetup {
    RegTestingSetup()
        : TestingSetup{ChainType::REGTEST} {}
};
 
struct Testnet4Setup : public TestingSetup {
    Testnet4Setup()
        : TestingSetup{ChainType::TESTNET4} {}
};
 
class CBlock;
class CScript;
 
struct TestChain100Setup : public TestingSetup {
    TestChain100Setup(
        ChainType chain_type = ChainType::REGTEST,
        TestOpts = {});
 
    CBlock CreateAndProcessBlock(const std::vector<CMutableTransaction>& txns,
                                 const CScript& scriptPubKey,
                                 bool sync = true);
 
    CBlock CreateBlock(
        const std::vector<CMutableTransaction>& txns,
        const CScript& scriptPubKey);
 
    void mineBlocks(int num_blocks);
 
    std::pair<CMutableTransaction, CAmount> CreateValidTransaction(const std::vector<CTransactionRef>& input_transactions,
                                                                   const std::vector<COutPoint>& inputs,
                                                                   int input_height,
                                                                   const std::vector<CKey>& input_signing_keys,
                                                                   const std::vector<CTxOut>& outputs,
                                                                   const std::optional<CFeeRate>& feerate,
                                                                   const std::optional<uint32_t>& fee_output);
    CMutableTransaction CreateValidMempoolTransaction(const std::vector<CTransactionRef>& input_transactions,
                                                      const std::vector<COutPoint>& inputs,
                                                      int input_height,
                                                      const std::vector<CKey>& input_signing_keys,
                                                      const std::vector<CTxOut>& outputs,
                                                      bool submit = true);
 
    CMutableTransaction CreateValidMempoolTransaction(CTransactionRef input_transaction,
                                                      uint32_t input_vout,
                                                      int input_height,
                                                      CKey input_signing_key,
                                                      CScript output_destination,
                                                      CAmount output_amount = CAmount(1 * COIN),
                                                      bool submit = true);
 
    std::vector<CTransactionRef> PopulateMempool(FastRandomContext& det_rand, size_t num_transactions, bool submit);
 
    FakeNodeClock m_clock{std::chrono::seconds{1598887952}}; // 2020-08-31, arbitrary
    std::vector<CTransactionRef> m_coinbase_txns; // For convenience, coinbase transactions
    CKey coinbaseKey; // private/public key needed to spend coinbase transactions
};
 
template <class T = const BasicTestingSetup>
std::unique_ptr<T> MakeNoLogFileContext(const ChainType chain_type = ChainType::REGTEST, TestOpts opts = {})
{
    opts.extra_args = Cat(
        {
            "-nodebuglogfile",
            "-nodebug",
        },
        opts.extra_args);
 
    return std::make_unique<T>(chain_type, opts);
}
 
class SocketTestingSetup : public BasicTestingSetup
{
public:
    explicit SocketTestingSetup();
    ~SocketTestingSetup();
 
    template <typename T = DynSock>
    std::shared_ptr<typename T::Pipes> ConnectClient(std::span<const std::byte> data)
    {
        auto connected_socket_pipes(std::make_shared<typename T::Pipes>());
        connected_socket_pipes->recv.PushBytes(data.data(), data.size());
        m_accepted_sockets.Push(std::make_unique<T>(connected_socket_pipes));
        return connected_socket_pipes;
    }
 
private:
    decltype(CreateSock) m_create_sock_orig;
 
    DynSock::Queue m_accepted_sockets;
};
 
CBlock getBlock13b8a();
 
#endif // BITCOIN_TEST_UTIL_SETUP_COMMON_H