11 #include <chainparams.h>
119 std::cerr << str_err << std::endl;
128 std::vector<const char*> arguments =
Cat(
132 "-logsourcelocations",
137 "-debugexclude=libevent",
138 "-debugexclude=leveldb",
152 throw std::runtime_error{error};
169 if (root_dir.empty())
ExitFailure(
"-testdatadir argument is empty, please specify a path");
187 std::cout <<
"Test directory (will not be deleted): " <<
m_path_root << std::endl;
203 static bool noui_connected =
false;
204 if (!noui_connected) {
206 noui_connected =
true;
252 .check_block_index = 1,
255 .worker_threads_num = 2,
257 const BlockManager::Options blockman_opts{
258 .chainparams = chainman_opts.chainparams,
260 .notifications = chainman_opts.notifications,
266 .memory_only =
true});
294 options.
prune = chainman.m_blockman.IsPruneMode();
305 if (!chainman.ActiveChainstate().ActivateBestChain(state)) {
306 throw std::runtime_error(
strprintf(
"ActivateBestChain failed. (%s)", state.
ToString()));
352 constexpr std::array<unsigned char, 32> vchKey = {
353 {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}};
362 m_node.
chainman->ActiveChain().Tip()->GetBlockHash().ToString() ==
363 "571d80a9967ae599cec0448b0b0ba1cfb606f584d8069bd7166b86854ba7a191");
370 for (
int i = 0; i < num_blocks; i++) {
371 std::vector<CMutableTransaction> noTxns;
379 const std::vector<CMutableTransaction>& txns,
383 BlockAssembler::Options options;
384 CBlock block =
BlockAssembler{chainstate,
nullptr, options}.CreateNewBlock(scriptPubKey)->block;
398 const std::vector<CMutableTransaction>& txns,
407 std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(block);
414 const std::vector<COutPoint>& inputs,
416 const std::vector<CKey>& input_signing_keys,
417 const std::vector<CTxOut>& outputs,
418 const std::optional<CFeeRate>& feerate,
419 const std::optional<uint32_t>& fee_output)
422 mempool_txn.
vin.reserve(inputs.size());
423 mempool_txn.
vout.reserve(outputs.size());
425 for (
const auto& outpoint : inputs) {
428 mempool_txn.
vout = outputs;
432 for (
const auto& input_signing_key : input_signing_keys) {
433 keystore.
AddKey(input_signing_key);
438 for (
const auto& input_transaction : input_transactions) {
439 AddCoins(coins_cache, *input_transaction.get(), input_height);
442 std::map<COutPoint, Coin> input_coins;
444 for (
const auto& outpoint_to_spend : inputs) {
447 assert(coins_cache.
GetCoin(outpoint_to_spend, utxo_to_spend));
448 input_coins.insert({outpoint_to_spend, utxo_to_spend});
449 inputs_amount += utxo_to_spend.
out.
nValue;
453 std::map<int, bilingual_str> input_errors;
455 CAmount current_fee = inputs_amount - std::accumulate(outputs.begin(), outputs.end(),
CAmount(0),
457 return acc +
out.nValue;
460 if (feerate.has_value()) {
461 assert(fee_output.has_value());
462 assert(fee_output.value() < mempool_txn.
vout.size());
464 CAmount deduction = target_fee - current_fee;
468 mempool_txn.
vout[fee_output.value()].nValue -= deduction;
470 input_errors.clear();
472 current_fee = target_fee;
475 return {mempool_txn, current_fee};
479 const std::vector<COutPoint>& inputs,
481 const std::vector<CKey>& input_signing_keys,
482 const std::vector<CTxOut>& outputs,
498 CKey input_signing_key,
503 COutPoint input{input_transaction->GetHash(), input_vout};
504 CTxOut output{output_amount, output_destination};
515 std::vector<CTransactionRef> mempool_transactions;
516 std::deque<std::pair<COutPoint, CAmount>> unspent_prevouts;
518 [](
const auto& tx){ return std::make_pair(COutPoint(tx->GetHash(), 0), tx->vout[0].nValue); });
519 while (num_transactions > 0 && !unspent_prevouts.empty()) {
522 const size_t num_inputs = det_rand.
randrange(24) + 1;
524 for (
size_t n{0}; n < num_inputs; ++n) {
525 if (unspent_prevouts.empty())
break;
526 const auto& [prevout, amount] = unspent_prevouts.front();
529 unspent_prevouts.pop_front();
531 const size_t num_outputs = det_rand.
randrange(24) + 1;
533 const CAmount amount_per_output = (total_in - fee) / num_outputs;
534 for (
size_t n{0}; n < num_outputs; ++n) {
536 mtx.
vout.emplace_back(amount_per_output, spk);
539 mempool_transactions.push_back(ptx);
540 if (amount_per_output > 3000) {
544 for (
size_t n{0}; n < num_outputs; ++n) {
545 unspent_prevouts.emplace_back(
COutPoint(ptx->GetHash(), n), amount_per_output);
546 std::swap(unspent_prevouts.back(), unspent_prevouts[det_rand.
randrange(unspent_prevouts.size())]);
558 return mempool_transactions;
596 ParseHex(
"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"),
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
int64_t CAmount
Amount in satoshis (Can be negative)
static constexpr CAmount COIN
The amount of satoshis in one BTC.
uint256 ArithToUint256(const arith_uint256 &a)
static constexpr unsigned int DEFAULT_MISBEHAVING_BANTIME
const std::function< void(const std::string &)> G_TEST_LOG_FUN
This is connected to the logger.
const std::function< std::vector< const char * >)> G_TEST_COMMAND_LINE_ARGUMENTS
Retrieve the command line arguments.
const std::function< std::string()> G_TEST_GET_FULL_NAME
Retrieve the unit test name.
const CChainParams & Params()
Return the currently selected parameters.
void SelectParams(const ChainType chain)
Sets the params returned by Params() to those for the given chain type.
#define Assert(val)
Identity function.
@ ALLOW_ANY
disable validation
void ForceSetArg(const std::string &strArg, const std::string &strValue)
bool ParseParameters(int argc, const char *const argv[], std::string &error)
fs::path GetDataDirNet() const
Get data directory path with appended network identifier.
void ClearPathCache()
Clear cached directory paths.
bool IsArgSet(const std::string &strArg) const
Return true if the given argument has been manually set.
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const
Return integer argument or default value.
void ClearArgs()
Clear available arguments.
fs::path GetDataDirBase() const
Get data directory path.
fs::path GetBlocksDirPath() const
Get blocks directory path.
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
void AddArg(const std::string &name, const std::string &help, unsigned int flags, const OptionsCategory &cat)
Add argument.
fs::path GetPathArg(std::string arg, const fs::path &default_value={}) const
Return path argument or default value.
bool StartLogging() EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
Start logging (and flush all buffered messages)
void DisconnectTestLogger() EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
Only for testing.
std::list< std::function< void(const std::string &)> >::iterator PushBackCallback(std::function< void(const std::string &)> fun) EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
Connect a slot to the print signal and return the connection.
std::vector< CTransactionRef > vtx
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
CCoinsView that adds a memory cache for transactions to another CCoinsView.
bool GetCoin(const COutPoint &outpoint, Coin &coin) const override
Retrieve the Coin (unspent transaction output) for a given outpoint.
Abstract view on the open txout dataset.
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
CAmount GetFee(uint32_t num_bytes) const
Return the fee in satoshis for the given vsize in vbytes.
An encapsulated private key.
CPubKey GetPubKey() const
Compute the public key from a private key.
void Set(const T pbegin, const T pend, bool fCompressedIn)
Initialize using begin and end iterators to byte data.
An outpoint - a combination of a transaction hash and an index n into its vout.
Serialized script, used inside transaction inputs and outputs.
The basic transaction that is broadcasted on the network and contained in blocks.
CTxMemPoolEntry stores data about the corresponding transaction, as well as data about all in-mempool...
An output of a transaction.
Chainstate stores and provides an API to update our local knowledge of the current best chain.
CTxOut out
unspent transaction output
Double ended buffer combining vector and stream-like interfaces.
Fillable signing provider that keeps keys in an address->secret map.
virtual bool AddKey(const CKey &key)
static std::unique_ptr< PeerManager > make(CConnman &connman, AddrMan &addrman, BanMan *banman, ChainstateManager &chainman, CTxMemPool &pool, node::Warnings &warnings, Options opts)
I randrange(I range) noexcept
Generate a random integer in the range [0..range), with range > 0.
uint256 rand256() noexcept
generate a random uint256.
std::string ToString() const
256-bit unsigned big integer.
std::string ToString() const
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
Access to the block database (blocks/index/)
Generate a new block, without valid proof-of-work.
Maintains a tree of blocks (stored in m_block_index) which is consulted to determine where the most-w...
static transaction_identifier FromUint256(const uint256 &id)
void AddCoins(CCoinsViewCache &cache, const CTransaction &tx, int nHeight, bool check_for_overwrite)
Utility function to add all of a transaction's outputs to a cache.
static const int COINBASE_MATURITY
Coinbase transaction outputs can only be spent after this number of new blocks (network rule)
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
fs::path FeeestPath(const ArgsManager &argsman)
bool TryCreateDirectories(const fs::path &p)
Ignores exceptions thrown by create_directories if the requested directory exists.
void UnlockDirectory(const fs::path &directory, const fs::path &lockfile_name)
Common init functions shared by bitcoin-node, bitcoin-wallet, etc.
void InitLogging(const ArgsManager &args)
Initialize global loggers.
void SetupServerArgs(ArgsManager &argsman)
Register all arguments with the ArgsManager.
bool AppInitParameterInteraction(const ArgsManager &args)
Initialization: parameter interaction.
BCLog::Logger & LogInstance()
static path absolute(const path &p)
static std::string PathToString(const path &path)
Convert path object to a byte string.
static path PathFromString(const std::string &string)
Convert byte string to path object.
std::unique_ptr< Chain > MakeChain(node::NodeContext &node)
Return implementation of Chain interface.
void RegenerateCommitments(CBlock &block, ChainstateManager &chainman)
Update an old GenerateCoinbaseCommitment from CreateNewBlock after the block txs have changed.
CacheSizes CalculateCacheSizes(const ArgsManager &args, size_t n_indexes)
util::Result< void > ApplyArgsManOptions(const ArgsManager &args, BlockManager::Options &opts)
ChainstateLoadResult LoadChainstate(ChainstateManager &chainman, const CacheSizes &cache_sizes, const ChainstateLoadOptions &options)
This sequence can have 4 types of outcomes:
ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager &chainman, const ChainstateLoadOptions &options)
void ThreadRename(const std::string &)
Rename a thread both in terms of an internal (in-memory) name as well as its system thread name.
void TraceThread(std::string_view thread_name, std::function< void()> thread_func)
A wrapper for do-something-once thread functions.
LockResult LockDirectory(const fs::path &directory, const fs::path &lockfile_name, bool probe_only)
static constexpr bool DEFAULT_ACCEPT_STALE_FEE_ESTIMATES
int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost, unsigned int bytes_per_sigop)
Compute the virtual transaction size (weight reinterpreted as bytes).
bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params ¶ms)
Check whether a block hash satisfies the proof-of-work requirement specified by nBits.
static constexpr TransactionSerParams TX_WITH_WITNESS
static CTransactionRef MakeTransactionRef(Tx &&txIn)
std::shared_ptr< const CTransaction > CTransactionRef
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.
static void RegisterAllCoreRPCCommands(CRPCTable &t)
std::vector< unsigned char > ToByteVector(const T &in)
static void ExitFailure(std::string_view str_err)
Test setup failure.
const std::function< std::string(const char *)> G_TRANSLATION_FUN
Translate string to current locale using Qt.
static void SetupUnitTestArgs(ArgsManager &argsman)
Register test-only arguments.
static FastRandomContext g_insecure_rand_ctx_temp_path
Random context to get unique temp data dirs.
static NetworkSetup g_networksetup_instance
std::ostream & operator<<(std::ostream &os, const arith_uint256 &num)
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
BasicTestingSetup(const ChainType chainType=ChainType::MAIN, TestOpts={})
bool m_has_custom_datadir
util::SignalInterrupt m_interrupt
NetEventsInterface * m_msgproc
A mutable version of CTransaction.
std::vector< CTxOut > vout
Testing setup that performs all steps up until right before ChainstateManager gets initialized.
bool m_block_tree_db_in_memory
ChainTestingSetup(const ChainType chainType=ChainType::MAIN, TestOpts={})
node::CacheSizes m_cache_sizes
void LoadVerifyActivateChainstate()
bool m_coins_db_in_memory
Application-specific storage settings.
fs::path path
Location in the filesystem where leveldb data will be stored.
Validation result for a transaction evaluated by MemPoolAccept (single or package).
const ResultType m_result_type
Result type.
bool deterministic_rng
Whether or not the internal RNG behaves deterministically (this is a test-only option).
void mineBlocks(int num_blocks)
Mine a series of new blocks on the active chain.
std::vector< CTransactionRef > m_coinbase_txns
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)
Create a transaction and, optionally, submit to the mempool.
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)
Create a transaction, optionally setting the fee based on the feerate.
std::vector< CTransactionRef > PopulateMempool(FastRandomContext &det_rand, size_t num_transactions, bool submit)
Create transactions spending from m_coinbase_txns.
void MockMempoolMinFee(const CFeeRate &target_feerate)
Mock the mempool minimum feerate by adding a transaction and calling TrimToSize(0),...
CBlock CreateAndProcessBlock(const std::vector< CMutableTransaction > &txns, const CScript &scriptPubKey, Chainstate *chainstate=nullptr)
Create a new block with just given transactions, coinbase paying to scriptPubKey, and try to add it t...
TestChain100Setup(const ChainType chain_type=ChainType::REGTEST, TestOpts={})
CBlock CreateBlock(const std::vector< CMutableTransaction > &txns, const CScript &scriptPubKey, Chainstate &chainstate)
Create a new block with just given transactions, coinbase paying to scriptPubKey.
bool block_tree_db_in_memory
std::vector< const char * > extra_args
bool setup_validation_interface
Testing setup that configures a complete environment.
TestingSetup(const ChainType chainType=ChainType::MAIN, TestOpts={})
An options struct for ChainstateManager, more ergonomically referred to as ChainstateManager::Options...
const CChainParams & chainparams
bool require_full_verification
Setting require_full_verification to true will require all checks at check_level (below) to succeed f...
bool block_tree_db_in_memory
std::unique_ptr< ValidationSignals > validation_signals
Issues calls about blocks and transactions.
std::unique_ptr< CConnman > connman
std::unique_ptr< kernel::Context > kernel
libbitcoin_kernel context
std::unique_ptr< CTxMemPool > mempool
std::unique_ptr< BanMan > banman
std::unique_ptr< AddrMan > addrman
std::unique_ptr< ChainstateManager > chainman
std::unique_ptr< node::Warnings > warnings
Manages all the node warnings.
std::unique_ptr< KernelNotifications > notifications
Issues blocking calls about sync status, errors and warnings.
std::unique_ptr< CScheduler > scheduler
std::unique_ptr< CBlockPolicyEstimator > fee_estimator
std::unique_ptr< PeerManager > peerman
std::atomic< int > exit_status
std::unique_ptr< const NetGroupManager > netgroupman
std::unique_ptr< ECC_Context > ecc_context
util::SignalInterrupt * shutdown
Interrupt object used to track whether node shutdown was requested.
std::unique_ptr< interfaces::Chain > chain
FastRandomContext g_insecure_rand_ctx
This global and the helpers that use it are not thread-safe.
void SeedRandomForTest(SeedRand seedtype)
Seed the RNG for testing.
@ SEED
Use (and report) random seed from environment, or a (truly) random one.
CTxMemPool::Options MemPoolOptionsForTest(const NodeContext &node)
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
static constexpr uint32_t MAX_BIP125_RBF_SEQUENCE
static constexpr int DEFAULT_CHECKLEVEL
static const signed int DEFAULT_CHECKBLOCKS
V Cat(V v1, V &&v2)
Concatenate two vectors, moving elements.