public override IEthModule Create()
{
ReadOnlyBlockTree readOnlyTree = new ReadOnlyBlockTree(_blockTree);
IReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree, _specProvider, _logManager);
var blockchainBridge = new BlockchainBridge(
readOnlyTxProcessingEnv.StateReader,
readOnlyTxProcessingEnv.StateProvider,
readOnlyTxProcessingEnv.StorageProvider,
readOnlyTxProcessingEnv.BlockTree,
_txPool,
_receiptStorage,
_filterStore,
_filterManager,
_wallet,
readOnlyTxProcessingEnv.TransactionProcessor,
_ethereumEcdsa,
_bloomStorage,
new ReceiptsRecovery(),
_logManager,
_rpcConfig.FindLogBlockDepthLimit);
return(new EthModule(_rpcConfig, _logManager, blockchainBridge));
}
public BlockchainBridge.CallOutput EstimateGas(BlockHeader header, Transaction tx, CancellationToken cancellationToken)
{
ReadOnlyTxProcessingEnv txProcessingEnv = _readOnlyTxProcessingEnvFactory.Create();
using IReadOnlyTransactionProcessor transactionProcessor = txProcessingEnv.Build(header.StateRoot !);
EstimateGasTracer estimateGasTracer = new();
(bool Success, string Error)tryCallResult = TryCallAndRestore(
transactionProcessor,
header,
UInt256.Max(header.Timestamp + 1, _timestamper.UnixTime.Seconds),
tx,
true,
estimateGasTracer.WithCancellation(cancellationToken));
GasEstimator gasEstimator = new(transactionProcessor, _stateProvider, _specProvider);
long estimate = gasEstimator.Estimate(tx, header, estimateGasTracer);
return(new BlockchainBridge.CallOutput
{
Error = tryCallResult.Success ? estimateGasTracer.Error : tryCallResult.Error,
GasSpent = estimate,
InputError = !tryCallResult.Success
});
}
public void Bridge_beam_head_is_correct_in_beam()
{
ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(_dbProvider, false),
new ReadOnlyTrieStore(new TrieStore(_dbProvider.StateDb, LimboLogs.Instance)),
new ReadOnlyBlockTree(_blockTree),
_specProvider,
LimboLogs.Instance);
Block block = Build.A.Block.WithNumber(7).TestObject;
_blockTree.Head.Returns(block);
_blockchainBridge = new BlockchainBridge(
processingEnv,
_txPool,
_receiptStorage,
_filterStore,
_filterManager,
_ethereumEcdsa,
_timestamper,
Substitute.For <ILogFinder>(),
false,
false);
_blockchainBridge.BeamHead.Number.Should().Be(7);
}
public override IEthModule Create()
{
ReadOnlyBlockTree readOnlyTree = new ReadOnlyBlockTree(_blockTree);
IReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree, _specProvider, _logManager);
TimeSpan cancellationTokenTimeout = TimeSpan.FromMilliseconds(_jsonRpcConfig.TracerTimeout);
CancellationToken cancellationToken = new CancellationTokenSource(cancellationTokenTimeout).Token;
var blockchainBridge = new BlockchainBridge(
readOnlyTxProcessingEnv.StateReader,
readOnlyTxProcessingEnv.StateProvider,
readOnlyTxProcessingEnv.StorageProvider,
readOnlyTxProcessingEnv.BlockTree,
_txPool,
_receiptFinder,
_filterStore,
_filterManager,
_wallet,
readOnlyTxProcessingEnv.TransactionProcessor,
_ethereumEcdsa,
_bloomStorage,
Timestamper.Default,
_logManager,
_isMining,
_rpcConfig.FindLogBlockDepthLimit,
cancellationToken);
TxPoolBridge txPoolBridge = new TxPoolBridge(_txPool, new WalletTxSigner(_wallet, _specProvider.ChainId), Timestamper.Default);
return(new EthModule(_rpcConfig, blockchainBridge, txPoolBridge, _logManager));
}
protected override BlockProcessor CreateBlockProcessor()
{
AbiEncoder abiEncoder = AbiEncoder.Instance;
ReadOnlyTransactionProcessorSource = new ReadOnlyTxProcessingEnv(
DbProvider,
new TrieStore(DbProvider.StateDb, LimboLogs.Instance).AsReadOnly(),
BlockTree, SpecProvider,
LimboLogs.Instance);
RegisterContract = new RegisterContract(abiEncoder, ChainSpec.Parameters.Registrar, ReadOnlyTransactionProcessorSource);
CertifierContract = new CertifierContract(
abiEncoder,
RegisterContract,
ReadOnlyTransactionProcessorSource);
return(new AuRaBlockProcessor(
SpecProvider,
Always.Valid,
new RewardCalculator(SpecProvider),
new BlockProcessor.BlockValidationTransactionsExecutor(TxProcessor, State),
State,
Storage,
ReceiptStorage,
LimboLogs.Instance,
BlockTree));
}
public Task InitBlockProducer()
{
if (_nethermindApi !.SealEngineType != SealEngineType.NethDev)
{
return(Task.CompletedTask);
}
var(getFromApi, setInApi) = _nethermindApi !.ForProducer;
ITxFilter txFilter = new NullTxFilter();
ITxSource txSource = new TxPoolTxSource(
getFromApi.TxPool, getFromApi.StateReader, getFromApi.LogManager, txFilter);
ILogger logger = getFromApi.LogManager.GetClassLogger();
if (logger.IsWarn)
{
logger.Warn("Starting Neth Dev block producer & sealer");
}
ReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(getFromApi.DbProvider, false);
ReadOnlyBlockTree readOnlyBlockTree = new ReadOnlyBlockTree(getFromApi.BlockTree);
ReadOnlyTxProcessingEnv producerEnv = new ReadOnlyTxProcessingEnv(
readOnlyDbProvider,
readOnlyBlockTree,
getFromApi.SpecProvider,
getFromApi.LogManager);
BlockProcessor producerProcessor = new BlockProcessor(
getFromApi !.SpecProvider,
getFromApi !.BlockValidator,
NoBlockRewards.Instance,
producerEnv.TransactionProcessor,
producerEnv.DbProvider.StateDb,
producerEnv.DbProvider.CodeDb,
producerEnv.StateProvider,
producerEnv.StorageProvider,
NullTxPool.Instance,
NullReceiptStorage.Instance,
getFromApi.LogManager);
IBlockchainProcessor producerChainProcessor = new BlockchainProcessor(
readOnlyBlockTree,
producerProcessor,
getFromApi.BlockPreprocessor,
getFromApi.LogManager,
BlockchainProcessor.Options.NoReceipts);
setInApi.BlockProducer = new DevBlockProducer(
txSource,
producerChainProcessor,
producerEnv.StateProvider,
getFromApi.BlockTree,
getFromApi.BlockProcessingQueue,
getFromApi.TxPool,
getFromApi.Timestamper,
getFromApi.LogManager);
return(Task.CompletedTask);
}
public async Task SetUp()
{
_dbProvider = await TestMemDbProvider.InitAsync();
_timestamper = new ManualTimestamper();
_blockTree = Substitute.For <IBlockTree>();
_txPool = Substitute.For <ITxPool>();
_receiptStorage = Substitute.For <IReceiptStorage>();
_filterStore = Substitute.For <IFilterStore>();
_filterManager = Substitute.For <IFilterManager>();
_transactionProcessor = Substitute.For <ITransactionProcessor>();
_ethereumEcdsa = Substitute.For <IEthereumEcdsa>();
_specProvider = MainnetSpecProvider.Instance;
ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(_dbProvider, false),
new TrieStore(_dbProvider.StateDb, LimboLogs.Instance).AsReadOnly(),
new ReadOnlyBlockTree(_blockTree),
_specProvider,
LimboLogs.Instance);
processingEnv.TransactionProcessor = _transactionProcessor;
_blockchainBridge = new BlockchainBridge(
processingEnv,
_txPool,
_receiptStorage,
_filterStore,
_filterManager,
_ethereumEcdsa,
_timestamper,
Substitute.For <ILogFinder>(),
false,
false);
}
public IBlockchainBridge CreateBlockchainBridge()
{
ReadOnlyBlockTree readOnlyTree = new ReadOnlyBlockTree(BlockTree);
IReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(DbProvider, false);
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(
readOnlyDbProvider,
readOnlyTree,
SpecProvider,
LogManager);
IMiningConfig miningConfig = ConfigProvider.GetConfig <IMiningConfig>();
ISyncConfig syncConfig = ConfigProvider.GetConfig <ISyncConfig>();
return(new BlockchainBridge(
readOnlyTxProcessingEnv,
TxPool,
ReceiptFinder,
FilterStore,
FilterManager,
EthereumEcdsa,
Timestamper,
LogFinder,
miningConfig.Enabled,
syncConfig.BeamSync && syncConfig.FastSync
));
}
public BlockchainBridge(ReadOnlyTxProcessingEnv processingEnv,
ITxPool?txPool,
IReceiptFinder?receiptStorage,
IFilterStore?filterStore,
IFilterManager?filterManager,
IEthereumEcdsa?ecdsa,
ITimestamper?timestamper,
ILogFinder?logFinder,
ISpecProvider specProvider,
bool isMining)
{
_processingEnv = processingEnv ?? throw new ArgumentNullException(nameof(processingEnv));
_stateReader = processingEnv.StateReader ?? throw new ArgumentNullException(nameof(processingEnv.StateReader));
_stateProvider = processingEnv.StateProvider ?? throw new ArgumentNullException(nameof(processingEnv.StateProvider));
_blockTree = processingEnv.BlockTree ?? throw new ArgumentNullException(nameof(processingEnv.BlockTree));
_transactionProcessor = processingEnv.TransactionProcessor ?? throw new ArgumentNullException(nameof(processingEnv.TransactionProcessor));
_txPool = txPool ?? throw new ArgumentNullException(nameof(_txPool));
_receiptFinder = receiptStorage ?? throw new ArgumentNullException(nameof(receiptStorage));
_filterStore = filterStore ?? throw new ArgumentNullException(nameof(filterStore));
_filterManager = filterManager ?? throw new ArgumentNullException(nameof(filterManager));
_ecdsa = ecdsa ?? throw new ArgumentNullException(nameof(ecdsa));
_timestamper = timestamper ?? throw new ArgumentNullException(nameof(timestamper));
_logFinder = logFinder ?? throw new ArgumentNullException(nameof(logFinder));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
IsMining = isMining;
}
public BlockchainBridge(
ReadOnlyTxProcessingEnv processingEnv,
ITxPool txPool,
IReceiptFinder receiptStorage,
IFilterStore filterStore,
IFilterManager filterManager,
IEthereumEcdsa ecdsa,
IBloomStorage bloomStorage,
ITimestamper timestamper,
ILogManager logManager,
bool isMining,
int findLogBlockDepthLimit = 1000,
CancellationToken cancellationToken = default(CancellationToken))
{
_processingEnv = processingEnv ?? throw new ArgumentNullException(nameof(processingEnv));
_stateReader = processingEnv.StateReader ?? throw new ArgumentNullException(nameof(processingEnv.StateReader));
_stateProvider = processingEnv.StateProvider ?? throw new ArgumentNullException(nameof(processingEnv.StateProvider));
_blockTree = processingEnv.BlockTree ?? throw new ArgumentNullException(nameof(processingEnv.BlockTree));
_transactionProcessor = processingEnv.TransactionProcessor ?? throw new ArgumentException(nameof(processingEnv.TransactionProcessor));
_txPool = txPool ?? throw new ArgumentNullException(nameof(_txPool));
_receiptFinder = receiptStorage ?? throw new ArgumentNullException(nameof(receiptStorage));
_filterStore = filterStore ?? throw new ArgumentException(nameof(filterStore));
_filterManager = filterManager ?? throw new ArgumentException(nameof(filterManager));
_ecdsa = ecdsa ?? throw new ArgumentNullException(nameof(ecdsa));
_timestamper = timestamper ?? throw new ArgumentNullException(nameof(timestamper));
IsMining = isMining;
_logFinder = new LogFinder(_blockTree, _receiptFinder, bloomStorage, logManager, new ReceiptsRecovery(), findLogBlockDepthLimit);
}
public override IEthModule Create()
{
ReadOnlyBlockTree readOnlyTree = new ReadOnlyBlockTree(_blockTree);
IReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree, _specProvider, _logManager);
var blockchainBridge = new BlockchainBridge(
readOnlyTxProcessingEnv,
_txPool,
_receiptFinder,
_filterStore,
_filterManager,
_ethereumEcdsa,
_bloomStorage,
Timestamper.Default,
_logManager,
_isMining,
_rpcConfig.FindLogBlockDepthLimit
);
return(new EthModule(
_rpcConfig,
blockchainBridge,
readOnlyTxProcessingEnv.BlockTree,
readOnlyTxProcessingEnv.StateReader,
_txPool,
_txSender,
_wallet,
_logManager));
}
public static INdmBlockchainBridge BuildABridge()
{
IDbProvider memDbProvider = TestMemDbProvider.Init();
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));
}
private ITxPermissionFilter?GetTxPermissionFilter(
ReadOnlyTxProcessingEnv environment,
ReadOnlyTransactionProcessorSource readOnlyTransactionProcessorSource,
IStateProvider?stateProvider = null)
{
if (_context.ChainSpec == null)
{
throw new StepDependencyException(nameof(_context.ChainSpec));
}
if (_context.ChainSpec.Parameters.TransactionPermissionContract != null)
{
var txPermissionFilter = new TxPermissionFilter(
new VersionedTransactionPermissionContract(_context.AbiEncoder,
_context.ChainSpec.Parameters.TransactionPermissionContract,
_context.ChainSpec.Parameters.TransactionPermissionContractTransition ?? 0,
readOnlyTransactionProcessorSource,
_context.TransactionPermissionContractVersions),
_context.TxFilterCache,
environment.StateProvider,
_context.LogManager);
return(txPermissionFilter);
}
return(null);
}
private IGasLimitOverride?GetGasLimitOverride(
ReadOnlyTxProcessingEnv environment,
ReadOnlyTransactionProcessorSource readOnlyTransactionProcessorSource,
IStateProvider?stateProvider = null)
{
if (_context.ChainSpec == null)
{
throw new StepDependencyException(nameof(_context.ChainSpec));
}
var blockGasLimitContractTransitions = _context.ChainSpec.AuRa.BlockGasLimitContractTransitions;
if (blockGasLimitContractTransitions?.Any() == true)
{
var gasLimitOverride = new AuRaContractGasLimitOverride(
blockGasLimitContractTransitions.Select(blockGasLimitContractTransition =>
new BlockGasLimitContract(
_context.AbiEncoder,
blockGasLimitContractTransition.Value,
blockGasLimitContractTransition.Key,
readOnlyTransactionProcessorSource))
.ToArray <IBlockGasLimitContract>(),
_context.GasLimitOverrideCache,
_auraConfig?.Minimum2MlnGasPerBlockWhenUsingBlockGasLimitContract == true,
_context.LogManager);
return(gasLimitOverride);
}
return(null);
}
public void Bridge_beam_head_is_correct(bool isBeam, long headNumber, long?expectedNumber)
{
ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(_dbProvider, false),
new ReadOnlyBlockTree(_blockTree),
_specProvider,
LimboLogs.Instance);
Block head = Build.A.Block.WithNumber(headNumber).TestObject;
Block bestSuggested = Build.A.Block.WithNumber(8).TestObject;
_blockTree.Head.Returns(head);
_blockTree.BestSuggestedBody.Returns(bestSuggested);
_blockchainBridge = new BlockchainBridge(
processingEnv,
_txPool,
_receiptStorage,
_filterStore,
_filterManager,
_ethereumEcdsa,
_timestamper,
Substitute.For <ILogFinder>(),
false,
isBeam);
if (expectedNumber.HasValue)
{
_blockchainBridge.BeamHead.Number.Should().Be(expectedNumber);
}
else
{
_blockchainBridge.BeamHead.Should().BeNull();
}
}
protected override BlockProcessor CreateBlockProcessor(
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv,
ReadOnlyTransactionProcessorSource readOnlyTransactionProcessorSource,
IReadOnlyDbProvider readOnlyDbProvider)
{
if (_context.RewardCalculatorSource == null)
{
throw new StepDependencyException(nameof(_context.RewardCalculatorSource));
}
if (_context.ValidatorStore == null)
{
throw new StepDependencyException(nameof(_context.ValidatorStore));
}
if (_context.ChainSpec == null)
{
throw new StepDependencyException(nameof(_context.ChainSpec));
}
if (_context.BlockTree == null)
{
throw new StepDependencyException(nameof(_context.BlockTree));
}
var validator = new AuRaValidatorFactory(
readOnlyTxProcessingEnv.StateProvider,
_context.AbiEncoder,
readOnlyTxProcessingEnv.TransactionProcessor,
readOnlyTransactionProcessorSource,
readOnlyTxProcessingEnv.BlockTree,
_context.ReceiptStorage,
_context.ValidatorStore,
_context.FinalizationManager,
_context.LogManager,
true)
.CreateValidatorProcessor(_context.ChainSpec.AuRa.Validators, _context.BlockTree.Head?.Header);
if (validator is IDisposable disposableValidator)
{
_context.DisposeStack.Push(disposableValidator);
}
return(new AuRaBlockProcessor(
_context.SpecProvider,
_context.BlockValidator,
_context.RewardCalculatorSource.Get(readOnlyTxProcessingEnv.TransactionProcessor),
readOnlyTxProcessingEnv.TransactionProcessor,
readOnlyDbProvider.StateDb,
readOnlyDbProvider.CodeDb,
readOnlyTxProcessingEnv.StateProvider,
readOnlyTxProcessingEnv.StorageProvider,
_context.TxPool,
_context.ReceiptStorage,
_context.LogManager,
readOnlyTxProcessingEnv.BlockTree,
GetTxPermissionFilter(readOnlyTxProcessingEnv, readOnlyTransactionProcessorSource, readOnlyTxProcessingEnv.StateProvider),
GetGasLimitOverride(readOnlyTxProcessingEnv, readOnlyTransactionProcessorSource, readOnlyTxProcessingEnv.StateProvider))
{
AuRaValidator = validator
});
}
protected virtual ITxSource CreateTxSourceForProducer(
ReadOnlyTxProcessingEnv processingEnv,
ReadOnlyTxProcessorSource readOnlyTxProcessorSource)
{
ITxSource innerSource = new TxPoolTxSource(_api.TxPool, processingEnv.StateReader, _api.LogManager);
return(new FilteredTxSource(innerSource, CreateGasPriceTxFilter(readOnlyTxProcessorSource)));
}
private BlockProcessor CreateBlockProcessor(
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv,
ISpecProvider specProvider,
IBlockValidator blockValidator,
IRewardCalculatorSource rewardCalculatorSource,
ITxPool txPool,
IReceiptStorage receiptStorage,
ILogManager logManager) =>
private TxPoolTxSource CreateTxPoolTxSource(ReadOnlyTxProcessingEnv processingEnv, IReadOnlyTxProcessorSource readOnlyTxProcessorSource)
{
// We need special one for TxPriority as its following Head separately with events and we want rules from Head, not produced block
IReadOnlyTxProcessorSource readOnlyTxProcessorSourceForTxPriority =
new ReadOnlyTxProcessingEnv(_api.DbProvider, _api.ReadOnlyTrieStore, _api.BlockTree, _api.SpecProvider, _api.LogManager);
(_txPriorityContract, _localDataSource) = TxAuRaFilterBuilders.CreateTxPrioritySources(_auraConfig, _api, readOnlyTxProcessorSourceForTxPriority);
if (_txPriorityContract != null || _localDataSource != null)
{
_minGasPricesContractDataStore = TxAuRaFilterBuilders.CreateMinGasPricesDataStore(_api, _txPriorityContract, _localDataSource) !;
_api.DisposeStack.Push(_minGasPricesContractDataStore);
ContractDataStore <Address> whitelistContractDataStore = new ContractDataStoreWithLocalData <Address>(
new HashSetContractDataStoreCollection <Address>(),
_txPriorityContract?.SendersWhitelist,
_api.BlockTree,
_api.ReceiptFinder,
_api.LogManager,
_localDataSource?.GetWhitelistLocalDataSource() ?? new EmptyLocalDataSource <IEnumerable <Address> >());
DictionaryContractDataStore <TxPriorityContract.Destination> prioritiesContractDataStore =
new DictionaryContractDataStore <TxPriorityContract.Destination>(
new TxPriorityContract.DestinationSortedListContractDataStoreCollection(),
_txPriorityContract?.Priorities,
_api.BlockTree,
_api.ReceiptFinder,
_api.LogManager,
_localDataSource?.GetPrioritiesLocalDataSource());
_api.DisposeStack.Push(whitelistContractDataStore);
_api.DisposeStack.Push(prioritiesContractDataStore);
ITxFilter auraTxFilter =
CreateAuraTxFilterForProducer(readOnlyTxProcessorSource, _api.SpecProvider);
ITxFilterPipeline txFilterPipeline = new TxFilterPipelineBuilder(_api.LogManager)
.WithCustomTxFilter(auraTxFilter)
.WithBaseFeeFilter(_api.SpecProvider)
.WithNullTxFilter()
.Build;
return(new TxPriorityTxSource(
_api.TxPool,
processingEnv.StateReader,
_api.LogManager,
txFilterPipeline,
whitelistContractDataStore,
prioritiesContractDataStore,
_api.SpecProvider,
_api.TransactionComparerProvider));
}
else
{
return(CreateStandardTxPoolTxSource(processingEnv, readOnlyTxProcessorSource));
}
}
public IBlockProcessor.IBlockTransactionsExecutor Create(ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv)
=> new AABlockProducerTransactionsExecutor(
readOnlyTxProcessingEnv.TransactionProcessor,
readOnlyTxProcessingEnv.StateProvider,
readOnlyTxProcessingEnv.StorageProvider,
_specProvider,
_logManager,
_signer,
_entryPointAddresses);
public override IMulticallModule Create()
{
var txProcessingEnv = new ReadOnlyTxProcessingEnv(dbProvider, trieNodeResolver, blockTree, specProvider, logManager);
var rewardCalculator = rewardCalculatorSource.Get(txProcessingEnv.TransactionProcessor);
var chainProcessingEnv = new ReadOnlyChainProcessingEnv(txProcessingEnv, Always.Valid, recoveryStep, rewardCalculator, receiptFinder, dbProvider, specProvider, logManager);
var tracer = new MyTracer(chainProcessingEnv.StateProvider, chainProcessingEnv.ChainProcessor);
return(new MulticallModule(tracer, blockTree, jsonRpcConfig));
}
public override ITraceModule Create()
{
var readOnlyTree = new ReadOnlyBlockTree(_blockTree);
var readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
var readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree, _specProvider, _logManager);
var readOnlyChainProcessingEnv = new ReadOnlyChainProcessingEnv(readOnlyTxProcessingEnv, AlwaysValidBlockValidator.Instance, _recoveryStep, _rewardCalculatorSource.Get(readOnlyTxProcessingEnv.TransactionProcessor), _receiptStorage, readOnlyDbProvider, _specProvider, _logManager);
Tracer tracer = new Tracer(readOnlyChainProcessingEnv.StateProvider, readOnlyChainProcessingEnv.ChainProcessor);
return(new TraceModule(_receiptStorage, tracer, readOnlyTree));
}
private TxPoolTxSource CreateStandardTxPoolTxSource(ReadOnlyTxProcessingEnv processingEnv, IReadOnlyTxProcessorSource readOnlyTxProcessorSource)
{
ITxFilter txSourceFilter = CreateAuraTxFilterForProducer(readOnlyTxProcessorSource, _api.SpecProvider);
ITxFilterPipeline txFilterPipeline = new TxFilterPipelineBuilder(_api.LogManager)
.WithCustomTxFilter(txSourceFilter)
.WithBaseFeeFilter(_api.SpecProvider)
.Build;
return(new TxPoolTxSource(_api.TxPool, _api.SpecProvider, _api.TransactionComparerProvider, _api.LogManager, txFilterPipeline));
}
public override IDebugModule Create()
{
IReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
ReadOnlyBlockTree readOnlyTree = new ReadOnlyBlockTree(_blockTree);
ReadOnlyTxProcessingEnv txEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree, _specProvider, _logManager);
ReadOnlyChainProcessingEnv readOnlyChainProcessingEnv = new ReadOnlyChainProcessingEnv(txEnv, _blockValidator, _recoveryStep, _rewardCalculator, _receiptStorage, readOnlyDbProvider, _specProvider, _logManager);
ITracer tracer = new Tracer(readOnlyChainProcessingEnv.Processor, _receiptStorage, new ReadOnlyBlockTree(_blockTree), _dbProvider.TraceDb);
DebugBridge debugBridge = new DebugBridge(_configProvider, readOnlyDbProvider, tracer, readOnlyChainProcessingEnv.Processor, readOnlyTree);
return(new DebugModule(_logManager, debugBridge));
}
public MevBlockProductionTransactionsExecutor(
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv,
ISpecProvider specProvider,
ILogManager logManager) :
this(
readOnlyTxProcessingEnv.TransactionProcessor,
readOnlyTxProcessingEnv.StateProvider,
readOnlyTxProcessingEnv.StorageProvider,
specProvider,
logManager)
{
}
public override ITraceModule Create()
{
var readOnlyTree = new ReadOnlyBlockTree(_blockTree);
var readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
var readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree, _specProvider, _logManager);
var readOnlyChainProcessingEnv = new ReadOnlyChainProcessingEnv(readOnlyTxProcessingEnv, Always.Valid, _recoveryStep, _rewardCalculatorSource.Get(readOnlyTxProcessingEnv.TransactionProcessor), _receiptStorage, readOnlyDbProvider, _specProvider, _logManager);
Tracer tracer = new Tracer(readOnlyChainProcessingEnv.StateProvider, readOnlyChainProcessingEnv.ChainProcessor);
TimeSpan cancellationTokenTimeout = TimeSpan.FromMilliseconds(_jsonRpcConfig.TracerTimeout);
CancellationToken cancellationToken = new CancellationTokenSource(cancellationTokenTimeout).Token;
return(new TraceModule(_receiptStorage, tracer, readOnlyTree, cancellationToken));
}
public override IProofModule Create()
{
ReadOnlyBlockTree readOnlyTree = new ReadOnlyBlockTree(_blockTree);
IReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree, _specProvider, _logManager);
ReadOnlyChainProcessingEnv readOnlyChainProcessingEnv = new ReadOnlyChainProcessingEnv(readOnlyTxProcessingEnv, Always.Valid, _recoveryStep, NoBlockRewards.Instance, new InMemoryReceiptStorage(), readOnlyDbProvider, _specProvider, _logManager);
Tracer tracer = new Tracer(
readOnlyTxProcessingEnv.StateProvider,
readOnlyChainProcessingEnv.ChainProcessor);
return(new ProofModule(tracer, _blockTree, _receiptFinder, _specProvider, _logManager));
}
public ResultWrapper <Keccak> Simulate(UserOperation userOperation,
BlockHeader parent,
UInt256?timestamp = null,
CancellationToken cancellationToken = default)
{
if (userOperation.AlreadySimulated)
{
// codehash of all accessed addresses should not change between calls
foreach (KeyValuePair <Address, Keccak> kv in userOperation.AddressesToCodeHashes)
{
(Address address, Keccak expectedCodeHash) = kv;
Keccak codeHash = _stateProvider.GetCodeHash(address);
if (codeHash != expectedCodeHash)
{
return(ResultWrapper <Keccak> .Fail($"codehash of address {address} changed since initial simulation"));
}
}
}
IReleaseSpec currentSpec = _specProvider.GetSpec(parent.Number + 1);
ReadOnlyTxProcessingEnv txProcessingEnv = _readOnlyTxProcessingEnvFactory.Create();
ITransactionProcessor transactionProcessor = txProcessingEnv.Build(_stateProvider.StateRoot);
// wrap userOp into a tx calling the simulateWallet function off-chain from zero-address (look at EntryPoint.sol for more context)
Transaction simulateValidationTransaction =
BuildSimulateValidationTransaction(userOperation, parent, currentSpec);
UserOperationSimulationResult simulationResult = SimulateValidation(simulateValidationTransaction, userOperation, parent, transactionProcessor);
if (!simulationResult.Success)
{
return(ResultWrapper <Keccak> .Fail(simulationResult.Error ?? "unknown simulation failure"));
}
if (userOperation.AlreadySimulated)
{
// if previously simulated we must make sure it doesn't access any more than it did on the first round
if (!userOperation.AccessList.AccessListContains(simulationResult.AccessList.Data))
{
return(ResultWrapper <Keccak> .Fail("access list exceeded"));
}
}
else
{
userOperation.AccessList = simulationResult.AccessList;
userOperation.AddressesToCodeHashes = simulationResult.AddressesToCodeHashes;
userOperation.AlreadySimulated = true;
}
return(ResultWrapper <Keccak> .Success(userOperation.RequestId !));
}
private (IBlockchainProcessor, IStateReader) CreateProcessor(Block block, IReadOnlyDbProvider readOnlyDbProvider, ISpecProvider specProvider, ILogManager logManager)
{
ReadOnlyTxProcessingEnv txEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, _readOnlyBlockTree, specProvider, logManager);
ReadOnlyChainProcessingEnv env = new ReadOnlyChainProcessingEnv(txEnv, _blockValidator, _recoveryStep, _rewardCalculatorSource.Get(txEnv.TransactionProcessor), NullReceiptStorage.Instance, _readOnlyDbProvider, specProvider, logManager);
env.BlockProcessor.TransactionProcessed += (sender, args) =>
{
if (_logger.IsInfo)
{
_logger.Info($"Processed tx {args.Index}/{block.Transactions.Length} of {block.Number}");
}
};
return(env.ChainProcessor, txEnv.StateReader);
}
protected BlockProducerContext GetProducerChain()
{
ReadOnlyDbProvider readOnlyDbProvider = new ReadOnlyDbProvider(_context.DbProvider, false);
ReadOnlyBlockTree readOnlyBlockTree = new ReadOnlyBlockTree(_context.BlockTree);
ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyBlockTree, _context.SpecProvider, _context.LogManager);
BlockProcessor blockProcessor = CreateBlockProcessor(readOnlyTxProcessingEnv, readOnlyDbProvider);
OneTimeChainProcessor chainProcessor = new OneTimeChainProcessor(readOnlyDbProvider, new BlockchainProcessor(readOnlyBlockTree, blockProcessor, _context.RecoveryStep, _context.LogManager, false));
PendingTxSelector pendingTxSelector = new PendingTxSelector(_context.TxPool, readOnlyTxProcessingEnv.StateProvider, _context.LogManager);
return(new BlockProducerContext
{
ChainProcessor = chainProcessor,
ReadOnlyStateProvider = readOnlyTxProcessingEnv.StateProvider,
PendingTxSelector = pendingTxSelector
});
}
