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));
}
public void transaction_is_addable_to_block_after_fill()
{
int chainId = 5;
var blockHeader = Build.A.BlockHeader.TestObject;
var tx = Build.A.GeneratedTransaction.WithSenderAddress(TestItem.AddressA).TestObject;
var timestamper = Substitute.For <ITimestamper>();
var stateReader = Substitute.For <IStateReader>();
var nodeAddress = TestItem.AddressA;
UInt256 expectedNonce = 10;
stateReader.GetNonce(blockHeader.StateRoot, nodeAddress).Returns(expectedNonce);
ulong expectedTimeStamp = 100;
timestamper.EpochSeconds.Returns(expectedTimeStamp);
var gasLimit = 200;
var innerTxSource = Substitute.For <ITxSource>();
innerTxSource.GetTransactions(blockHeader, gasLimit).Returns(new[] { tx });
TxSealer txSealer = new TxSealer(new Signer(chainId, Build.A.PrivateKey.TestObject, LimboLogs.Instance), timestamper);
var transactionFiller = new GeneratedTxSourceSealer(innerTxSource, txSealer, stateReader, LimboLogs.Instance);
var txResult = transactionFiller.GetTransactions(blockHeader, gasLimit).First();
txResult.IsSigned.Should().BeTrue();
txResult.Nonce.Should().Be(expectedNonce);
txResult.Hash.Should().Be(tx.CalculateHash());
txResult.Timestamp.Should().Be(expectedTimeStamp);
}
protected override async Task <TestBlockchain> Build(ISpecProvider specProvider = null, UInt256?initialValues = null)
{
BloomStorage bloomStorage = new BloomStorage(new BloomConfig(), new MemDb(), new InMemoryDictionaryFileStoreFactory());
specProvider ??= MainnetSpecProvider.Instance;
await base.Build(specProvider, initialValues);
IFilterStore filterStore = new FilterStore();
IFilterManager filterManager = new FilterManager(filterStore, BlockProcessor, TxPool, LimboLogs.Instance);
ReceiptsRecovery receiptsRecovery = new ReceiptsRecovery(new EthereumEcdsa(specProvider.ChainId, LimboLogs.Instance), specProvider);
LogFinder = new LogFinder(BlockTree, ReceiptStorage, bloomStorage, LimboLogs.Instance, receiptsRecovery);
ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(DbProvider, false),
new TrieStore(DbProvider.StateDb, LimboLogs.Instance).AsReadOnly(),
new ReadOnlyBlockTree(BlockTree),
SpecProvider,
LimboLogs.Instance);
Bridge ??= new BlockchainBridge(processingEnv, TxPool, ReceiptStorage, filterStore, filterManager, EthereumEcdsa, Timestamper, LogFinder, SpecProvider, false, false);
BlockFinder ??= BlockTree;
ITxSigner txSigner = new WalletTxSigner(TestWallet, specProvider?.ChainId ?? 0);
ITxSealer txSealer0 = new TxSealer(txSigner, Timestamper);
ITxSealer txSealer1 = new NonceReservingTxSealer(txSigner, Timestamper, TxPool);
TxSender ??= new TxPoolSender(TxPool, txSealer0, txSealer1);
EthRpcModule = new EthRpcModule(
new JsonRpcConfig(),
Bridge,
BlockFinder,
StateReader,
TxPool,
TxSender,
TestWallet,
LimboLogs.Instance,
SpecProvider);
return(this);
}
public void transactions_are_addable_to_block_after_sealing()
{
int chainId = 5;
var blockHeader = Build.A.BlockHeader.TestObject;
var tx1 = Build.A.GeneratedTransaction.WithSenderAddress(TestItem.AddressA).TestObject;
var tx2 = Build.A.GeneratedTransaction.WithSenderAddress(TestItem.AddressA).TestObject;
var timestamper = Substitute.For <ITimestamper>();
var stateReader = Substitute.For <IStateReader>();
var nodeAddress = TestItem.AddressA;
UInt256 expectedNonce = 10;
stateReader.GetNonce(blockHeader.StateRoot, nodeAddress).Returns(expectedNonce);
ulong expectedTimeStamp = 100;
timestamper.UnixTime.Returns(UnixTime.FromSeconds(expectedTimeStamp));
var gasLimit = 200;
var innerTxSource = Substitute.For <ITxSource>();
innerTxSource.GetTransactions(blockHeader, gasLimit).Returns(new[] { tx1, tx2 });
TxSealer txSealer = new TxSealer(new Signer((ulong)chainId, Build.A.PrivateKey.TestObject, LimboLogs.Instance), timestamper);
var transactionFiller = new GeneratedTxSource(innerTxSource, txSealer, stateReader, LimboLogs.Instance);
var sealedTxs = transactionFiller.GetTransactions(blockHeader, gasLimit).ToArray();
var sealedTx1 = sealedTxs.First();
var sealedTx2 = sealedTxs.Skip(1).First();
sealedTx1.IsSigned.Should().BeTrue();
sealedTx1.Nonce.Should().Be(expectedNonce);
sealedTx1.Hash.Should().Be(tx1.CalculateHash());
sealedTx1.Timestamp.Should().Be(expectedTimeStamp);
sealedTx2.IsSigned.Should().BeTrue();
sealedTx2.Nonce.Should().Be(expectedNonce + 1);
sealedTx2.Hash.Should().NotBe(tx1.CalculateHash());
sealedTx2.Timestamp.Should().Be(expectedTimeStamp);
}
public static INdmBlockchainBridge BuildABridge()
{
MemDbProvider memDbProvider = new MemDbProvider();
StateReader stateReader = new StateReader(memDbProvider.StateDb, memDbProvider.CodeDb, LimboLogs.Instance);
StateProvider stateProvider = new StateProvider(memDbProvider.StateDb, memDbProvider.CodeDb, LimboLogs.Instance);
StorageProvider storageProvider = new StorageProvider(memDbProvider.StateDb, stateProvider, LimboLogs.Instance);
IEthereumEcdsa ecdsa = new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance);
ITxPool txPool = new TxPool.TxPool(new InMemoryTxStorage(), Timestamper.Default, ecdsa, MainnetSpecProvider.Instance, new TxPoolConfig(), stateProvider, LimboLogs.Instance);
// BlockTree blockTree = new BlockTree(memDbProvider.BlocksDb, memDbProvider.HeadersDb, memDbProvider.BlockInfosDb, new ChainLevelInfoRepository(memDbProvider.BlockInfosDb), MainnetSpecProvider.Instance, txPool, NullBloomStorage.Instance, new SyncConfig(), LimboLogs.Instance);
BlockTree blockTree = Build.A.BlockTree().OfChainLength(1).TestObject;
IWallet wallet = new DevWallet(new WalletConfig(), LimboLogs.Instance);
VirtualMachine virtualMachine = new VirtualMachine(stateProvider, storageProvider, new BlockhashProvider(blockTree, LimboLogs.Instance), MainnetSpecProvider.Instance, LimboLogs.Instance);
TransactionProcessor processor = new TransactionProcessor(MainnetSpecProvider.Instance, stateProvider, storageProvider, virtualMachine, LimboLogs.Instance);
ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(memDbProvider, false),
new ReadOnlyBlockTree(blockTree),
MainnetSpecProvider.Instance, LimboLogs.Instance);
BlockchainBridge blockchainBridge = new BlockchainBridge(
processingEnv,
txPool,
new InMemoryReceiptStorage(),
NullFilterStore.Instance,
NullFilterManager.Instance,
ecdsa,
NullBloomStorage.Instance,
Timestamper.Default,
LimboLogs.Instance,
false,
false);
WalletTxSigner txSigner = new WalletTxSigner(wallet, ChainId.Mainnet);
ITxSealer txSealer0 = new TxSealer(txSigner, Timestamper.Default);
ITxSealer txSealer1 = new NonceReservingTxSealer(txSigner, Timestamper.Default, txPool);
ITxSender txSender = new TxPoolSender(txPool, txSealer0, txSealer1);
return(new NdmBlockchainBridge(blockchainBridge, blockTree, stateReader, txSender));
}
protected override ITxSource CreateTxSourceForProducer(ReadOnlyTxProcessingEnv processingEnv, IReadOnlyTxProcessorSource readOnlyTxProcessorSource)
{
bool CheckAddPosdaoTransactions(IList <ITxSource> list, long auRaPosdaoTransition)
{
if (auRaPosdaoTransition < AuRaParameters.TransitionDisabled && _validator is ITxSource validatorSource)
{
list.Insert(0, validatorSource);
return(true);
}
return(false);
}
bool CheckAddRandomnessTransactions(IList <ITxSource> list, IDictionary <long, Address>?randomnessContractAddress, ISigner signer)
{
IList <IRandomContract> GetRandomContracts(
IDictionary <long, Address> randomnessContractAddressPerBlock,
IAbiEncoder abiEncoder,
IReadOnlyTxProcessorSource txProcessorSource,
ISigner signerLocal) =>
randomnessContractAddressPerBlock
.Select(kvp => new RandomContract(
abiEncoder,
kvp.Value,
txProcessorSource,
kvp.Key,
signerLocal))
.ToArray <IRandomContract>();
if (randomnessContractAddress?.Any() == true)
{
var randomContractTxSource = new RandomContractTxSource(
GetRandomContracts(randomnessContractAddress, _api.AbiEncoder,
readOnlyTxProcessorSource,
signer),
new EciesCipher(_api.CryptoRandom),
signer,
_api.NodeKey,
_api.CryptoRandom,
_api.LogManager);
list.Insert(0, randomContractTxSource);
return(true);
}
return(false);
}
if (_api.ChainSpec == null)
{
throw new StepDependencyException(nameof(_api.ChainSpec));
}
if (_api.BlockTree == null)
{
throw new StepDependencyException(nameof(_api.BlockTree));
}
if (_api.EngineSigner == null)
{
throw new StepDependencyException(nameof(_api.EngineSigner));
}
IList <ITxSource> txSources = new List <ITxSource> {
base.CreateTxSourceForProducer(processingEnv, readOnlyTxProcessorSource)
};
bool needSigner = false;
needSigner |= CheckAddPosdaoTransactions(txSources, _api.ChainSpec.AuRa.PosdaoTransition);
needSigner |= CheckAddRandomnessTransactions(txSources, _api.ChainSpec.AuRa.RandomnessContractAddress, _api.EngineSigner);
ITxSource txSource = txSources.Count > 1 ? new CompositeTxSource(txSources.ToArray()) : txSources[0];
if (needSigner)
{
TxSealer transactionSealer = new TxSealer(_api.EngineSigner, _api.Timestamper);
txSource = new GeneratedTxSource(txSource, transactionSealer, processingEnv.StateReader, _api.LogManager);
}
if (_txPermissionFilter != null)
{
// we now only need to filter generated transactions here, as regular ones are filtered on TxPoolTxSource filter based on CreateTxSourceFilter method
txSource = new FilteredTxSource <GeneratedTransaction>(txSource, _txPermissionFilter, _api.LogManager);
}
return(txSource);
}
protected override ITxSource CreateTxSourceForProducer(ReadOnlyTxProcessingEnv readOnlyTxProcessingEnv, ReadOnlyTransactionProcessorSource readOnlyTransactionProcessorSource)
{
bool CheckAddPosdaoTransactions(IList <ITxSource> list, long auRaPosdaoTransition)
{
if (auRaPosdaoTransition < AuRaParameters.TransitionDisabled && _validator is ITxSource validatorSource)
{
list.Insert(0, validatorSource);
return(true);
}
return(false);
}
bool CheckAddRandomnessTransactions(IList <ITxSource> list, IDictionary <long, Address> randomnessContractAddress, ISigner signer)
{
IList <IRandomContract> GetRandomContracts(
IDictionary <long, Address> randomnessContractAddressPerBlock,
IAbiEncoder abiEncoder,
IReadOnlyTransactionProcessorSource txProcessorSource,
ISigner signer) =>
randomnessContractAddressPerBlock
.Select(kvp => new RandomContract(
abiEncoder,
kvp.Value,
txProcessorSource,
kvp.Key,
signer))
.ToArray <IRandomContract>();
if (randomnessContractAddress?.Any() == true)
{
var randomContractTxSource = new RandomContractTxSource(
GetRandomContracts(randomnessContractAddress, _context.AbiEncoder,
readOnlyTransactionProcessorSource,
signer),
new EciesCipher(_context.CryptoRandom),
_context.NodeKey,
_context.CryptoRandom);
list.Insert(0, randomContractTxSource);
return(true);
}
return(false);
}
if (_context.ChainSpec == null)
{
throw new StepDependencyException(nameof(_context.ChainSpec));
}
if (_context.BlockTree == null)
{
throw new StepDependencyException(nameof(_context.BlockTree));
}
if (_context.Signer == null)
{
throw new StepDependencyException(nameof(_context.Signer));
}
IList <ITxSource> txSources = new List <ITxSource> {
base.CreateTxSourceForProducer(readOnlyTxProcessingEnv, readOnlyTransactionProcessorSource)
};
bool needSigner = false;
needSigner |= CheckAddPosdaoTransactions(txSources, _context.ChainSpec.AuRa.PosdaoTransition);
needSigner |= CheckAddRandomnessTransactions(txSources, _context.ChainSpec.AuRa.RandomnessContractAddress, _context.Signer);
ITxSource txSource = txSources.Count > 1 ? new CompositeTxSource(txSources.ToArray()) : txSources[0];
if (needSigner)
{
TxSealer transactionSealer = new TxSealer(_context.Signer, _context.Timestamper);
txSource = new GeneratedTxSourceSealer(txSource, transactionSealer, readOnlyTxProcessingEnv.StateReader);
}
var txPermissionFilter = GetTxPermissionFilter(readOnlyTxProcessingEnv, readOnlyTransactionProcessorSource);
if (txPermissionFilter != null)
{
txSource = new TxFilterTxSource(txSource, txPermissionFilter);
}
return(txSource);
}
private Task InitBlockchain()
{
if (_api.ChainSpec == null)
{
throw new StepDependencyException(nameof(_api.ChainSpec));
}
if (_api.DbProvider == null)
{
throw new StepDependencyException(nameof(_api.DbProvider));
}
if (_api.SpecProvider == null)
{
throw new StepDependencyException(nameof(_api.SpecProvider));
}
ILogger logger = _api.LogManager.GetClassLogger();
IInitConfig initConfig = _api.Config <IInitConfig>();
ISyncConfig syncConfig = _api.Config <ISyncConfig>();
if (syncConfig.DownloadReceiptsInFastSync && !syncConfig.DownloadBodiesInFastSync)
{
logger.Warn($"{nameof(syncConfig.DownloadReceiptsInFastSync)} is selected but {nameof(syncConfig.DownloadBodiesInFastSync)} - enabling bodies to support receipts download.");
syncConfig.DownloadBodiesInFastSync = true;
}
Account.AccountStartNonce = _api.ChainSpec.Parameters.AccountStartNonce;
Signer signer = new Signer(_api.SpecProvider.ChainId, _api.OriginalSignerKey, _api.LogManager);
_api.Signer = signer;
_api.SignerStore = signer;
_api.StateProvider = new StateProvider(
_api.DbProvider.StateDb,
_api.DbProvider.CodeDb,
_api.LogManager);
_api.EthereumEcdsa = new EthereumEcdsa(_api.SpecProvider.ChainId, _api.LogManager);
_api.TxPool = new TxPool.TxPool(
new PersistentTxStorage(_api.DbProvider.PendingTxsDb),
Timestamper.Default,
_api.EthereumEcdsa,
_api.SpecProvider,
_api.Config <ITxPoolConfig>(),
_api.StateProvider,
_api.LogManager);
TxSealer standardSealer = new TxSealer(_api.Signer, _api.Timestamper);
NonceReservingTxSealer nonceReservingTxSealer =
new NonceReservingTxSealer(_api.Signer, _api.Timestamper, _api.TxPool);
IVaultConfig vaultConfig = _api.Config <IVaultConfig>();
if (!vaultConfig.Enabled)
{
_api.TxSender = new TxPoolSender(_api.TxPool, standardSealer, nonceReservingTxSealer);
}
else
{
IVaultService vaultService = new VaultService(vaultConfig, _api.LogManager);
IVaultWallet wallet = new VaultWallet(vaultService, vaultConfig.VaultId, _api.LogManager);
ITxSigner vaultSigner = new VaultTxSigner(wallet, _api.ChainSpec.ChainId);
// change vault to provide, use sealer to set the gas price as well
_api.TxSender = new VaultTxSender(vaultSigner, vaultConfig, _api.ChainSpec.ChainId);
}
IBloomConfig?bloomConfig = _api.Config <IBloomConfig>();
IFileStoreFactory fileStoreFactory = initConfig.DiagnosticMode == DiagnosticMode.MemDb
? (IFileStoreFactory) new InMemoryDictionaryFileStoreFactory()
: new FixedSizeFileStoreFactory(Path.Combine(initConfig.BaseDbPath, DbNames.Bloom), DbNames.Bloom, Bloom.ByteLength);
_api.BloomStorage = bloomConfig.Index
? new BloomStorage(bloomConfig, _api.DbProvider.BloomDb, fileStoreFactory)
: (IBloomStorage)NullBloomStorage.Instance;
_api.DisposeStack.Push(_api.BloomStorage);
_api.ChainLevelInfoRepository = new ChainLevelInfoRepository(_api.DbProvider.BlockInfosDb);
_api.BlockTree = new BlockTree(
_api.DbProvider.BlocksDb,
_api.DbProvider.HeadersDb,
_api.DbProvider.BlockInfosDb,
_api.ChainLevelInfoRepository,
_api.SpecProvider,
_api.TxPool,
_api.BloomStorage,
_api.Config <ISyncConfig>(),
_api.LogManager);
// Init state if we need system calls before actual processing starts
if (_api.BlockTree.Head != null)
{
_api.StateProvider.StateRoot = _api.BlockTree.Head.StateRoot;
}
_api.ReceiptStorage = initConfig.StoreReceipts ? (IReceiptStorage?)new PersistentReceiptStorage(_api.DbProvider.ReceiptsDb, _api.SpecProvider, new ReceiptsRecovery()) : NullReceiptStorage.Instance;
_api.ReceiptFinder = new FullInfoReceiptFinder(_api.ReceiptStorage, new ReceiptsRecovery(), _api.BlockTree);
_api.RecoveryStep = new TxSignaturesRecoveryStep(_api.EthereumEcdsa, _api.TxPool, _api.LogManager);
_api.StorageProvider = new StorageProvider(
_api.DbProvider.StateDb,
_api.StateProvider,
_api.LogManager);
// blockchain processing
BlockhashProvider blockhashProvider = new BlockhashProvider(
_api.BlockTree, _api.LogManager);
VirtualMachine virtualMachine = new VirtualMachine(
_api.StateProvider,
_api.StorageProvider,
blockhashProvider,
_api.SpecProvider,
_api.LogManager);
_api.TransactionProcessor = new TransactionProcessor(
_api.SpecProvider,
_api.StateProvider,
_api.StorageProvider,
virtualMachine,
_api.LogManager);
InitSealEngine();
if (_api.SealValidator == null)
{
throw new StepDependencyException(nameof(_api.SealValidator));
}
/* validation */
_api.HeaderValidator = CreateHeaderValidator();
OmmersValidator ommersValidator = new OmmersValidator(
_api.BlockTree,
_api.HeaderValidator,
_api.LogManager);
TxValidator txValidator = new TxValidator(_api.SpecProvider.ChainId);
_api.BlockValidator = new BlockValidator(
txValidator,
_api.HeaderValidator,
ommersValidator,
_api.SpecProvider,
_api.LogManager);
ReadOnlyDbProvider readOnly = new ReadOnlyDbProvider(_api.DbProvider, false);
StateReader stateReader = new StateReader(readOnly.StateDb, readOnly.CodeDb, _api.LogManager);
_api.TxPoolInfoProvider = new TxPoolInfoProvider(stateReader, _api.TxPool);
_api.MainBlockProcessor = CreateBlockProcessor();
BlockchainProcessor blockchainProcessor = new BlockchainProcessor(
_api.BlockTree,
_api.MainBlockProcessor,
_api.RecoveryStep,
_api.LogManager,
new BlockchainProcessor.Options
{
AutoProcess = !syncConfig.BeamSync,
StoreReceiptsByDefault = initConfig.StoreReceipts,
});
_api.BlockProcessingQueue = blockchainProcessor;
_api.BlockchainProcessor = blockchainProcessor;
if (syncConfig.BeamSync)
{
BeamBlockchainProcessor beamBlockchainProcessor = new BeamBlockchainProcessor(
new ReadOnlyDbProvider(_api.DbProvider, false),
_api.BlockTree,
_api.SpecProvider,
_api.LogManager,
_api.BlockValidator,
_api.RecoveryStep,
_api.RewardCalculatorSource !,
_api.BlockProcessingQueue,
_api.SyncModeSelector !);
_api.DisposeStack.Push(beamBlockchainProcessor);
}
return(Task.CompletedTask);
}
protected virtual Task InitBlockchain()
{
var(_get, _set) = _api.ForBlockchain;
if (_get.ChainSpec == null)
{
throw new StepDependencyException(nameof(_get.ChainSpec));
}
if (_get.DbProvider == null)
{
throw new StepDependencyException(nameof(_get.DbProvider));
}
if (_get.SpecProvider == null)
{
throw new StepDependencyException(nameof(_get.SpecProvider));
}
ILogger logger = _get.LogManager.GetClassLogger();
IInitConfig initConfig = _get.Config <IInitConfig>();
ISyncConfig syncConfig = _get.Config <ISyncConfig>();
if (syncConfig.DownloadReceiptsInFastSync && !syncConfig.DownloadBodiesInFastSync)
{
logger.Warn($"{nameof(syncConfig.DownloadReceiptsInFastSync)} is selected but {nameof(syncConfig.DownloadBodiesInFastSync)} - enabling bodies to support receipts download.");
syncConfig.DownloadBodiesInFastSync = true;
}
Account.AccountStartNonce = _get.ChainSpec.Parameters.AccountStartNonce;
var stateProvider = _set.StateProvider = new StateProvider(
_get.DbProvider.StateDb,
_get.DbProvider.CodeDb,
_get.LogManager);
ReadOnlyDbProvider readOnly = new ReadOnlyDbProvider(_api.DbProvider, false);
var stateReader = _set.StateReader = new StateReader(readOnly.StateDb, readOnly.CodeDb, _api.LogManager);
_set.ChainHeadStateProvider = new ChainHeadReadOnlyStateProvider(_get.BlockTree, stateReader);
PersistentTxStorage txStorage = new PersistentTxStorage(_get.DbProvider.PendingTxsDb);
// Init state if we need system calls before actual processing starts
if (_get.BlockTree !.Head != null)
{
stateProvider.StateRoot = _get.BlockTree.Head.StateRoot;
}
var txPool = _api.TxPool = CreateTxPool(txStorage);
var onChainTxWatcher = new OnChainTxWatcher(_get.BlockTree, txPool, _get.SpecProvider, _api.LogManager);
_get.DisposeStack.Push(onChainTxWatcher);
_api.BlockPreprocessor.AddFirst(
new RecoverSignatures(_get.EthereumEcdsa, txPool, _get.SpecProvider, _get.LogManager));
var storageProvider = _set.StorageProvider = new StorageProvider(
_get.DbProvider.StateDb,
stateProvider,
_get.LogManager);
// blockchain processing
BlockhashProvider blockhashProvider = new BlockhashProvider(
_get.BlockTree, _get.LogManager);
VirtualMachine virtualMachine = new VirtualMachine(
stateProvider,
storageProvider,
blockhashProvider,
_get.SpecProvider,
_get.LogManager);
_api.TransactionProcessor = new TransactionProcessor(
_get.SpecProvider,
stateProvider,
storageProvider,
virtualMachine,
_get.LogManager);
InitSealEngine();
if (_api.SealValidator == null)
{
throw new StepDependencyException(nameof(_api.SealValidator));
}
/* validation */
var headerValidator = _set.HeaderValidator = CreateHeaderValidator();
OmmersValidator ommersValidator = new OmmersValidator(
_get.BlockTree,
headerValidator,
_get.LogManager);
TxValidator txValidator = new TxValidator(_get.SpecProvider.ChainId);
var blockValidator = _set.BlockValidator = new BlockValidator(
txValidator,
headerValidator,
ommersValidator,
_get.SpecProvider,
_get.LogManager);
_set.TxPoolInfoProvider = new TxPoolInfoProvider(_api.StateReader, _api.TxPool);
var mainBlockProcessor = _set.MainBlockProcessor = CreateBlockProcessor();
BlockchainProcessor blockchainProcessor = new BlockchainProcessor(
_get.BlockTree,
mainBlockProcessor,
_api.BlockPreprocessor,
_get.LogManager,
new BlockchainProcessor.Options
{
AutoProcess = !syncConfig.BeamSync,
StoreReceiptsByDefault = initConfig.StoreReceipts,
});
_set.BlockProcessingQueue = blockchainProcessor;
_set.BlockchainProcessor = blockchainProcessor;
if (syncConfig.BeamSync)
{
BeamBlockchainProcessor beamBlockchainProcessor = new BeamBlockchainProcessor(
new ReadOnlyDbProvider(_api.DbProvider, false),
_get.BlockTree,
_get.SpecProvider,
_get.LogManager,
blockValidator,
_api.BlockPreprocessor,
_api.RewardCalculatorSource !, // TODO: does it work with AuRa?
blockchainProcessor,
_get.SyncModeSelector !);
_api.DisposeStack.Push(beamBlockchainProcessor);
}
// TODO: can take the tx sender from plugin here maybe
ITxSigner txSigner = new WalletTxSigner(_get.Wallet, _get.SpecProvider.ChainId);
TxSealer standardSealer = new TxSealer(txSigner, _get.Timestamper);
NonceReservingTxSealer nonceReservingTxSealer =
new NonceReservingTxSealer(txSigner, _get.Timestamper, txPool);
_set.TxSender = new TxPoolSender(txPool, nonceReservingTxSealer, standardSealer);
// TODO: possibly hide it (but need to confirm that NDM does not really need it)
var filterStore = _set.FilterStore = new FilterStore();
_set.FilterManager = new FilterManager(filterStore, mainBlockProcessor, txPool, _get.LogManager);
return(Task.CompletedTask);
}
public virtual Task Execute(CancellationToken cancellationToken)
{
if (_api.RpcModuleProvider == null)
{
throw new StepDependencyException(nameof(_api.RpcModuleProvider));
}
if (_api.TxPool == null)
{
throw new StepDependencyException(nameof(_api.TxPool));
}
if (_api.BlockTree == null)
{
throw new StepDependencyException(nameof(_api.BlockTree));
}
if (_api.Wallet == null)
{
throw new StepDependencyException(nameof(_api.Wallet));
}
if (_api.SpecProvider == null)
{
throw new StepDependencyException(nameof(_api.SpecProvider));
}
ILogger logger = _api.LogManager.GetClassLogger();
IJsonRpcConfig jsonRpcConfig = _api.Config <IJsonRpcConfig>();
if (!jsonRpcConfig.Enabled)
{
return(Task.CompletedTask);
}
// the following line needs to be called in order to make sure that the CLI library is referenced from runner and built alongside
if (logger.IsDebug)
{
logger.Debug($"Resolving CLI ({nameof(CliModuleLoader)})");
}
IInitConfig initConfig = _api.Config <IInitConfig>();
INdmConfig ndmConfig = _api.Config <INdmConfig>();
IJsonRpcConfig rpcConfig = _api.Config <IJsonRpcConfig>();
IBaselineConfig baselineConfig = _api.Config <IBaselineConfig>();
IVaultConfig vaultConfig = _api.Config <IVaultConfig>();
INetworkConfig networkConfig = _api.Config <INetworkConfig>();
if (ndmConfig.Enabled && !(_api.NdmInitializer is null) && ndmConfig.ProxyEnabled)
{
EthModuleProxyFactory proxyFactory = new EthModuleProxyFactory(_api.EthJsonRpcClientProxy, _api.Wallet);
_api.RpcModuleProvider.Register(new SingletonModulePool <IEthModule>(proxyFactory, true));
if (logger.IsInfo)
{
logger.Info("Enabled JSON RPC Proxy for NDM.");
}
}
else
{
EthModuleFactory ethModuleFactory = new EthModuleFactory(
_api.DbProvider,
_api.TxPool,
_api.TxSender,
_api.Signer,
_api.Wallet,
_api.BlockTree,
_api.EthereumEcdsa,
_api.MainBlockProcessor,
_api.ReceiptFinder,
_api.SpecProvider,
rpcConfig,
_api.BloomStorage,
_api.LogManager,
initConfig.IsMining);
_api.RpcModuleProvider.Register(new BoundedModulePool <IEthModule>(8, ethModuleFactory));
}
ProofModuleFactory proofModuleFactory = new ProofModuleFactory(_api.DbProvider, _api.BlockTree, _api.RecoveryStep, _api.ReceiptFinder, _api.SpecProvider, _api.LogManager);
_api.RpcModuleProvider.Register(new BoundedModulePool <IProofModule>(2, proofModuleFactory));
DebugModuleFactory debugModuleFactory = new DebugModuleFactory(
_api.DbProvider,
_api.BlockTree,
rpcConfig,
_api.BlockValidator,
_api.RecoveryStep,
_api.RewardCalculatorSource,
_api.ReceiptStorage,
new ReceiptMigration(_api),
_api.ConfigProvider,
_api.SpecProvider,
_api.LogManager);
_api.RpcModuleProvider.Register(new BoundedModulePool <IDebugModule>(8, debugModuleFactory));
TraceModuleFactory traceModuleFactory = new TraceModuleFactory(_api.DbProvider, _api.BlockTree, rpcConfig, _api.RecoveryStep, _api.RewardCalculatorSource, _api.ReceiptStorage, _api.SpecProvider, _api.LogManager);
_api.RpcModuleProvider.Register(new BoundedModulePool <ITraceModule>(8, traceModuleFactory));
PersonalModule personalModule = new PersonalModule(
_api.EthereumEcdsa,
_api.Wallet,
_api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IPersonalModule>(personalModule, true));
AdminModule adminModule = new AdminModule(_api.BlockTree, networkConfig, _api.PeerManager, _api.StaticNodesManager, _api.Enode, initConfig.BaseDbPath);
_api.RpcModuleProvider.Register(new SingletonModulePool <IAdminModule>(adminModule, true));
LogFinder logFinder = new LogFinder(
_api.BlockTree,
_api.ReceiptFinder,
_api.BloomStorage,
_api.LogManager,
new ReceiptsRecovery(), 1024);
if (baselineConfig.Enabled)
{
IDbProvider dbProvider = _api.DbProvider !;
IStateReader stateReader = new StateReader(dbProvider.StateDb, dbProvider.CodeDb, _api.LogManager);
ITxSealer txSealer = new TxSealer(_api.Signer, _api.Timestamper);
ITxSender txSender = new TxPoolSender(_api.TxPool, txSealer);
BaselineModuleFactory baselineModuleFactory = new BaselineModuleFactory(
txSender,
stateReader,
logFinder,
_api.BlockTree,
_api.AbiEncoder,
_api.FileSystem,
_api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IBaselineModule>(baselineModuleFactory, true));
if (logger?.IsInfo ?? false)
{
logger !.Info($"Baseline RPC Module has been enabled");
}
}
TxPoolModule txPoolModule = new TxPoolModule(_api.BlockTree, _api.TxPoolInfoProvider, _api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <ITxPoolModule>(txPoolModule, true));
if (vaultConfig.Enabled)
{
VaultService vaultService = new VaultService(vaultConfig, _api.LogManager);
VaultModule vaultModule = new VaultModule(vaultService, _api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IVaultModule>(vaultModule, true));
if (logger?.IsInfo ?? false)
{
logger !.Info($"Vault RPC Module has been enabled");
}
}
NetModule netModule = new NetModule(_api.LogManager, new NetBridge(_api.Enode, _api.SyncServer));
_api.RpcModuleProvider.Register(new SingletonModulePool <INetModule>(netModule, true));
ParityModule parityModule = new ParityModule(
_api.EthereumEcdsa,
_api.TxPool,
_api.BlockTree,
_api.ReceiptFinder,
_api.Enode,
_api.SignerStore,
_api.KeyStore,
_api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IParityModule>(parityModule, true));
return(Task.CompletedTask);
}
