public void Initialize()
{
ISpecProvider specProvider = MainnetSpecProvider.Instance;
ITxPool txPool = NullTxPool.Instance;
MemDbProvider dbProvider = new MemDbProvider();
BlockTree blockTree = new BlockTree(
dbProvider.BlocksDb,
dbProvider.HeadersDb,
dbProvider.BlockInfosDb,
new ChainLevelInfoRepository(dbProvider.BlockInfosDb),
specProvider,
txPool,
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);
}
public void Initialize()
{
ISpecProvider specProvider = MainnetSpecProvider.Instance;
ITxPool txPool = NullTxPool.Instance;
MemDbProvider dbProvider = new MemDbProvider();
BlockTree blockTree = new BlockTree(
dbProvider.BlocksDb,
dbProvider.HeadersDb,
dbProvider.BlockInfosDb,
new ChainLevelInfoRepository(dbProvider.BlockInfosDb),
specProvider,
txPool,
new BloomStorage(new BloomConfig(), dbProvider.HeadersDb, new InMemoryDictionaryFileStoreFactory()),
new SyncConfig(),
LimboLogs.Instance);
_modulePool = new BoundedModulePool <IEthModule>(
1,
new EthModuleFactory(
dbProvider,
txPool,
NullWallet.Instance,
blockTree,
new EthereumEcdsa(MainnetSpecProvider.Instance, LimboLogs.Instance),
NullBlockProcessor.Instance,
new InMemoryReceiptStorage(),
specProvider,
new JsonRpcConfig(),
NullBloomStorage.Instance,
LimboLogs.Instance,
false));
}
public static INdmBlockchainBridge BuildABridge()
{
MemDbProvider memDbProvider = new MemDbProvider();
StateReader stateReader = new StateReader(memDbProvider.StateDb, memDbProvider.CodeDb, LimboLogs.Instance);
StateProvider stateProvider = new StateProvider(memDbProvider.StateDb, memDbProvider.CodeDb, LimboLogs.Instance);
IEthereumEcdsa ecdsa = new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance);
ITxPool txPool = new TxPool.TxPool(new InMemoryTxStorage(), ecdsa, MainnetSpecProvider.Instance, new TxPoolConfig(), stateProvider, LimboLogs.Instance);
BlockTree blockTree = Build.A.BlockTree().OfChainLength(1).TestObject;
IWallet wallet = new DevWallet(new WalletConfig(), LimboLogs.Instance);
ReceiptsRecovery receiptsRecovery = new ReceiptsRecovery(ecdsa, MainnetSpecProvider.Instance);
LogFinder logFinder = new LogFinder(blockTree, new InMemoryReceiptStorage(), NullBloomStorage.Instance, LimboLogs.Instance, receiptsRecovery, 1024);
ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(memDbProvider, false),
new ReadOnlyBlockTree(blockTree),
MainnetSpecProvider.Instance, LimboLogs.Instance);
BlockchainBridge blockchainBridge = new BlockchainBridge(
processingEnv,
txPool,
new InMemoryReceiptStorage(),
NullFilterStore.Instance,
NullFilterManager.Instance,
ecdsa,
Timestamper.Default,
logFinder,
false,
false);
WalletTxSigner txSigner = new WalletTxSigner(wallet, ChainId.Mainnet);
ITxSealer txSealer0 = new TxSealer(txSigner, Timestamper.Default);
ITxSealer txSealer1 = new NonceReservingTxSealer(txSigner, Timestamper.Default, txPool);
ITxSender txSender = new TxPoolSender(txPool, txSealer0, txSealer1);
return(new NdmBlockchainBridge(blockchainBridge, blockTree, stateReader, txSender));
}
public void Will_fail_if_launched_without_fast_blocks_enabled()
{
MemDbProvider memDbProvider = new MemDbProvider();
BlockTree blockTree = new BlockTree(memDbProvider.BlocksDb, memDbProvider.HeadersDb, memDbProvider.BlockInfosDb, new ChainLevelInfoRepository(memDbProvider.BlockInfosDb), MainnetSpecProvider.Instance, NullTxPool.Instance, NullBloomStorage.Instance, LimboLogs.Instance);
Assert.Throws <InvalidOperationException>(() => new FastHeadersSyncFeed(blockTree, Substitute.For <ISyncPeerPool>(), new SyncConfig(), Substitute.For <ISyncReport>(), LimboLogs.Instance));
}
public void Initialize()
{
ISpecProvider specProvider = MainNetSpecProvider.Instance;
ITxPool txPool = NullTxPool.Instance;
MemDbProvider dbProvider = new MemDbProvider();
BlockTree blockTree = new BlockTree(dbProvider.BlocksDb, dbProvider.HeadersDb, dbProvider.BlockInfosDb, new ChainLevelInfoRepository(dbProvider.BlockInfosDb), specProvider, txPool, new SyncConfig(), LimboLogs.Instance);
_factory = new EthModuleFactory(dbProvider, txPool, NullWallet.Instance, blockTree, new EthereumEcdsa(MainNetSpecProvider.Instance, LimboLogs.Instance), NullBlockProcessor.Instance, new InMemoryReceiptStorage(), specProvider, LimboLogs.Instance);
}
public async Task Can_prepare_3_requests_in_a_row()
{
MemDbProvider memDbProvider = new MemDbProvider();
BlockTree blockTree = new BlockTree(memDbProvider.BlocksDb, memDbProvider.HeadersDb, memDbProvider.BlockInfosDb, new ChainLevelInfoRepository(memDbProvider.BlockInfosDb), MainnetSpecProvider.Instance, NullTxPool.Instance, NullBloomStorage.Instance, LimboLogs.Instance);
FastHeadersSyncFeed feed = new FastHeadersSyncFeed(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();
}
public void Can_restore()
{
MemDbProvider provider = new MemDbProvider(NullLogManager.Instance);
provider.GetOrCreateCodeDb();
provider.GetOrCreateStateDb();
for (int i = 0; i < 1000; i++)
{
int snapshot = provider.TakeSnapshot();
provider.Restore(snapshot);
}
Assert.AreEqual(0, provider.Snapshots.Count);
}
public void Does_not_keep_unnecessary_snapshots()
{
MemDbProvider provider = new MemDbProvider(NullLogManager.Instance);
provider.GetOrCreateCodeDb();
provider.GetOrCreateStateDb();
for (int i = 0; i < 1000; i++)
{
provider.TakeSnapshot();
provider.Commit(Olympic.Instance);
}
Assert.AreEqual(0, provider.Snapshots.Count);
}
private void SetupBeamProcessor()
{
MemDbProvider memDbProvider = new MemDbProvider();
_ = new BeamBlockchainProcessor(
new ReadOnlyDbProvider(memDbProvider, false),
_blockTree,
MainNetSpecProvider.Instance,
LimboLogs.Instance,
_validator,
NullRecoveryStep.Instance,
new InstanceRewardCalculatorSource(NoBlockRewards.Instance),
_blockchainProcessor
);
}
private void SetupBeamProcessor(ISyncModeSelector syncModeSelector = null)
{
MemDbProvider memDbProvider = new MemDbProvider();
_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 Can_keep_returning_nulls_after_all_batches_were_prepared()
{
MemDbProvider memDbProvider = new MemDbProvider();
BlockTree blockTree = new BlockTree(memDbProvider.BlocksDb, memDbProvider.HeadersDb, memDbProvider.BlockInfosDb, new ChainLevelInfoRepository(memDbProvider.BlockInfosDb), MainnetSpecProvider.Instance, NullTxPool.Instance, NullBloomStorage.Instance, LimboLogs.Instance);
FastHeadersSyncFeed feed = new FastHeadersSyncFeed(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 static INdmBlockchainBridge BuildABridge()
{
MemDbProvider memDbProvider = new MemDbProvider();
StateReader stateReader = new StateReader(memDbProvider.StateDb, memDbProvider.CodeDb, LimboLogs.Instance);
StateProvider stateProvider = new StateProvider(memDbProvider.StateDb, memDbProvider.CodeDb, LimboLogs.Instance);
StorageProvider storageProvider = new StorageProvider(memDbProvider.StateDb, stateProvider, LimboLogs.Instance);
IEthereumEcdsa ecdsa = new EthereumEcdsa(MainNetSpecProvider.Instance, LimboLogs.Instance);
ITxPool txPool = new TxPool.TxPool(new InMemoryTxStorage(), Timestamper.Default, ecdsa, MainNetSpecProvider.Instance, new TxPoolConfig(), stateProvider, LimboLogs.Instance);
// BlockTree blockTree = new BlockTree(memDbProvider.BlocksDb, memDbProvider.HeadersDb, memDbProvider.BlockInfosDb, new ChainLevelInfoRepository(memDbProvider.BlockInfosDb), MainNetSpecProvider.Instance, txPool, NullBloomStorage.Instance, new SyncConfig(), LimboLogs.Instance);
BlockTree blockTree = Build.A.BlockTree().OfChainLength(1).TestObject;
IWallet wallet = new DevWallet(new WalletConfig(), LimboLogs.Instance);
VirtualMachine virtualMachine = new VirtualMachine(stateProvider, storageProvider, new BlockhashProvider(blockTree, LimboLogs.Instance), MainNetSpecProvider.Instance, LimboLogs.Instance);
TransactionProcessor processor = new TransactionProcessor(MainNetSpecProvider.Instance, stateProvider, storageProvider, virtualMachine, LimboLogs.Instance);
BlockchainBridge blockchainBridge = new BlockchainBridge(stateReader, stateProvider, storageProvider, blockTree, txPool, new InMemoryReceiptStorage(), NullFilterStore.Instance, NullFilterManager.Instance, wallet, processor, ecdsa, NullBloomStorage.Instance, new ReceiptsRecovery());
return(new NdmBlockchainBridge(blockchainBridge, txPool));
}
public VirtualMachineTests()
{
_spec = RopstenSpecProvider.Instance;
ILogManager logger = NullLogManager.Instance;
IDb codeDb = new MemDb();
_stateDb = new SnapshotableDb(new MemDb());
StateTree stateTree = new StateTree(_stateDb);
_stateProvider = new StateProvider(stateTree, codeDb, logger);
_storageDbProvider = new MemDbProvider(logger);
_storageProvider = new StorageProvider(_storageDbProvider, _stateProvider, logger);
_ethereumSigner = new EthereumSigner(_spec, logger);
IBlockhashProvider blockhashProvider = new TestBlockhashProvider();
IVirtualMachine virtualMachine = new VirtualMachine(_stateProvider, _storageProvider, blockhashProvider, logger);
_processor = new TransactionProcessor(_spec, _stateProvider, _storageProvider, virtualMachine, this, logger);
}
public SyncingContext(SynchronizerType synchronizerType)
{
_logger = _logManager.GetClassLogger();
ISyncConfig syncConfig = synchronizerType == SynchronizerType.Fast ? SyncConfig.WithFastSync : SyncConfig.WithFullSyncOnly;
MemDbProvider dbProvider = new MemDbProvider();
ISnapshotableDb stateDb = dbProvider.StateDb;
ISnapshotableDb codeDb = dbProvider.CodeDb;
MemDb blockInfoDb = new MemDb();
BlockTree = new BlockTree(new MemDb(), new MemDb(), blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), new SingleReleaseSpecProvider(Constantinople.Instance, 1), NullBloomStorage.Instance, _logManager);
NodeStatsManager stats = new NodeStatsManager(_logManager);
SyncPeerPool = new SyncPeerPool(BlockTree, stats, 25, _logManager);
SyncProgressResolver syncProgressResolver = new SyncProgressResolver(BlockTree, NullReceiptStorage.Instance, stateDb, new MemDb(), syncConfig, _logManager);
MultiSyncModeSelector syncModeSelector = new MultiSyncModeSelector(syncProgressResolver, SyncPeerPool, syncConfig, _logManager);
Synchronizer = new Synchronizer(
dbProvider,
MainnetSpecProvider.Instance,
BlockTree,
NullReceiptStorage.Instance,
Always.Valid,
Always.Valid,
SyncPeerPool,
stats,
syncModeSelector,
syncConfig,
_logManager);
SyncServer = new SyncServer(stateDb, codeDb, BlockTree, NullReceiptStorage.Instance, Always.Valid, Always.Valid, SyncPeerPool, syncModeSelector, syncConfig, _logManager);
SyncPeerPool.Start();
Synchronizer.Start();
Synchronizer.SyncEvent += SynchronizerOnSyncEvent;
AllInstances.Add(this);
}
public static INdmBlockchainBridge BuildABridge()
{
MemDbProvider memDbProvider = new MemDbProvider();
StateReader stateReader = new StateReader(memDbProvider.StateDb, memDbProvider.CodeDb, LimboLogs.Instance);
StateProvider stateProvider = new StateProvider(memDbProvider.StateDb, memDbProvider.CodeDb, LimboLogs.Instance);
StorageProvider storageProvider = new StorageProvider(memDbProvider.StateDb, stateProvider, LimboLogs.Instance);
IEthereumEcdsa ecdsa = new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance);
ITxPool txPool = new TxPool.TxPool(new InMemoryTxStorage(), Timestamper.Default, ecdsa, MainnetSpecProvider.Instance, new TxPoolConfig(), stateProvider, LimboLogs.Instance);
// BlockTree blockTree = new BlockTree(memDbProvider.BlocksDb, memDbProvider.HeadersDb, memDbProvider.BlockInfosDb, new ChainLevelInfoRepository(memDbProvider.BlockInfosDb), MainnetSpecProvider.Instance, txPool, NullBloomStorage.Instance, new SyncConfig(), LimboLogs.Instance);
BlockTree blockTree = Build.A.BlockTree().OfChainLength(1).TestObject;
IWallet wallet = new DevWallet(new WalletConfig(), LimboLogs.Instance);
VirtualMachine virtualMachine = new VirtualMachine(stateProvider, storageProvider, new BlockhashProvider(blockTree, LimboLogs.Instance), MainnetSpecProvider.Instance, LimboLogs.Instance);
TransactionProcessor processor = new TransactionProcessor(MainnetSpecProvider.Instance, stateProvider, storageProvider, virtualMachine, LimboLogs.Instance);
ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(memDbProvider, false),
new ReadOnlyBlockTree(blockTree),
MainnetSpecProvider.Instance, LimboLogs.Instance);
BlockchainBridge blockchainBridge = new BlockchainBridge(
processingEnv,
txPool,
new InMemoryReceiptStorage(),
NullFilterStore.Instance,
NullFilterManager.Instance,
ecdsa,
NullBloomStorage.Instance,
Timestamper.Default,
LimboLogs.Instance,
false,
false);
WalletTxSigner txSigner = new WalletTxSigner(wallet, ChainId.Mainnet);
ITxSealer txSealer0 = new TxSealer(txSigner, Timestamper.Default);
ITxSealer txSealer1 = new NonceReservingTxSealer(txSigner, Timestamper.Default, txPool);
ITxSender txSender = new TxPoolSender(txPool, txSealer0, txSealer1);
return(new NdmBlockchainBridge(blockchainBridge, blockTree, stateReader, txSender));
}
public void Initialize()
{
ISpecProvider specProvider = MainnetSpecProvider.Instance;
ITxPool txPool = NullTxPool.Instance;
MemDbProvider dbProvider = new MemDbProvider();
IJsonRpcConfig jsonRpcConfig = new JsonRpcConfig();
BlockTree blockTree = new BlockTree(dbProvider.BlocksDb, dbProvider.HeadersDb, dbProvider.BlockInfosDb, new ChainLevelInfoRepository(dbProvider.BlockInfosDb), specProvider, txPool, NullBloomStorage.Instance, new SyncConfig(), LimboLogs.Instance);
_factory = new EthModuleFactory(
dbProvider,
txPool,
Substitute.For <ITxSender>(),
NullWallet.Instance,
blockTree,
new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance),
NullBlockProcessor.Instance,
new InMemoryReceiptStorage(),
specProvider,
new JsonRpcConfig(),
NullBloomStorage.Instance,
LimboLogs.Instance, false);
}
public void Setup()
{
_genesisBlock = Build.A.Block.WithNumber(0).TestObject;
_blockTree = Build.A.BlockTree(_genesisBlock).OfChainLength(1).TestObject;
MemDbProvider dbProvider = new MemDbProvider();
_stateDb = dbProvider.StateDb;
_codeDb = dbProvider.CodeDb;
_receiptsDb = dbProvider.ReceiptsDb;
_receiptStorage = Substitute.For <IReceiptStorage>();
SyncConfig quickConfig = new SyncConfig();
quickConfig.FastSync = false;
var stats = new NodeStatsManager(new StatsConfig(), LimboLogs.Instance);
_pool = new SyncPeerPool(_blockTree, stats, 25, LimboLogs.Instance);
SyncConfig syncConfig = new SyncConfig();
SyncProgressResolver resolver = new SyncProgressResolver(_blockTree, _receiptStorage, _stateDb, dbProvider.BeamStateDb, 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, LimboLogs.Instance);
}
private void Initialize(bool auRa = false)
{
MemDbProvider dbProvider = new MemDbProvider();
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 Build_some_chain()
{
/* logging & instrumentation */
var logger = new OneLoggerLogManager(new SimpleConsoleLogger());
/* spec */
var blockMiningTime = TimeSpan.FromMilliseconds(500);
var sealEngine = new FakeSealEngine(blockMiningTime);
var specProvider = RopstenSpecProvider.Instance;
/* store & validation */
var blockTree = new BlockTree(new MemDb(), new MemDb(), new MemDb(), specProvider, logger);
var difficultyCalculator = new DifficultyCalculator(specProvider);
var headerValidator = new HeaderValidator(difficultyCalculator, blockTree, sealEngine, specProvider, logger);
var ommersValidator = new OmmersValidator(blockTree, headerValidator, logger);
var transactionValidator = new TransactionValidator(new SignatureValidator(ChainId.Ropsten));
var blockValidator = new BlockValidator(transactionValidator, headerValidator, ommersValidator, specProvider, logger);
/* state & storage */
var dbProvider = new MemDbProvider(logger);
var stateTree = new StateTree(dbProvider.GetOrCreateStateDb());
var stateProvider = new StateProvider(stateTree, dbProvider.GetOrCreateCodeDb(), logger);
var storageProvider = new StorageProvider(dbProvider, stateProvider, logger);
/* blockchain processing */
var ethereumSigner = new EthereumSigner(specProvider, logger);
var transactionStore = new TransactionStore();
var blockhashProvider = new BlockhashProvider(blockTree);
var virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, logger);
var processor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, NullTracer.Instance, logger);
var rewardCalculator = new RewardCalculator(specProvider);
var blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, processor, dbProvider, stateProvider, storageProvider, transactionStore, logger);
var blockchainProcessor = new BlockchainProcessor(blockTree, sealEngine, transactionStore, difficultyCalculator, blockProcessor, ethereumSigner, logger);
/* load ChainSpec and init */
ChainSpecLoader loader = new ChainSpecLoader(new UnforgivingJsonSerializer());
string path = Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\..\..\Chains", "ropsten.json"));
logger.GetClassLogger().Info($"Loading ChainSpec from {path}");
ChainSpec chainSpec = loader.Load(File.ReadAllBytes(path));
foreach (KeyValuePair <Address, BigInteger> allocation in chainSpec.Allocations)
{
stateProvider.CreateAccount(allocation.Key, allocation.Value);
}
stateProvider.Commit(specProvider.GenesisSpec);
chainSpec.Genesis.Header.StateRoot = stateProvider.StateRoot; // TODO: shall it be HeaderSpec and not BlockHeader?
chainSpec.Genesis.Header.Hash = BlockHeader.CalculateHash(chainSpec.Genesis.Header);
if (chainSpec.Genesis.Hash != new Keccak("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d"))
{
throw new Exception("Unexpected genesis hash");
}
/* start processing */
sealEngine.IsMining = true;
var testTransactionsGenerator = new TestTransactionsGenerator(transactionStore, ethereumSigner, blockMiningTime, logger);
testTransactionsGenerator.Start();
blockchainProcessor.Start();
blockTree.SuggestBlock(chainSpec.Genesis);
BigInteger roughlyNumberOfBlocks = 6;
Thread.Sleep(blockMiningTime * (int)roughlyNumberOfBlocks);
await blockchainProcessor.StopAsync(false);
Assert.GreaterOrEqual(blockTree.Head.Number, roughlyNumberOfBlocks - 2, "number of blocks");
Assert.GreaterOrEqual(blockTree.Head.TotalTransactions, roughlyNumberOfBlocks - 2, "number of transactions");
}
public void Get_storage()
{
MemDbProvider dbProvider = new MemDbProvider();
/* all testing will be touching just a single storage cell */
StorageCell storageCell = new StorageCell(_address1, UInt256.One);
StateProvider state = new StateProvider(dbProvider, Logger);
StorageProvider storage = new StorageProvider(dbProvider, 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();
/* 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();
state.Commit(MuirGlacier.Instance);
state.CommitTree();
StateReader reader = new StateReader(dbProvider, 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(dbProvider, LimboLogs.Instance);
processorStateProvider.StateRoot = state.StateRoot;
StorageProvider processorStorageProvider =
new StorageProvider(dbProvider, processorStateProvider, LimboLogs.Instance);
processorStorageProvider.Set(storageCell, newValue);
processorStorageProvider.Commit();
processorStorageProvider.CommitTrees();
processorStateProvider.Commit(MuirGlacier.Instance);
processorStateProvider.CommitTree();
/* 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 */
}
public void GlobalSetup()
{
var dbProvider = new MemDbProvider();
ISnapshotableDb codeDb = dbProvider.CodeDb;
ISnapshotableDb stateDb = dbProvider.StateDb;
IDb blockInfoDb = new MemDb(10, 5);
ISpecProvider specProvider = MainnetSpecProvider.Instance;
IReleaseSpec spec = MainnetSpecProvider.Instance.GenesisSpec;
StateProvider stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance);
stateProvider.CreateAccount(Address.Zero, 1000.Ether());
stateProvider.Commit(spec);
StorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, LimboLogs.Instance);
StateReader stateReader = new StateReader(stateDb, codeDb, LimboLogs.Instance);
ChainLevelInfoRepository chainLevelInfoRepository = new ChainLevelInfoRepository(blockInfoDb);
BlockTree blockTree = new BlockTree(dbProvider, chainLevelInfoRepository, specProvider, NullTxPool.Instance, NullBloomStorage.Instance, LimboLogs.Instance);
_blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance);
_virtualMachine = new VirtualMachine(stateProvider, storageProvider, _blockhashProvider, specProvider, LimboLogs.Instance);
Block genesisBlock = Build.A.Block.Genesis.TestObject;
blockTree.SuggestBlock(genesisBlock);
Block block1 = Build.A.Block.WithParent(genesisBlock).WithNumber(1).TestObject;
blockTree.SuggestBlock(block1);
TransactionProcessor transactionProcessor
= new TransactionProcessor(MainnetSpecProvider.Instance, stateProvider, storageProvider, _virtualMachine, LimboLogs.Instance);
BlockProcessor blockProcessor = new BlockProcessor(specProvider, Always.Valid, new RewardCalculator(specProvider), transactionProcessor,
stateDb, codeDb, stateProvider, storageProvider, NullTxPool.Instance, NullReceiptStorage.Instance, LimboLogs.Instance);
EthereumEcdsa ecdsa = new EthereumEcdsa(specProvider.ChainId, LimboLogs.Instance);
BlockchainProcessor blockchainProcessor = new BlockchainProcessor(
blockTree,
blockProcessor,
new TxSignaturesRecoveryStep(
ecdsa,
NullTxPool.Instance,
specProvider,
LimboLogs.Instance),
LimboLogs.Instance,
BlockchainProcessor.Options.NoReceipts);
blockchainProcessor.Process(genesisBlock, ProcessingOptions.None, NullBlockTracer.Instance);
blockchainProcessor.Process(block1, ProcessingOptions.None, NullBlockTracer.Instance);
IBloomStorage bloomStorage = new BloomStorage(new BloomConfig(), new MemDb(), new InMemoryDictionaryFileStoreFactory());
LogFinder logFinder = new LogFinder(
blockTree,
new InMemoryReceiptStorage(),
bloomStorage,
LimboLogs.Instance,
new ReceiptsRecovery(ecdsa, specProvider));
BlockchainBridge bridge = new BlockchainBridge(
new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(dbProvider, false),
new ReadOnlyBlockTree(blockTree),
specProvider,
LimboLogs.Instance),
NullTxPool.Instance,
NullReceiptStorage.Instance,
NullFilterStore.Instance,
NullFilterManager.Instance,
ecdsa,
Timestamper.Default,
logFinder,
false,
false);
_ethModule = new EthModule(
new JsonRpcConfig(),
bridge,
blockTree,
stateReader,
NullTxPool.Instance,
NullTxSender.Instance,
NullWallet.Instance,
LimboLogs.Instance);
}
protected async Task RunTest(BlockchainTest test, Stopwatch stopwatch = null)
{
LoggingTraceListener traceListener = new LoggingTraceListener();
// TODO: not supported in .NET Core, need to replace?
// Debug.Listeners.Clear();
// Debug.Listeners.Add(traceListener);
IDbProvider dbProvider = new MemDbProvider(_logManager);
StateTree stateTree = new StateTree(dbProvider.GetOrCreateStateDb());
ISpecProvider specProvider;
if (test.NetworkAfterTransition != null)
{
specProvider = new CustomSpecProvider(
(0, Frontier.Instance),
(1, test.Network),
(test.TransitionBlockNumber, test.NetworkAfterTransition));
}
else
{
specProvider = new CustomSpecProvider(
(0, Frontier.Instance), // TODO: this thing took a lot of time to find after it was removed!, genesis block is always initialized with Frontier
(1, test.Network));
}
if (specProvider.GenesisSpec != Frontier.Instance)
{
Assert.Fail("Expected genesis spec to be Frontier for blockchain tests");
}
IDifficultyCalculator difficultyCalculator = new DifficultyCalculator(specProvider);
IRewardCalculator rewardCalculator = new RewardCalculator(specProvider);
IBlockTree blockTree = new BlockTree(new MemDb(), new MemDb(), new MemDb(), specProvider, _logManager);
IBlockhashProvider blockhashProvider = new BlockhashProvider(blockTree);
ISignatureValidator signatureValidator = new SignatureValidator(ChainId.MainNet);
ITransactionValidator transactionValidator = new TransactionValidator(signatureValidator);
IHeaderValidator headerValidator = new HeaderValidator(difficultyCalculator, blockTree, SealEngine, specProvider, _logManager);
IOmmersValidator ommersValidator = new OmmersValidator(blockTree, headerValidator, _logManager);
IBlockValidator blockValidator = new BlockValidator(transactionValidator, headerValidator, ommersValidator, specProvider, _logManager);
IStateProvider stateProvider = new StateProvider(stateTree, dbProvider.GetOrCreateCodeDb(), _logManager);
IStorageProvider storageProvider = new StorageProvider(dbProvider, stateProvider, _logManager);
IVirtualMachine virtualMachine = new VirtualMachine(
stateProvider,
storageProvider,
blockhashProvider,
_logManager);
ISealEngine sealEngine = new EthashSealEngine(new Ethash(_logManager), _logManager);
ITransactionStore transactionStore = new TransactionStore();
IEthereumSigner signer = new EthereumSigner(specProvider, _logManager);
IBlockProcessor blockProcessor = new BlockProcessor(
specProvider,
blockValidator,
rewardCalculator,
new TransactionProcessor(
specProvider,
stateProvider,
storageProvider,
virtualMachine,
NullTracer.Instance,
_logManager),
dbProvider,
stateProvider,
storageProvider,
transactionStore,
_logManager);
IBlockchainProcessor blockchainProcessor = new BlockchainProcessor(blockTree,
sealEngine,
transactionStore, difficultyCalculator, blockProcessor, signer, _logManager);
InitializeTestState(test, stateProvider, storageProvider, specProvider);
List <(Block Block, string ExpectedException)> correctRlpsBlocks = new List <(Block, string)>();
for (int i = 0; i < test.Blocks.Length; i++)
{
try
{
TestBlockJson testBlockJson = test.Blocks[i];
var rlpContext = Hex.ToBytes(testBlockJson.Rlp).AsRlpContext();
Block suggestedBlock = Rlp.Decode <Block>(rlpContext);
Assert.AreEqual(new Keccak(testBlockJson.BlockHeader.Hash), suggestedBlock.Header.Hash, "hash of the block");
for (int ommerIndex = 0; ommerIndex < suggestedBlock.Ommers.Length; ommerIndex++)
{
Assert.AreEqual(new Keccak(testBlockJson.UncleHeaders[ommerIndex].Hash), suggestedBlock.Ommers[ommerIndex].Hash, "hash of the ommer");
}
correctRlpsBlocks.Add((suggestedBlock, testBlockJson.ExpectedException));
}
catch (Exception e)
{
_logger?.Info($"Invalid RLP ({i})");
}
}
if (correctRlpsBlocks.Count == 0)
{
Assert.AreEqual(new Keccak(test.GenesisBlockHeader.Hash), test.LastBlockHash);
return;
}
if (test.GenesisRlp == null)
{
test.GenesisRlp = Rlp.Encode(new Block(Convert(test.GenesisBlockHeader)));
}
Block genesisBlock = Rlp.Decode <Block>(test.GenesisRlp.Bytes);
Assert.AreEqual(new Keccak(test.GenesisBlockHeader.Hash), genesisBlock.Header.Hash, "genesis header hash");
blockTree.NewHeadBlock += (sender, args) =>
{
if (args.Block.Number == 0)
{
Assert.AreEqual(genesisBlock.Header.StateRoot, stateTree.RootHash, "genesis state root");
}
};
blockchainProcessor.Start();
blockTree.SuggestBlock(genesisBlock);
for (int i = 0; i < correctRlpsBlocks.Count; i++)
{
stopwatch?.Start();
try
{
if (correctRlpsBlocks[i].ExpectedException != null)
{
_logger.Info($"Expecting block exception: {correctRlpsBlocks[i].ExpectedException}");
}
if (correctRlpsBlocks[i].Block.Hash == null)
{
throw new Exception($"null hash in {test.Name} block {i}");
}
// TODO: mimic the actual behaviour where block goes through validating sync manager?
if (blockValidator.ValidateSuggestedBlock(correctRlpsBlocks[i].Block))
{
blockTree.SuggestBlock(correctRlpsBlocks[i].Block);
}
else
{
Console.WriteLine("Invalid block");
}
}
catch (InvalidBlockException ex)
{
}
catch (Exception ex)
{
_logger?.Info(ex.ToString());
}
}
await blockchainProcessor.StopAsync(true);
stopwatch?.Stop();
RunAssertions(test, blockTree.RetrieveHeadBlock(), storageProvider, stateProvider);
}
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 = new MemDbProvider();
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,
Timestamper,
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, TxPool, NullBloomStorage.Instance, 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 TxSignaturesRecoveryStep(EthereumEcdsa, TxPool, SpecProvider, LimboLogs.Instance), LimboLogs.Instance, BlockchainProcessor.Options.Default);
chainProcessor.Start();
StateReader = new StateReader(StateDb, CodeDb, LimboLogs.Instance);
TxPoolTxSource txPoolTxSource = new TxPoolTxSource(TxPool, StateReader, LimboLogs.Instance);
ISealer sealer = new NethDevSealEngine(TestItem.AddressD);
BlockProducer = new TestBlockProducer(txPoolTxSource, chainProcessor, State, sealer, BlockTree, chainProcessor, Timestamper, LimboLogs.Instance);
BlockProducer.Start();
_resetEvent = new SemaphoreSlim(0);
BlockTree.NewHeadBlock += (s, e) =>
{
_resetEvent.Release(1);
};
var genesis = GetGenesisBlock();
BlockTree.SuggestBlock(genesis);
await _resetEvent.WaitAsync(CancellationToken.None);
await AddBlocksOnStart();
return(this);
}
public async Task Test()
{
TimeSpan miningDelay = TimeSpan.FromMilliseconds(50);
/* logging & instrumentation */
var logger = new OneLoggerLogManager(new SimpleConsoleLogger(true));
/* spec */
var sealEngine = new FakeSealEngine(miningDelay);
sealEngine.IsMining = true;
var specProvider = RopstenSpecProvider.Instance;
/* store & validation */
var blockTree = new BlockTree(new MemDb(), new MemDb(), new MemDb(), specProvider, logger);
var difficultyCalculator = new DifficultyCalculator(specProvider);
var headerValidator = new HeaderValidator(difficultyCalculator, blockTree, sealEngine, specProvider, logger);
var ommersValidator = new OmmersValidator(blockTree, headerValidator, logger);
var transactionValidator = new TransactionValidator(new SignatureValidator(ChainId.Ropsten));
var blockValidator = new BlockValidator(transactionValidator, headerValidator, ommersValidator, specProvider, logger);
/* state & storage */
var codeDb = new MemDb();
var stateDb = new MemDb();
var stateTree = new StateTree(stateDb);
var stateProvider = new StateProvider(stateTree, codeDb, logger);
var storageDbProvider = new MemDbProvider(logger);
var storageProvider = new StorageProvider(storageDbProvider, stateProvider, logger);
/* blockchain processing */
var ethereumSigner = new EthereumSigner(specProvider, logger);
var transactionStore = new TransactionStore();
var blockhashProvider = new BlockhashProvider(blockTree);
var virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, logger);
var processor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, NullTracer.Instance, logger);
var rewardCalculator = new RewardCalculator(specProvider);
var blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, processor, storageDbProvider, stateProvider, storageProvider, transactionStore, logger);
var blockchainProcessor = new BlockchainProcessor(blockTree, sealEngine, transactionStore, difficultyCalculator, blockProcessor, ethereumSigner, logger, new PerfService(NullLogManager.Instance));
/* load ChainSpec and init */
ChainSpecLoader loader = new ChainSpecLoader(new UnforgivingJsonSerializer());
string path = Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\..\..\Chains", "ropsten.json"));
logger.GetClassLogger().Info($"Loading ChainSpec from {path}");
ChainSpec chainSpec = loader.Load(File.ReadAllBytes(path));
foreach (KeyValuePair <Address, UInt256> allocation in chainSpec.Allocations)
{
stateProvider.CreateAccount(allocation.Key, allocation.Value);
}
stateProvider.Commit(specProvider.GenesisSpec);
chainSpec.Genesis.Header.StateRoot = stateProvider.StateRoot; // TODO: shall it be HeaderSpec and not BlockHeader?
chainSpec.Genesis.Header.Hash = BlockHeader.CalculateHash(chainSpec.Genesis.Header);
if (chainSpec.Genesis.Hash != new Keccak("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d"))
{
throw new Exception("Unexpected genesis hash");
}
/* start processing */
blockTree.SuggestBlock(chainSpec.Genesis);
blockchainProcessor.Start();
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
blockTree.NewHeadBlock += (sender, args) =>
{
if (args.Block.Number == 6)
{
manualResetEvent.Set();
}
};
manualResetEvent.WaitOne(miningDelay * 12);
await blockchainProcessor.StopAsync(true).ContinueWith(
t =>
{
if (t.IsFaulted)
{
throw t.Exception;
}
Assert.GreaterOrEqual((int)blockTree.Head.Number, 6);
});
}
private SyncTestContext CreateSyncManager(int index)
{
var logManager = NoErrorLimboLogs.Instance;
ConsoleAsyncLogger logger = new ConsoleAsyncLogger(LogLevel.Debug, "PEER " + index + " ");
// var logManager = new OneLoggerLogManager(logger);
var specProvider = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, MainnetSpecProvider.Instance.ChainId);
var dbProvider = new MemDbProvider();
IDb blockDb = dbProvider.BlocksDb;
IDb headerDb = dbProvider.HeadersDb;
IDb blockInfoDb = dbProvider.BlockInfosDb;
ISnapshotableDb codeDb = dbProvider.CodeDb;
ISnapshotableDb stateDb = dbProvider.StateDb;
var stateReader = new StateReader(stateDb, codeDb, logManager);
var stateProvider = new StateProvider(stateDb, codeDb, logManager);
stateProvider.CreateAccount(TestItem.AddressA, 10000.Ether());
stateProvider.Commit(specProvider.GenesisSpec);
stateProvider.CommitTree();
stateProvider.RecalculateStateRoot();
stateDb.Commit();
var storageProvider = new StorageProvider(stateDb, stateProvider, logManager);
var receiptStorage = new InMemoryReceiptStorage();
var ecdsa = new EthereumEcdsa(specProvider.ChainId, logManager);
var txPool = new TxPool.TxPool(new InMemoryTxStorage(), Timestamper.Default, ecdsa, specProvider, new TxPoolConfig(), stateProvider, logManager);
var tree = new BlockTree(blockDb, headerDb, blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), specProvider, txPool, NullBloomStorage.Instance, logManager);
var blockhashProvider = new BlockhashProvider(tree, LimboLogs.Instance);
var virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, specProvider, logManager);
var sealValidator = Always.Valid;
var headerValidator = new HeaderValidator(tree, sealValidator, specProvider, logManager);
var txValidator = Always.Valid;
var ommersValidator = new OmmersValidator(tree, headerValidator, logManager);
var blockValidator = new BlockValidator(txValidator, headerValidator, ommersValidator, specProvider, logManager);
ISyncConfig syncConfig = _synchronizerType == SynchronizerType.Fast ? SyncConfig.WithFastSync : SyncConfig.WithFullSyncOnly;
var rewardCalculator = new RewardCalculator(specProvider);
var txProcessor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, logManager);
var blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, txProcessor, stateDb, codeDb, stateProvider, storageProvider, txPool, receiptStorage, logManager);
var step = new TxSignaturesRecoveryStep(ecdsa, txPool, specProvider, logManager);
var processor = new BlockchainProcessor(tree, blockProcessor, step, logManager, BlockchainProcessor.Options.Default);
var nodeStatsManager = new NodeStatsManager(new StatsConfig(), logManager);
var syncPeerPool = new SyncPeerPool(tree, nodeStatsManager, 25, logManager);
StateProvider devState = new StateProvider(stateDb, codeDb, logManager);
StorageProvider devStorage = new StorageProvider(stateDb, devState, logManager);
var devEvm = new VirtualMachine(devState, devStorage, blockhashProvider, specProvider, logManager);
var devTxProcessor = new TransactionProcessor(specProvider, devState, devStorage, devEvm, logManager);
var devBlockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, devTxProcessor, stateDb, codeDb, devState, devStorage, txPool, receiptStorage, logManager);
var devChainProcessor = new BlockchainProcessor(tree, devBlockProcessor, step, logManager, BlockchainProcessor.Options.NoReceipts);
var transactionSelector = new TxPoolTxSource(txPool, stateReader, logManager);
var producer = new DevBlockProducer(
transactionSelector,
devChainProcessor,
stateProvider, tree,
processor,
txPool,
Timestamper.Default,
logManager);
SyncProgressResolver resolver = new SyncProgressResolver(tree, receiptStorage, stateDb, new MemDb(), syncConfig, logManager);
MultiSyncModeSelector selector = new MultiSyncModeSelector(resolver, syncPeerPool, syncConfig, logManager);
Synchronizer synchronizer = new Synchronizer(
dbProvider,
MainnetSpecProvider.Instance,
tree,
NullReceiptStorage.Instance,
blockValidator,
sealValidator,
syncPeerPool,
nodeStatsManager,
StaticSelector.Full,
syncConfig,
logManager);
var syncServer = new SyncServer(stateDb, codeDb, tree, receiptStorage, Always.Valid, Always.Valid, syncPeerPool, selector, syncConfig, logManager);
ManualResetEventSlim waitEvent = new ManualResetEventSlim();
tree.NewHeadBlock += (s, e) => waitEvent.Set();
if (index == 0)
{
_genesis = Build.A.Block.Genesis.WithStateRoot(stateProvider.StateRoot).TestObject;
producer.Start();
}
syncPeerPool.Start();
synchronizer.Start();
processor.Start();
tree.SuggestBlock(_genesis);
if (!waitEvent.Wait(1000))
{
throw new Exception("No genesis");
}
SyncTestContext context = new SyncTestContext();
context.Ecdsa = ecdsa;
context.BlockchainProcessor = processor;
context.PeerPool = syncPeerPool;
context.StateProvider = stateProvider;
context.Synchronizer = synchronizer;
context.SyncServer = syncServer;
context.Tree = tree;
context.BlockProducer = producer;
context.TxPool = txPool;
context.Logger = logger;
return(context);
}
