public async Task SetUp()
{
_config = new VaultConfig();
_config.Host = "localhost:8082";
_config.Scheme = "http";
_config.Path = "api/v1";
_config.Token = $"bearer {TestContext.Parameters["token"]}";
var vaultSealingForTestsHelper = new VaultSealingForTestsHelper(_config);
await vaultSealingForTestsHelper.Unseal();
_vaultService = new VaultService(_config, new TestLogManager(LogLevel.Trace));
_vaultModule = new VaultModule(_vaultService, new TestLogManager(LogLevel.Trace));
provide.Model.Vault.Vault vault = new provide.Model.Vault.Vault();
vault.Name = "Test Vault";
vault.Description = "Test Vault used for test purposes";
ResultWrapper <provide.Model.Vault.Vault> res = await _vaultModule.vault_createVault(vault);
if (res.Result != Result.Success || res.Data.Id is null)
{
throw new ApplicationException("Failed to create vault");
}
_vaultId = res.Data.Id.Value;
}
public async Task SetUp()
{
VaultConfig config = new VaultConfig();
config.Host = "localhost:8082";
config.Scheme = "http";
config.Path = "api/v1";
config.Token = $"bearer {TestContext.Parameters["token"]}";
_vaultService = new VaultService(
config,
new TestLogManager(LogLevel.Trace)
);
provide.Model.Vault.Vault vault = new provide.Model.Vault.Vault();
vault.Name = "Name";
vault.Description = "Description";
// Create a single Vault instance
provide.Model.Vault.Vault response = await _vaultService.CreateVault(vault);
response.Id.Should().NotBeNull();
_vaultId = response.Id !.Value;
_wallet = new VaultWallet(_vaultService, _vaultId.ToString(), LimboLogs.Instance);
}
public async Task ConnectionError()
{
var vault = new VaultService(new Uri("http://unknown-server:8200"));
var result = await vault.HealthStatusAsync();
Assert.Equal(VaultHealthStatus.ConnectionError, result);
}
private async Task <DefaultVaultService> AuthVaultService()
{
var token = "de24bef9-56f1-8391-98ce-f6fa9ab53df1";
var vault = new VaultService(_vaultAddress).AuthenticateUsingToken(token) as DefaultVaultService;
return(vault);
}
public ProfileController(ProfileService ps, VaultService vs, KeepService ks, VaultKeepService vks)
{
_ks = ks;
_vs = vs;
_ps = ps;
_vks = vks;
}
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 void SetUp()
{
_config = new VaultConfig();
_config.Host = "localhost:8082";
_config.Scheme = "http";
_config.Path = "api/v1";
_config.Token = $"bearer {TestContext.Parameters["token"]}";
_vaultService = new VaultService(_config, LimboLogs.Instance);
}
private void Unlock_Click(object sender, RoutedEventArgs e)
{
var password = Password.Password;
var vaultService = new VaultService();
vaultService.DecryptVault(_VaultStatus, password);
_Editor.VaultUnlocked();
Close();
}
public LoginViewModel(
IEventAggregator eventAggregator,
IDataService dataService,
VaultService vaultService)
{
_eventAggregator = eventAggregator;
_dataService = dataService;
_vaultService = vaultService;
_vaultService.PasswordChanged += _vaultService_PasswordChanged;
_canLogin = true;
_userName = "******";
}
public void Can_Initialize_VaultTxSender_without_exceptions()
{
var vaultConfig = new VaultConfig();
vaultConfig.VaultId = "1b16996e-3595-4985-816c-043345d22f8c";
var _vaultService = new VaultService(vaultConfig, LimboLogs.Instance);
IVaultWallet wallet = new VaultWallet(_vaultService, vaultConfig.VaultId, LimboLogs.Instance);
ITxSigner vaultSigner = new VaultTxSigner(wallet, 1);
Assert.DoesNotThrow(() => { new VaultTxSender(vaultSigner, vaultConfig, 1); });
}
public async Task SetUp()
{
_config = new VaultConfig();
_config.Host = "localhost:8082";
_config.Scheme = "http";
_config.Path = "api/v1";
_config.Token = $"bearer {TestContext.Parameters["token"]}";
var vaultSealingForTestsHelper = new VaultSealingForTestsHelper(_config);
await vaultSealingForTestsHelper.Unseal();
_vaultService = new VaultService(_config, LimboLogs.Instance);
}
static void Main(string[] args)
{
try
{
UserCredential credential;
// Load client secrets.
using (var stream =
new FileStream("credentials.json", FileMode.Open, FileAccess.Read))
{
/* The file token.json stores the user's access and refresh tokens, and is created
* automatically when the authorization flow completes for the first time. */
string credPath = "token.json";
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.FromStream(stream).Secrets,
Scopes,
"user",
CancellationToken.None,
new FileDataStore(credPath, true)).Result;
Console.WriteLine("Credential file saved to: " + credPath);
}
// Create Vault API service.
var service = new VaultService(new BaseClientService.Initializer
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName
});
// Define request parameters.
MattersResource.ListRequest request = service.Matters.List();
request.PageSize = 10;
// List matters.
ListMattersResponse response = request.Execute();
Console.WriteLine("Matters:");
if (response.Matters == null || response.Matters.Count == 0)
{
Console.WriteLine("No matters found.");
return;
}
foreach (var matter in response.Matters)
{
Console.WriteLine("{0} ({1})", matter.Name, matter.MatterId);
}
}
catch (FileNotFoundException e)
{
Console.WriteLine(e.Message);
}
}
public IHttpActionResult GetVaultById(int vaultId)
{
VaultService vaultService = CreateVaultService();
var vault = vaultService.GetVaultById(vaultId);
if (vault.GameId != null)
{
vault.GameUrl = "https://" + HttpContext.Current.Request.Url.Authority + "/api/Game?GameId=" + vault.GameId;
}
if (vault.LocationId != null)
{
vault.LocationUrl = "https://" + HttpContext.Current.Request.Url.Authority + "/api/Location?LocationId=" + vault.LocationId;
}
return(Ok(vault));
}
static void Main(string[] args)
{
UserCredential credential;
using (var stream =
new FileStream("client_secret.json", FileMode.Open, FileAccess.Read))
{
string credPath = System.Environment.GetFolderPath(
System.Environment.SpecialFolder.Personal);
credPath = Path.Combine(credPath, ".credentials/vault.googleapis.com-dotnet-quickstart.json");
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
Scopes,
"user",
CancellationToken.None,
new FileDataStore(credPath, true)).Result;
Console.WriteLine("Credential file saved to: " + credPath);
}
// Create Vault API service.
var service = new VaultService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName,
});
// Define request parameters.
MattersResource.ListRequest request = service.Matters.List();
request.PageSize = 10;
// List matters.
ListMattersResponse response = request.Execute();
Console.WriteLine("Matters:");
if (response.Matters != null && response.Matters.Count > 0)
{
foreach (var matter in response.Matters)
{
Console.WriteLine("{0} ({1})", matter.Name, matter.MatterId);
}
}
else
{
Console.WriteLine("No matters found.");
}
Console.Read();
}
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 static void RefreshTreeView()
{
RootNode.Items.Clear();
var projectDirectory = Path.GetDirectoryName(ProjectPath);
var vaultService = new VaultService();
var userVaultItem = new TreeViewItem();
userVaultItem.Header = "User Vault";
userVaultItem.MouseDoubleClick += (sender, args) =>
{
OpenFileService.OpenFile(vaultService.GetUserVaultPath());
};
RootNode.Items.Add(userVaultItem);
RecursivelyBuildFolderTree(RootNode.Items, projectDirectory);
}
/// <summary>
/// Adds an <see cref="IConfigurationProvider"/> that reads configuration values from the HashiCorp Vault. This provider uses 'token' authentication.
/// </summary>
/// <param name="configurationBuilder">The <see cref="IConfigurationBuilder"/> to add to.</param>
/// <param name="vaultUri">The HashiCorp Vault uri.</param>
/// <param name="token">The authentication token.</param>
/// <param name="prefix">The prefix to use when retrieving secrets from the Vault.</param>
/// <returns>The <see cref="IConfigurationBuilder"/>.</returns>
public static IConfigurationBuilder AddVault(this IConfigurationBuilder configurationBuilder, Uri vaultUri, string token, string prefix)
{
if (vaultUri == null)
{
throw new ArgumentNullException(nameof(vaultUri));
}
if (string.IsNullOrWhiteSpace(token))
{
throw new ArgumentNullException(nameof(token));
}
var vault = new VaultService(vaultUri).AuthenticateUsingToken(token);
var source = new VaultConfigurationSource(vault, prefix);
return(configurationBuilder.Add(source));
}
public IHttpActionResult GetVaultsByCharacterId(int characterIdGetVaults)
{
VaultService vaultService = CreateVaultService();
var vaults = vaultService.GetAllVaultsByCharacterId(characterIdGetVaults);
foreach (VaultListItem h in vaults)
{
if (h.GameId != null)
{
h.GameUrl = "https://" + HttpContext.Current.Request.Url.Authority + "/api/Game?GameId=" + h.GameId;
}
if (h.LocationId != null)
{
h.LocationUrl = "https://" + HttpContext.Current.Request.Url.Authority + "/api/Location?LocationId=" + h.LocationId;
}
}
return(Ok(vaults));
}
public static async Task <string> PrintInvoiceAsync([ActivityTrigger] DurableActivityContext inputs, ILogger log)
{
CloudStorageAccount cloudStorageAccount = null;
var(orderId, parentId) = inputs.GetInput <(string, string)>();
log.LogInformation($" >>>>>> Printing invoice for the order {orderId}. <<<<<<");
var storageConnectionString = String.Empty;
// local debug uses visualstudio user as MSI
var securityVault = new VaultService(Environment.GetEnvironmentVariable("VaultName"));
try
{
storageConnectionString = securityVault.GetSecret("cn-storageaccount").Result;
}
catch (Exception)
{
storageConnectionString = Environment.GetEnvironmentVariable("StorageConnectionString");
}
var text = new AsciiArt("to blob storage");
log.LogInformation(text.ToString());
// save document to blob storage
cloudStorageAccount = CloudStorageAccount.Parse(storageConnectionString);
CloudBlobClient cloudBlobClient = cloudStorageAccount.CreateCloudBlobClient();
var blobContainer = cloudBlobClient.GetContainerReference("invoices");
var blockBlob = blobContainer.GetBlockBlobReference($"{orderId}.png");
var bytes = Encoding.ASCII.GetBytes(orderId);
using (var ms = new MemoryStream())
{
ms.Write(bytes, 0, bytes.Length);
ms.Flush();
ms.Position = 0;
blockBlob.UploadFromStream(ms);
}
// Demo code : Never use random in functions
return(String.Format("LBL{0}", Guid.NewGuid().ToString()));
}
/// <summary>
/// Adds an <see cref="IConfigurationProvider"/> that reads configuration values from the HashiCorp Vault. This provider uses 'userpass' authentication.
/// </summary>
/// <param name="configurationBuilder">The <see cref="IConfigurationBuilder"/> to add to.</param>
/// <param name="vaultUri">The HashiCorp Vault uri.</param>
/// <param name="userName">The user name for userpass authentication.</param>
/// <param name="password">The password for userpass authentication.</param>
/// <param name="prefix">The prefix to use when retrieving secrets from the Vault.</param>
/// <returns>The <see cref="IConfigurationBuilder"/>.</returns>
public static IConfigurationBuilder AddVault(this IConfigurationBuilder configurationBuilder, Uri vaultUri, string userName, string password, string prefix)
{
if (vaultUri == null)
{
throw new ArgumentNullException(nameof(vaultUri));
}
if (string.IsNullOrWhiteSpace(userName))
{
throw new ArgumentNullException(nameof(userName));
}
if (string.IsNullOrWhiteSpace(password))
{
throw new ArgumentNullException(nameof(password));
}
var vault = new VaultService(vaultUri).AuthenticateUsingUserPass(userName, password);
var source = new VaultConfigurationSource(vault, prefix);
return(configurationBuilder.Add(source));
}
public VaultEditor(string filePath)
{
InitializeComponent();
_VaultService = new VaultService();
_Vault = _VaultService.OpenVaultFile(filePath);
if (_Vault.IsInitialized)
{
InitializeButton.Visibility = Visibility.Hidden;
}
if (_Vault.IsUnlocked || !_Vault.IsInitialized)
{
UnlockButton.Visibility = Visibility.Hidden;
}
if (!_Vault.IsUnlocked || !_Vault.IsInitialized)
{
// If we have not unlocked the vault, it cannot be modified.
NewSecretButton.IsEnabled = false;
}
}
public LoginView(VaultService vaultService)
{
_vaultService = vaultService;
InitializeComponent();
}
public VaultsController(VaultService vs, VaultKeepService vks)
{
_vks = vks;
_vs = vs;
}
public ProfilesController(ProfileService ps, KeepsService ks, VaultService vs)
{
_ps = ps;
_ks = ks;
_vs = vs;
}
private VaultService CreateVaultService()
{
var vaultService = new VaultService();
return(vaultService);
}
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);
}
public VaultsController(VaultService service, KeepService kservice)
{
_service = service;
_kservice = kservice;
}
public AccountController(ProfileService ps, KeepService ks, VaultService vs)
{
_ps = ps;
_ks = ks;
_vs = vs;
}
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));
}
if (_api.TxSender == null)
{
throw new StepDependencyException(nameof(_api.TxSender));
}
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.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);
BaselineModuleFactory baselineModuleFactory = new BaselineModuleFactory(
_api.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.EngineSignerStore,
_api.KeyStore,
_api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IParityModule>(parityModule, true));
return(Task.CompletedTask);
}
public ProfilesController(KeepService ks, VaultService vs, ProfileService ps)
{
_ps = ps;
_vserv = vs;
_kserv = ks;
}