public TransactionProcessorTests(bool eip155Enabled)
{
_isEip155Enabled = eip155Enabled;
_specProvider = eip155Enabled ? (ISpecProvider)MainnetSpecProvider.Instance : MainnetSpecProvider.Instance;
}
public TxBundleSimulator(ITracerFactory tracerFactory, IGasLimitCalculator gasLimitCalculator, ITimestamper timestamper, ITxPool txPool, ISpecProvider specProvider, ISigner?signer) : base(tracerFactory, specProvider, signer)
{
_gasLimitCalculator = gasLimitCalculator;
_timestamper = timestamper;
_txPool = txPool;
}
private static void LoadGenesisBlock(ChainSpec chainSpec, Keccak expectedGenesisHash, BlockTree blockTree, StateProvider stateProvider, ISpecProvider specProvider)
{
// if we already have a database with blocks then we do not need to load genesis from spec
if (blockTree.Genesis != null)
{
return;
}
foreach (KeyValuePair <Address, BigInteger> allocation in chainSpec.Allocations)
{
stateProvider.CreateAccount(allocation.Key, allocation.Value);
}
stateProvider.Commit(specProvider.GenesisSpec);
Block genesis = chainSpec.Genesis;
genesis.StateRoot = stateProvider.StateRoot;
genesis.Hash = BlockHeader.CalculateHash(genesis.Header);
ManualResetEvent genesisProcessedEvent = new ManualResetEvent(false);
void GenesisProcessed(object sender, BlockEventArgs args)
{
blockTree.NewHeadBlock -= GenesisProcessed;
genesisProcessedEvent.Set();
}
blockTree.NewHeadBlock += GenesisProcessed;
blockTree.SuggestBlock(genesis);
genesisProcessedEvent.WaitOne();
// if expectedGenesisHash is null here then it means that we do not care about the exact value in advance (e.g. in test scenarios)
if (expectedGenesisHash != null && blockTree.Genesis.Hash != expectedGenesisHash)
{
throw new Exception($"Unexpected genesis hash, expected {expectedGenesisHash}, but was {blockTree.Genesis.Hash}");
}
}
public RewardCalculator(ISpecProvider specProvider)
{
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
}
private void InitializeTestState(GeneralStateTest test, IStateProvider stateProvider, IStorageProvider storageProvider, ISpecProvider specProvider)
{
foreach (KeyValuePair <Address, AccountState> accountState in test.Pre)
{
foreach (KeyValuePair <UInt256, byte[]> storageItem in accountState.Value.Storage)
{
storageProvider.Set(new StorageCell(accountState.Key, storageItem.Key), storageItem.Value.WithoutLeadingZeros().ToArray());
}
stateProvider.CreateAccount(accountState.Key, accountState.Value.Balance);
Keccak codeHash = stateProvider.UpdateCode(accountState.Value.Code);
stateProvider.UpdateCodeHash(accountState.Key, codeHash, specProvider.GenesisSpec);
for (int i = 0; i < accountState.Value.Nonce; i++)
{
stateProvider.IncrementNonce(accountState.Key);
}
}
storageProvider.Commit();
stateProvider.Commit(specProvider.GenesisSpec);
storageProvider.CommitTrees();
stateProvider.CommitTree();
storageProvider.Reset();
stateProvider.Reset();
}
public On CreateNode(PrivateKey privateKey, bool withGenesisAlreadyProcessed = false)
{
if (_logger.IsInfo)
{
_logger.Info($"CREATING NODE {privateKey.Address}");
}
_logManagers[privateKey] = LimboLogs.Instance;
// _logManagers[privateKey] = new OneLoggerLogManager(new ConsoleAsyncLogger(LogLevel.Debug, $"{privateKey.Address} "));
var nodeLogManager = _logManagers[privateKey];
AutoResetEvent newHeadBlockEvent = new AutoResetEvent(false);
_blockEvents.Add(privateKey, newHeadBlockEvent);
MemDb blocksDb = new MemDb();
MemDb headersDb = new MemDb();
MemDb blockInfoDb = new MemDb();
ISnapshotableDb stateDb = new StateDb();
ISnapshotableDb codeDb = new StateDb();
ISpecProvider specProvider = RinkebySpecProvider.Instance;
StateReader stateReader = new StateReader(stateDb, codeDb, nodeLogManager);
StateProvider stateProvider = new StateProvider(stateDb, codeDb, nodeLogManager);
stateProvider.CreateAccount(TestItem.PrivateKeyD.Address, 100.Ether());
stateProvider.Commit(GoerliSpecProvider.Instance.GenesisSpec);
stateProvider.CommitTree();
TxPool.TxPool txPool = new TxPool.TxPool(new InMemoryTxStorage(), _timestamper, _ethereumEcdsa, GoerliSpecProvider.Instance, new TxPoolConfig(), stateProvider, _logManager);
_pools[privateKey] = txPool;
BlockTree blockTree = new BlockTree(blocksDb, headersDb, blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), GoerliSpecProvider.Instance, txPool, NullBloomStorage.Instance, nodeLogManager);
blockTree.NewHeadBlock += (sender, args) => { _blockEvents[privateKey].Set(); };
BlockhashProvider blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance);
_blockTrees.Add(privateKey, blockTree);
IBasicWallet wallet = new BasicWallet(privateKey);
SnapshotManager snapshotManager = new SnapshotManager(_cliqueConfig, blocksDb, blockTree, _ethereumEcdsa, nodeLogManager);
_snapshotManager[privateKey] = snapshotManager;
CliqueSealer cliqueSealer = new CliqueSealer(wallet, _cliqueConfig, snapshotManager, privateKey.Address, nodeLogManager);
_genesis.Header.StateRoot = _genesis3Validators.Header.StateRoot = stateProvider.StateRoot;
_genesis.Header.Hash = _genesis.Header.CalculateHash();
_genesis3Validators.Header.Hash = _genesis3Validators.Header.CalculateHash();
StorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, nodeLogManager);
TransactionProcessor transactionProcessor = new TransactionProcessor(GoerliSpecProvider.Instance, stateProvider, storageProvider, new VirtualMachine(stateProvider, storageProvider, blockhashProvider, specProvider, nodeLogManager), nodeLogManager);
BlockProcessor blockProcessor = new BlockProcessor(GoerliSpecProvider.Instance, Always.Valid, NoBlockRewards.Instance, transactionProcessor, stateDb, codeDb, stateProvider, storageProvider, txPool, NullReceiptStorage.Instance, nodeLogManager);
BlockchainProcessor processor = new BlockchainProcessor(blockTree, blockProcessor, new AuthorRecoveryStep(snapshotManager), nodeLogManager, false);
processor.Start();
StateProvider minerStateProvider = new StateProvider(stateDb, codeDb, nodeLogManager);
StorageProvider minerStorageProvider = new StorageProvider(stateDb, minerStateProvider, nodeLogManager);
VirtualMachine minerVirtualMachine = new VirtualMachine(minerStateProvider, minerStorageProvider, blockhashProvider, specProvider, nodeLogManager);
TransactionProcessor minerTransactionProcessor = new TransactionProcessor(GoerliSpecProvider.Instance, minerStateProvider, minerStorageProvider, minerVirtualMachine, nodeLogManager);
BlockProcessor minerBlockProcessor = new BlockProcessor(GoerliSpecProvider.Instance, Always.Valid, NoBlockRewards.Instance, minerTransactionProcessor, stateDb, codeDb, minerStateProvider, minerStorageProvider, txPool, NullReceiptStorage.Instance, nodeLogManager);
BlockchainProcessor minerProcessor = new BlockchainProcessor(blockTree, minerBlockProcessor, new AuthorRecoveryStep(snapshotManager), nodeLogManager, false);
if (withGenesisAlreadyProcessed)
{
ProcessGenesis(privateKey);
}
TxPoolTxSource txPoolTxSource = new TxPoolTxSource(txPool, stateReader, nodeLogManager);
CliqueBlockProducer blockProducer = new CliqueBlockProducer(txPoolTxSource, minerProcessor, minerStateProvider, blockTree, _timestamper, new CryptoRandom(), snapshotManager, cliqueSealer, privateKey.Address, _cliqueConfig, nodeLogManager);
blockProducer.Start();
_producers.Add(privateKey, blockProducer);
return(this);
}
public FixedBlockChainHeadSpecProvider(ISpecProvider specProvider, long fixedBlock = 10_000_000)
{
_specProvider = specProvider;
_fixedBlock = fixedBlock;
}
public BlockValidator(ITxValidator txValidator, IHeaderValidator headerValidator, IOmmersValidator ommersValidator, ISpecProvider specProvider, ILogManager logManager)
{
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
_txValidator = txValidator ?? throw new ArgumentNullException(nameof(headerValidator));
_ommersValidator = ommersValidator ?? throw new ArgumentNullException(nameof(ommersValidator));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_headerValidator = headerValidator ?? throw new ArgumentNullException(nameof(headerValidator));
}
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 KatVirtualMachine(IStateProvider stateProvider, IStorageProvider storageProvider, IStateUpdateHashProvider blockhashProvider, ISpecProvider specProvider, ILogManager logManager)
: base(stateProvider, storageProvider, blockhashProvider, specProvider, logManager)
{
}
private async Task InitBlockchain()
{
_specProvider = new ChainSpecBasedSpecProvider(_chainSpec);
Account.AccountStartNonce = _chainSpec.Parameters.AccountStartNonce;
/* sync */
IDbConfig dbConfig = _configProvider.GetConfig <IDbConfig>();
_syncConfig = _configProvider.GetConfig <ISyncConfig>();
foreach (PropertyInfo propertyInfo in typeof(IDbConfig).GetProperties())
{
if (_logger.IsDebug)
{
_logger.Debug($"DB {propertyInfo.Name}: {propertyInfo.GetValue(dbConfig)}");
}
}
_dbProvider = HiveEnabled
? (IDbProvider) new MemDbProvider()
: new RocksDbProvider(_initConfig.BaseDbPath, dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts || _syncConfig.DownloadReceiptsInFastSync);
_ethereumEcdsa = new EthereumEcdsa(_specProvider, _logManager);
_txPool = new TxPool(
new PersistentTxStorage(_dbProvider.PendingTxsDb, _specProvider),
Timestamp.Default,
_ethereumEcdsa,
_specProvider,
_txPoolConfig, _logManager);
var _rc7FixDb = _initConfig.EnableRc7Fix ? _dbProvider.HeadersDb : NullDb.Instance;
_receiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _rc7FixDb, _specProvider, _logManager);
// IDbProvider debugRecorder = new RocksDbProvider(Path.Combine(_dbBasePath, "debug"), dbConfig);
// _dbProvider = new RpcDbProvider(_jsonSerializer, new BasicJsonRpcClient(KnownRpcUris.NethVm1, _jsonSerializer, _logManager), _logManager, debugRecorder);
// IDbProvider debugReader = new ReadOnlyDbProvider(new RocksDbProvider(Path.Combine(_dbBasePath, "debug"), dbConfig));
// _dbProvider = debugReader;
_blockTree = new BlockTree(
_dbProvider.BlocksDb,
_dbProvider.HeadersDb,
_dbProvider.BlockInfosDb,
_specProvider,
_txPool,
_syncConfig,
_logManager);
_recoveryStep = new TxSignaturesRecoveryStep(_ethereumEcdsa, _txPool, _logManager);
CliqueConfig cliqueConfig = null;
_snapshotManager = null;
switch (_chainSpec.SealEngineType)
{
case SealEngineType.None:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Clique:
_rewardCalculator = NoBlockRewards.Instance;
cliqueConfig = new CliqueConfig();
cliqueConfig.BlockPeriod = _chainSpec.Clique.Period;
cliqueConfig.Epoch = _chainSpec.Clique.Epoch;
_snapshotManager = new SnapshotManager(cliqueConfig, _dbProvider.BlocksDb, _blockTree, _ethereumEcdsa, _logManager);
_sealValidator = new CliqueSealValidator(cliqueConfig, _snapshotManager, _logManager);
_recoveryStep = new CompositeDataRecoveryStep(_recoveryStep, new AuthorRecoveryStep(_snapshotManager));
if (_initConfig.IsMining)
{
_sealer = new CliqueSealer(new BasicWallet(_nodeKey), cliqueConfig, _snapshotManager, _nodeKey.Address, _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
break;
case SealEngineType.NethDev:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Ethash:
_rewardCalculator = new RewardCalculator(_specProvider);
var difficultyCalculator = new DifficultyCalculator(_specProvider);
if (_initConfig.IsMining)
{
_sealer = new EthashSealer(new Ethash(_logManager), _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
_sealValidator = new EthashSealValidator(_logManager, difficultyCalculator, new Ethash(_logManager));
break;
default:
throw new NotSupportedException($"Seal engine type {_chainSpec.SealEngineType} is not supported in Nethermind");
}
/* validation */
_headerValidator = new HeaderValidator(
_blockTree,
_sealValidator,
_specProvider,
_logManager);
var ommersValidator = new OmmersValidator(
_blockTree,
_headerValidator,
_logManager);
var txValidator = new TxValidator(_specProvider.ChainId);
_blockValidator = new BlockValidator(
txValidator,
_headerValidator,
ommersValidator,
_specProvider,
_logManager);
var stateProvider = new StateProvider(
_dbProvider.StateDb,
_dbProvider.CodeDb,
_logManager);
_stateProvider = stateProvider;
var storageProvider = new StorageProvider(
_dbProvider.StateDb,
stateProvider,
_logManager);
_txPoolInfoProvider = new TxPoolInfoProvider(stateProvider);
_transactionPoolInfoProvider = new TxPoolInfoProvider(stateProvider);
/* blockchain processing */
var blockhashProvider = new BlockhashProvider(
_blockTree, _logManager);
var virtualMachine = new VirtualMachine(
stateProvider,
storageProvider,
blockhashProvider,
_logManager);
var transactionProcessor = new TransactionProcessor(
_specProvider,
stateProvider,
storageProvider,
virtualMachine,
_logManager);
_blockProcessor = new BlockProcessor(
_specProvider,
_blockValidator,
_rewardCalculator,
transactionProcessor,
_dbProvider.StateDb,
_dbProvider.CodeDb,
_dbProvider.TraceDb,
stateProvider,
storageProvider,
_txPool,
_receiptStorage,
_logManager);
_blockchainProcessor = new BlockchainProcessor(
_blockTree,
_blockProcessor,
_recoveryStep,
_logManager,
_initConfig.StoreReceipts,
_initConfig.StoreTraces);
// create shared objects between discovery and peer manager
IStatsConfig statsConfig = _configProvider.GetConfig <IStatsConfig>();
_nodeStatsManager = new NodeStatsManager(statsConfig, _logManager);
if (_initConfig.IsMining)
{
IReadOnlyDbProvider minerDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
AlternativeChain producerChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator,
_specProvider, minerDbProvider, _recoveryStep, _logManager, _txPool, _receiptStorage);
switch (_chainSpec.SealEngineType)
{
case SealEngineType.Clique:
{
if (_logger.IsWarn)
{
_logger.Warn("Starting Clique block producer & sealer");
}
_blockProducer = new CliqueBlockProducer(_txPool, producerChain.Processor,
_blockTree, _timestamp, _cryptoRandom, producerChain.StateProvider, _snapshotManager, (CliqueSealer)_sealer, _nodeKey.Address, cliqueConfig, _logManager);
break;
}
case SealEngineType.NethDev:
{
if (_logger.IsWarn)
{
_logger.Warn("Starting Dev block producer & sealer");
}
_blockProducer = new DevBlockProducer(_txPool, producerChain.Processor, _blockTree,
_timestamp, _logManager);
break;
}
default:
throw new NotSupportedException($"Mining in {_chainSpec.SealEngineType} mode is not supported");
}
_blockProducer.Start();
}
_blockchainProcessor.Start();
LoadGenesisBlock(_chainSpec, string.IsNullOrWhiteSpace(_initConfig.GenesisHash) ? null : new Keccak(_initConfig.GenesisHash), _blockTree, stateProvider, _specProvider);
if (_initConfig.ProcessingEnabled)
{
#pragma warning disable 4014
LoadBlocksFromDb();
#pragma warning restore 4014
}
else
{
if (_logger.IsWarn)
{
_logger.Warn($"Shutting down the blockchain processor due to {nameof(InitConfig)}.{nameof(InitConfig.ProcessingEnabled)} set to false");
}
await _blockchainProcessor.StopAsync();
}
if (HiveEnabled)
{
await InitHive();
}
if (HiveEnabled)
{
await InitHive();
}
var producers = new List <IProducer>();
if (_initConfig.PubSubEnabled)
{
var kafkaProducer = await PrepareKafkaProducer(_blockTree, _configProvider.GetConfig <IKafkaConfig>());
producers.Add(kafkaProducer);
}
var grpcClientConfig = _configProvider.GetConfig <IGrpcClientConfig>();
if (grpcClientConfig.Enabled)
{
var grpcProducer = new GrpcProducer(_grpcClient, _logManager);
producers.Add(grpcProducer);
}
ISubscription subscription;
if (producers.Any())
{
subscription = new Subscription(producers, _blockProcessor, _logManager);
}
else
{
subscription = new EmptySubscription();
}
_disposeStack.Push(subscription);
_dataBridge = new DataBridge(subscription, _receiptStorage, _blockTree, _logManager);
_dataBridge.Start();
await InitializeNetwork();
}
public PersistentTxStorage(IDb database, ISpecProvider specProvider)
{
_database = database;
_specProvider = specProvider;
}
public HeaderValidator(IDifficultyCalculator difficultyCalculator, IBlockTree blockTree, ISealEngine sealEngine, ISpecProvider specProvider, ILogManager logManager)
{
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
_difficultyCalculator = difficultyCalculator ?? throw new ArgumentNullException(nameof(difficultyCalculator));
_blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_sealEngine = sealEngine ?? throw new ArgumentNullException(nameof(sealEngine));
_daoBlockNumber = specProvider?.DaoBlockNumber;
}
public ReceiptsRecovery(IEthereumEcdsa ecdsa, ISpecProvider specProvider)
{
_ecdsa = ecdsa ?? throw new ArgumentNullException(nameof(ecdsa));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
}
public NewHeadSubscription(IJsonRpcDuplexClient jsonRpcDuplexClient, IBlockTree?blockTree, ILogManager?logManager, ISpecProvider specProvider, Filter?filter = null)
: base(jsonRpcDuplexClient)
{
_blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
_includeTransactions = filter?.IncludeTransactions ?? false;
_specProvider = specProvider;
_blockTree.BlockAddedToMain += OnBlockAddedToMain;
if (_logger.IsTrace)
{
_logger.Trace($"NewHeads subscription {Id} will track BlockAddedToMain");
}
}
private void InitializeTestState(BlockchainTest test, IStateProvider stateProvider, IStorageProvider storageProvider, ISpecProvider specProvider)
{
foreach (KeyValuePair <Address, AccountState> accountState in
((IEnumerable <KeyValuePair <Address, AccountState> >)test.Pre ?? Array.Empty <KeyValuePair <Address, AccountState> >()))
{
foreach (KeyValuePair <UInt256, byte[]> storageItem in accountState.Value.Storage)
{
storageProvider.Set(new StorageCell(accountState.Key, storageItem.Key), storageItem.Value);
}
stateProvider.CreateAccount(accountState.Key, accountState.Value.Balance);
Keccak codeHash = stateProvider.UpdateCode(accountState.Value.Code);
stateProvider.UpdateCodeHash(accountState.Key, codeHash, specProvider.GenesisSpec);
for (int i = 0; i < accountState.Value.Nonce; i++)
{
stateProvider.IncrementNonce(accountState.Key);
}
}
storageProvider.Commit();
stateProvider.Commit(specProvider.GenesisSpec);
storageProvider.CommitTrees(0);
stateProvider.CommitTree(0);
storageProvider.Reset();
stateProvider.Reset();
}
public ReceiptsMessageSerializer(ISpecProvider specProvider)
{
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
}
public void Initialize()
{
Rlp.RegisterDecoders(typeof(ParityTraceDecoder).Assembly);
ISpecProvider specProvider = MainNetSpecProvider.Instance;
IEthereumEcdsa ethereumEcdsa = new EthereumEcdsa(specProvider, LimboLogs.Instance);
ITxStorage txStorage = new InMemoryTxStorage();
ITxPool txPool = new TxPool(txStorage, Timestamp.Default, ethereumEcdsa, specProvider, new TxPoolConfig(), LimboLogs.Instance);
ISnapshotableDb stateDb = new StateDb();
ISnapshotableDb codeDb = new StateDb();
IStateReader stateReader = new StateReader(stateDb, codeDb, LimboLogs.Instance);
IStateProvider stateProvider = new StateProvider(stateDb, codeDb, 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 StorageAddress(TestItem.AddressA, UInt256.One), Bytes.FromHexString("0xabcdef"));
storageProvider.Commit();
stateProvider.Commit(specProvider.GenesisSpec);
IDb blockDb = new MemDb();
IDb headerDb = new MemDb();
IDb blockInfoDb = new MemDb();
IDb traceDb = new MemDb();
IBlockTree blockTree = new BlockTree(blockDb, headerDb, blockInfoDb, specProvider, txPool, LimboLogs.Instance);
IReceiptStorage receiptStorage = new InMemoryReceiptStorage();
VirtualMachine virtualMachine = new VirtualMachine(stateProvider, storageProvider, new BlockhashProvider(blockTree, LimboLogs.Instance), LimboLogs.Instance);
TransactionProcessor txProcessor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, LimboLogs.Instance);
IBlockProcessor blockProcessor = new BlockProcessor(specProvider, AlwaysValidBlockValidator.Instance, new RewardCalculator(specProvider), txProcessor, stateDb, codeDb, traceDb, stateProvider, storageProvider, txPool, receiptStorage, LimboLogs.Instance);
IFilterStore filterStore = new FilterStore();
IFilterManager filterManager = new FilterManager(filterStore, blockProcessor, txPool, LimboLogs.Instance);
_blockchainBridge = new BlockchainBridge(stateReader, stateProvider, storageProvider, blockTree, txPool, new TxPoolInfoProvider(stateProvider), receiptStorage, filterStore, filterManager, NullWallet.Instance, txProcessor, ethereumEcdsa);
BlockchainProcessor blockchainProcessor = new BlockchainProcessor(blockTree, blockProcessor, new TxSignaturesRecoveryStep(ethereumEcdsa, txPool, LimboLogs.Instance), LimboLogs.Instance, true, true);
blockchainProcessor.Start();
ManualResetEventSlim resetEvent = new ManualResetEventSlim(false);
blockTree.NewHeadBlock += (s, e) =>
{
if (e.Block.Number == 9)
{
resetEvent.Set();
}
};
Block genesis = Build.A.Block.Genesis.WithStateRoot(new Keccak("0x1ef7300d8961797263939a3d29bbba4ccf1702fabf02d8ad7a20b454edb6fd2f")).TestObject;
blockTree.SuggestBlock(genesis);
Block previousBlock = genesis;
for (int i = 1; i < 10; i++)
{
Block block = Build.A.Block.WithNumber(i).WithParent(previousBlock).WithStateRoot(new Keccak("0x1ef7300d8961797263939a3d29bbba4ccf1702fabf02d8ad7a20b454edb6fd2f")).TestObject;
blockTree.SuggestBlock(block);
previousBlock = block;
}
resetEvent.Wait();
_ethModule = new EthModule(LimboLogs.Instance, _blockchainBridge);
_blockTree = blockTree;
}
new protected async Task StartRunners(IConfigProvider configProvider)
{
InitRlp();
_configProvider = configProvider;
_initConfig = _configProvider.GetConfig <IInitConfig>();
_logManager = new NLogManager(_initConfig.LogFileName, _initConfig.LogDirectory);
_logger = _logManager.GetClassLogger();
_networkHelper = new NetworkHelper(_logger);
SetupKeyStore();
LoadChainSpec();
IDbConfig dbConfig = _configProvider.GetConfig <IDbConfig>();
_dbProvider = new RocksDbProvider(_initConfig.BaseDbPath, dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts);
var stateProvider = new StateProvider(
_dbProvider.StateDb,
_dbProvider.CodeDb,
_logManager);
_stateProvider = stateProvider;
/* blockchain processing */
if (_chainSpec.ChainId == RopstenSpecProvider.Instance.ChainId)
{
_specProvider = RopstenSpecProvider.Instance;
}
else if (_chainSpec.ChainId == MainNetSpecProvider.Instance.ChainId)
{
_specProvider = MainNetSpecProvider.Instance;
}
else if (_chainSpec.ChainId == RinkebySpecProvider.Instance.ChainId)
{
_specProvider = RinkebySpecProvider.Instance;
}
else if (_chainSpec.ChainId == GoerliSpecProvider.Instance.ChainId)
{
_specProvider = GoerliSpecProvider.Instance;
}
else
{
_specProvider = new SingleReleaseSpecProvider(Latest.Release, _chainSpec.ChainId);
}
_ethereumEcdsa = new EthereumEcdsa(_specProvider, _logManager);
_txPool = new TxPool(
new PersistentTransactionStorage(_dbProvider.PendingTxsDb, _specProvider),
new PendingTransactionThresholdValidator(_initConfig.ObsoletePendingTransactionInterval,
_initConfig.RemovePendingTransactionInterval), new Timestamp(),
_ethereumEcdsa, _specProvider, _logManager, _initConfig.RemovePendingTransactionInterval,
_initConfig.PeerNotificationThreshold);
_receiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _specProvider);
_blockTree = new BlockTree(
_dbProvider.BlocksDb,
_dbProvider.HeadersDb,
_dbProvider.BlockInfosDb,
_specProvider,
_txPool,
_logManager);
_recoveryStep = new TxSignaturesRecoveryStep(_ethereumEcdsa, _txPool, _logManager);
CliqueConfig cliqueConfig = null;
_snapshotManager = null;
switch (_chainSpec.SealEngineType)
{
case SealEngineType.None:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Clique:
_rewardCalculator = NoBlockRewards.Instance;
cliqueConfig = new CliqueConfig();
cliqueConfig.BlockPeriod = _chainSpec.Clique.Period;
cliqueConfig.Epoch = _chainSpec.Clique.Epoch;
_snapshotManager = new SnapshotManager(cliqueConfig, _dbProvider.BlocksDb, _blockTree, _ethereumEcdsa, _logManager);
_sealValidator = new CliqueSealValidator(cliqueConfig, _snapshotManager, _logManager);
_recoveryStep = new CompositeDataRecoveryStep(_recoveryStep, new AuthorRecoveryStep(_snapshotManager));
if (_initConfig.IsMining)
{
_sealer = new CliqueSealer(new BasicWallet(_nodeKey), cliqueConfig, _snapshotManager, _nodeKey.Address, _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
break;
case SealEngineType.NethDev:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Ethash:
_rewardCalculator = new RewardCalculator(_specProvider);
var difficultyCalculator = new DifficultyCalculator(_specProvider);
if (_initConfig.IsMining)
{
_sealer = new EthashSealer(new Ethash(_logManager), _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
_sealValidator = new EthashSealValidator(_logManager, difficultyCalculator, new Ethash(_logManager));
break;
default:
throw new NotSupportedException($"Seal engine type {_chainSpec.SealEngineType} is not supported in Nethermind");
}
_headerValidator = new HeaderValidator(
_blockTree,
_sealValidator,
_specProvider,
_logManager);
var ommersValidator = new OmmersValidator(
_blockTree,
_headerValidator,
_logManager);
var storageProvider = new StorageProvider(
_dbProvider.StateDb,
stateProvider,
_logManager);
var txValidator = new TxValidator(_specProvider.ChainId);
_blockValidator = new BlockValidator(
txValidator,
_headerValidator,
ommersValidator,
_specProvider,
_logManager);
var blockhashProvider = new BlockhashProvider(
_blockTree, _logManager);
var virtualMachine = new VirtualMachine(
stateProvider,
storageProvider,
blockhashProvider,
_logManager);
var transactionProcessor = new TransactionProcessor(
_specProvider,
stateProvider,
storageProvider,
virtualMachine,
_logManager);
_blockProcessor = new BlockProcessor(
_specProvider,
_blockValidator,
_rewardCalculator,
transactionProcessor,
_dbProvider.StateDb,
_dbProvider.CodeDb,
_dbProvider.TraceDb,
stateProvider,
storageProvider,
_txPool,
_receiptStorage,
_configProvider.GetConfig <ISyncConfig>(),
_logManager);
_blockchainProcessor = new BlockchainProcessor(
_blockTree,
_blockProcessor,
_recoveryStep,
_logManager,
_initConfig.StoreReceipts,
_initConfig.StoreTraces);
string chainFile = Path.Join(Path.GetDirectoryName(_initConfig.ChainSpecPath), "chain.rlp");
if (!File.Exists(chainFile))
{
_logger.Info($"Chain file does not exist: {chainFile}, skipping");
return;
}
var chainFileContent = File.ReadAllBytes(chainFile);
var context = new Rlp.DecoderContext(chainFileContent);
var blocks = new List <Block>();
while (context.ReadNumberOfItemsRemaining() > 0)
{
context.PeekNextItem();
blocks.Add(Rlp.Decode <Block>(context));
}
for (int i = 0; i < blocks.Count; i++)
{
ProcessBlock(blocks[i]);
}
}
public NdmRequiredServices(
IConfigProvider configProvider,
IConfigManager configManager,
INdmConfig ndmConfig,
string baseDbPath,
IDbProvider rocksProvider,
IMongoProvider mongoProvider,
ILogManager logManager,
IBlockTree blockTree,
ITxPool transactionPool,
ISpecProvider specProvider,
IReceiptStorage receiptStorage,
IFilterStore filterStore,
IFilterManager filterManager,
IWallet wallet,
ITimestamper timestamper,
IEthereumEcdsa ecdsa,
IKeyStore keyStore,
IRpcModuleProvider rpcModuleProvider,
IJsonSerializer jsonSerializer,
ICryptoRandom cryptoRandom,
IEnode enode,
INdmConsumerChannelManager ndmConsumerChannelManager,
INdmDataPublisher ndmDataPublisher,
IGrpcServer grpcServer,
IEthRequestService ethRequestService,
INdmNotifier notifier,
bool enableUnsecuredDevWallet,
IBlockProcessor blockProcessor,
IJsonRpcClientProxy?jsonRpcClientProxy,
IEthJsonRpcClientProxy?ethJsonRpcClientProxy,
IHttpClient httpClient,
IMonitoringService monitoringService,
IBloomStorage bloomStorage)
{
ConfigProvider = configProvider ?? throw new ArgumentNullException(nameof(configProvider));
ConfigManager = configManager ?? throw new ArgumentNullException(nameof(configManager));
NdmConfig = ndmConfig ?? throw new ArgumentNullException(nameof(ndmConfig));
BaseDbPath = baseDbPath ?? throw new ArgumentNullException(nameof(baseDbPath));
RocksProvider = rocksProvider ?? throw new ArgumentNullException(nameof(rocksProvider));
MongoProvider = mongoProvider ?? throw new ArgumentNullException(nameof(mongoProvider));
LogManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
BlockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
TransactionPool = transactionPool ?? throw new ArgumentNullException(nameof(transactionPool));
SpecProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
ReceiptStorage = receiptStorage ?? throw new ArgumentNullException(nameof(receiptStorage));
FilterStore = filterStore ?? throw new ArgumentNullException(nameof(filterStore));
FilterManager = filterManager ?? throw new ArgumentNullException(nameof(filterManager));
Wallet = wallet ?? throw new ArgumentNullException(nameof(wallet));
Timestamper = timestamper ?? throw new ArgumentNullException(nameof(timestamper));
Ecdsa = ecdsa ?? throw new ArgumentNullException(nameof(ecdsa));
KeyStore = keyStore ?? throw new ArgumentNullException(nameof(keyStore));
RpcModuleProvider = rpcModuleProvider ?? throw new ArgumentNullException(nameof(rpcModuleProvider));
JsonSerializer = jsonSerializer ?? throw new ArgumentNullException(nameof(jsonSerializer));
CryptoRandom = cryptoRandom ?? throw new ArgumentNullException(nameof(cryptoRandom));
Enode = enode ?? throw new ArgumentNullException(nameof(enode));
NdmConsumerChannelManager = ndmConsumerChannelManager ?? throw new ArgumentNullException(nameof(ndmConsumerChannelManager));
NdmDataPublisher = ndmDataPublisher ?? throw new ArgumentNullException(nameof(ndmDataPublisher));
GrpcServer = grpcServer ?? throw new ArgumentNullException(nameof(grpcServer));
EthRequestService = ethRequestService ?? throw new ArgumentNullException(nameof(ethRequestService));
Notifier = notifier ?? throw new ArgumentNullException(nameof(notifier));
EnableUnsecuredDevWallet = enableUnsecuredDevWallet;
BlockProcessor = blockProcessor ?? throw new ArgumentNullException(nameof(blockProcessor));
HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
MonitoringService = monitoringService ?? throw new ArgumentNullException(nameof(monitoringService));
JsonRpcClientProxy = jsonRpcClientProxy;
EthJsonRpcClientProxy = ethJsonRpcClientProxy;
BloomStorage = bloomStorage;
}
private (IBlockchainProcessor, IStateReader) CreateProcessor(Block block, IReadOnlyDbProvider readOnlyDbProvider, ISpecProvider specProvider, ILogManager logManager)
{
// TODO: need to pass the state with cache
ReadOnlyTxProcessingEnv txEnv = new(readOnlyDbProvider, new TrieStore(readOnlyDbProvider.StateDb, logManager).AsReadOnly(), _readOnlyBlockTree, specProvider, logManager);
ReadOnlyChainProcessingEnv env = new(txEnv, _blockValidator, _recoveryStep, _rewardCalculatorSource.Get(txEnv.TransactionProcessor), NullReceiptStorage.Instance, _readOnlyDbProvider, specProvider, logManager);
env.BlockProcessor.TransactionProcessed += (_, args) =>
{
Interlocked.Increment(ref Metrics.BeamedTransactions);
if (_logger.IsInfo)
{
_logger.Info($"Processed tx {args.Index + 1}/{block.Transactions?.Length} of {block.Number}");
}
};
return(env.ChainProcessor, txEnv.StateReader);
}
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, 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);
BlockchainProcessor blockchainProcessor = new BlockchainProcessor(
blockTree,
blockProcessor,
new TxSignaturesRecoveryStep(new EthereumEcdsa(specProvider, LimboLogs.Instance), NullTxPool.Instance, LimboLogs.Instance),
LimboLogs.Instance,
false);
blockchainProcessor.Process(genesisBlock, ProcessingOptions.None, NullBlockTracer.Instance);
blockchainProcessor.Process(block1, ProcessingOptions.None, NullBlockTracer.Instance);
IBloomStorage bloomStorage = new BloomStorage(new BloomConfig(), new MemDb(), new InMemoryDictionaryFileStoreFactory());
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),
bloomStorage,
LimboLogs.Instance,
false);
_ethModule = new EthModule(new JsonRpcConfig(), bridge, LimboLogs.Instance);
}
public async Task <TestRpcBlockchain> Build(ISpecProvider specProvider = null)
{
return((TestRpcBlockchain)(await _blockchain.Build(specProvider)));
}
private async Task InitBlockchain()
{
/* spec */
if (_chainSpec.ChainId == RopstenSpecProvider.Instance.ChainId)
{
_specProvider = RopstenSpecProvider.Instance;
}
else if (_chainSpec.ChainId == MainNetSpecProvider.Instance.ChainId)
{
_specProvider = MainNetSpecProvider.Instance;
}
else if (_chainSpec.ChainId == RinkebySpecProvider.Instance.ChainId)
{
_specProvider = RinkebySpecProvider.Instance;
}
else if (_chainSpec.ChainId == GoerliSpecProvider.Instance.ChainId)
{
_specProvider = GoerliSpecProvider.Instance;
}
else if (_chainSpec.ChainId == SturebySpecProvider.Instance.ChainId)
{
_specProvider = SturebySpecProvider.Instance;
}
else
{
_specProvider = new SingleReleaseSpecProvider(LatestRelease.Instance, _chainSpec.ChainId);
}
/* sync */
IDbConfig dbConfig = _configProvider.GetConfig <IDbConfig>();
foreach (PropertyInfo propertyInfo in typeof(IDbConfig).GetProperties())
{
if (_logger.IsDebug)
{
_logger.Debug($"DB {propertyInfo.Name}: {propertyInfo.GetValue(dbConfig)}");
}
}
_dbProvider = HiveEnabled
? (IDbProvider) new MemDbProvider()
: new RocksDbProvider(_initConfig.BaseDbPath, dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts);
_ethereumEcdsa = new EthereumEcdsa(_specProvider, _logManager);
_txPool = new TxPool(
new PersistentTransactionStorage(_dbProvider.PendingTxsDb, _specProvider),
new PendingTransactionThresholdValidator(_initConfig.ObsoletePendingTransactionInterval,
_initConfig.RemovePendingTransactionInterval), new Timestamp(),
_ethereumEcdsa, _specProvider, _logManager, _initConfig.RemovePendingTransactionInterval,
_initConfig.PeerNotificationThreshold);
_receiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _specProvider);
// IDbProvider debugRecorder = new RocksDbProvider(Path.Combine(_dbBasePath, "debug"), dbConfig);
// _dbProvider = new RpcDbProvider(_jsonSerializer, new BasicJsonRpcClient(KnownRpcUris.NethVm1, _jsonSerializer, _logManager), _logManager, debugRecorder);
// IDbProvider debugReader = new ReadOnlyDbProvider(new RocksDbProvider(Path.Combine(_dbBasePath, "debug"), dbConfig));
// _dbProvider = debugReader;
_blockTree = new BlockTree(
_dbProvider.BlocksDb,
_dbProvider.HeadersDb,
_dbProvider.BlockInfosDb,
_specProvider,
_txPool,
_logManager);
_recoveryStep = new TxSignaturesRecoveryStep(_ethereumEcdsa, _txPool, _logManager);
CliqueConfig cliqueConfig = null;
_snapshotManager = null;
switch (_chainSpec.SealEngineType)
{
case SealEngineType.None:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Clique:
_rewardCalculator = NoBlockRewards.Instance;
cliqueConfig = new CliqueConfig();
cliqueConfig.BlockPeriod = _chainSpec.CliquePeriod;
cliqueConfig.Epoch = _chainSpec.CliqueEpoch;
_snapshotManager = new SnapshotManager(cliqueConfig, _dbProvider.BlocksDb, _blockTree, _ethereumEcdsa, _logManager);
_sealValidator = new CliqueSealValidator(cliqueConfig, _snapshotManager, _logManager);
_recoveryStep = new CompositeDataRecoveryStep(_recoveryStep, new AuthorRecoveryStep(_snapshotManager));
if (_initConfig.IsMining)
{
_sealer = new CliqueSealer(new BasicWallet(_nodeKey), cliqueConfig, _snapshotManager, _nodeKey.Address, _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
break;
case SealEngineType.NethDev:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Ethash:
_rewardCalculator = new RewardCalculator(_specProvider);
var difficultyCalculator = new DifficultyCalculator(_specProvider);
if (_initConfig.IsMining)
{
_sealer = new EthashSealer(new Ethash(_logManager), _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
_sealValidator = new EthashSealValidator(_logManager, difficultyCalculator, new Ethash(_logManager));
break;
default:
throw new NotSupportedException($"Seal engine type {_chainSpec.SealEngineType} is not supported in Nethermind");
}
/* validation */
_headerValidator = new HeaderValidator(
_blockTree,
_sealValidator,
_specProvider,
_logManager);
var ommersValidator = new OmmersValidator(
_blockTree,
_headerValidator,
_logManager);
var txValidator = new TxValidator(_specProvider.ChainId);
_blockValidator = new BlockValidator(
txValidator,
_headerValidator,
ommersValidator,
_specProvider,
_logManager);
var stateProvider = new StateProvider(
_dbProvider.StateDb,
_dbProvider.CodeDb,
_logManager);
_stateProvider = stateProvider;
var storageProvider = new StorageProvider(
_dbProvider.StateDb,
stateProvider,
_logManager);
_transactionPoolInfoProvider = new TxPoolInfoProvider(stateProvider);
/* blockchain processing */
var blockhashProvider = new BlockhashProvider(
_blockTree, _logManager);
var virtualMachine = new VirtualMachine(
stateProvider,
storageProvider,
blockhashProvider,
_logManager);
var transactionProcessor = new TransactionProcessor(
_specProvider,
stateProvider,
storageProvider,
virtualMachine,
_logManager);
_blockProcessor = new BlockProcessor(
_specProvider,
_blockValidator,
_rewardCalculator,
transactionProcessor,
_dbProvider.StateDb,
_dbProvider.CodeDb,
_dbProvider.TraceDb,
stateProvider,
storageProvider,
_txPool,
_receiptStorage,
_configProvider.GetConfig <ISyncConfig>(),
_logManager);
_blockchainProcessor = new BlockchainProcessor(
_blockTree,
_blockProcessor,
_recoveryStep,
_logManager,
_initConfig.StoreReceipts,
_initConfig.StoreTraces);
// create shared objects between discovery and peer manager
IStatsConfig statsConfig = _configProvider.GetConfig <IStatsConfig>();
_nodeStatsManager = new NodeStatsManager(statsConfig, _logManager);
if (_initConfig.IsMining)
{
IReadOnlyDbProvider minerDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
AlternativeChain producerChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator,
_specProvider, minerDbProvider, _recoveryStep, _logManager, _txPool, _receiptStorage);
switch (_chainSpec.SealEngineType)
{
case SealEngineType.Clique:
{
if (_logger.IsWarn)
{
_logger.Warn("Starting Clique block producer & sealer");
}
_blockProducer = new CliqueBlockProducer(_txPool, producerChain.Processor,
_blockTree, _timestamp, _cryptoRandom, producerChain.StateProvider, _snapshotManager, (CliqueSealer)_sealer, _nodeKey.Address, cliqueConfig, _logManager);
break;
}
case SealEngineType.NethDev:
{
if (_logger.IsWarn)
{
_logger.Warn("Starting Dev block producer & sealer");
}
_blockProducer = new DevBlockProducer(_txPool, producerChain.Processor, _blockTree,
_timestamp, _logManager);
break;
}
default:
throw new NotSupportedException($"Mining in {_chainSpec.SealEngineType} mode is not supported");
}
_blockProducer.Start();
}
if (!HiveEnabled)
{
_blockchainProcessor.Start();
LoadGenesisBlock(_chainSpec, string.IsNullOrWhiteSpace(_initConfig.GenesisHash) ? null : new Keccak(_initConfig.GenesisHash), _blockTree, stateProvider, _specProvider);
if (_initConfig.ProcessingEnabled)
{
#pragma warning disable 4014
LoadBlocksFromDb();
#pragma warning restore 4014
}
else
{
if (_logger.IsWarn)
{
_logger.Warn($"Shutting down the blockchain processor due to {nameof(InitConfig)}.{nameof(InitConfig.ProcessingEnabled)} set to false");
}
await _blockchainProcessor.StopAsync();
}
}
await InitializeNetwork(
_receiptStorage,
_sealValidator,
txValidator);
}
public void order_is_correct(Func <IEnumerable <Transaction>, IEnumerable <Transaction> > transactionSelect)
{
IContractDataStore <Address> sendersWhitelist = Substitute.For <IContractDataStore <Address> >();
IDictionaryContractDataStore <TxPriorityContract.Destination> priorities = Substitute.For <IDictionaryContractDataStore <TxPriorityContract.Destination> >();
BlockHeader blockHeader = Build.A.BlockHeader.TestObject;
byte[] p5Signature = { 0, 1, 2, 3 };
byte[] p6Signature = { 0, 0, 0, 2 };
byte[] p0signature = { 0, 0, 0, 1 };
sendersWhitelist.GetItemsFromContractAtBlock(blockHeader).Returns(WhitelistedSenders);
SetPriority(priorities, blockHeader, TestItem.AddressB, p5Signature, 5);
SetPriority(priorities, blockHeader, TestItem.AddressB, p6Signature, 6);
Transaction A_B_0_10_10_P6 = Build.A.NamedTransaction(nameof(A_B_0_10_10_P6))
.WithSenderAddress(TestItem.AddressA)
.To(TestItem.AddressB)
.WithNonce(0)
.WithGasPrice(10)
.WithGasLimit(10)
.WithData(p6Signature)
.TestObject;
Transaction A_B_0_10_20_P6 = Build.A.NamedTransaction(nameof(A_B_0_10_20_P6))
.WithSenderAddress(TestItem.AddressA)
.To(TestItem.AddressB)
.WithNonce(0)
.WithGasPrice(10)
.WithGasLimit(20)
.WithData(p6Signature)
.TestObject;
Transaction A_B_0_10_5_P6 = Build.A.NamedTransaction(nameof(A_B_0_10_5_P6))
.WithSenderAddress(TestItem.AddressA)
.To(TestItem.AddressB)
.WithNonce(0)
.WithGasPrice(10)
.WithGasLimit(5)
.WithData(p6Signature)
.TestObject;
Transaction A_B_0_10_10_P5 = Build.A.NamedTransaction(nameof(A_B_0_10_10_P5))
.WithSenderAddress(TestItem.AddressA)
.To(TestItem.AddressB)
.WithNonce(0)
.WithGasPrice(10)
.WithGasLimit(10)
.WithData(p5Signature)
.TestObject;
Transaction A_B_0_20_10_P5 = Build.A.NamedTransaction(nameof(A_B_0_20_10_P5))
.WithSenderAddress(TestItem.AddressA)
.To(TestItem.AddressB)
.WithNonce(0)
.WithGasPrice(20)
.WithGasLimit(10)
.WithData(p5Signature)
.TestObject;
Transaction A_B_1_20_10_P5 = Build.A.NamedTransaction(nameof(A_B_1_20_10_P5))
.WithSenderAddress(TestItem.AddressA)
.To(TestItem.AddressB)
.WithNonce(1)
.WithGasPrice(20)
.WithGasLimit(10)
.WithData(p5Signature)
.TestObject;
Transaction A_B_1_200_10_P0 = Build.A.NamedTransaction(nameof(A_B_1_200_10_P0))
.WithSenderAddress(TestItem.AddressA)
.To(TestItem.AddressB)
.WithNonce(1)
.WithGasPrice(200)
.WithGasLimit(10)
.WithData(p0signature)
.TestObject;
Transaction A_A_0_100_100_P0 = Build.A.NamedTransaction(nameof(A_A_0_100_100_P0))
.WithSenderAddress(TestItem.AddressA)
.To(TestItem.AddressA)
.WithNonce(0)
.WithGasPrice(100)
.WithGasLimit(100)
.WithData(p5Signature)
.TestObject;
Transaction A_A_1_100_100_P0 = Build.A.NamedTransaction(nameof(A_A_1_100_100_P0))
.WithSenderAddress(TestItem.AddressA)
.To(TestItem.AddressA)
.WithNonce(1)
.WithGasPrice(100)
.WithGasLimit(100)
.WithData(p5Signature)
.TestObject;
Transaction A_A_1_1000_1000_P0 = Build.A.NamedTransaction(nameof(A_A_1_1000_1000_P0))
.WithSenderAddress(TestItem.AddressA)
.To(TestItem.AddressA)
.WithNonce(1)
.WithGasPrice(1000)
.WithGasLimit(1000)
.WithData(p5Signature)
.TestObject;
Transaction A_A_2_1000_1_P0 = Build.A.NamedTransaction(nameof(A_A_2_1000_1_P0))
.WithSenderAddress(TestItem.AddressA)
.To(TestItem.AddressA)
.WithNonce(2)
.WithGasPrice(1000)
.WithGasLimit(1)
.WithData(p5Signature)
.TestObject;
Transaction B_B_2_1000_1_P6 = Build.A.NamedTransaction(nameof(B_B_2_1000_1_P6))
.WithSenderAddress(TestItem.AddressB)
.To(TestItem.AddressB)
.WithNonce(2)
.WithGasPrice(1000)
.WithGasLimit(1)
.WithData(p6Signature)
.TestObject;
Transaction B_B_2_15_1_P5 = Build.A.NamedTransaction(nameof(B_B_2_15_1_P5))
.WithSenderAddress(TestItem.AddressB)
.To(TestItem.AddressB)
.WithNonce(2)
.WithGasPrice(15)
.WithGasLimit(1)
.WithData(p5Signature)
.TestObject;
Transaction B_B_3_15_1_P6 = Build.A.NamedTransaction(nameof(B_B_3_15_1_P6))
.WithSenderAddress(TestItem.AddressB)
.To(TestItem.AddressB)
.WithNonce(3)
.WithGasPrice(15)
.WithGasLimit(1)
.WithData(p6Signature)
.TestObject;
Transaction C_B_3_10_1_P6_W = Build.A.NamedTransaction(nameof(C_B_3_10_1_P6_W))
.WithSenderAddress(TestItem.AddressC)
.To(TestItem.AddressB)
.WithNonce(3)
.WithGasPrice(10)
.WithGasLimit(1)
.WithData(p6Signature)
.TestObject;
Transaction C_B_4_10_1_P0_W = Build.A.NamedTransaction(nameof(C_B_4_10_1_P0_W))
.WithSenderAddress(TestItem.AddressC)
.To(TestItem.AddressB)
.WithNonce(4)
.WithGasPrice(10)
.WithGasLimit(1)
.TestObject;
Transaction D_B_4_100_1_P0_W = Build.A.NamedTransaction(nameof(D_B_4_100_1_P0_W))
.WithSenderAddress(TestItem.AddressD)
.To(TestItem.AddressB)
.WithNonce(4)
.WithGasPrice(100)
.WithGasLimit(1)
.TestObject;
IEnumerable <Transaction> transactions = new []
{
A_B_1_200_10_P0,
A_A_2_1000_1_P0,
A_A_1_1000_1000_P0,
C_B_4_10_1_P0_W,
A_A_1_100_100_P0,
A_A_0_100_100_P0,
A_B_0_10_10_P5,
D_B_4_100_1_P0_W,
C_B_3_10_1_P6_W,
A_B_0_10_10_P6,
A_B_0_20_10_P5,
B_B_2_15_1_P5,
A_B_0_10_5_P6,
B_B_3_15_1_P6,
A_B_0_10_20_P6,
A_B_1_20_10_P5,
B_B_2_1000_1_P6
};
IEnumerable <Transaction> expectation = new []
{
C_B_3_10_1_P6_W,
D_B_4_100_1_P0_W,
C_B_4_10_1_P0_W,
B_B_2_1000_1_P6,
A_B_0_10_5_P6,
A_B_0_10_10_P6,
A_B_0_10_20_P6,
A_B_0_20_10_P5,
B_B_2_15_1_P5,
B_B_3_15_1_P6,
A_B_0_10_10_P5,
A_A_0_100_100_P0,
A_B_1_20_10_P5,
A_A_1_1000_1000_P0,
A_B_1_200_10_P0,
A_A_1_100_100_P0,
A_A_2_1000_1_P0
};
transactions = transactionSelect?.Invoke(transactions) ?? transactions;
expectation = transactionSelect?.Invoke(expectation) ?? expectation;
IBlockTree blockTree = Substitute.For <IBlockTree>();
Block block = Build.A.Block.WithNumber(0).TestObject;
blockTree.Head.Returns(block);
ISpecProvider specProvider = Substitute.For <ISpecProvider>();
specProvider.GetSpec(Arg.Any <long>()).Returns(new ReleaseSpec()
{
IsEip1559Enabled = false
});
TransactionComparerProvider transactionComparerProvider = new(specProvider, blockTree);
IComparer <Transaction> defaultComparer = transactionComparerProvider.GetDefaultComparer();
IComparer <Transaction> comparer = new CompareTxByPriorityOnSpecifiedBlock(sendersWhitelist, priorities, blockHeader)
.ThenBy(defaultComparer);
Dictionary <Address?, Transaction[]> txBySender = transactions.GroupBy(t => t.SenderAddress)
.ToDictionary(
g => g.Key,
g => g.OrderBy(t => t,
// to simulate order coming from TxPool
comparer.GetPoolUniqueTxComparerByNonce()).ToArray());
Transaction[] orderedTransactions = TxPoolTxSource.Order(txBySender, comparer).ToArray();
orderedTransactions.Should().BeEquivalentTo(expectation, o => o.WithStrictOrdering());
}
public void Setup()
{
_specProvider = RopstenSpecProvider.Instance;
_ethereumEcdsa = new EthereumEcdsa(_specProvider, NullLogManager.Instance);
}
public EthereumEcdsa(ISpecProvider specProvider, ILogManager logManager)
{
_specProvider = specProvider;
_logger = logManager.GetClassLogger();
_chainIdValue = specProvider.ChainId;
}
public EthashDifficultyCalculator(ISpecProvider specProvider)
{
_specProvider = specProvider;
}
public static IMinGasPriceTxFilter CreateStandardMinGasPriceTxFilter(IMiningConfig miningConfig, ISpecProvider specProvider) => new MinGasPriceTxFilter(miningConfig.MinGasPrice, specProvider);
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 StateProvider(trieStore, codeDb, LimboLogs.Instance);
stateProvider.CreateAccount(Address.Zero, 1000.Ether());
stateProvider.Commit(spec);
StorageProvider storageProvider = new StorageProvider(trieStore, stateProvider, LimboLogs.Instance);
StateReader stateReader = new StateReader(trieStore, codeDb, LimboLogs.Instance);
ChainLevelInfoRepository chainLevelInfoRepository = new ChainLevelInfoRepository(blockInfoDb);
BlockTree blockTree = new BlockTree(dbProvider, chainLevelInfoRepository, specProvider, 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,
stateProvider, storageProvider, NullTxPool.Instance, NullReceiptStorage.Instance, NullWitnessCollector.Instance, LimboLogs.Instance);
EthereumEcdsa ecdsa = new EthereumEcdsa(specProvider.ChainId, LimboLogs.Instance);
BlockchainProcessor blockchainProcessor = new BlockchainProcessor(
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 LogFinder(
blockTree,
new InMemoryReceiptStorage(),
bloomStorage,
LimboLogs.Instance,
new ReceiptsRecovery(ecdsa, specProvider));
BlockchainBridge bridge = new BlockchainBridge(
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,
false,
false);
_ethModule = new EthModule(
new JsonRpcConfig(),
bridge,
blockTree,
stateReader,
NullTxPool.Instance,
NullTxSender.Instance,
NullWallet.Instance,
LimboLogs.Instance);
}
