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));
}
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 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));
}
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);
}
