CMutableTransaction coinbaseTx{};

CMutableTransaction naughtyTx{};

CBlockIndex* pindexPrev = testing_setup->m_node.chainman->ActiveChain().Tip();

assert(pindexPrev != nullptr);

block.nBits = GetNextWorkRequired(pindexPrev, &block, chainparams.GetConsensus());

CMasternodeSync& mn_sync,

CGovernanceManager& govman,

PeerManager& peerman,

const CActiveMasternodeManager* const mn_activeman,

const std::unique_ptr<CDeterministicMNManager>& dmnman,

const std::unique_ptr<LLMQContext>& llmq_ctx,

m_mn_sync(mn_sync),

m_govman(govman),

m_peerman(peerman),

m_mn_activeman(mn_activeman),

m_dmnman(dmnman),

m_llmq_ctx(llmq_ctx),

m_cj_ctx(cj_ctx) {}

void CDSNotificationInterface::InitializeCurrentBlockTip()

{

}

void CDSNotificationInterface::AcceptedBlockHeader(const CBlockIndex *pindexNew)

class CConnman;

class CDeterministicMNManager;

class CGovernanceManager;

class CMasternodeSync;

class PeerManager;

struct CJContext;

CMasternodeSync& mn_sync,

CGovernanceManager& govman,

PeerManager& peerman,

const CActiveMasternodeManager* const mn_activeman,

const std::unique_ptr<CDeterministicMNManager>& dmnman,

const std::unique_ptr<LLMQContext>& llmq_ctx,

CMasternodeSync& m_mn_sync;

CGovernanceManager& m_govman;

PeerManager& m_peerman;

const CActiveMasternodeManager* const m_mn_activeman;

const std::unique_ptr<CDeterministicMNManager>& m_dmnman;

const std::unique_ptr<LLMQContext>& m_llmq_ctx;

#include <tinyformat.h>

#include <util/thread.h>

#include <util/translation.h>

#include <warnings.h>

constexpr uint8_t DB_BEST_BLOCK{'B'};

bool BaseIndex::Start(CChainState& active_chainstate)

{

m_chainstate = &active_chainstate;

// Need to register this ValidationInterface before running Init(), so that

// callbacks are not missed if Init sets m_synced to true.

ECC_Stop();

node.mempool.reset();

node.fee_estimator.reset();

node.scheduler.reset();

try {

}

#endif

{

assert(args.GetBoolArg("-statsenabled", DEFAULT_STATSD_ENABLE));

CCoinsStats stats{CoinStatsHashType::NONE};

statsClient.gauge("utxoset.tx", stats.nTransactions, 1.0f);

statsClient.gauge("utxoset.txOutputs", stats.nTransactionOutputs, 1.0f);

statsClient.gauge("utxoset.dbSizeBytes", stats.nDiskSize, 1.0f);

}

// short version of GetNetworkHashPS(120, -1);

CBlockIndex *pindex = tip;

int64_t minTime = pindex->GetBlockTime();

int64_t maxTime = minTime;

// No need for cs_main, we never use null tip here

statsClient.gaugeDouble("network.difficulty", (double)GetDifficulty(tip));

statsClient.gauge("transactions.totalTransactions", tip->nChainTx, 1.0f);

{

node.mempool = std::make_unique<CTxMemPool>(node.fee_estimator.get(), check_ratio);

assert(!node.chainman);

assert(!node.mn_metaman);

node.mn_metaman = std::make_unique<CMasternodeMetaMan>();

#endif

pdsNotificationInterface = new CDSNotificationInterface(

);

RegisterValidationInterface(pdsNotificationInterface);

node.llmq_ctx = std::make_unique<LLMQContext>(chainman.ActiveChainstate(), *node.connman, *node.dmnman, *node.evodb, *node.mn_metaman, *node.mnhf_manager, *node.sporkman,

*node.mempool, node.mn_activeman.get(), *node.mn_sync, node.peerman, /* unit_tests = */ false, /* wipe = */ fReset || fReindexChainState);

// Enable CMNHFManager::{Process, Undo}Block

// Have to start it early to let VerifyDB check ChainLock signatures in coinbase

node.llmq_ctx->Start();

// If the loaded chain has a wrong genesis, bail out immediately

// (we're likely using a testnet datadir, or the other way around).

if (!chainman.BlockIndex().empty() &&

return InitError(_("Incorrect or no genesis block found. Wrong datadir for network?"));

}

if (!chainparams.GetConsensus().hashDevnetGenesisBlock.IsNull() && !chainman.BlockIndex().empty() &&

return InitError(_("Incorrect or no devnet genesis block found. Wrong datadir for devnet specified?"));

}

// If we're not mid-reindex (based on disk + args), add a genesis block on disk

// (otherwise we use the one already on disk).

// This is called again in ThreadImport after the reindex completes.

strLoadError = _("Error initializing block database");

break;

}

// TODO: CEvoDB instance should probably be a part of CChainState

// (for multiple chainstates to actually work in parallel)

// and not a global

strLoadError = _("Failed to commit EvoDB");

failed_chainstate_init = true;

break;

// TODO: CEvoDB instance should probably be a part of CChainState

// (for multiple chainstates to actually work in parallel)

// and not a global

// EvoDB processed some blocks earlier but we have no blocks anymore, something is wrong

strLoadError = _("Error initializing block database");

failed_verification = true;

// ********************************************************* Step 7d: Setup other Dash services

if (!node.netfulfilledman->LoadCache(fLoadCacheFiles)) {

auto file_path = (GetDataDir() / "netfulfilled.dat").string();

// ********************************************************* Step 8: start indexers

if (args.GetBoolArg("-txindex", DEFAULT_TXINDEX)) {

g_txindex = std::make_unique<TxIndex>(nTxIndexCache, false, fReindex);

return false;

}

}

for (const auto& filter_type : g_enabled_filter_types) {

InitBlockFilterIndex(filter_type, filter_index_cache, false, fReindex);

return false;

}

}

