public async Task <IReadOnlyCollection <AssetBalanceModel> > GetLykkeAsync()
{
IReadOnlyCollection <Balance> balances = await _balanceService.GetAsync(ExchangeNames.Lykke);
IReadOnlyCollection <Credit> credits = await _creditService.GetAllAsync();
string[] assets = balances.Select(o => o.AssetId)
.Union(credits.Select(o => o.AssetId))
.ToArray();
var model = new List <AssetBalanceModel>();
foreach (string assetId in assets)
{
Balance balance = balances.SingleOrDefault(o => o.AssetId == assetId);
Credit credit = credits.SingleOrDefault(o => o.AssetId == assetId);
decimal balanceAmount = balance?.Amount ?? decimal.Zero;
decimal creditAmount = credit?.Amount ?? decimal.Zero;
model.Add(new AssetBalanceModel
{
AssetId = assetId,
Amount = balanceAmount,
CreditAmount = creditAmount,
Disbalance = balanceAmount - creditAmount
});
}
return(model);
}
public async Task HandleAsync(string customerId)
{
var customerBalance = await _balanceService.GetAsync(customerId);
if (customerBalance.Error != CustomerBalanceError.None)
{
_log.Error(message: "Cannot seize balance of a customer because of error", context: customerBalance.Error);
return;
}
if (customerBalance.Total == 0)
{
await _seizeBalanceFromCustomerCompletedPublisher.PublishAsync(
new SeizeBalanceFromCustomerCompletedEvent { CustomerId = customerId });
return;
}
var walletResult = await _walletOwnersRepository.GetByOwnerIdAsync(customerId);
if (walletResult == null)
{
_log.Error(message: "Cannot seize balance of a customer because the wallet is missing", context: customerId);
return;
}
await _operationRequestsProducer.AddAsync(customerId, OperationType.SeizeToInternal, new SeizeToInternalContext
{
Account = walletResult.WalletId,
Amount = customerBalance.Total,
Reason = BalanceSeizeReason,
});
}
public async Task CreateMissedAsync(string userId)
{
string source = _quoteService.GetSources().FirstOrDefault();
IReadOnlyCollection <Balance> balances = await _balanceService.GetAsync();
foreach (Balance balance in balances)
{
if (balance.Amount <= 0)
{
continue;
}
Asset asset = _assetsReadModelRepository.TryGetIfEnabled(balance.AssetId);
if (asset == null)
{
continue;
}
AssetPair assetPair = _assetPairsReadModelRepository.GetAllEnabled()
.FirstOrDefault(o => o.BaseAssetId == asset.Id && o.QuotingAssetId == "USD");
if (assetPair == null)
{
continue;
}
IReadOnlyCollection <Instrument> instruments = await GetAllAsync();
Instrument instrument = instruments.FirstOrDefault(o => o.AssetPairId == assetPair.Id);
if (instrument != null)
{
continue;
}
instrument = new Instrument
{
AssetPairId = assetPair.Id,
QuoteSource = source,
Markup = 0,
Levels = 1,
MinSpread = .2m,
MaxSpread = .8m,
Mode = InstrumentMode.Disabled,
IsApproved = false
};
await _instrumentRepository.InsertAsync(instrument);
_cache.Set(instrument);
}
_log.InfoWithDetails("Missed instruments created", new { userId });
}
public async Task <GetWalletsResponse> GetWalletBalancesAsync()
{
IReadOnlyCollection <Balance> balances = await _balanceService.GetAsync(ExchangeNames.Lykke);
return(new GetWalletsResponse
{
Wallets = balances.Select(o => new WalletBalanceModel
{
Asset = o.AssetId,
Balance = o.Amount,
Reserved = 0
}).ToList()
});
}
private async Task <TransferError> ValidateSenderBalance(string senderId, Money18 amount)
{
var senderBalance = await _balanceService.GetAsync(senderId);
switch (senderBalance.Error)
{
case CustomerBalanceError.InvalidCustomerId:
return(TransferError.InvalidSenderId);
case CustomerBalanceError.CustomerWalletMissing:
return(TransferError.SenderWalletMissing);
case CustomerBalanceError.None when senderBalance.Total < amount:
return(TransferError.NotEnoughFunds);
}
return(TransferError.None);
}
public async Task <BalanceIndicatorsReport> GetAsync()
{
IReadOnlyCollection <Balance> externalBalances = await _balanceService.GetAsync(ExchangeNames.External);
decimal riskExposure = 0;
decimal equity = 0;
decimal fiatEquity = 0;
foreach (Balance balance in externalBalances)
{
decimal amountInUsd;
bool isFiat = false;
if (balance.AssetId == AssetConsts.UsdAssetId)
{
amountInUsd = balance.Amount;
isFiat = true;
}
else
{
Domain.AssetSettings assetSettings = await _assetSettingsService.GetByIdAsync(balance.AssetId);
if (assetSettings == null)
{
continue;
}
if (!assetSettings.IsCrypto)
{
isFiat = true;
}
Quote quote = await _quoteService
.GetAsync(assetSettings.QuoteSource, assetSettings.ExternalAssetPairId);
if (quote == null)
{
continue;
}
amountInUsd = Calculator.CalculateCrossMidPrice(balance.Amount, quote, assetSettings.IsInverse)
.Item1;
}
if (balance.Amount < 0)
{
riskExposure += Math.Abs(amountInUsd);
}
equity += amountInUsd;
if (isFiat)
{
fiatEquity += amountInUsd;
}
}
return(new BalanceIndicatorsReport
{
Equity = equity,
FiatEquity = fiatEquity,
RiskExposure = riskExposure
});
}
public async Task <IReadOnlyCollection <BalanceModel> > GetAllAsync()
{
IReadOnlyCollection <Balance> balances = await _balanceService.GetAsync();
return(Mapper.Map <BalanceModel[]>(balances));
}
public async Task <CustomerBalanceResponseModel> GetBalanceAsync(Guid customerId)
{
var result = await _balanceService.GetAsync(customerId.ToString());
return(_mapper.Map <CustomerBalanceResponseModel>(result));
}
public async Task <IReadOnlyCollection <BalanceReport> > GetAsync()
{
IReadOnlyCollection <Balance> lykkeBalances = await _balanceService.GetAsync(ExchangeNames.Lykke);
IReadOnlyCollection <Balance> externalBalances = await _balanceService.GetAsync(ExchangeNames.External);
IReadOnlyCollection <Credit> credits = await _creditService.GetAllAsync();
IReadOnlyCollection <Domain.AssetSettings> assetsSettings = await _assetSettingsService.GetAllAsync();
string[] assets = externalBalances
.Select(o => o.AssetId)
.Union(lykkeBalances.Select(o => o.AssetId).Union(credits.Select(o => o.AssetId))
.Select(o => assetsSettings.SingleOrDefault(p => p.LykkeAssetId == o)?.AssetId ?? o))
.ToArray();
var reports = new List <BalanceReport>();
foreach (string assetId in assets)
{
Domain.AssetSettings assetSettings = assetsSettings.SingleOrDefault(o => o.AssetId == assetId);
string lykkeAssetId = assetSettings?.LykkeAssetId ?? assetId;
Balance lykkeBalance = lykkeBalances.SingleOrDefault(o => o.AssetId == lykkeAssetId);
Balance externalBalance = externalBalances.SingleOrDefault(o => o.AssetId == assetId);
Credit credit = credits.SingleOrDefault(o => o.AssetId == lykkeAssetId);
decimal lykkeDisbalance = (lykkeBalance?.Amount ?? 0) - (credit?.Amount ?? 0);
decimal totalAmount = lykkeDisbalance + (externalBalance?.Amount ?? 0);
if (totalAmount != 0)
{
(decimal? TotalAmountInUsd, decimal? Rate)tuple = (null, null);
if (assetId == AssetConsts.UsdAssetId)
{
tuple = (totalAmount, 1);
}
else if (assetSettings != null)
{
Quote quote = await _quoteService
.GetAsync(assetSettings.QuoteSource, assetSettings.ExternalAssetPairId);
if (quote != null)
{
tuple = Calculator.CalculateCrossMidPrice(totalAmount, quote, assetSettings.IsInverse);
}
}
reports.Add(new BalanceReport
{
Asset = assetId,
LykkeAssetId = lykkeAssetId,
ExternalAssetId = assetId,
LykkeAmount = lykkeBalance?.Amount,
LykkeCreditAmount = credit?.Amount,
LykkeDisbalance = lykkeDisbalance,
ExternalAmount = externalBalance?.Amount,
TotalAmount = totalAmount,
TotalAmountInUsd = tuple.TotalAmountInUsd,
CrossRate = tuple.Rate
});
}
}
return(reports);
}
