public void Initialize()
        {
            ISpecProvider specProvider = MainnetSpecProvider.Instance;
            ITxPool       txPool       = NullTxPool.Instance;
            MemDbProvider dbProvider   = new MemDbProvider();

            BlockTree blockTree = new BlockTree(
                dbProvider.BlocksDb,
                dbProvider.HeadersDb,
                dbProvider.BlockInfosDb,
                new ChainLevelInfoRepository(dbProvider.BlockInfosDb),
                specProvider,
                txPool,
                new BloomStorage(new BloomConfig(), dbProvider.HeadersDb, new InMemoryDictionaryFileStoreFactory()),
                new SyncConfig(),
                LimboLogs.Instance);

            _modulePool = new BoundedModulePool <IEthModule>(
                1,
                new EthModuleFactory(
                    dbProvider,
                    txPool,
                    NullWallet.Instance,
                    blockTree,
                    new EthereumEcdsa(MainnetSpecProvider.Instance, LimboLogs.Instance),
                    NullBlockProcessor.Instance,
                    new InMemoryReceiptStorage(),
                    specProvider,
                    new JsonRpcConfig(),
                    NullBloomStorage.Instance,
                    LimboLogs.Instance,
                    false));
        }
示例#2
0
        public async Task Initialize()
        {
            ISpecProvider specProvider = MainnetSpecProvider.Instance;
            ITxPool       txPool       = NullTxPool.Instance;
            IDbProvider   dbProvider   = await TestMemDbProvider.InitAsync();

            BlockTree blockTree = new BlockTree(
                dbProvider.BlocksDb,
                dbProvider.HeadersDb,
                dbProvider.BlockInfosDb,
                new ChainLevelInfoRepository(dbProvider.BlockInfosDb),
                specProvider,
                new BloomStorage(new BloomConfig(), dbProvider.HeadersDb, new InMemoryDictionaryFileStoreFactory()),
                new SyncConfig(),
                LimboLogs.Instance);

            _modulePool = new BoundedModulePool <IEthModule>(new EthModuleFactory(
                                                                 txPool,
                                                                 Substitute.For <ITxSender>(),
                                                                 NullWallet.Instance,
                                                                 blockTree,
                                                                 new JsonRpcConfig(),
                                                                 LimboLogs.Instance,
                                                                 Substitute.For <IStateReader>(),
                                                                 Substitute.For <IBlockchainBridgeFactory>()), 1, 1000);
        }
示例#3
0
        public Task InitRpcModules()
        {
            if (_baselineConfig.Enabled)
            {
                BaselineModuleFactory baselineModuleFactory = new BaselineModuleFactory(
                    _api.TxSender !,
                    _api.StateReader !,
                    _api.CreateBlockchainBridge(),
                    _api.BlockTree !,
                    _api.AbiEncoder,
                    _api.FileSystem,
                    _api.LogManager);

                var modulePool = new BoundedModulePool <IBaselineModule>(baselineModuleFactory, 2, 1000);
                _api.RpcModuleProvider !.Register(modulePool);

                if (_logger.IsInfo)
                {
                    _logger.Info("Baseline RPC Module has been enabled");
                }
            }

            return(Task.CompletedTask);
        }