if (args.GetBoolArg("-coinstatsindex", DEFAULT_COINSTATSINDEX)) {

g_coin_stats_index = std::make_unique<CoinStatsIndex>(/* cache size */ 0, false, fReindex);

return false;

}

}

if (args.GetBoolArg("-statsenabled", DEFAULT_STATSD_ENABLE)) {

int nStatsPeriod = std::min(std::max((int)args.GetArg("-statsperiod", DEFAULT_STATSD_PERIOD), MIN_STATSD_PERIOD), MAX_STATSD_PERIOD);

}

// ********************************************************* Step 11: import blocks

// Either install a handler to notify us when genesis activates, or set fHaveGenesis directly.

// No locking, as this happens before any background thread is started.

boost::signals2::connection block_notify_genesis_wait_connection;

block_notify_genesis_wait_connection = uiInterface.NotifyBlockTip_connect(std::bind(BlockNotifyGenesisWait, std::placeholders::_2));

} else {

fHaveGenesis = true;

tip_info->header_time = ::pindexBestHeader->GetBlockTime();

}

}

if (node.peerman) node.peerman->SetBestHeight(chain_active_height);

// Map ports with UPnP or NAT-PMP.

pblocktemplate->vTxSigOps.push_back(-1); // updated at end

LOCK2(cs_main, m_mempool.cs);

CBlockIndex* pindexPrev = m_chainstate.m_chain.Tip();

assert(pindexPrev != nullptr);

nHeight = pindexPrev->nHeight + 1;

pblocktemplate->vTxSigOps[0] = GetLegacySigOpCount(*pblock->vtx[0]);

BlockValidationState state;

if (!TestBlockValidity(state, m_clhandler, m_evoDb, chainparams, m_chainstate, *pblock, pindexPrev, false, false)) {

throw std::runtime_error(strprintf("%s: TestBlockValidity failed: %s", __func__, state.ToString()));

}

m_mn_activeman(mn_activeman),

m_ignore_incoming_txs(ignore_incoming_txs)

{

// Stale tip checking and peer eviction are on two different timers, but we

// don't want them to get out of sync due to drift in the scheduler, so we

// combine them in one function and schedule at the quicker (peer-eviction)

}

if (mn_activeman != nullptr) {

}

g_wallet_init_interface.AutoLockMasternodeCollaterals();

assert(node.mempool);

assert(node.chainman);

LOCK2(cs_main, node.mempool->cs);

CCoinsViewCache& chain_view = node.chainman->ActiveChainstate().CoinsTip();

CCoinsViewMemPool mempool_view(&chain_view, *node.mempool);

for (auto& coin : coins) {

if (!pindex) {

LOCK(cs_main);

pindex = blockman.LookupBlockIndex(view->GetBestBlock());

}

stats.nHeight = Assert(pindex)->nHeight;