public async Task <IActionResult> Get()
{
var allAssets = await _assetsService.AssetGetAllAsync();
return(Ok(
GetBaseAssetsRespModel.Create(
allAssets
.Where(x => !x.IsDisabled)
.Select(x => x.ConvertToApiModel())
.OrderBy(x => x.DisplayId == null)
.ThenBy(x => x.DisplayId)
.ToArray())));
}
public async Task UpdateCache()
{
var assets = (await _assetsService.AssetGetAllAsync())
.ToDictionary(
a => a.Id,
a => (IAsset) new Asset
{
Id = a.Id,
Name = a.Name,
Accuracy = a.Accuracy
});
_assetsCache.Init(assets);
}
public AssetsLocalCache(
[NotNull] ILogFactory logFactory,
[NotNull] IAssetsService assetsService,
[NotNull] RetryPolicySettings retryPolicySettings,
[NotNull] ExpirationPeriodsSettings expirationPeriodsSettings)
{
ILog log = logFactory.CreateLog(this);
_assetsCache = new CachedDataDictionary <string, Asset>
(
async() =>
{
IList <Asset> assets = await Policy
.Handle <Exception>()
.WaitAndRetryAsync(
retryPolicySettings.DefaultAttempts,
attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)),
(ex, timestamp) => log.Error("Getting assets dictionary with retry", ex))
.ExecuteAsync(() => assetsService.AssetGetAllAsync(true));
return(assets.ToDictionary(itm => itm.Id));
}, expirationPeriodsSettings.AssetsCache);
_assetPairsCache = new CachedDataDictionary <string, AssetPair>(
async() =>
{
IList <AssetPair> assetPairs = await Policy
.Handle <Exception>()
.WaitAndRetryAsync(
retryPolicySettings.DefaultAttempts,
attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)),
(ex, timestamp) => log.Error("Getting asset pairs dictionary with retry", ex))
.ExecuteAsync(() => assetsService.AssetPairGetAllAsync());
return(assetPairs.ToDictionary(itm => itm.Id));
}, expirationPeriodsSettings.AssetsCache);
}
public async Task <BlockchainTransactionsInfo> GetTransactionsInfoAsync(IEnumerable <Asset> assets, string address, string assetId = null, DateTime?fromDate = null, int?fromBlock = null)
{
var ethAsset = (await _assetsService.AssetGetAllAsync()).FirstOrDefault(x => x.BlockChainAssetId == "ETH");
if (ethAsset == null)
{
return(new BlockchainTransactionsInfo());
}
var result = new BlockchainTransactionsInfo
{
AssetId = ethAsset.Id
};
if (!fromDate.HasValue)
{
return(result);
}
var hasTransactions = true;
int count = 100;
int start = 0;
while (hasTransactions)
{
var addressHistoryResponse = await _client.ApiTransactionsHistoryPostAsync(new AddressTransactions
{
Address = address,
Count = count,
Start = start
});
if (addressHistoryResponse is ApiException error)
{
continue;
}
if (addressHistoryResponse is FilteredAddressHistoryResponse historyResponse)
{
var transactions = historyResponse.History.Where(x => x.BlockTimeUtc >= fromDate.Value).ToList();
hasTransactions = transactions.Any();
foreach (var historyItem in transactions)
{
var fees = BigInteger.Parse(historyItem.GasPrice ?? "0") * BigInteger.Parse(historyItem.GasUsed ?? "0");
var sign = EthServiceHelpers.CalculateSign(address, historyItem.FromProperty, historyItem.To);
var value = sign == 1
? historyItem.Value
: (BigInteger.Parse(historyItem.Value) + fees).ToString();
decimal ethValue = sign * EthServiceHelpers
.ConvertFromContract(
value,
ethAsset.MultiplierPower,
ethAsset.Accuracy);
result.TransactionsCount++;
if (sign == 1)
{
result.ReceivedAmount += ethValue;
}
if (sign == -1)
{
result.SpentAmount += ethValue;
}
}
start += count;
count += count;
}
}
return(result);
}
public async Task Execute()
{
IList <Erc20Token> erc20Tokens = null;
try
{
var tradeableAssets = await _assetsService.AssetGetAllAsync();
var supportedTokenAssets = tradeableAssets.Where(asset =>
asset.Type == Lykke.Service.Assets.Client.Models.AssetType.Erc20Token && asset.IsTradable);
var assetIds = supportedTokenAssets.Select(x => x.Id);
var tradableTokens = await _assetsService.Erc20TokenGetBySpecificationAsync(new Lykke.Service.Assets.Client.Models.Erc20TokenSpecification()
{
Ids = assetIds.ToList(),
});
erc20Tokens = tradableTokens?.Items;
}
catch (Exception exc)
{
await _logger.WriteErrorAsync(nameof(Erc20DepositMonitoringContracts),
nameof(Execute),
"Assets Service unavailable",
exc,
DateTime.UtcNow);
return;
}
if (erc20Tokens != null && !erc20Tokens.Any())
{
await _logger.WriteWarningAsync(nameof(Erc20DepositMonitoringContracts),
nameof(Execute),
"",
"No tokens available for trade",
DateTime.UtcNow);
return;
}
await _erc20DepositContractService.ProcessAllAsync(async (item) =>
{
try
{
//Check that deposit contract assigned to user
if (!string.IsNullOrEmpty(item.UserAddress))
{
// null - means we ask for all balances on current address
var tokenBalances = await _erc20BalanceService.GetBalancesForAddress(item.ContractAddress, new string[0]);
if (tokenBalances != null)
{
foreach (var tokenBalance in tokenBalances)
{
string tokenAddress = tokenBalance.Erc20TokenAddress?.ToLower();
string formattedAddress =
_userTransferWalletRepository.FormatAddressForErc20(item.ContractAddress, tokenAddress);
IUserTransferWallet wallet =
await _userTransferWalletRepository.GetUserContractAsync(item.UserAddress, formattedAddress);
if (wallet == null ||
string.IsNullOrEmpty(wallet.LastBalance) ||
wallet.LastBalance == "0")
{
BigInteger balance =
await _ercInterfaceService.GetBalanceForExternalTokenAsync(item.ContractAddress, tokenAddress);
if (balance > 0)
{
await _userTransferWalletRepository.ReplaceAsync(new UserTransferWallet()
{
LastBalance = balance.ToString(),
TransferContractAddress = formattedAddress,
UserAddress = item.UserAddress,
UpdateDate = DateTime.UtcNow
});
await _erc20DepositTransactionService.PutContractTransferTransaction(new Erc20DepositContractTransaction()
{
Amount = balance.ToString(),
UserAddress = item.UserAddress,
TokenAddress = tokenAddress,
ContractAddress = item.ContractAddress,
CreateDt = DateTime.UtcNow,
});
await _logger.WriteInfoAsync(nameof(Erc20DepositMonitoringContracts),
nameof(Execute), "", $"Balance on transfer address - {item.ContractAddress} is {balance} (Tokens of {tokenBalance.Erc20TokenAddress})" +
$" transfer belongs to user {item.UserAddress}", DateTime.UtcNow);
}
}
}
}
}
else
{
//TODO
//Notify That deposit contract does not have a user;
}
}
catch (Exception e)
{
await _logger.WriteErrorAsync(nameof(Erc20DepositMonitoringContracts),
nameof(Execute), "", e, DateTime.UtcNow);
}
});
}
/// <summary>
/// Returns all assets including nontradable.
/// </summary>
/// <param name='operations'>The operations group for this extension method</param>
/// <returns></returns>
public static IList <Asset> AssetGetAll(this IAssetsService operations)
{
return(operations.AssetGetAllAsync(true).GetAwaiter().GetResult());
}
