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));
}
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,
_receiptFinder,
_filterStore,
_filterManager,
_wallet,
readOnlyTxProcessingEnv.TransactionProcessor,
_ethereumEcdsa,
_bloomStorage,
Timestamper.Default,
_logManager,
_isMining,
_rpcConfig.FindLogBlockDepthLimit);
TxPoolBridge txPoolBridge = new TxPoolBridge(_txPool, _wallet, Timestamper.Default, _specProvider.ChainId);
return(new EthModule(_rpcConfig, blockchainBridge, txPoolBridge, _logManager));
}
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);
BlockchainBridge blockchainBridge = new BlockchainBridge(stateReader, stateProvider, storageProvider, blockTree, txPool, new InMemoryReceiptStorage(), NullFilterStore.Instance, NullFilterManager.Instance, wallet, processor, ecdsa, NullBloomStorage.Instance, Timestamper.Default, LimboLogs.Instance, false);
TxPoolBridge txPoolBridge = new TxPoolBridge(txPool, new WalletTxSigner(wallet, ChainId.Mainnet), Timestamper.Default);
return(new NdmBlockchainBridge(txPoolBridge, blockchainBridge, txPool));
}
public override IBaselineModule Create()
{
TxPoolBridge txPoolBridge = new TxPoolBridge(_txPool, new WalletTxSigner(_wallet, _specProvider.ChainId), Timestamper.Default);
return(new BaselineModule(txPoolBridge, _logFinder, _blockFinder, _abiEncoder, _fileSystem, new MemDb(), _logManager));
}
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.ChainId, LimboLogs.Instance), NullTxPool.Instance, 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());
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(ChainId.Mainnet, LimboLogs.Instance),
bloomStorage,
Timestamper.Default,
LimboLogs.Instance,
false);
TxPoolBridge txPoolBridge = new TxPoolBridge(NullTxPool.Instance, NullWallet.Instance, Timestamper.Default, specProvider.ChainId);
_ethModule = new EthModule(new JsonRpcConfig(), bridge, txPoolBridge, LimboLogs.Instance);
}
public virtual Task Execute(CancellationToken cancellationToken)
{
if (_context.RpcModuleProvider == null)
{
throw new StepDependencyException(nameof(_context.RpcModuleProvider));
}
if (_context.TxPool == null)
{
throw new StepDependencyException(nameof(_context.TxPool));
}
if (_context.BlockTree == null)
{
throw new StepDependencyException(nameof(_context.BlockTree));
}
if (_context.Wallet == null)
{
throw new StepDependencyException(nameof(_context.Wallet));
}
if (_context.SpecProvider == null)
{
throw new StepDependencyException(nameof(_context.SpecProvider));
}
ILogger logger = _context.LogManager.GetClassLogger();
IJsonRpcConfig jsonRpcConfig = _context.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 = _context.Config <IInitConfig>();
INdmConfig ndmConfig = _context.Config <INdmConfig>();
IJsonRpcConfig rpcConfig = _context.Config <IJsonRpcConfig>();
IBaselineConfig baselineConfig = _context.Config <IBaselineConfig>();
INetworkConfig networkConfig = _context.Config <INetworkConfig>();
if (ndmConfig.Enabled && !(_context.NdmInitializer is null) && ndmConfig.ProxyEnabled)
{
EthModuleProxyFactory proxyFactory = new EthModuleProxyFactory(_context.EthJsonRpcClientProxy, _context.Wallet);
_context.RpcModuleProvider.Register(new SingletonModulePool <IEthModule>(proxyFactory, true));
if (logger.IsInfo)
{
logger.Info("Enabled JSON RPC Proxy for NDM.");
}
}
else
{
EthModuleFactory ethModuleFactory = new EthModuleFactory(_context.DbProvider, _context.TxPool, _context.Wallet, _context.BlockTree,
_context.EthereumEcdsa, _context.MainBlockProcessor, _context.ReceiptFinder, _context.SpecProvider, rpcConfig, _context.BloomStorage, _context.LogManager, initConfig.IsMining);
_context.RpcModuleProvider.Register(new BoundedModulePool <IEthModule>(8, ethModuleFactory));
}
ProofModuleFactory proofModuleFactory = new ProofModuleFactory(_context.DbProvider, _context.BlockTree, _context.RecoveryStep, _context.ReceiptFinder, _context.SpecProvider, _context.LogManager);
_context.RpcModuleProvider.Register(new BoundedModulePool <IProofModule>(2, proofModuleFactory));
DebugModuleFactory debugModuleFactory = new DebugModuleFactory(_context.DbProvider, _context.BlockTree, _context.BlockValidator, _context.RecoveryStep, _context.RewardCalculatorSource, _context.ReceiptStorage, _context.ConfigProvider, _context.SpecProvider, _context.LogManager);
_context.RpcModuleProvider.Register(new BoundedModulePool <IDebugModule>(8, debugModuleFactory));
TraceModuleFactory traceModuleFactory = new TraceModuleFactory(_context.DbProvider, _context.BlockTree, _context.RecoveryStep, _context.RewardCalculatorSource, _context.ReceiptStorage, _context.SpecProvider, _context.LogManager);
_context.RpcModuleProvider.Register(new BoundedModulePool <ITraceModule>(8, traceModuleFactory));
if (initConfig.EnableUnsecuredDevWallet)
{
PersonalBridge personalBridge = new PersonalBridge(_context.EthereumEcdsa, _context.Wallet);
PersonalModule personalModule = new PersonalModule(personalBridge, _context.LogManager);
_context.RpcModuleProvider.Register(new SingletonModulePool <IPersonalModule>(personalModule, true));
}
AdminModule adminModule = new AdminModule(_context.BlockTree, networkConfig, _context.PeerManager, _context.StaticNodesManager, _context.Enode, initConfig.BaseDbPath);
_context.RpcModuleProvider.Register(new SingletonModulePool <IAdminModule>(adminModule, true));
LogFinder logFinder = new LogFinder(
_context.BlockTree,
_context.ReceiptFinder,
_context.BloomStorage,
_context.LogManager,
new ReceiptsRecovery(), 1024);
if (baselineConfig.Enabled)
{
BaselineModuleFactory baselineModuleFactory = new BaselineModuleFactory(
_context.TxPool,
logFinder,
_context.BlockTree,
_context.AbiEncoder,
_context.Wallet,
_context.SpecProvider,
_context.FileSystem,
_context.LogManager);
_context.RpcModuleProvider.Register(new SingletonModulePool <IBaselineModule>(baselineModuleFactory, true));
if (logger?.IsInfo ?? false)
{
logger !.Info($"Baseline RPC Module has been enabled");
}
}
IDepositConfig depositConfig = _context.Config <IDepositConfig>();
if (depositConfig.DepositContractAddress != null)
{
TxPoolBridge txPoolBridge = new TxPoolBridge(
_context.TxPool, new WalletTxSigner(_context.Wallet, _context.SpecProvider.ChainId), _context.Timestamper);
DepositModule depositModule = new DepositModule(txPoolBridge, logFinder, depositConfig, _context.LogManager);
_context.RpcModuleProvider.Register(new SingletonModulePool <IDepositModule>(depositModule, true));
}
TxPoolModule txPoolModule = new TxPoolModule(_context.BlockTree, _context.TxPoolInfoProvider, _context.LogManager);
_context.RpcModuleProvider.Register(new SingletonModulePool <ITxPoolModule>(txPoolModule, true));
NetModule netModule = new NetModule(_context.LogManager, new NetBridge(_context.Enode, _context.SyncServer));
_context.RpcModuleProvider.Register(new SingletonModulePool <INetModule>(netModule, true));
ParityModule parityModule = new ParityModule(_context.EthereumEcdsa, _context.TxPool, _context.BlockTree, _context.ReceiptFinder, _context.LogManager);
_context.RpcModuleProvider.Register(new SingletonModulePool <IParityModule>(parityModule, true));
SubsystemStateChanged?.Invoke(this, new SubsystemStateEventArgs(EthereumSubsystemState.Running));
return(Task.CompletedTask);
}
public void SetUp()
{
_txPool = Substitute.For <ITxPool>();
_wallet = Substitute.For <IWallet>();
_txPoolBridge = new TxPoolBridge(_txPool, _wallet, Timestamper.Default, ChainId.Mainnet);
}
public INdmServices Init(NdmRequiredServices services)
{
AddDecoders();
var config = services.NdmConfig;
var consumerAddress = string.IsNullOrWhiteSpace(config.ConsumerAddress)
? Address.Zero
: new Address(config.ConsumerAddress);
var contractAddress = string.IsNullOrWhiteSpace(config.ContractAddress)
? Address.Zero
: new Address(config.ContractAddress);
var configId = config.Id;
var configManager = services.ConfigManager;
var logManager = services.LogManager;
var timestamper = services.Timestamper;
var wallet = services.Wallet;
var readOnlyTree = new ReadOnlyBlockTree(services.BlockTree);
var readOnlyDbProvider = new ReadOnlyDbProvider(services.RocksProvider, false);
var readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree,
services.SpecProvider, logManager);
var jsonRpcConfig = services.ConfigProvider.GetConfig <IJsonRpcConfig>();
var blockchainBridge = new BlockchainBridge(
readOnlyTxProcessingEnv.StateReader,
readOnlyTxProcessingEnv.StateProvider,
readOnlyTxProcessingEnv.StorageProvider,
readOnlyTxProcessingEnv.BlockTree,
services.TransactionPool,
services.ReceiptFinder,
services.FilterStore,
services.FilterManager,
wallet,
readOnlyTxProcessingEnv.TransactionProcessor,
services.Ecdsa,
services.BloomStorage,
Timestamper.Default,
logManager,
false,
jsonRpcConfig.FindLogBlockDepthLimit);
var txPoolBridge = new TxPoolBridge(services.TransactionPool, new WalletTxSigner(services.Wallet, services.SpecProvider.ChainId), services.Timestamper);
var dataAssetRlpDecoder = new DataAssetDecoder();
var encoder = new AbiEncoder();
INdmBlockchainBridge ndmBlockchainBridge;
if (config.ProxyEnabled)
{
if (config.JsonRpcUrlProxies == null || services.EthJsonRpcClientProxy == null)
{
throw new InvalidDataException("JSON RPC proxy is enabled but the proxies were not initialized properly.");
}
services.JsonRpcClientProxy !.SetUrls(config.JsonRpcUrlProxies !);
ndmBlockchainBridge = new NdmBlockchainBridgeProxy(services.EthJsonRpcClientProxy);
}
else
{
ndmBlockchainBridge = new NdmBlockchainBridge(txPoolBridge, blockchainBridge, services.TransactionPool);
}
var gasPriceService = new GasPriceService(services.HttpClient, configManager, configId, timestamper,
logManager);
var transactionService = new TransactionService(ndmBlockchainBridge, wallet, configManager, configId,
logManager);
var depositService = new DepositService(ndmBlockchainBridge, encoder, wallet, contractAddress);
var ndmConsumerChannelManager = services.NdmConsumerChannelManager;
var ndmDataPublisher = services.NdmDataPublisher;
var jsonRpcNdmConsumerChannel = new JsonRpcNdmConsumerChannel(logManager);
if (config.JsonRpcDataChannelEnabled)
{
ndmConsumerChannelManager.Add(jsonRpcNdmConsumerChannel);
}
return(new Services(services, new NdmCreatedServices(consumerAddress, encoder, dataAssetRlpDecoder,
depositService, gasPriceService, transactionService, ndmDataPublisher, jsonRpcNdmConsumerChannel,
ndmConsumerChannelManager, ndmBlockchainBridge)));
}
public void SetUp()
{
_txPool = Substitute.For <ITxPool>();
_txSigner = Substitute.For <ITxSigner>();
_txPoolBridge = new TxPoolBridge(_txPool, _txSigner, Timestamper.Default);
}
