public async Task SetUp()
{
_dbProvider = await TestMemDbProvider.InitAsync();
_timestamper = new ManualTimestamper();
_blockTree = Substitute.For <IBlockTree>();
_txPool = Substitute.For <ITxPool>();
_receiptStorage = Substitute.For <IReceiptStorage>();
_filterStore = Substitute.For <IFilterStore>();
_filterManager = Substitute.For <IFilterManager>();
_transactionProcessor = Substitute.For <ITransactionProcessor>();
_ethereumEcdsa = Substitute.For <IEthereumEcdsa>();
_specProvider = MainnetSpecProvider.Instance;
ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(_dbProvider, false),
new TrieStore(_dbProvider.StateDb, LimboLogs.Instance).AsReadOnly(),
new ReadOnlyBlockTree(_blockTree),
_specProvider,
LimboLogs.Instance);
processingEnv.TransactionProcessor = _transactionProcessor;
_blockchainBridge = new BlockchainBridge(
processingEnv,
_txPool,
_receiptStorage,
_filterStore,
_filterManager,
_ethereumEcdsa,
_timestamper,
Substitute.For <ILogFinder>(),
false,
false);
}
public async Task Initialize()
{
ISpecProvider specProvider = MainnetSpecProvider.Instance;
ITxPool txPool = NullTxPool.Instance;
IDbProvider dbProvider = await TestMemDbProvider.InitAsync();
BlockTree blockTree = new BlockTree(
dbProvider.BlocksDb,
dbProvider.HeadersDb,
dbProvider.BlockInfosDb,
new ChainLevelInfoRepository(dbProvider.BlockInfosDb),
specProvider,
new BloomStorage(new BloomConfig(), dbProvider.HeadersDb, new InMemoryDictionaryFileStoreFactory()),
new SyncConfig(),
LimboLogs.Instance);
_modulePool = new BoundedModulePool <IEthModule>(new EthModuleFactory(
txPool,
Substitute.For <ITxSender>(),
NullWallet.Instance,
blockTree,
new JsonRpcConfig(),
LimboLogs.Instance,
Substitute.For <IStateReader>(),
Substitute.For <IBlockchainBridgeFactory>()), 1, 1000);
}
public async Task Can_keep_returning_nulls_after_all_batches_were_prepared()
{
IDbProvider memDbProvider = await TestMemDbProvider.InitAsync();
BlockTree blockTree = new(memDbProvider, new ChainLevelInfoRepository(memDbProvider.BlockInfosDb),
MainnetSpecProvider.Instance, NullBloomStorage.Instance, LimboLogs.Instance);
ISyncConfig syncConfig = new SyncConfig
{
FastSync = true,
FastBlocks = true,
PivotNumber = "1000",
PivotHash = Keccak.Zero.ToString(),
PivotTotalDifficulty = "1000"
};
PoSSwitcher poSSwitcher = new(new MergeConfig(), syncConfig, memDbProvider.MetadataDb, blockTree !,
MainnetSpecProvider.Instance, LimboLogs.Instance);
IBeaconPivot pivot = PreparePivot(2000, syncConfig, blockTree);
BeaconHeadersSyncFeed feed = new(poSSwitcher, Substitute.For <ISyncModeSelector>(), blockTree,
Substitute.For <ISyncPeerPool>(), syncConfig, Substitute.For <ISyncReport>(),
pivot, new MergeConfig()
{
Enabled = true
}, new NoopInvalidChainTracker(), LimboLogs.Instance);
feed.InitializeFeed();
for (int i = 0; i < 6; i++)
{
await feed.PrepareRequest();
}
HeadersSyncBatch?result = await feed.PrepareRequest();
result.Should().BeNull();
}
public async Task Will_fail_if_launched_without_fast_blocks_enabled()
{
IDbProvider memDbProvider = await TestMemDbProvider.InitAsync();
BlockTree blockTree = new(memDbProvider.BlocksDb, memDbProvider.HeadersDb, memDbProvider.BlockInfosDb, new ChainLevelInfoRepository(memDbProvider.BlockInfosDb), MainnetSpecProvider.Instance, NullBloomStorage.Instance, LimboLogs.Instance);
Assert.Throws <InvalidOperationException>(() => new HeadersSyncFeed(blockTree, Substitute.For <ISyncPeerPool>(), new SyncConfig(), Substitute.For <ISyncReport>(), LimboLogs.Instance));
}
public async Task Can_prepare_3_requests_in_a_row()
{
IDbProvider memDbProvider = await TestMemDbProvider.InitAsync();
BlockTree blockTree = new(memDbProvider.BlocksDb, memDbProvider.HeadersDb, memDbProvider.BlockInfosDb, new ChainLevelInfoRepository(memDbProvider.BlockInfosDb), MainnetSpecProvider.Instance, NullBloomStorage.Instance, LimboLogs.Instance);
HeadersSyncFeed feed = new(blockTree, Substitute.For <ISyncPeerPool>(), new SyncConfig {
FastSync = true, FastBlocks = true, PivotNumber = "1000", PivotHash = Keccak.Zero.ToString(), PivotTotalDifficulty = "1000"
}, Substitute.For <ISyncReport>(), LimboLogs.Instance);
HeadersSyncBatch batch1 = await feed.PrepareRequest();
HeadersSyncBatch batch2 = await feed.PrepareRequest();
HeadersSyncBatch batch3 = await feed.PrepareRequest();
}
private async Task SetupBeamProcessor(ISyncModeSelector syncModeSelector = null)
{
IDbProvider memDbProvider = await TestMemDbProvider.InitAsync();
_beamBlockchainProcessor = new BeamBlockchainProcessor(
new ReadOnlyDbProvider(memDbProvider, false),
_blockTree,
MainnetSpecProvider.Instance,
LimboLogs.Instance,
_validator,
NullRecoveryStep.Instance,
NoBlockRewards.Instance,
_blockchainProcessingQueue,
syncModeSelector ?? new StaticSelector(SyncMode.Beam)
);
}
public async Task ProviderInitTests_BeamSyncDbProvider()
{
var syncModeSelector = Substitute.For <ISyncModeSelector>();
var dbProvider = await TestMemDbProvider.InitAsync();
var rocksDbFactory = new RocksDbFactory(new DbConfig(), LimboLogs.Instance, Path.Combine(_folderWithDbs, "beam"));
IDbProvider beamSyncDbProvider = new BeamSyncDbProvider(syncModeSelector, dbProvider, new SyncConfig(), LimboLogs.Instance);
var initializer = new ConsumerNdmDbInitializer(beamSyncDbProvider, new NdmConfig(), rocksDbFactory, new MemDbFactory());
initializer.Reset();
await initializer.InitAsync();
Assert.IsTrue(beamSyncDbProvider.GetDb <IDb>(ConsumerNdmDbNames.ConsumerDepositApprovals) is MemDb);
Assert.IsTrue(beamSyncDbProvider.GetDb <IDb>(ConsumerNdmDbNames.ConsumerReceipts) is MemDb);
Assert.IsTrue(beamSyncDbProvider.GetDb <IDb>(ConsumerNdmDbNames.ConsumerSessions) is MemDb);
Assert.IsTrue(beamSyncDbProvider.GetDb <IDb>(ConsumerNdmDbNames.Deposits) is MemDb);
}
public async Task Can_keep_returning_nulls_after_all_batches_were_prepared()
{
IDbProvider memDbProvider = await TestMemDbProvider.InitAsync();
BlockTree blockTree = new(memDbProvider.BlocksDb, memDbProvider.HeadersDb, memDbProvider.BlockInfosDb, new ChainLevelInfoRepository(memDbProvider.BlockInfosDb), MainnetSpecProvider.Instance, NullBloomStorage.Instance, LimboLogs.Instance);
HeadersSyncFeed feed = new(blockTree, Substitute.For <ISyncPeerPool>(), new SyncConfig {
FastSync = true, FastBlocks = true, PivotNumber = "1000", PivotHash = Keccak.Zero.ToString(), PivotTotalDifficulty = "1000"
}, Substitute.For <ISyncReport>(), LimboLogs.Instance);
for (int i = 0; i < 10; i++)
{
await feed.PrepareRequest();
}
var result = await feed.PrepareRequest();
result.Should().BeNull();
}
public async Task Setup()
{
InMemoryReceiptStorage receiptStorage = new();
_specProvider = new TestSpecProvider(London.Instance);
_blockTree = Build.A.BlockTree().WithTransactions(receiptStorage, _specProvider).OfChainLength(10).TestObject;
_dbProvider = await TestMemDbProvider.InitAsync();
ProofModuleFactory moduleFactory = new(
_dbProvider,
_blockTree,
new TrieStore(_dbProvider.StateDb, LimboLogs.Instance).AsReadOnly(),
new CompositeBlockPreprocessorStep(new RecoverSignatures(new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance), NullTxPool.Instance, _specProvider, LimboLogs.Instance)),
receiptStorage,
_specProvider,
LimboLogs.Instance);
_proofRpcModule = moduleFactory.Create();
}
public async Task Setup()
{
_genesisBlock = Build.A.Block.WithNumber(0).TestObject;
_blockTree = Build.A.BlockTree(_genesisBlock).OfChainLength(1).TestObject;
IDbProvider dbProvider = await TestMemDbProvider.InitAsync();
_stateDb = dbProvider.StateDb;
_codeDb = dbProvider.CodeDb;
_receiptStorage = Substitute.For <IReceiptStorage>();
SyncConfig quickConfig = new SyncConfig();
quickConfig.FastSync = false;
ITimerFactory timerFactory = Substitute.For <ITimerFactory>();
var stats = new NodeStatsManager(timerFactory, LimboLogs.Instance);
_pool = new SyncPeerPool(_blockTree, stats, 25, LimboLogs.Instance);
SyncConfig syncConfig = new SyncConfig();
SyncProgressResolver resolver = new SyncProgressResolver(
_blockTree,
_receiptStorage,
_stateDb,
dbProvider.BeamTempDb,
new TrieStore(_stateDb, LimboLogs.Instance),
syncConfig,
LimboLogs.Instance);
MultiSyncModeSelector syncModeSelector = new MultiSyncModeSelector(resolver, _pool, syncConfig, LimboLogs.Instance);
_synchronizer = new Synchronizer(dbProvider, MainnetSpecProvider.Instance, _blockTree, _receiptStorage, Always.Valid, Always.Valid, _pool, stats, syncModeSelector, syncConfig, LimboLogs.Instance);
_syncServer = new SyncServer(
_stateDb,
_codeDb,
_blockTree,
_receiptStorage,
Always.Valid,
Always.Valid,
_pool,
syncModeSelector,
quickConfig,
new WitnessCollector(new MemDb(), LimboLogs.Instance),
LimboLogs.Instance);
}
public async Task Initialize()
{
ISpecProvider specProvider = MainnetSpecProvider.Instance;
ITxPool txPool = NullTxPool.Instance;
IDbProvider dbProvider = await TestMemDbProvider.InitAsync();
BlockTree blockTree = new(dbProvider.BlocksDb, dbProvider.HeadersDb, dbProvider.BlockInfosDb, new ChainLevelInfoRepository(dbProvider.BlockInfosDb), specProvider, NullBloomStorage.Instance, new SyncConfig(), LimboLogs.Instance);
_factory = new EthModuleFactory(
txPool,
Substitute.For <ITxSender>(),
NullWallet.Instance,
blockTree,
new JsonRpcConfig(),
LimboLogs.Instance,
Substitute.For <IStateReader>(),
Substitute.For <IBlockchainBridgeFactory>(),
Substitute.For <ISpecProvider>(),
Substitute.For <IReceiptStorage>(),
Substitute.For <IGasPriceOracle>(),
Substitute.For <IEthSyncingInfo>());
}
protected virtual async Task <TestBlockchain> Build(ISpecProvider specProvider = null, UInt256?initialValues = null)
{
Timestamper = new ManualTimestamper(new DateTime(2020, 2, 15, 12, 50, 30, DateTimeKind.Utc));
JsonSerializer = new EthereumJsonSerializer();
SpecProvider = specProvider ?? MainnetSpecProvider.Instance;
EthereumEcdsa = new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance);
ITxStorage txStorage = new InMemoryTxStorage();
DbProvider = await TestMemDbProvider.InitAsync();
State = new StateProvider(StateDb, CodeDb, LimboLogs.Instance);
State.CreateAccount(TestItem.AddressA, (initialValues ?? 1000.Ether()));
State.CreateAccount(TestItem.AddressB, (initialValues ?? 1000.Ether()));
State.CreateAccount(TestItem.AddressC, (initialValues ?? 1000.Ether()));
byte[] code = Bytes.FromHexString("0xabcd");
Keccak codeHash = Keccak.Compute(code);
State.UpdateCode(code);
State.UpdateCodeHash(TestItem.AddressA, codeHash, SpecProvider.GenesisSpec);
Storage = new StorageProvider(StateDb, State, LimboLogs.Instance);
Storage.Set(new StorageCell(TestItem.AddressA, UInt256.One), Bytes.FromHexString("0xabcdef"));
Storage.Commit();
State.Commit(SpecProvider.GenesisSpec);
State.CommitTree();
TxPool = new TxPool.TxPool(
txStorage,
EthereumEcdsa,
SpecProvider,
new TxPoolConfig(),
new StateProvider(StateDb, CodeDb, LimboLogs.Instance),
LimboLogs.Instance);
IDb blockDb = new MemDb();
IDb headerDb = new MemDb();
IDb blockInfoDb = new MemDb();
BlockTree = new BlockTree(blockDb, headerDb, blockInfoDb, new ChainLevelInfoRepository(blockDb), SpecProvider, NullBloomStorage.Instance, LimboLogs.Instance);
new OnChainTxWatcher(BlockTree, TxPool, SpecProvider, LimboLogs.Instance);
ReceiptStorage = new InMemoryReceiptStorage();
VirtualMachine virtualMachine = new VirtualMachine(State, Storage, new BlockhashProvider(BlockTree, LimboLogs.Instance), SpecProvider, LimboLogs.Instance);
TxProcessor = new TransactionProcessor(SpecProvider, State, Storage, virtualMachine, LimboLogs.Instance);
BlockProcessor = CreateBlockProcessor();
BlockchainProcessor chainProcessor = new BlockchainProcessor(BlockTree, BlockProcessor, new RecoverSignatures(EthereumEcdsa, TxPool, SpecProvider, LimboLogs.Instance), LimboLogs.Instance, Nethermind.Blockchain.Processing.BlockchainProcessor.Options.Default);
BlockchainProcessor = chainProcessor;
chainProcessor.Start();
StateReader = new StateReader(StateDb, CodeDb, LimboLogs.Instance);
TxPoolTxSource txPoolTxSource = CreateTxPoolTxSource();
ISealer sealer = new NethDevSealEngine(TestItem.AddressD);
BlockProducer = new TestBlockProducer(txPoolTxSource, chainProcessor, State, sealer, BlockTree, chainProcessor, Timestamper, LimboLogs.Instance);
BlockProducer.Start();
_resetEvent = new SemaphoreSlim(0);
_suggestedBlockResetEvent = new ManualResetEvent(true);
BlockTree.NewHeadBlock += (s, e) =>
{
_resetEvent.Release(1);
};
BlockProducer.LastProducedBlockChanged += (s, e) =>
{
_suggestedBlockResetEvent.Set();
};
var genesis = GetGenesisBlock();
BlockTree.SuggestBlock(genesis);
await _resetEvent.WaitAsync();
//if (!await _resetEvent.WaitAsync(1000))
// {
// throw new InvalidOperationException("Failed to process genesis in 1s.");
// }
await AddBlocksOnStart();
return(this);
}
public async Task Get_storage()
{
IDbProvider dbProvider = await TestMemDbProvider.InitAsync();
/* all testing will be touching just a single storage cell */
StorageCell storageCell = new StorageCell(_address1, UInt256.One);
TrieStore trieStore = new TrieStore(dbProvider.StateDb, Logger);
StateProvider state = new StateProvider(trieStore, dbProvider.CodeDb, Logger);
StorageProvider storage = new StorageProvider(trieStore, state, Logger);
/* to start with we need to create an account that we will be setting storage at */
state.CreateAccount(storageCell.Address, UInt256.One);
state.Commit(MuirGlacier.Instance);
state.CommitTree(1);
/* at this stage we have an account with empty storage at the address that we want to test */
byte[] initialValue = new byte[] { 1, 2, 3 };
storage.Set(storageCell, initialValue);
storage.Commit();
storage.CommitTrees(2);
state.Commit(MuirGlacier.Instance);
state.CommitTree(2);
StateReader reader = new StateReader(
new TrieStore(dbProvider.StateDb, LimboLogs.Instance), dbProvider.CodeDb, Logger);
var account = reader.GetAccount(state.StateRoot, _address1);
var retrieved = reader.GetStorage(account.StorageRoot, storageCell.Index);
retrieved.Should().BeEquivalentTo(initialValue);
/* at this stage we set the value in storage to 1,2,3 at the tested storage cell */
/* Now we are testing scenario where the storage is being changed by the block processor.
* To do that we create some different storage / state access stack that represents the processor.
* It is a different stack of objects than the one that is used by the blockchain bridge. */
byte[] newValue = new byte[] { 1, 2, 3, 4, 5 };
StateProvider processorStateProvider =
new StateProvider(trieStore, new MemDb(), LimboLogs.Instance);
processorStateProvider.StateRoot = state.StateRoot;
StorageProvider processorStorageProvider =
new StorageProvider(trieStore, processorStateProvider, LimboLogs.Instance);
processorStorageProvider.Set(storageCell, newValue);
processorStorageProvider.Commit();
processorStorageProvider.CommitTrees(3);
processorStateProvider.Commit(MuirGlacier.Instance);
processorStateProvider.CommitTree(3);
/* At this stage the DB should have the storage value updated to 5.
* We will try to retrieve the value by taking the state root from the processor.*/
retrieved =
reader.GetStorage(processorStateProvider.GetStorageRoot(storageCell.Address), storageCell.Index);
retrieved.Should().BeEquivalentTo(newValue);
/* If it failed then it means that the blockchain bridge cached the previous call value */
}
private async Task Initialize(bool auRa = false)
{
IDbProvider dbProvider = await TestMemDbProvider.InitAsync();
ISpecProvider specProvider = MainnetSpecProvider.Instance;
_jsonRpcConfig = new JsonRpcConfig();
IEthereumEcdsa ethereumEcdsa = new EthereumEcdsa(specProvider.ChainId, LimboLogs.Instance);
ITxStorage txStorage = new InMemoryTxStorage();
_stateDb = new StateDb();
_stateProvider = new StateProvider(dbProvider, LimboLogs.Instance);
_stateProvider.CreateAccount(TestItem.AddressA, 1000.Ether());
_stateProvider.CreateAccount(TestItem.AddressB, 1000.Ether());
_stateProvider.CreateAccount(TestItem.AddressC, 1000.Ether());
byte[] code = Bytes.FromHexString("0xabcd");
Keccak codeHash = Keccak.Compute(code);
_stateProvider.UpdateCode(code);
_stateProvider.UpdateCodeHash(TestItem.AddressA, codeHash, specProvider.GenesisSpec);
IStorageProvider storageProvider = new StorageProvider(_stateDb, _stateProvider, LimboLogs.Instance);
storageProvider.Set(new StorageCell(TestItem.AddressA, UInt256.One), Bytes.FromHexString("0xabcdef"));
storageProvider.Commit();
_stateProvider.Commit(specProvider.GenesisSpec);
_stateProvider.CommitTree();
ITxPool txPool = new TxPool.TxPool(txStorage, ethereumEcdsa, specProvider, new TxPoolConfig(), _stateProvider, LimboLogs.Instance);
IChainLevelInfoRepository chainLevels = new ChainLevelInfoRepository(dbProvider);
IBlockTree blockTree = new BlockTree(dbProvider, chainLevels, specProvider, NullBloomStorage.Instance, LimboLogs.Instance);
IReceiptStorage receiptStorage = new InMemoryReceiptStorage();
VirtualMachine virtualMachine = new VirtualMachine(_stateProvider, storageProvider, new BlockhashProvider(blockTree, LimboLogs.Instance), specProvider, LimboLogs.Instance);
TransactionProcessor txProcessor = new TransactionProcessor(specProvider, _stateProvider, storageProvider, virtualMachine, LimboLogs.Instance);
IBlockProcessor blockProcessor = new BlockProcessor(
specProvider,
Always.Valid,
new RewardCalculator(specProvider),
txProcessor,
dbProvider.StateDb,
dbProvider.CodeDb,
_stateProvider,
storageProvider,
txPool,
receiptStorage,
LimboLogs.Instance);
var signatureRecovery = new RecoverSignatures(ethereumEcdsa, txPool, specProvider, LimboLogs.Instance);
BlockchainProcessor blockchainProcessor = new BlockchainProcessor(blockTree, blockProcessor, signatureRecovery, LimboLogs.Instance, BlockchainProcessor.Options.Default);
blockchainProcessor.Start();
ManualResetEventSlim resetEvent = new ManualResetEventSlim(false);
blockTree.NewHeadBlock += (s, e) =>
{
Console.WriteLine(e.Block.Header.Hash);
if (e.Block.Number == 9)
{
resetEvent.Set();
}
};
var genesisBlockBuilder = Build.A.Block.Genesis.WithStateRoot(new Keccak("0x1ef7300d8961797263939a3d29bbba4ccf1702fabf02d8ad7a20b454edb6fd2f"));
if (auRa)
{
genesisBlockBuilder.WithAura(0, new byte[65]);
}
Block genesis = genesisBlockBuilder.TestObject;
blockTree.SuggestBlock(genesis);
Block previousBlock = genesis;
for (int i = 1; i < 10; i++)
{
List <Transaction> transactions = new List <Transaction>();
for (int j = 0; j < i; j++)
{
transactions.Add(Build.A.Transaction.WithNonce((UInt256)j).SignedAndResolved().TestObject);
}
BlockBuilder builder = Build.A.Block.WithNumber(i).WithParent(previousBlock).WithTransactions(transactions.ToArray()).WithStateRoot(new Keccak("0x1ef7300d8961797263939a3d29bbba4ccf1702fabf02d8ad7a20b454edb6fd2f"));
if (auRa)
{
builder.WithAura(i, i.ToByteArray());
}
Block block = builder.TestObject;
blockTree.SuggestBlock(block);
previousBlock = block;
}
ReceiptsRecovery receiptsRecovery = new ReceiptsRecovery(new EthereumEcdsa(specProvider.ChainId, LimboLogs.Instance), specProvider);
IReceiptFinder receiptFinder = new FullInfoReceiptFinder(receiptStorage, receiptsRecovery, blockTree);
resetEvent.Wait(2000);
_traceModule = new TraceModule(receiptFinder, new Tracer(_stateProvider, blockchainProcessor), blockTree, _jsonRpcConfig);
}
public async Task Setup()
{
_genesisBlock = Build.A.Block.WithNumber(0).TestObject;
_blockTree = Build.A.BlockTree(_genesisBlock).OfChainLength(1).TestObject;
IDbProvider dbProvider = await TestMemDbProvider.InitAsync();
_stateDb = dbProvider.StateDb;
_codeDb = dbProvider.CodeDb;
_receiptStorage = Substitute.For <IReceiptStorage>();
SyncConfig quickConfig = new() { FastSync = false };
ITimerFactory timerFactory = Substitute.For <ITimerFactory>();
NodeStatsManager stats = new(timerFactory, LimboLogs.Instance);
_pool = new SyncPeerPool(_blockTree, stats, new TotalDifficultyBetterPeerStrategy(LimboLogs.Instance), 25, LimboLogs.Instance);
SyncConfig syncConfig = new();
ProgressTracker progressTracker = new(_blockTree, dbProvider.StateDb, LimboLogs.Instance);
SnapProvider snapProvider = new(progressTracker, dbProvider, LimboLogs.Instance);
TrieStore trieStore = new(_stateDb, LimboLogs.Instance);
SyncProgressResolver resolver = new(
_blockTree,
_receiptStorage,
_stateDb,
trieStore,
progressTracker,
syncConfig,
LimboLogs.Instance);
TotalDifficultyBetterPeerStrategy bestPeerStrategy = new(LimboLogs.Instance);
MultiSyncModeSelector syncModeSelector = new(resolver, _pool, syncConfig, No.BeaconSync, bestPeerStrategy, LimboLogs.Instance);
Pivot pivot = new (syncConfig);
SyncReport syncReport = new(_pool, stats, syncModeSelector, syncConfig, pivot, LimboLogs.Instance);
BlockDownloaderFactory blockDownloaderFactory = new(
MainnetSpecProvider.Instance,
_blockTree,
_receiptStorage,
Always.Valid,
Always.Valid,
_pool,
new TotalDifficultyBetterPeerStrategy(LimboLogs.Instance),
syncReport,
LimboLogs.Instance);
_synchronizer = new Synchronizer(
dbProvider,
MainnetSpecProvider.Instance,
_blockTree,
_receiptStorage,
_pool,
stats,
syncModeSelector,
syncConfig,
snapProvider,
blockDownloaderFactory,
pivot,
syncReport,
LimboLogs.Instance);
_syncServer = new SyncServer(
trieStore,
_codeDb,
_blockTree,
_receiptStorage,
Always.Valid,
Always.Valid,
_pool,
syncModeSelector,
quickConfig,
new WitnessCollector(new MemDb(), LimboLogs.Instance),
Policy.FullGossip,
MainnetSpecProvider.Instance,
LimboLogs.Instance);
}