public static Task <ApiResponse <WalletAddresses> > GetDepositAddressesAsync(IDepositProvider provider, WalletAddressAssetContext context)
{
// TODO: review.
//if (provider.CanGenerateDepositAddress && !provider.CanPeekDepositAddress)
// throw new Exception($"{provider.Title} cannot 'peek' deposit addresses.");
return(ApiHelpers.WrapExceptionAsync(() => provider.GetAddressesForAssetAsync(context), nameof(GetDepositAddresses), provider, context));
}
public void Setup()
{
_depositProvider = Substitute.For <IDepositProvider>();
_sessionService = Substitute.For <ISessionService>();
_consumerNotifier = Substitute.For <IConsumerNotifier>();
_timestamper = new Timestamper(Date);
_sessionRepository = Substitute.For <IConsumerSessionRepository>();
_dataConsumerService = new DataConsumerService(_depositProvider, _sessionService, _consumerNotifier,
_timestamper, _sessionRepository, LimboLogs.Instance);
}
public DataConsumerService(IDepositProvider depositProvider, ISessionService sessionService,
IConsumerNotifier consumerNotifier, ITimestamper timestamper, IConsumerSessionRepository sessionRepository,
ILogManager logManager)
{
_depositProvider = depositProvider;
_sessionService = sessionService;
_consumerNotifier = consumerNotifier;
_timestamper = timestamper;
_sessionRepository = sessionRepository;
_logger = logManager.GetClassLogger();
}
public SessionService(IProviderService providerService, IDepositProvider depositProvider,
IDataAssetService dataAssetService, IConsumerSessionRepository sessionRepository, ITimestamper timestamper,
IConsumerNotifier consumerNotifier, ILogManager logManager)
{
_providerService = providerService;
_depositProvider = depositProvider;
_dataAssetService = dataAssetService;
_sessionRepository = sessionRepository;
_timestamper = timestamper;
_consumerNotifier = consumerNotifier;
_logger = logManager.GetClassLogger();
}
public void Setup()
{
_dataAssetService = Substitute.For <IDataAssetService>();
_depositProvider = Substitute.For <IDepositProvider>();
_providerService = Substitute.For <IProviderService>();
_sessionService = Substitute.For <ISessionService>();
_wallet = Substitute.For <IWallet>();
_consumerNotifier = Substitute.For <IConsumerNotifier>();
_sessionRepository = Substitute.For <IConsumerSessionRepository>();
_providerPeer = Substitute.For <INdmPeer>();
_dataStreamService = new DataStreamService(_dataAssetService, _depositProvider, _providerService,
_sessionService, _wallet, _consumerNotifier, _sessionRepository, LimboLogs.Instance);
}
public DataStreamService(IDataAssetService dataAssetService, IDepositProvider depositProvider,
IProviderService providerService, ISessionService sessionService, IWallet wallet,
IConsumerNotifier consumerNotifier, IConsumerSessionRepository sessionRepository, ILogManager logManager)
{
_dataAssetService = dataAssetService;
_depositProvider = depositProvider;
_providerService = providerService;
_sessionService = sessionService;
_wallet = wallet;
_consumerNotifier = consumerNotifier;
_sessionRepository = sessionRepository;
_logger = logManager.GetClassLogger();
}
public void Setup()
{
_dataRequestFactory = Substitute.For <IDataRequestFactory>();
_depositProvider = Substitute.For <IDepositProvider>();
_kycVerifier = Substitute.For <IKycVerifier>();
_wallet = Substitute.For <IWallet>();
_providerService = Substitute.For <IProviderService>();
_timestamper = new Timestamper(Date);
_sessionRepository = Substitute.For <IConsumerSessionRepository>();
_consumerNotifier = Substitute.For <IConsumerNotifier>();
_dataRequestService = new DataRequestService(_dataRequestFactory, _depositProvider, _kycVerifier, _wallet,
_providerService, _timestamper, _sessionRepository, _consumerNotifier, LimboLogs.Instance);
}
public DataRequestService(IDataRequestFactory dataRequestFactory, IDepositProvider depositProvider,
IKycVerifier kycVerifier, IWallet wallet, IProviderService providerService, ITimestamper timestamper,
IConsumerSessionRepository sessionRepository, IConsumerNotifier consumerNotifier, ILogManager logManager)
{
_dataRequestFactory = dataRequestFactory;
_depositProvider = depositProvider;
_kycVerifier = kycVerifier;
_wallet = wallet;
_providerService = providerService;
_timestamper = timestamper;
_sessionRepository = sessionRepository;
_consumerNotifier = consumerNotifier;
_logger = logManager.GetClassLogger();
}
private void GetAddressesForAsset(IDepositProvider provider, WalletAddressAssetContext context)
{
if (context == null)
{
return;
}
var r = AsyncContext.Run(() => provider.GetAddressesForAssetAsync(context));
Assert.IsTrue(r != null);
Trace.WriteLine($"Deposit addresses for {context.Asset}:");
foreach (var walletAddress in r)
{
Trace.WriteLine($"\"{walletAddress.Address}\"");
}
}
public void Setup()
{
_depositProvider = Substitute.For <IDepositProvider>();
_providerService = Substitute.For <IProviderService>();
_receiptRequestValidator = Substitute.For <IReceiptRequestValidator>();
_sessionService = Substitute.For <ISessionService>();
_receiptRepository = Substitute.For <IReceiptRepository>();
_sessionRepository = Substitute.For <IConsumerSessionRepository>();
_abiEncoder = Substitute.For <IAbiEncoder>();
_wallet = Substitute.For <IWallet>();
_ecdsa = Substitute.For <IEthereumEcdsa>();
_timestamper = Timestamper.Default;
_nodePublicKey = TestItem.PublicKeyA;
_receiptService = new ReceiptService(_depositProvider, _providerService, _receiptRequestValidator,
_sessionService, _timestamper, _receiptRepository, _sessionRepository, _abiEncoder, _wallet,
_ecdsa, _nodePublicKey, LimboLogs.Instance);
}
private void GetAddressesTest(IDepositProvider provider, WalletAddressContext context)
{
if (context == null)
{
return;
}
var r = AsyncContext.Run(() => provider.GetAddressesAsync(context));
Assert.True(r != null);
OutputWriter.WriteLine("All deposit addresses:");
foreach (var walletAddress in r.WalletAddresses)
{
OutputWriter.WriteLine($"{walletAddress.Asset}: \"{walletAddress.Address}\"");
}
}
public ReceiptService(IDepositProvider depositProvider, IProviderService providerService,
IReceiptRequestValidator receiptRequestValidator, ISessionService sessionService, ITimestamper timestamper,
IReceiptRepository receiptRepository, IConsumerSessionRepository sessionRepository, IAbiEncoder abiEncoder,
IWallet wallet, IEthereumEcdsa ecdsa, PublicKey nodePublicKey, ILogManager logManager)
{
_depositProvider = depositProvider;
_providerService = providerService;
_receiptRequestValidator = receiptRequestValidator;
_sessionService = sessionService;
_timestamper = timestamper;
_receiptRepository = receiptRepository;
_sessionRepository = sessionRepository;
_abiEncoder = abiEncoder;
_wallet = wallet;
_ecdsa = ecdsa;
_nodePublicKey = nodePublicKey;
_logger = logManager.GetClassLogger();
}
public void Setup()
{
IConsumerNotifier notifier = new ConsumerNotifier(Substitute.For <INdmNotifier>());
DepositsInMemoryDb db = new DepositsInMemoryDb();
IProviderRepository providerRepository = new ProviderInMemoryRepository(db);
DataAssetProvider provider = new DataAssetProvider(_providerAddress, "provider");
DataAssetService dataAssetService = new DataAssetService(providerRepository, notifier, LimboLogs.Instance);
_asset1 = new DataAsset(_asset1Id, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1), new DataAssetRule(100)), provider, state: DataAssetState.Published);
dataAssetService.AddDiscovered(_asset1, _ndmPeer);
_deposit1 = new Deposit(_deposit1Id, 1, 2, 3);
_details1 = new DepositDetails(_deposit1, _asset1, Address.Zero, new byte[0], 1, new TransactionInfo[0], 1);
_asset2 = new DataAsset(_asset2Id, "name", "desc", 1, DataAssetUnitType.Time, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published);
dataAssetService.AddDiscovered(_asset2, _ndmPeer);
_deposit2 = new Deposit(_deposit2Id, 1, 2, 3);
_details2 = new DepositDetails(_deposit2, _asset2, Address.Zero, new byte[0], 1, new TransactionInfo[0], 2);
_closed = new DataAsset(_closedId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Closed);
dataAssetService.AddDiscovered(_closed, _ndmPeer);
_depositForClosed = new Deposit(_depositForClosedId, 1, 2, 3);
_depositForClosedDetails = new DepositDetails(_depositForClosed, _closed, Address.Zero, new byte[0], 1, new TransactionInfo[0]);
_missingAsset = new DataAsset(_missingAssetId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published);
_depositForMissing = new Deposit(_depositForMissingId, 1, 2, 3);
_depositForMissingDetails = new DepositDetails(_depositForMissing, _missingAsset, Address.Zero, new byte[0], 1, new TransactionInfo[0]);
IDepositProvider depositProvider = Substitute.For <IDepositProvider>();
depositProvider.GetAsync(_deposit1Id).Returns(_details1);
depositProvider.GetAsync(_deposit2Id).Returns(_details2);
depositProvider.GetAsync(_depositForMissingId).Returns(_depositForMissingDetails);
depositProvider.GetAsync(_depositForClosedId).Returns(_depositForClosedDetails);
_ndmPeer = Substitute.For <INdmPeer>();
_ndmPeer.ProviderAddress.Returns(_providerAddress);
_ndmPeer.NodeId.Returns(_providerNodeId);
_providerService = new ProviderService(providerRepository, notifier, LimboLogs.Instance);
_providerService.Add(_ndmPeer);
_sessionRepository = new ConsumerSessionInMemoryRepository();
_sessionService = new SessionService(_providerService, depositProvider, dataAssetService, _sessionRepository, Timestamper.Default, notifier, LimboLogs.Instance);
}
public void KeepFresh(UserContext context, IDepositProvider provider, Asset asset, bool forceStale = false)
{
var stale = forceStale || _ws.Any(x => x.Asset == asset && (!x.IsFresh() || x.IsExpired()));
if (!stale)
{
return;
}
lock (Lock)
{
var r = ApiCoordinator.FetchAllDepositAddresses(provider, new WalletAddressAssetContext(asset, context));
if (r.IsNull)
{
return;
}
AddRange(r.Response.WalletAddresses);
this.Save(context);
}
}
private void GetAddresses(IDepositProvider provider, WalletAddressContext context)
{
if (context == null)
{
return;
}
try
{
var r = AsyncContext.Run(() => provider.GetAddressesAsync(context));
Assert.IsTrue(r != null);
Trace.WriteLine("All deposit addresses:");
foreach (var walletAddress in r)
{
Trace.WriteLine($"{walletAddress.Asset}: \"{walletAddress.Address}\"");
}
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
public static Task <ApiResponse <TransferSuspensions> > GetTransferSuspensionsAsync(IDepositProvider provider, NetworkProviderContext context = null)
{
context = context ?? new NetworkProviderContext();
return(ApiHelpers.WrapExceptionAsync(() => provider.GetTransferSuspensionsAsync(context), nameof(GetTransferSuspensions), provider, context));
}
public static ApiResponse <TransferSuspensions> GetTransferSuspensions(IDepositProvider provider, NetworkProviderContext context = null)
{
return(AsyncContext.Run(() => GetTransferSuspensionsAsync(provider, context)));
}
public static ApiResponse <WalletAddressesResult> FetchAllDepositAddresses(IDepositProvider provider, WalletAddressContext context)
{
return(AsyncContext.Run(() => GetAllDepositAddressesAsync(provider, context)));
}
/// <summary>
/// This is broken, needs a review -> get all address, or just the latest?
/// </summary>
/// <param name="context"></param>
/// <param name="provider"></param>
/// <param name="asset"></param>
/// <returns></returns>
public static WalletAddress GetLatestDepositAddress(this UserContext context, IDepositProvider provider, Asset asset)
{
/* var wd = context.Data(provider);
* var w = wd.GetLatest(asset);
* if (w != null && w.IsFresh())
* return w;
*
* WalletAddress address = null;
*
* var r = ApiCoordinator.GetDepositAddresses(provider, new WalletAddressAssetContext(asset, context));
* if (!r.IsNull && r.Response.Count != 0)
* address = r.Response.OrderByDescending(x=>x.UtcCreated).FirstOrDefault();
*
* if (address == null)
* {
* var r2 = ApiCoordinator.GetDepositAddresses(provider, new WalletAddressAssetContext(asset, context));
* if (r2.IsNull || r2.Response.Count == 0)
* return null;
*
* address = r2.Response.OrderByDescending(x => x.UtcCreated).FirstOrDefault();
* }
*
* wd.Add(address);
* wd.Save(context);
* return wd.GetLatest(asset);*/
return(null);
}
public static ApiResponse <WalletAddresses> GetDepositAddresses(IDepositProvider provider, WalletAddressAssetContext context)
{
return(AsyncContext.Run(() => GetDepositAddressesAsync(provider, context)));
}
