private static readonly Ethash Ethash = new Ethash(); // temporarily keep reusing the same one as otherwise it would recreate cache for each test
protected void Setup(ILogger logger)
{
_logger = logger;
ILogger stateLogger = ShouldLog.State ? _logger : null;
_multiDb = new MultiDb(stateLogger);
_chain = new BlockStore();
_blockhashProvider = new BlockhashProvider(_chain);
_virtualMachines = new Dictionary <EthereumNetwork, IVirtualMachine>();
_stateProviders = new Dictionary <EthereumNetwork, StateProvider>();
_storageProviders = new Dictionary <EthereumNetwork, IStorageProvider>();
_blockValidators = new Dictionary <EthereumNetwork, IBlockValidator>();
EthereumNetwork[] networks = { EthereumNetwork.Frontier, EthereumNetwork.Homestead, EthereumNetwork.Byzantium, EthereumNetwork.SpuriousDragon, EthereumNetwork.TangerineWhistle };
foreach (EthereumNetwork ethereumNetwork in networks)
{
IEthereumRelease spec = _protocolSpecificationProvider.GetSpec(ethereumNetwork, 1);
ISignatureValidator signatureValidator = new SignatureValidator(spec, ChainId.MainNet);
ITransactionValidator transactionValidator = new TransactionValidator(spec, signatureValidator);
IBlockHeaderValidator headerValidator = new BlockHeaderValidator(_chain, Ethash);
IOmmersValidator ommersValidator = new OmmersValidator(_chain, headerValidator);
IBlockValidator blockValidator = new BlockValidator(transactionValidator, headerValidator, ommersValidator, stateLogger);
_blockValidators[ethereumNetwork] = blockValidator;
_stateProviders[ethereumNetwork] = new StateProvider(new StateTree(_multiDb.CreateDb()), spec, stateLogger);
_storageProviders[ethereumNetwork] = new StorageProvider(_multiDb, _stateProviders[ethereumNetwork], stateLogger);
_virtualMachines[ethereumNetwork] = new VirtualMachine(
spec,
_stateProviders[ethereumNetwork],
_storageProviders[ethereumNetwork],
_blockhashProvider,
ShouldLog.Evm ? logger : null);
}
}
public void Setup()
{
_dbProvider = new MemDbProvider(_logManager);
_blockhashProvider = new TestBlockhashProvider();
_stateProvider = new StateProvider(new StateTree(_dbProvider.GetOrCreateStateDb()), _dbProvider.GetOrCreateCodeDb(), _logManager);
_storageProvider = new StorageProvider(new MemDbProvider(_logManager), _stateProvider, _logManager);
}
public void GlobalSetup()
{
ISnapshotableDb codeDb = new StateDb();
ISnapshotableDb stateDb = new 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(new MemDb(), new MemDb(), blockInfoDb, chainLevelInfoRepository, specProvider, NullTxPool.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, AlwaysValidBlockValidator.Instance, new RewardCalculator(specProvider), transactionProcessor,
stateDb, codeDb, new MemDb(), stateProvider, storageProvider, NullTxPool.Instance, NullReceiptStorage.Instance, LimboLogs.Instance);
BlockchainProcessor blockchainProcessor = new BlockchainProcessor(
blockTree,
blockProcessor,
new TxSignaturesRecoveryStep(new EthereumEcdsa(specProvider, LimboLogs.Instance), NullTxPool.Instance, LimboLogs.Instance),
LimboLogs.Instance,
false,
false);
blockchainProcessor.Process(genesisBlock, ProcessingOptions.None, NullBlockTracer.Instance);
blockchainProcessor.Process(block1, ProcessingOptions.None, NullBlockTracer.Instance);
BlockchainBridge bridge = new BlockchainBridge(
stateReader,
stateProvider,
storageProvider,
blockTree,
NullTxPool.Instance,
NullReceiptStorage.Instance,
NullFilterStore.Instance,
NullFilterManager.Instance, new DevWallet(new WalletConfig(), LimboLogs.Instance), transactionProcessor, new EthereumEcdsa(MainNetSpecProvider.Instance, LimboLogs.Instance));
_ethModule = new EthModule(LimboLogs.Instance, bridge);
}
public void Setup()
{
_stateDb = new StateDb();
_codeDb = new StateDb();
_blockhashProvider = new TestBlockhashProvider();
_stateProvider = new StateProvider(_stateDb, _codeDb, _logManager);
_storageProvider = new StorageProvider(_stateDb, _stateProvider, _logManager);
}
public void Setup()
{
_stateDb = new StateDb();
_codeDb = new StateDb();
_blockhashProvider = new TestBlockhashProvider();
_specProvider = OlympicSpecProvider.Instance;;
_stateProvider = new StateProvider(_stateDb, _codeDb, _logManager);
_storageProvider = new StorageProvider(_stateDb, _stateProvider, _logManager);
}
public RpcState(IBlockTree blockTree, ISpecProvider specProvider, IReadOnlyDbProvider readOnlyDbProvider,
ILogManager logManager)
{
var stateDb = readOnlyDbProvider.StateDb;
var codeDb = readOnlyDbProvider.CodeDb;
StateReader = new StateReader(readOnlyDbProvider.StateDb, codeDb, logManager);
StateProvider = new StateProvider(stateDb, codeDb, logManager);
StorageProvider = new StorageProvider(stateDb, StateProvider, logManager);
BlockTree = new ReadOnlyBlockTree(blockTree);
BlockhashProvider = new BlockhashProvider(BlockTree, logManager);
VirtualMachine = new VirtualMachine(StateProvider, StorageProvider, BlockhashProvider, logManager);
TransactionProcessor = new TransactionProcessor(specProvider, StateProvider, StorageProvider,
VirtualMachine, logManager);
}
public ReadOnlyTxProcessingEnv(IReadOnlyDbProvider readOnlyDbProvider, ReadOnlyBlockTree readOnlyBlockTree, ISpecProvider specProvider, ILogManager logManager)
{
ISnapshotableDb stateDb = readOnlyDbProvider.StateDb;
IDb codeDb = readOnlyDbProvider.CodeDb;
StateReader = new StateReader(stateDb, codeDb, logManager);
StateProvider = new StateProvider(stateDb, codeDb, logManager);
StorageProvider = new StorageProvider(stateDb, StateProvider, logManager);
BlockTree = readOnlyBlockTree;
BlockhashProvider = new BlockhashProvider(BlockTree, logManager);
VirtualMachine = new VirtualMachine(StateProvider, StorageProvider, BlockhashProvider, specProvider, logManager);
TransactionProcessor = new TransactionProcessor(specProvider, StateProvider, StorageProvider, VirtualMachine, logManager);
}
public virtual void Setup()
{
ILogManager logger = LimboLogs.Instance;
ISnapshotableDb beamSyncDb = new StateDb(new BeamSyncDb(new MemDb(), LimboLogs.Instance));
IDb beamSyncCodeDb = new BeamSyncDb(new MemDb(), LimboLogs.Instance);
IDb codeDb = UseBeamSync ? beamSyncCodeDb : new StateDb();
_stateDb = UseBeamSync ? beamSyncDb : new StateDb();
TestState = new StateProvider(_stateDb, codeDb, logger);
Storage = new StorageProvider(_stateDb, TestState, logger);
_ethereumEcdsa = new EthereumEcdsa(SpecProvider, logger);
IBlockhashProvider blockhashProvider = TestBlockhashProvider.Instance;
Machine = new VirtualMachine(TestState, Storage, blockhashProvider, SpecProvider, logger);
_processor = new TransactionProcessor(SpecProvider, TestState, Storage, Machine, logger);
}
public virtual void Setup()
{
ILogManager logManager = GetLogManager();
MemDb beamStateDb = new MemDb();
IDb beamSyncDb = new BeamSyncDb(new MemDb(), beamStateDb, StaticSelector.Full, logManager);
IDb beamSyncCodeDb = new BeamSyncDb(new MemDb(), beamStateDb, StaticSelector.Full, logManager);
IDb codeDb = UseBeamSync ? beamSyncCodeDb : new MemDb();
_stateDb = UseBeamSync ? beamSyncDb : new MemDb();
var trieStore = new TrieStore(_stateDb, logManager);
TestState = new StateProvider(trieStore, codeDb, logManager);
Storage = new StorageProvider(trieStore, TestState, logManager);
_ethereumEcdsa = new EthereumEcdsa(SpecProvider.ChainId, logManager);
IBlockhashProvider blockhashProvider = TestBlockhashProvider.Instance;
Machine = new VirtualMachine(TestState, Storage, blockhashProvider, SpecProvider, logManager);
_processor = new TransactionProcessor(SpecProvider, TestState, Storage, Machine, logManager);
}
public void GlobalSetup()
{
var dbProvider = TestMemDbProvider.Init();
IDb codeDb = dbProvider.CodeDb;
IDb stateDb = dbProvider.StateDb;
IDb blockInfoDb = new MemDb(10, 5);
ISpecProvider specProvider = MainnetSpecProvider.Instance;
IReleaseSpec spec = MainnetSpecProvider.Instance.GenesisSpec;
var trieStore = new TrieStore(stateDb, LimboLogs.Instance);
StateProvider stateProvider = new(trieStore, codeDb, LimboLogs.Instance);
stateProvider.CreateAccount(Address.Zero, 1000.Ether());
stateProvider.Commit(spec);
StorageProvider storageProvider = new(trieStore, stateProvider, LimboLogs.Instance);
StateReader stateReader = new(trieStore, codeDb, LimboLogs.Instance);
ChainLevelInfoRepository chainLevelInfoRepository = new (blockInfoDb);
BlockTree blockTree = new(dbProvider, chainLevelInfoRepository, specProvider, NullBloomStorage.Instance, LimboLogs.Instance);
_blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance);
_virtualMachine = new VirtualMachine(_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(MainnetSpecProvider.Instance, stateProvider, storageProvider, _virtualMachine, LimboLogs.Instance);
IBlockProcessor.IBlockTransactionsExecutor transactionsExecutor = new BlockProcessor.BlockValidationTransactionsExecutor(transactionProcessor, stateProvider);
BlockProcessor blockProcessor = new(specProvider, Always.Valid, new RewardCalculator(specProvider), transactionsExecutor,
stateProvider, storageProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, LimboLogs.Instance);
EthereumEcdsa ecdsa = new(specProvider.ChainId, LimboLogs.Instance);
BlockchainProcessor blockchainProcessor = new(
blockTree,
blockProcessor,
new RecoverSignatures(
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(
blockTree,
new InMemoryReceiptStorage(),
bloomStorage,
LimboLogs.Instance,
new ReceiptsRecovery(ecdsa, specProvider));
BlockchainBridge bridge = new(
new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(dbProvider, false),
trieStore.AsReadOnly(),
new ReadOnlyBlockTree(blockTree),
specProvider,
LimboLogs.Instance),
NullTxPool.Instance,
NullReceiptStorage.Instance,
NullFilterStore.Instance,
NullFilterManager.Instance,
ecdsa,
Timestamper.Default,
logFinder,
specProvider,
false);
GasPriceOracle gasPriceOracle = new(blockTree, specProvider);
FeeHistoryOracle feeHistoryOracle = new(blockTree, NullReceiptStorage.Instance, specProvider);
EthSyncingInfo ethSyncingInfo = new(blockTree);
_ethModule = new EthRpcModule(
new JsonRpcConfig(),
bridge,
blockTree,
stateReader,
NullTxPool.Instance,
NullTxSender.Instance,
NullWallet.Instance,
Substitute.For <IReceiptFinder>(),
LimboLogs.Instance,
specProvider,
gasPriceOracle,
ethSyncingInfo,
feeHistoryOracle);
}
