public async Task Init(INethermindApi nethermindApi)
{
_nethermindApi = nethermindApi;
_logger = nethermindApi.LogManager.GetClassLogger();
_config = nethermindApi.Config <IMulticallConfig>();
await Task.CompletedTask;
}
public Task Init(INethermindApi nethermindApi)
{
_api = nethermindApi;
var(getFromAPi, _) = _api.ForInit;
_ethStatsConfig = getFromAPi.Config <IEthStatsConfig>();
IInitConfig initConfig = getFromAPi.Config <IInitConfig>();
_isOn = _ethStatsConfig.Enabled;
_logger = getFromAPi.LogManager.GetClassLogger();
if (!_isOn)
{
if (!initConfig.WebSocketsEnabled)
{
_logger.Warn($"{nameof(EthStatsPlugin)} disabled due to {nameof(initConfig.WebSocketsEnabled)} set to false");
}
else
{
_logger.Warn($"{nameof(EthStatsPlugin)} plugin disabled due to {nameof(EthStatsConfig)} settings set to false");
}
}
return(Task.CompletedTask);
}
public Task Init(INethermindApi api)
{
_api = api;
_healthChecksConfig = _api.Config <IHealthChecksConfig>();
return(Task.CompletedTask);
}
public Task Init(INethermindApi nethermindApi)
{
_api = nethermindApi;
_mergeConfig = nethermindApi.Config <IMergeConfig>();
_logger = _api.LogManager.GetClassLogger();
return(Task.CompletedTask);
}
public Task Init(INethermindApi nethermindApi)
{
_nethermindApi = nethermindApi;
if (_nethermindApi !.SealEngineType != SealEngineType.Clique)
{
return(Task.CompletedTask);
}
var(getFromApi, setInApi) = _nethermindApi.ForInit;
_cliqueConfig = new CliqueConfig
{
BlockPeriod = getFromApi !.ChainSpec !.Clique.Period,
Epoch = getFromApi.ChainSpec.Clique.Epoch
};
_snapshotManager = new SnapshotManager(
_cliqueConfig,
getFromApi.DbProvider !.BlocksDb,
getFromApi.BlockTree !,
getFromApi.EthereumEcdsa !,
getFromApi.LogManager);
setInApi.HealthHintService = new CliqueHealthHintService(_snapshotManager, getFromApi.ChainSpec);
setInApi.SealValidator = new CliqueSealValidator(
_cliqueConfig,
_snapshotManager,
getFromApi.LogManager);
setInApi.RewardCalculatorSource = NoBlockRewards.Instance;
setInApi.BlockPreprocessor.AddLast(new AuthorRecoveryStep(_snapshotManager !));
return(Task.CompletedTask);
}
public Task Init(INethermindApi api)
{
_api = api;
var(getFromAPi, _) = _api.ForInit;
_analyticsConfig = getFromAPi.Config <IAnalyticsConfig>();
IInitConfig initConfig = getFromAPi.Config <IInitConfig>();
_isOn = initConfig.WebSocketsEnabled &&
(_analyticsConfig.PluginsEnabled ||
_analyticsConfig.StreamBlocks ||
_analyticsConfig.StreamTransactions);
if (!_isOn)
{
if (!initConfig.WebSocketsEnabled)
{
getFromAPi.LogManager.GetClassLogger().Warn($"{nameof(AnalyticsPlugin)} disabled due to {nameof(initConfig.WebSocketsEnabled)} set to false");
}
else
{
getFromAPi.LogManager.GetClassLogger().Warn($"{nameof(AnalyticsPlugin)} plugin disabled due to {nameof(AnalyticsConfig)} settings set to false");
}
}
return(Task.CompletedTask);
}
public Task Init(INethermindApi api)
{
_baselineConfig = api.Config <IBaselineConfig>();
_api = api;
_logger = api.LogManager.GetClassLogger();
return(Task.CompletedTask);
}
public virtual Task Init(INethermindApi nethermindApi)
{
_api = nethermindApi;
_mergeConfig = nethermindApi.Config <IMergeConfig>();
_syncConfig = nethermindApi.Config <ISyncConfig>();
_logger = _api.LogManager.GetClassLogger();
if (MergeEnabled)
{
if (_api.DbProvider == null)
{
throw new ArgumentException(nameof(_api.DbProvider));
}
if (_api.BlockTree == null)
{
throw new ArgumentException(nameof(_api.BlockTree));
}
if (_api.SpecProvider == null)
{
throw new ArgumentException(nameof(_api.SpecProvider));
}
if (_api.ChainSpec == null)
{
throw new ArgumentException(nameof(_api.ChainSpec));
}
if (_api.SealValidator == null)
{
throw new ArgumentException(nameof(_api.SealValidator));
}
EnsureJsonRpcUrl();
EnsureReceiptAvailable();
_blockCacheService = new BlockCacheService();
_poSSwitcher = new PoSSwitcher(
_mergeConfig,
_syncConfig,
_api.DbProvider.GetDb <IDb>(DbNames.Metadata),
_api.BlockTree,
_api.SpecProvider,
_api.LogManager);
_invalidChainTracker = new InvalidChainTracker.InvalidChainTracker(
_poSSwitcher,
_api.BlockTree,
_blockCacheService,
_api.LogManager);
_api.DisposeStack.Push(_invalidChainTracker);
_blockFinalizationManager = new ManualBlockFinalizationManager();
_api.RewardCalculatorSource = new MergeRewardCalculatorSource(
_api.RewardCalculatorSource ?? NoBlockRewards.Instance, _poSSwitcher);
_api.SealValidator = new MergeSealValidator(_poSSwitcher, _api.SealValidator);
_api.GossipPolicy = new MergeGossipPolicy(_api.GossipPolicy, _poSSwitcher, _blockCacheService);
_api.BlockPreprocessor.AddFirst(new MergeProcessingRecoveryStep(_poSSwitcher));
}
return(Task.CompletedTask);
}
public InitializeNetwork(INethermindApi api)
{
_api = api;
_logger = _api.LogManager.GetClassLogger();
_networkConfig = _api.Config <INetworkConfig>();
_syncConfig = _api.Config <ISyncConfig>();
}
public INethermindApi Create(IEnumerable <IConsensusPlugin> consensusPlugins)
{
ChainSpec chainSpec = LoadChainSpec(_jsonSerializer);
bool wasCreated = Interlocked.CompareExchange(ref _apiCreated, 1, 0) == 1;
if (wasCreated)
{
throw new NotSupportedException("Creation of multiple APIs not supported.");
}
string engine = chainSpec.SealEngineType;
IConsensusPlugin?enginePlugin = consensusPlugins.FirstOrDefault(p => p.SealEngineType == engine);
INethermindApi nethermindApi = enginePlugin?.CreateApi() ?? new NethermindApi();
nethermindApi.ConfigProvider = _configProvider;
nethermindApi.EthereumJsonSerializer = _jsonSerializer;
nethermindApi.LogManager = _logManager;
nethermindApi.SealEngineType = engine;
nethermindApi.SpecProvider = new ChainSpecBasedSpecProvider(chainSpec);
nethermindApi.GasLimitCalculator = new FollowOtherMiners(nethermindApi.SpecProvider);
nethermindApi.ChainSpec = chainSpec;
SetLoggerVariables(chainSpec);
return(nethermindApi);
}
public async Task Init(INethermindApi api)
{
_vaultConfig = api.Config <IVaultConfig>();
_api = api;
_logger = api.LogManager.GetClassLogger();
_vaultService = new VaultService(_vaultConfig, _api.LogManager);
if (_vaultConfig.Enabled)
{
var passwordProvider = new FilePasswordProvider()
{
FileName = _vaultConfig.VaultKeyFile.GetApplicationResourcePath()
}
.OrReadFromConsole("Provide passsphrase to unlock Vault");
var vaultKeyStoreFacade = new VaultKeyStoreFacade(passwordProvider);
_vaultSealingHelper = new VaultSealingHelper(vaultKeyStoreFacade, _vaultConfig, _logger);
await _vaultSealingHelper.Unseal();
}
IVaultWallet wallet = new VaultWallet(_vaultService, _vaultConfig.VaultId, _api.LogManager);
ITxSigner vaultSigner = new VaultTxSigner(wallet, _api.ChainSpec.ChainId);
// TODO: change vault to provide, use sealer to set the gas price as well
// TODO: need to verify the timing of initializations so the TxSender replacement works fine
_api.TxSender = new VaultTxSender(vaultSigner, _vaultConfig, _api.ChainSpec.ChainId);
}
public Task Init(INethermindApi?nethermindApi)
{
_nethermindApi = nethermindApi ?? throw new ArgumentNullException(nameof(nethermindApi));
_mevConfig = _nethermindApi.Config <IMevConfig>();
_logger = _nethermindApi.LogManager.GetClassLogger();
return(Task.CompletedTask);
}
public ApplyMemoryHint(INethermindApi api)
{
_api = api ?? throw new ArgumentNullException(nameof(api));
_initConfig = api.Config <IInitConfig>();
_dbConfig = api.Config <IDbConfig>();
_networkConfig = api.Config <INetworkConfig>();
_syncConfig = api.Config <ISyncConfig>();
_txPoolConfig = api.Config <ITxPoolConfig>();
}
public Task Init(INethermindApi api)
{
_api = api;
var(getFromAPi, _) = _api.ForInit;
_kafkaConfig = getFromAPi.Config <IKafkaConfig>();
_logger = getFromAPi.LogManager.GetClassLogger();
return(Task.CompletedTask);
}
public Task Init(INethermindApi api)
{
_api = api;
_healthChecksConfig = _api.Config <IHealthChecksConfig>();
_jsonRpcConfig = _api.Config <IJsonRpcConfig>();
_logger = api.LogManager.GetClassLogger();
return(Task.CompletedTask);
}
public Task Init(INethermindApi api)
{
_ndmApi = new NdmApi(api);
// TODO: load messages nicely?
api.MessageSerializationService.Register(Assembly.GetAssembly(typeof(HiMessageSerializer)));
ILogger logger = api.LogManager.GetClassLogger();
INdmConfig ndmConfig = api.ConfigProvider.GetConfig <INdmConfig>();
bool ndmEnabled = ndmConfig.Enabled;
if (ndmEnabled)
{
_ndmApi.NdmDataPublisher = new NdmDataPublisher();
_ndmApi.NdmConsumerChannelManager = new NdmConsumerChannelManager();
string initializerName = ndmConfig.InitializerName;
if (logger.IsInfo)
{
logger.Info($"NDM initializer: {initializerName}");
}
Type?ndmInitializerType = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(a => a.GetTypes())
.FirstOrDefault(t =>
t.GetCustomAttribute <NdmInitializerAttribute>()?.Name == initializerName);
if (ndmInitializerType == null)
{
if (logger.IsError)
{
logger.Error(
$"NDM enabled but the initializer {initializerName} has not been found. Ensure that a plugin exists with the properly set {nameof(NdmInitializerAttribute)}");
}
}
NdmModule ndmModule = new(_ndmApi);
NdmConsumersModule ndmConsumersModule = new(_ndmApi);
_ndmInitializer =
new NdmInitializerFactory(ndmInitializerType, ndmModule, ndmConsumersModule, api.LogManager)
.CreateOrFail();
if (api.GrpcServer != null)
{
var grpcChannel = new GrpcNdmConsumerChannel(api.GrpcServer);
_ndmApi.NdmConsumerChannelManager.Add(grpcChannel);
}
NdmWebSocketsModule ndmWebSocketsModule =
new(
_ndmApi.NdmConsumerChannelManager,
_ndmApi.NdmDataPublisher,
api.EthereumJsonSerializer);
api.WebSocketsManager.AddModule(ndmWebSocketsModule);
}
return(Task.CompletedTask);
}
public void Can_initialize()
{
INethermindApi api = Substitute.For <INethermindApi>();
api.Config <IMevConfig>().Returns(MevConfig.Default);
api.LogManager.Returns(LimboLogs.Instance);
MevPlugin plugin = new();
plugin.Init(api);
}
private IEnumerable <Assembly> GetStepsAssemblies(INethermindApi api)
{
yield return(typeof(IStep).Assembly);
yield return(GetType().Assembly);
IEnumerable <IInitializationPlugin> enabledInitializationPlugins =
_api.Plugins.OfType <IInitializationPlugin>().Where(p => p.ShouldRunSteps(api));
foreach (IInitializationPlugin initializationPlugin in enabledInitializationPlugins)
{
yield return(initializationPlugin.GetType().Assembly);
}
}
public void Can_register_json_rpc()
{
INethermindApi api = Substitute.For <INethermindApi>();
api.ForRpc.Returns((api, api));
api.Config <IMevConfig>().Returns(MevConfig.Default);
api.Config <IJsonRpcConfig>().Returns(JsonRpcConfig.Default);
api.LogManager.Returns(LimboLogs.Instance);
MevPlugin plugin = new();
plugin.Init(api);
plugin.InitRpcModules();
}
public Task Init(INethermindApi api)
{
_vaultConfig = api.Config <IVaultConfig>();
_api = api;
_logger = api.LogManager.GetClassLogger();
_vaultService = new VaultService(_vaultConfig, _api.LogManager);
IVaultWallet wallet = new VaultWallet(_vaultService, _vaultConfig.VaultId, _api.LogManager);
ITxSigner vaultSigner = new VaultTxSigner(wallet, _api.ChainSpec.ChainId);
// TODO: change vault to provide, use sealer to set the gas price as well
// TODO: need to verify the timing of initializations so the TxSender replacement works fine
_api.TxSender = new VaultTxSender(vaultSigner, _vaultConfig, _api.ChainSpec.ChainId);
return(Task.CompletedTask);
}
public JsonRpcRunner(
IJsonRpcProcessor jsonRpcProcessor,
IWebSocketsManager webSocketsManager,
IConfigProvider configurationProvider,
ILogManager logManager,
INethermindApi api)
{
_jsonRpcConfig = configurationProvider.GetConfig <IJsonRpcConfig>();
_initConfig = configurationProvider.GetConfig <IInitConfig>();
_configurationProvider = configurationProvider;
_logManager = logManager;
_jsonRpcProcessor = jsonRpcProcessor;
_webSocketsManager = webSocketsManager;
_logger = logManager.GetClassLogger();
_api = api;
}
public EthereumStepsManager(
IEthereumStepsLoader loader,
INethermindApi context,
ILogManager logManager)
{
if (loader == null)
{
throw new ArgumentNullException(nameof(loader));
}
_api = context ?? throw new ArgumentNullException(nameof(context));
_logger = logManager?.GetClassLogger <EthereumStepsManager>()
?? throw new ArgumentNullException(nameof(logManager));
_allSteps = loader.LoadSteps(_api.GetType()).ToList();
_allStepsByBaseType = _allSteps.ToDictionary(s => s.StepBaseType, s => s);
}
public async Task database_path_should_be_base_db_and_ndm_db_path()
{
_initConfig.BaseDbPath = "db";
_ndmConfig.DatabasePath = "ndm";
INethermindApi nethermindApi = Substitute.For <INethermindApi>();
var configProvider = Substitute.For <IConfigProvider>();
configProvider.GetConfig <INdmConfig>().Returns(_ndmConfig);
configProvider.GetConfig <IInitConfig>().Returns(_initConfig);
nethermindApi.ConfigProvider.Returns(configProvider);
INdmApi ndmApi = new NdmApi(nethermindApi);
ndmApi.AccountService = Substitute.For <IAccountService>();
await _ndmInitializer.InitAsync(ndmApi);
_ndmInitializer.DbPath.Should().Be(Path.Combine(_initConfig.BaseDbPath, _ndmConfig.DatabasePath));
}
public Task Init(INethermindApi api)
{
_api = api;
_analyticsConfig = _api.Config <IAnalyticsConfig>();
IInitConfig initConfig = _api.Config <IInitConfig>();
if (initConfig.WebSocketsEnabled &&
(_analyticsConfig.PluginsEnabled ||
_analyticsConfig.StreamBlocks ||
_analyticsConfig.StreamTransactions))
{
AnalyticsWebSocketsModule webSocketsModule = new AnalyticsWebSocketsModule(_api.EthereumJsonSerializer);
_api.WebSocketsManager !.AddModule(webSocketsModule, true);
_api.Publishers.Add(webSocketsModule);
_api.TxPool.NewDiscovered += TxPoolOnNewDiscovered;
}
return(Task.CompletedTask);
}
public Task Init(INethermindApi nethermindApi)
{
_nethermindApi = nethermindApi;
if (_nethermindApi !.SealEngineType != Nethermind.Core.SealEngineType.Ethash)
{
return(Task.CompletedTask);
}
var(getFromApi, setInApi) = _nethermindApi.ForInit;
setInApi.RewardCalculatorSource = new RewardCalculator(getFromApi.SpecProvider);
EthashDifficultyCalculator difficultyCalculator = new(getFromApi.SpecProvider);
Ethash ethash = new(getFromApi.LogManager);
setInApi.Sealer = getFromApi.Config <IMiningConfig>().Enabled
? new EthashSealer(ethash, getFromApi.EngineSigner, getFromApi.LogManager)
: NullSealEngine.Instance;
setInApi.SealValidator = new EthashSealValidator(getFromApi.LogManager, difficultyCalculator, getFromApi.CryptoRandom, ethash, _nethermindApi.Timestamper);
return(Task.CompletedTask);
}
public async Task database_path_should_be_base_db_and_ndm_db_path()
{
_initConfig.BaseDbPath = "db";
_ndmConfig.DatabasePath = "ndm";
INethermindApi nethermindApi = Substitute.For <INethermindApi>();
var configProvider = Substitute.For <IConfigProvider>();
configProvider.GetConfig <INdmConfig>().Returns(_ndmConfig);
configProvider.GetConfig <IInitConfig>().Returns(_initConfig);
nethermindApi.ConfigProvider.Returns(configProvider);
INdmApi ndmApi = new NdmApi(nethermindApi);
ndmApi.ConsumerService = Substitute.For <IConsumerService>();
ndmApi.AccountService = Substitute.For <IAccountService>();
ndmApi.NdmConsumerChannelManager = Substitute.For <INdmConsumerChannelManager>();
ndmApi.Enode = new Enode(TestItem.PublicKeyA, IPAddress.Any, 30303);
await _ndmInitializer.InitAsync(ndmApi);
_ndmInitializer.DbPath.Should().Be(Path.Combine(_initConfig.BaseDbPath, _ndmConfig.DatabasePath));
}
private static void InitializeFullPruning(
IPruningConfig pruningConfig,
IInitConfig initConfig,
INethermindApi api,
IStateReader stateReader)
{
IPruningTrigger?CreateAutomaticTrigger(string dbPath)
{
long threshold = pruningConfig.FullPruningThresholdMb.MB();
switch (pruningConfig.FullPruningTrigger)
{
case FullPruningTrigger.StateDbSize:
return(new PathSizePruningTrigger(dbPath, threshold, api.TimerFactory, api.FileSystem));
case FullPruningTrigger.VolumeFreeSpace:
return(new DiskFreeSpacePruningTrigger(dbPath, threshold, api.TimerFactory, api.FileSystem));
default:
return(null);
}
}
if (pruningConfig.Mode.IsFull())
{
IDb stateDb = api.DbProvider !.StateDb;
if (stateDb is IFullPruningDb fullPruningDb)
{
IPruningTrigger?pruningTrigger = CreateAutomaticTrigger(fullPruningDb.GetPath(initConfig.BaseDbPath));
if (pruningTrigger is not null)
{
api.PruningTrigger.Add(pruningTrigger);
}
FullPruner pruner = new(fullPruningDb, api.PruningTrigger, pruningConfig, api.BlockTree !, stateReader, api.LogManager);
api.DisposeStack.Push(pruner);
}
}
}
public Task Init(INethermindApi nethermindApi)
{
_api = nethermindApi;
_mergeConfig = nethermindApi.Config <IMergeConfig>();
_logger = _api.LogManager.GetClassLogger();
if (_mergeConfig.Enabled)
{
if (string.IsNullOrEmpty(_mergeConfig.BlockAuthorAccount))
{
if (_logger.IsError)
{
_logger.Error($"{nameof(MergeConfig)}.{nameof(_mergeConfig.BlockAuthorAccount)} is not set up. Cannot create blocks. Stopping.");
}
Environment.Exit(13); // ERROR_INVALID_DATA
}
_api.EngineSigner = new Eth2Signer(new Address(_mergeConfig.BlockAuthorAccount));
_api.RewardCalculatorSource = NoBlockRewards.Instance;
}
return(Task.CompletedTask);
}
public async Task Init(INethermindApi nethermindApi)
{
_api = nethermindApi;
_txPool = _api.TxPool;
_blockProcessor = _api.MainBlockProcessor;
_config = _api.Config <IDslConfig>();
if (_config.Enabled)
{
_logger = _api.LogManager.GetClassLogger();
if (_logger.IsInfo)
{
_logger.Info("Initializing DSL plugin ...");
}
var dslScript = await LoadDSLScript();
var inputStream = new AntlrInputStream(dslScript);
var lexer = new DslGrammarLexer(inputStream);
var tokens = new CommonTokenStream(lexer);
var parser = new DslGrammarParser(tokens);
parser.BuildParseTree = true;
IParseTree tree = parser.init();
_listener = new ParseTreeListener();
_listener.OnEnterInit = OnInitEntry;
_listener.OnEnterExpression = OnExpressionEntry;
_listener.OnEnterCondition = OnConditionEntry;
_listener.OnExitInit = BuildPipeline;
ParseTreeWalker.Default.Walk(_listener, tree);
if (_logger.IsInfo)
{
_logger.Info("DSL plugin initialized.");
}
}
}
public PluginManager(INethermindApi nethermindApi)
{
_nethermindApi = nethermindApi ?? throw new ArgumentNullException(nameof(nethermindApi));
}
