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