public IWebSocketsClient CreateClient(IWebSocketsModule module, WebSocket webSocket, string client)
{
var socketsClient = module.CreateClient(webSocket, client);
_modules.TryAdd(module.Name, module);
return(socketsClient);
}
public void AddModule(IWebSocketsModule module, bool isDefault = false)
{
_modules.TryAdd(module.Name, module);
if (isDefault)
{
defaultModule = module;
}
}
public NdmAccountUpdater(IWebSocketsModule module, Address accountAddress, IBlockProcessor blockProcessor, IReadOnlyStateProvider stateProvider, Address?coldWalletAddress = null)
{
_blockProcessor = blockProcessor ?? throw new ArgumentNullException(nameof(blockProcessor));
_webSocketsModule = module ?? throw new ArgumentNullException(nameof(module));
_accountAddress = accountAddress ?? throw new ArgumentNullException(nameof(accountAddress));
_stateProvider = stateProvider ?? throw new ArgumentNullException(nameof(stateProvider));
_coldWalletAddress = coldWalletAddress;
_blockProcessor.BlockProcessed += UpdateAccountBalance;
_blockProcessor.BlockProcessed += UpdateAccountNonce;
if (_coldWalletAddress != null)
{
_blockProcessor.BlockProcessed += UpdateColdWalletBalance;
_blockProcessor.BlockProcessed += UpdateColdWalletNonce;
}
}
public NdmNotifier(IWebSocketsModule webSocketsModule)
{
_webSocketsModule = webSocketsModule;
}
protected async Task PreInitAsync(INdmApi ndmApi)
{
if (ndmApi == null)
{
throw new ArgumentNullException(nameof(ndmApi));
}
IDbProvider?dbProvider = ndmApi.DbProvider;
if (dbProvider == null)
{
throw new ArgumentNullException(nameof(dbProvider));
}
IConfigProvider configProvider = ndmApi.ConfigProvider;
ILogManager logManager = ndmApi.LogManager;
if (!(configProvider.GetConfig <INdmConfig>() is NdmConfig defaultConfig))
{
return;
}
if (!defaultConfig.Enabled)
{
return;
}
if (defaultConfig.StoreConfigInDatabase && string.IsNullOrWhiteSpace(defaultConfig.Id))
{
throw new ArgumentException("NDM config stored in database requires an id.", nameof(defaultConfig.Id));
}
IConfigRepository configRepository;
IEthRequestRepository ethRequestRepository;
switch (defaultConfig.Persistence?.ToLowerInvariant())
{
case "mongo":
ndmApi.MongoProvider = new MongoProvider(configProvider.GetConfig <INdmMongoConfig>(), logManager);
IMongoDatabase?database = ndmApi.MongoProvider.GetDatabase();
if (database == null)
{
throw new ApplicationException("Failed to initialize Mongo database");
}
configRepository = new ConfigMongoRepository(database);
ethRequestRepository = new EthRequestMongoRepository(database);
break;
default:
ndmApi.MongoProvider = NullMongoProvider.Instance;
var ndmDbProvider = new NdmDbInitializer(defaultConfig, ndmApi.DbProvider, ndmApi.RocksDbFactory, ndmApi.MemDbFactory);
await ndmDbProvider.Init();
configRepository = new ConfigRocksRepository(ndmApi.DbProvider.GetDb <IDb>(NdmDbNames.Configs), new NdmConfigDecoder());
ethRequestRepository = new EthRequestRocksRepository(ndmApi.DbProvider.GetDb <IDb>(NdmDbNames.EthRequests),
new EthRequestDecoder());
break;
}
ndmApi.ConfigManager = new ConfigManager(defaultConfig, configRepository);
ndmApi.NdmConfig = await ndmApi.ConfigManager.GetAsync(defaultConfig.Id);
if (ndmApi.NdmConfig is null)
{
ndmApi.NdmConfig = defaultConfig;
if (defaultConfig.StoreConfigInDatabase)
{
await ndmApi.ConfigManager.UpdateAsync((NdmConfig)ndmApi.NdmConfig);
}
}
IWebSocketsModule webSocketsModule = ndmApi.WebSocketsManager !.GetModule("ndm");
ndmApi.NdmNotifier = new NdmNotifier(webSocketsModule);
ndmApi.EthRequestService = new EthRequestService(ndmApi.NdmConfig.FaucetHost, logManager);
string baseDbPath = configProvider.GetConfig <IInitConfig>().BaseDbPath;
ndmApi.BaseDbPath = DbPath = Path.Combine(baseDbPath, ndmApi.NdmConfig.DatabasePath);
await _ndmModule.InitAsync();
if (ndmApi.NdmConfig.FaucetEnabled)
{
// faucet should be separate from NDM? but it uses MongoDB?
// so maybe we could extract Mongo DB beyond NDM? why would it be related?
if (string.IsNullOrWhiteSpace(ndmApi.NdmConfig.FaucetAddress))
{
ndmApi.NdmFaucet = EmptyFaucet.Instance;
_logger.Warn("Faucet cannot be started due to missing faucet address configuration.");
}
else
{
Address faucetAddress = new(ndmApi.NdmConfig.FaucetAddress);
ndmApi.NdmFaucet = new NdmFaucet(
ndmApi.BlockchainBridge,
ethRequestRepository,
faucetAddress,
ndmApi.NdmConfig.FaucetWeiRequestMaxValue,
ndmApi.NdmConfig.FaucetEthDailyRequestsTotalValue,
ndmApi.NdmConfig.FaucetEnabled,
ndmApi.Timestamper,
ndmApi.Wallet,
logManager);
}
}
else
{
ndmApi.NdmFaucet = EmptyFaucet.Instance;
}
ndmApi.ConsumerAddress = string.IsNullOrWhiteSpace(ndmApi.NdmConfig.ConsumerAddress)
? Address.Zero
: new Address(ndmApi.NdmConfig.ConsumerAddress);
ndmApi.ProviderAddress = string.IsNullOrWhiteSpace(ndmApi.NdmConfig.ProviderAddress)
? Address.Zero
: new Address(ndmApi.NdmConfig.ProviderAddress);
await _ndmConsumersModule.Init();
}
public static void UseWebSocketsModules(this IApplicationBuilder app)
{
IWebSocketsManager webSocketsManager;
ILogger logger;
using (var scope = app.ApplicationServices.CreateScope())
{
webSocketsManager = scope.ServiceProvider.GetService <IWebSocketsManager>();
logger = scope.ServiceProvider.GetService <ILogManager>().GetClassLogger();
}
app.Use(async(context, next) =>
{
var id = string.Empty;
var client = string.Empty;
IWebSocketsModule module = null;
try
{
string moduleName = String.Empty;
if (context.Request.Path.HasValue)
{
var path = context.Request.Path.Value;
moduleName = path.Split("/").LastOrDefault();
}
module = webSocketsManager.GetModule(moduleName);
if (module is null)
{
context.Response.StatusCode = 400;
return;
}
if (!module.TryInit(context.Request))
{
context.Response.StatusCode = 400;
return;
}
client = context.Request.Query.TryGetValue("client", out var clientValues)
? clientValues.FirstOrDefault()
: string.Empty;
if (logger.IsInfo)
{
logger.Info($"Initializing WebSockets for client: '{client}'.");
}
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
var socketsClient = webSocketsManager.CreateClient(module, webSocket, client);
id = socketsClient.Id;
await webSocket.ReceiveAsync(socketsClient);
}
catch (Exception ex)
{
logger.Error("WebSockets error.", ex);
}
finally
{
if (!(module is null) && !string.IsNullOrWhiteSpace(id))
{
module.RemoveClient(id);
if (logger.IsInfo)
{
logger.Info($"Closing WebSockets for client: '{client}'.");
}
}
}
});
}
public void AddModule(IWebSocketsModule module)
{
_modules.TryAdd(module.Name, module);
}
public async Task InitAsync()
{
AddDecoders();
var logManager = _api.LogManager;
var logger = logManager.GetClassLogger();
var skipDepositVerification = HasEnabledVariable("SKIP_DEPOSIT_VERIFICATION");
var backgroundServicesDisabled = HasEnabledVariable("BACKGROUND_SERVICES_DISABLED");
var disableSendingPaymentClaimTransaction = HasEnabledVariable("SENDING_PAYMENT_CLAIM_TRANSACTION_DISABLED");
var instantPaymentClaimVerificationEnabled = HasEnabledVariable("INSTANT_PAYMENT_CLAIM_VERIFICATION_ENABLED");
if (skipDepositVerification)
{
if (logger.IsWarn)
{
logger.Warn("*** NDM provider skipping deposit verification ***");
}
}
if (backgroundServicesDisabled)
{
if (logger.IsWarn)
{
logger.Warn("*** NDM provider background services are disabled ***");
}
}
if (disableSendingPaymentClaimTransaction)
{
if (logger.IsWarn)
{
logger.Warn("*** NDM provider sending payment claim transaction is disabled ***");
}
}
if (instantPaymentClaimVerificationEnabled)
{
if (logger.IsWarn)
{
logger.Warn("*** NDM provider instant payment claim verification is enabled ***");
}
}
var blockchainBridge = _api.BlockchainBridge;
var ndmConfig = _api.NdmConfig;
var txPool = _api.TxPool;
var dbConfig = _api.ConfigProvider.GetConfig <IProviderDbConfig>();
var contractAddress = string.IsNullOrWhiteSpace(ndmConfig.ContractAddress)
? Address.Zero
: new Address(ndmConfig.ContractAddress);
_gasPriceService = _api.GasPriceService;
var dbInitializer = new ProviderDbInitializer(_api.DbProvider, dbConfig, _api.RocksDbFactory, _api.MemDbFactory);
await dbInitializer.Init();
var consumerRlpDecoder = new ConsumerDecoder();
var dataAssetRlpDecoder = new DataAssetDecoder();
var depositApprovalRlpDecoder = new DepositApprovalDecoder();
var paymentClaimRlpDecoder = new PaymentClaimDecoder();
var receiptRlpDecoder = new DataDeliveryReceiptDetailsDecoder();
var sessionRlpDecoder = new ProviderSessionDecoder();
var unitsRangeRlpDecoder = new UnitsRangeDecoder();
var accountAddress = string.IsNullOrWhiteSpace(ndmConfig.ProviderAddress)
? Address.Zero
: new Address(ndmConfig.ProviderAddress);
var coldWalletAddress = string.IsNullOrWhiteSpace(ndmConfig.ProviderColdWalletAddress)
? Address.Zero
: new Address(ndmConfig.ProviderColdWalletAddress);
var depositService = new DepositService(blockchainBridge, _api.AbiEncoder,
_api.Wallet, contractAddress);
var paymentService = new PaymentService(blockchainBridge, _api.AbiEncoder,
_api.Wallet, contractAddress, logManager, txPool);
var refundPolicy = new RefundPolicy();
var dataAvailabilityValidator = new DataAvailabilityValidator();
var transactionVerifier = new TransactionVerifier(blockchainBridge, ndmConfig.BlockConfirmations);
var transactionService = _api.TransactionService;
var timestamper = _api.Timestamper;
IConsumerRepository consumerRepository;
IDataAssetRepository dataAssetRepository;
IProviderDepositApprovalRepository depositApprovalRepository;
IPaymentClaimRepository paymentClaimRepository;
IProviderSessionRepository sessionRepository;
IReceiptRepository receiptRepository;
switch (ndmConfig.Persistence?.ToLowerInvariant())
{
case "mongo":
IMongoDatabase?database = _api.MongoProvider.GetDatabase();
if (database == null)
{
throw new InvalidOperationException("Failed to initialize Mongo DB for NDM");
}
consumerRepository = new ConsumerMongoRepository(database);
dataAssetRepository = new DataAssetMongoRepository(database);
depositApprovalRepository = new ProviderDepositApprovalMongoRepository(database);
paymentClaimRepository = new PaymentClaimMongoRepository(database);
receiptRepository = new ReceiptMongoRepository(database, "providerReceipts");
sessionRepository = new ProviderSessionMongoRepository(database);
break;
default:
consumerRepository = new ConsumerRocksRepository(_api.Db <IDb>(ProviderDbNames.Consumers),
consumerRlpDecoder);
dataAssetRepository = new DataAssetRocksRepository(_api.Db <IDb>(ProviderDbNames.DataAssets),
dataAssetRlpDecoder);
depositApprovalRepository = new ProviderDepositApprovalRocksRepository(
_api.Db <IDb>(ProviderDbNames.ProviderDepositApprovals), depositApprovalRlpDecoder);
paymentClaimRepository = new PaymentClaimRocksRepository(_api.Db <IDb>(ProviderDbNames.PaymentClaims),
paymentClaimRlpDecoder);
receiptRepository = new ReceiptRocksRepository(_api.Db <IDb>(ProviderDbNames.ProviderReceipts),
receiptRlpDecoder);
sessionRepository = new ProviderSessionRocksRepository(_api.Db <IDb>(ProviderDbNames.ProviderSessions),
sessionRlpDecoder);
break;
}
var wallet = _api.Wallet;
var depositHandlerFactory = new DepositNodesHandlerFactory();
_providerThresholdsService = new ProviderThresholdsService(_api.ConfigManager, ndmConfig.Id, logManager);
var receiptsPolicies = new ReceiptsPolicies(_providerThresholdsService);
IPaymentClaimProcessor paymentClaimProcessor = new PaymentClaimProcessor(_gasPriceService,
consumerRepository, paymentClaimRepository, paymentService, coldWalletAddress, timestamper,
unitsRangeRlpDecoder, logManager, disableSendingPaymentClaimTransaction);
if (instantPaymentClaimVerificationEnabled)
{
paymentClaimProcessor = new InstantPaymentClaimProcessor(paymentClaimProcessor, paymentClaimRepository,
logManager);
}
var receiptProcessor = new ReceiptProcessor(sessionRepository, _api.AbiEncoder,
_api.EthereumEcdsa, logManager);
var sessionManager = new SessionManager(sessionRepository, _api.Timestamper,
logManager);
_depositManager = new DepositManager(depositHandlerFactory, sessionManager, receiptsPolicies, wallet,
accountAddress, receiptProcessor, paymentClaimProcessor, consumerRepository, paymentClaimRepository,
receiptRepository, sessionRepository, timestamper, _gasPriceService, logManager);
_providerService = new ProviderService(_api.ConfigManager, ndmConfig.Id,
consumerRepository, dataAssetRepository, depositApprovalRepository, paymentClaimRepository,
paymentClaimProcessor, sessionRepository, timestamper, _api.EthereumEcdsa,
_api.AbiEncoder, _api.NdmDataPublisher, _gasPriceService,
dataAvailabilityValidator, sessionManager, transactionVerifier, _depositManager, refundPolicy,
depositService, wallet, blockchainBridge, accountAddress, coldWalletAddress,
_api.Enode.PublicKey, ndmConfig.ProviderName, ndmConfig.FilesPath,
ndmConfig.FileMaxSize, ndmConfig.BlockConfirmations, paymentService.GasLimit, logManager,
skipDepositVerification, backgroundServicesDisabled);
_reportService = new ReportService(consumerRepository, paymentClaimRepository);
_providerTransactionsService = new ProviderTransactionsService(transactionService,
paymentClaimRepository, timestamper, logManager);
_providerGasLimitsService = new ProviderGasLimitsService(paymentService);
IWebSocketsModule ndmWebSocketsModule = _api.WebSocketsManager.GetModule("ndm");
_api.NdmAccountUpdater = ndmConfig.ProviderColdWalletAddress != null
? new NdmAccountUpdater(ndmWebSocketsModule, _providerService.GetAddress(), _api.MainBlockProcessor, _api.StateProvider, new Address(ndmConfig.ProviderColdWalletAddress))
: new NdmAccountUpdater(ndmWebSocketsModule, _providerService.GetAddress(), _api.MainBlockProcessor, _api.StateProvider);
}
public async Task Init()
{
AddDecoders();
ILogManager logManager = _api.LogManager;
ILogger logger = logManager.GetClassLogger();
bool disableSendingDepositTransaction = HasEnabledVariable("SENDING_DEPOSIT_TRANSACTION_DISABLED");
bool instantDepositVerificationEnabled = HasEnabledVariable("INSTANT_DEPOSIT_VERIFICATION_ENABLED");
bool backgroundServicesDisabled = HasEnabledVariable("BACKGROUND_SERVICES_DISABLED");
if (disableSendingDepositTransaction)
{
if (logger.IsWarn)
{
logger.Warn("*** NDM sending deposit transaction is disabled ***");
}
}
if (instantDepositVerificationEnabled)
{
if (logger.IsWarn)
{
logger.Warn("*** NDM instant deposit verification is enabled ***");
}
}
if (backgroundServicesDisabled)
{
if (logger.IsWarn)
{
logger.Warn("*** NDM background services are disabled ***");
}
}
INdmConfig ndmConfig = _api.NdmConfig;
string configId = ndmConfig.Id;
IDbConfig dbConfig = _api.ConfigProvider.GetConfig <IDbConfig>();
Address contractAddress = string.IsNullOrWhiteSpace(ndmConfig.ContractAddress)
? Address.Zero
: new Address(ndmConfig.ContractAddress);
DepositDetailsDecoder depositDetailsRlpDecoder = new DepositDetailsDecoder();
DepositApprovalDecoder depositApprovalRlpDecoder = new DepositApprovalDecoder();
DataDeliveryReceiptDetailsDecoder receiptRlpDecoder = new DataDeliveryReceiptDetailsDecoder();
ConsumerSessionDecoder sessionRlpDecoder = new ConsumerSessionDecoder();
ReceiptRequestValidator receiptRequestValidator = new ReceiptRequestValidator(logManager);
IDepositDetailsRepository depositRepository;
IConsumerDepositApprovalRepository depositApprovalRepository;
IProviderRepository providerRepository;
IReceiptRepository receiptRepository;
IConsumerSessionRepository sessionRepository;
IDepositUnitsCalculator depositUnitsCalculator;
switch (ndmConfig.Persistence?.ToLowerInvariant())
{
case "mongo":
IMongoDatabase?database = _api.MongoProvider.GetDatabase();
if (database == null)
{
throw new ApplicationException("Failed to initialize Mongo DB.");
}
sessionRepository = new ConsumerSessionMongoRepository(database);
depositUnitsCalculator = new DepositUnitsCalculator(sessionRepository, _api.Timestamper);
depositRepository = new DepositDetailsMongoRepository(database, depositUnitsCalculator);
depositApprovalRepository = new ConsumerDepositApprovalMongoRepository(database);
providerRepository = new ProviderMongoRepository(database);
receiptRepository = new ReceiptMongoRepository(database, "consumerReceipts");
break;
case "memory":
if (logger.IsWarn)
{
logger.Warn("*** NDM is using in memory database ***");
}
DepositsInMemoryDb depositsDatabase = new DepositsInMemoryDb();
sessionRepository = new ConsumerSessionInMemoryRepository();
depositUnitsCalculator = new DepositUnitsCalculator(sessionRepository, _api.Timestamper);
depositRepository = new DepositDetailsInMemoryRepository(depositsDatabase, depositUnitsCalculator);
depositApprovalRepository = new ConsumerDepositApprovalInMemoryRepository();
providerRepository = new ProviderInMemoryRepository(depositsDatabase);
receiptRepository = new ReceiptInMemoryRepository();
break;
default:
var dbInitializer = new ConsumerNdmDbInitializer(_api.DbProvider, ndmConfig, _api.RocksDbFactory, _api.MemDbFactory);
await dbInitializer.InitAsync();
sessionRepository = new ConsumerSessionRocksRepository(_api.Db <IDb>(ConsumerNdmDbNames.ConsumerSessions),
sessionRlpDecoder);
depositUnitsCalculator = new DepositUnitsCalculator(sessionRepository, _api.Timestamper);
depositRepository = new DepositDetailsRocksRepository(_api.Db <IDb>(ConsumerNdmDbNames.Deposits),
depositDetailsRlpDecoder, depositUnitsCalculator);
depositApprovalRepository = new ConsumerDepositApprovalRocksRepository(
_api.Db <IDb>(ConsumerNdmDbNames.ConsumerDepositApprovals), depositApprovalRlpDecoder);
providerRepository = new ProviderRocksRepository(_api.Db <IDb>(ConsumerNdmDbNames.Deposits),
depositDetailsRlpDecoder);
receiptRepository = new ReceiptRocksRepository(_api.Db <IDb>(ConsumerNdmDbNames.ConsumerReceipts),
receiptRlpDecoder);
break;
}
uint requiredBlockConfirmations = ndmConfig.BlockConfirmations;
IAbiEncoder abiEncoder = _api.AbiEncoder;
INdmBlockchainBridge blockchainBridge = _api.BlockchainBridge;
IBlockProcessor blockProcessor = _api.MainBlockProcessor;
IConfigManager configManager = _api.ConfigManager;
Address consumerAddress = _api.ConsumerAddress;
ICryptoRandom cryptoRandom = _api.CryptoRandom;
IDepositService depositService = _api.DepositService;
gasPriceService = _api.GasPriceService;
IEthereumEcdsa ecdsa = _api.EthereumEcdsa;
ethRequestService = _api.EthRequestService;
jsonRpcNdmConsumerChannel = _api.JsonRpcNdmConsumerChannel;
INdmNotifier ndmNotifier = _api.NdmNotifier;
PublicKey nodePublicKey = _api.Enode.PublicKey;
timestamper = _api.Timestamper;
IWallet wallet = _api.Wallet;
IHttpClient httpClient = _api.HttpClient;
IJsonRpcClientProxy? jsonRpcClientProxy = _api.JsonRpcClientProxy;
IEthJsonRpcClientProxy?ethJsonRpcClientProxy = _api.EthJsonRpcClientProxy;
TransactionService transactionService = _api.TransactionService;
IMonitoringService monitoringService = _api.MonitoringService;
IWebSocketsModule ndmWebSocketsModule = _api.WebSocketsManager.GetModule("ndm");
monitoringService?.RegisterMetrics(typeof(Metrics));
DataRequestFactory dataRequestFactory = new DataRequestFactory(wallet, nodePublicKey);
TransactionVerifier transactionVerifier = new TransactionVerifier(blockchainBridge, requiredBlockConfirmations);
DepositProvider depositProvider = new DepositProvider(depositRepository, depositUnitsCalculator, logManager);
KycVerifier kycVerifier = new KycVerifier(depositApprovalRepository, logManager);
ConsumerNotifier consumerNotifier = new ConsumerNotifier(ndmNotifier);
DataAssetService dataAssetService = new DataAssetService(providerRepository, consumerNotifier, logManager);
ProviderService providerService = new ProviderService(providerRepository, consumerNotifier, logManager);
DataRequestService dataRequestService = new DataRequestService(dataRequestFactory, depositProvider, kycVerifier, wallet,
providerService, timestamper, sessionRepository, consumerNotifier, logManager);
SessionService sessionService = new SessionService(providerService, depositProvider, dataAssetService,
sessionRepository, timestamper, consumerNotifier, logManager);
DataConsumerService dataConsumerService = new DataConsumerService(depositProvider, sessionService,
consumerNotifier, timestamper, sessionRepository, logManager);
DataStreamService dataStreamService = new DataStreamService(dataAssetService, depositProvider,
providerService, sessionService, wallet, consumerNotifier, sessionRepository, logManager);
DepositApprovalService depositApprovalService = new DepositApprovalService(dataAssetService, providerService,
depositApprovalRepository, timestamper, consumerNotifier, logManager);
DepositConfirmationService depositConfirmationService = new DepositConfirmationService(blockchainBridge, consumerNotifier,
depositRepository, depositService, logManager, requiredBlockConfirmations);
IDepositManager depositManager = new DepositManager(depositService, depositUnitsCalculator,
dataAssetService, kycVerifier, providerService, abiEncoder, cryptoRandom, wallet, gasPriceService,
depositRepository, timestamper, logManager, requiredBlockConfirmations,
disableSendingDepositTransaction);
if (instantDepositVerificationEnabled)
{
depositManager = new InstantDepositManager(depositManager, depositRepository, timestamper, logManager,
requiredBlockConfirmations);
}
depositReportService = new DepositReportService(depositRepository, depositUnitsCalculator, receiptRepository, sessionRepository,
timestamper);
ReceiptService receiptService = new ReceiptService(depositProvider, providerService, receiptRequestValidator,
sessionService, timestamper, receiptRepository, sessionRepository, abiEncoder, wallet, ecdsa,
nodePublicKey, logManager);
RefundService refundService = new RefundService(blockchainBridge, abiEncoder, depositRepository,
contractAddress, logManager, wallet);
RefundClaimant refundClaimant = new RefundClaimant(refundService, blockchainBridge, depositRepository,
transactionVerifier, gasPriceService, timestamper, logManager);
_api.AccountService = new AccountService(configManager, dataStreamService, providerService,
sessionService, consumerNotifier, wallet, configId, consumerAddress, logManager);
_api.NdmAccountUpdater = new NdmAccountUpdater(ndmWebSocketsModule, consumerAddress, _api.MainBlockProcessor, _api.ChainHeadStateProvider);
ProxyService proxyService = new ProxyService(jsonRpcClientProxy, configManager, configId, logManager);
_api.ConsumerService = new ConsumerService(_api.AccountService, dataAssetService, dataRequestService,
dataConsumerService, dataStreamService, depositManager, depositApprovalService, providerService,
receiptService, refundService, sessionService, proxyService);
ethPriceService = new EthPriceService(httpClient, timestamper, logManager);
daiPriceService = new DaiPriceService(httpClient, timestamper, logManager);
consumerTransactionsService = new ConsumerTransactionsService(transactionService, depositRepository,
timestamper, logManager);
gasLimitsService = new ConsumerGasLimitsService(depositService, refundService);
if (!backgroundServicesDisabled)
{
bool useDepositTimer = ndmConfig.ProxyEnabled;
ConsumerServicesBackgroundProcessor consumerServicesBackgroundProcessor =
new ConsumerServicesBackgroundProcessor(
_api.AccountService,
refundClaimant,
depositConfirmationService,
ethPriceService,
daiPriceService,
_api.GasPriceService,
_api.MainBlockProcessor,
depositRepository,
consumerNotifier,
logManager,
useDepositTimer,
ethJsonRpcClientProxy);
consumerServicesBackgroundProcessor.Init();
}
}
private static async Task ReceiveAsync(WebSocket webSocket, IWebSocketsClient client, IWebSocketsModule module)
{
var buffer = new byte[1024 * 4];
var result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
while (!result.CloseStatus.HasValue)
{
var data = buffer.Slice(0, result.Count);
await module.ExecuteAsync(client, data);
result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
}
await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
module.Cleanup(client);
}
