public DebugModuleFactory(
IDbProvider dbProvider,
IBlockTree blockTree,
IJsonRpcConfig jsonRpcConfig,
IBlockValidator blockValidator,
IBlockPreprocessorStep recoveryStep,
IRewardCalculatorSource rewardCalculator,
IReceiptStorage receiptStorage,
IReceiptsMigration receiptsMigration,
ITrieNodeResolver trieStore,
IConfigProvider configProvider,
ISpecProvider specProvider,
ILogManager logManager)
{
_dbProvider = dbProvider.AsReadOnly(false);
_blockTree = blockTree.AsReadOnly();
_jsonRpcConfig = jsonRpcConfig ?? throw new ArgumentNullException(nameof(jsonRpcConfig));
_blockValidator = blockValidator ?? throw new ArgumentNullException(nameof(blockValidator));
_recoveryStep = recoveryStep ?? throw new ArgumentNullException(nameof(recoveryStep));
_rewardCalculatorSource = rewardCalculator ?? throw new ArgumentNullException(nameof(rewardCalculator));
_receiptStorage = receiptStorage ?? throw new ArgumentNullException(nameof(receiptStorage));
_receiptsMigration = receiptsMigration ?? throw new ArgumentNullException(nameof(receiptsMigration));
_trieStore = (trieStore ?? throw new ArgumentNullException(nameof(trieStore))).AsReadOnly();
_configProvider = configProvider ?? throw new ArgumentNullException(nameof(configProvider));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_logManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
_logger = logManager.GetClassLogger();
}
public ProofModuleFactory(
IDbProvider dbProvider,
IBlockTree blockTree,
ITrieStore trieStore,
IBlockPreprocessorStep recoveryStep,
IReceiptFinder receiptFinder,
ISpecProvider specProvider,
ILogManager logManager)
{
_logManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
_recoveryStep = recoveryStep ?? throw new ArgumentNullException(nameof(recoveryStep));
_receiptFinder = receiptFinder ?? throw new ArgumentNullException(nameof(receiptFinder));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_dbProvider = dbProvider.AsReadOnly(false);
_blockTree = blockTree.AsReadOnly();
_trieStore = trieStore.AsReadOnly();
}
public void Setup()
{
IDb blocksDb = new MemDb();
IDb blocksInfoDb = new MemDb();
IDb headersDb = new MemDb();
ChainLevelInfoRepository repository = new ChainLevelInfoRepository(blocksInfoDb);
ISpecProvider specProvider = MainnetSpecProvider.Instance;
_blockTree = new BlockTree(blocksDb, headersDb, blocksInfoDb, repository, specProvider, NullBloomStorage.Instance, new SyncConfig(), LimboLogs.Instance);
MemDb stateDb = new MemDb();
MemDb codeDb = new MemDb();
ITrieStore trieStore = new ReadOnlyTrieStore(new TrieStore(stateDb, LimboLogs.Instance));
StateProvider stateProvider = new StateProvider(trieStore, codeDb, LimboLogs.Instance);
StorageProvider storageProvider = new StorageProvider(trieStore, stateProvider, LimboLogs.Instance);
BlockhashProvider blockhashProvider = new BlockhashProvider(_blockTree, LimboLogs.Instance);
VirtualMachine virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, specProvider, LimboLogs.Instance);
TransactionProcessor transactionProcessor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, LimboLogs.Instance);
BlockProcessor blockProcessor = new BlockProcessor(
specProvider,
Always.Valid,
NoBlockRewards.Instance,
transactionProcessor,
stateProvider,
storageProvider,
NullTxPool.Instance,
NullReceiptStorage.Instance,
NullWitnessCollector.Instance,
LimboLogs.Instance);
var txRecovery = new RecoverSignatures(new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance), NullTxPool.Instance, specProvider, LimboLogs.Instance);
_processor = new BlockchainProcessor(_blockTree, blockProcessor, txRecovery, LimboLogs.Instance, BlockchainProcessor.Options.NoReceipts);
Block genesis = Build.A.Block.Genesis.TestObject;
_blockTree.SuggestBlock(genesis);
_processor.Process(genesis, ProcessingOptions.None, NullBlockTracer.Instance);
_tracer = new Tracer(stateProvider, _processor);
}
public ReadOnlyTxProcessingEnv(
IReadOnlyDbProvider readOnlyDbProvider,
ReadOnlyTrieStore readOnlyTrieStore,
ReadOnlyBlockTree readOnlyBlockTree,
ISpecProvider specProvider,
ILogManager logManager)
{
DbProvider = readOnlyDbProvider;
_codeDb = readOnlyDbProvider.CodeDb.AsReadOnly(true);
StateReader = new StateReader(readOnlyTrieStore, _codeDb, logManager);
StateProvider = new StateProvider(readOnlyTrieStore, _codeDb, logManager);
StorageProvider = new StorageProvider(readOnlyTrieStore, StateProvider, logManager);
BlockTree = readOnlyBlockTree;
BlockhashProvider = new BlockhashProvider(BlockTree, logManager);
Machine = new VirtualMachine(StateProvider, StorageProvider, BlockhashProvider, specProvider, logManager);
TransactionProcessor = new TransactionProcessor(specProvider, StateProvider, StorageProvider, Machine, logManager);
}
protected override BlockProcessor CreateBlockProcessor()
{
var validator = new AuRaParameters.Validator()
{
Addresses = TestItem.Addresses,
ValidatorType = AuRaParameters.ValidatorType.List
};
TransactionPermissionContractVersions =
new LruCache <Keccak, UInt256>(PermissionBasedTxFilter.Cache.MaxCacheSize, nameof(TransactionPermissionContract));
var trieStore = new ReadOnlyTrieStore(new TrieStore(DbProvider.StateDb, LimboLogs.Instance));
IReadOnlyTxProcessorSource txProcessorSource = new ReadOnlyTxProcessingEnv(
DbProvider,
trieStore,
BlockTree,
SpecProvider,
LimboLogs.Instance);
var transactionPermissionContract = new VersionedTransactionPermissionContract(new AbiEncoder(), _contractAddress, 1,
new ReadOnlyTxProcessingEnv(DbProvider, trieStore, BlockTree, SpecProvider, LimboLogs.Instance), TransactionPermissionContractVersions, LimboLogs.Instance);
TxPermissionFilterCache = new PermissionBasedTxFilter.Cache();
PermissionBasedTxFilter = new PermissionBasedTxFilter(transactionPermissionContract, TxPermissionFilterCache, LimboLogs.Instance);
return(new AuRaBlockProcessor(
SpecProvider,
Always.Valid,
new RewardCalculator(SpecProvider),
TxProcessor,
State,
Storage,
TxPool,
ReceiptStorage,
LimboLogs.Instance,
BlockTree,
PermissionBasedTxFilter));
}
public TraceModuleFactory(
IDbProvider dbProvider,
IBlockTree blockTree,
ITrieNodeResolver trieNodeResolver,
IJsonRpcConfig jsonRpcConfig,
IBlockPreprocessorStep recoveryStep,
IRewardCalculatorSource rewardCalculatorSource,
IReceiptStorage receiptFinder,
ISpecProvider specProvider,
ILogManager logManager)
{
_dbProvider = dbProvider.AsReadOnly(false);
_blockTree = blockTree.AsReadOnly();
_trieNodeResolver = trieNodeResolver.AsReadOnly();
_jsonRpcConfig = jsonRpcConfig ?? throw new ArgumentNullException(nameof(jsonRpcConfig));
_recoveryStep = recoveryStep ?? throw new ArgumentNullException(nameof(recoveryStep));
_rewardCalculatorSource =
rewardCalculatorSource ?? throw new ArgumentNullException(nameof(rewardCalculatorSource));
_receiptStorage = receiptFinder ?? throw new ArgumentNullException(nameof(receiptFinder));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_logManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
_logger = logManager.GetClassLogger();
}
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();
MemDb stateDb = new MemDb();
MemDb codeDb = new MemDb();
ISpecProvider specProvider = RinkebySpecProvider.Instance;
var trieStore = new TrieStore(stateDb, nodeLogManager);
StateReader stateReader = new StateReader(trieStore, codeDb, nodeLogManager);
StateProvider stateProvider = new StateProvider(trieStore, codeDb, nodeLogManager);
stateProvider.CreateAccount(TestItem.PrivateKeyD.Address, 100.Ether());
GoerliSpecProvider goerliSpecProvider = GoerliSpecProvider.Instance;
stateProvider.Commit(goerliSpecProvider.GenesisSpec);
stateProvider.CommitTree(0);
BlockTree blockTree = new BlockTree(blocksDb, headersDb, blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), goerliSpecProvider, NullBloomStorage.Instance, nodeLogManager);
TxPool.TxPool txPool = new TxPool.TxPool(new InMemoryTxStorage(), _ethereumEcdsa, new ChainHeadSpecProvider(goerliSpecProvider, blockTree),
new TxPoolConfig(), stateProvider, new TxValidator(goerliSpecProvider.ChainId), _logManager);
_pools[privateKey] = txPool;
blockTree.NewHeadBlock += (sender, args) => { _blockEvents[privateKey].Set(); };
BlockhashProvider blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance);
_blockTrees.Add(privateKey, blockTree);
SnapshotManager snapshotManager = new SnapshotManager(_cliqueConfig, blocksDb, blockTree, _ethereumEcdsa, nodeLogManager);
_snapshotManager[privateKey] = snapshotManager;
CliqueSealer cliqueSealer = new CliqueSealer(new Signer(ChainId.Goerli, privateKey, LimboLogs.Instance), _cliqueConfig, snapshotManager, 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(trieStore, stateProvider, nodeLogManager);
TransactionProcessor transactionProcessor = new TransactionProcessor(goerliSpecProvider, stateProvider, storageProvider, new VirtualMachine(stateProvider, storageProvider, blockhashProvider, specProvider, nodeLogManager), nodeLogManager);
BlockProcessor blockProcessor = new BlockProcessor(
goerliSpecProvider,
Always.Valid,
NoBlockRewards.Instance,
transactionProcessor,
stateProvider,
storageProvider,
txPool,
NullReceiptStorage.Instance,
NullWitnessCollector.Instance,
nodeLogManager);
BlockchainProcessor processor = new BlockchainProcessor(blockTree, blockProcessor, new AuthorRecoveryStep(snapshotManager), nodeLogManager, BlockchainProcessor.Options.NoReceipts);
processor.Start();
var minerTrieStore = new ReadOnlyTrieStore(trieStore);
StateProvider minerStateProvider = new StateProvider(minerTrieStore, codeDb, nodeLogManager);
StorageProvider minerStorageProvider = new StorageProvider(minerTrieStore, minerStateProvider, nodeLogManager);
VirtualMachine minerVirtualMachine = new VirtualMachine(minerStateProvider, minerStorageProvider, blockhashProvider, specProvider, nodeLogManager);
TransactionProcessor minerTransactionProcessor = new TransactionProcessor(goerliSpecProvider, minerStateProvider, minerStorageProvider, minerVirtualMachine, nodeLogManager);
BlockProcessor minerBlockProcessor = new BlockProcessor(
goerliSpecProvider,
Always.Valid,
NoBlockRewards.Instance,
minerTransactionProcessor,
minerStateProvider,
minerStorageProvider,
txPool,
NullReceiptStorage.Instance,
NullWitnessCollector.Instance,
nodeLogManager);
BlockchainProcessor minerProcessor = new BlockchainProcessor(blockTree, minerBlockProcessor, new AuthorRecoveryStep(snapshotManager), nodeLogManager, BlockchainProcessor.Options.NoReceipts);
if (withGenesisAlreadyProcessed)
{
ProcessGenesis(privateKey);
}
TxPoolTxSource txPoolTxSource = new TxPoolTxSource(txPool, stateReader, nodeLogManager);
CliqueBlockProducer blockProducer = new CliqueBlockProducer(
txPoolTxSource,
minerProcessor,
minerStateProvider,
blockTree,
_timestamper,
new CryptoRandom(),
snapshotManager,
cliqueSealer,
new TargetAdjustedGasLimitCalculator(goerliSpecProvider, new MiningConfig()),
MainnetSpecProvider.Instance,
_cliqueConfig,
nodeLogManager);
blockProducer.Start();
_producers.Add(privateKey, blockProducer);
return(this);
}
