public async Task <WhitelistItemCreateResponse> CreateWhitelistItemAsync(WhitelistItemCreateRequest request)
{
var retryPolicy = Policy
.Handle <Exception>(ex =>
{
_log.WriteWarning(nameof(CreateWhitelistItemAsync), new { requestId = request.RequestId, clientId = request.Scope.UserNativeId, accountId = request.Scope.AccountId }, $"Retry on Exception: {ex.Message}.", ex);
return(true);
})
.OrResult <WhitelistItemCreateResponse>(response =>
{
if (response.BodyCase == WhitelistItemCreateResponse.BodyOneofCase.Error)
{
_log.WriteWarning(nameof(CreateWhitelistItemAsync), response.ToJson(), "Response from sirius.");
}
return(response.BodyCase == WhitelistItemCreateResponse.BodyOneofCase.Error);
}
)
.WaitAndRetryAsync(_delay);
try
{
_log.WriteInfo(nameof(CreateWhitelistItemAsync), info: "Creating whitelist item in sirius",
context: new { requestId = request.RequestId, clientId = request.Scope.UserNativeId, accountId = request.Scope.AccountId });
var result = await retryPolicy.ExecuteAsync(async() => await _siriusApiClient.WhitelistItems.CreateAsync(request));
if (result.BodyCase == WhitelistItemCreateResponse.BodyOneofCase.Error)
{
_log.WriteError(nameof(CreateWhitelistItemAsync), new { requestId = request.RequestId, clientId = request.Scope.UserNativeId, accountId = request.Scope.AccountId });
return(null);
}
_log.WriteInfo(nameof(CreateWhitelistItemAsync), info: "Whitelist item created in siruis",
context: new { whitelistItemId = result.WhitelistItem.Id, requestId = request.RequestId, clientId = request.Scope.UserNativeId, accountId = request.Scope.AccountId });
return(result);
}
catch (Exception ex)
{
_log.WriteError(nameof(CreateWhitelistItemAsync), new { requestId = request.RequestId, clientId = request.Scope.UserNativeId, accountId = request.Scope.AccountId }, ex);
return(null);
}
}
public async Task CreateWalletsAsync(string clientId)
{
long?accountId = null;
var accountResponse = await SearchAccountAsync(clientId);
if (accountResponse == null)
{
_log.WriteWarning(nameof(CreateWalletsAsync), info: "Error getting account from sirius", context: new { clientId });
return;
}
if (accountResponse.Body.Items.Count == 0)
{
string accountRequestId = $"{_brokerAccountId}_{clientId}_account";
string userRequestId = $"{clientId}_user";
var userCreateResponse = await CreateUserAsync(clientId, userRequestId);
if (userCreateResponse == null)
{
_log.WriteWarning(nameof(CreateWalletsAsync), info: "Error creating user in sirius",
context: new { clientId, requestId = userRequestId });
return;
}
var createResponse = await CreateAccountAsync(clientId, userCreateResponse.User.Id, accountRequestId);
if (createResponse == null)
{
_log.WriteWarning(nameof(CreateWalletsAsync), info: "Error creating account in sirius",
context: new { clientId, requestId = accountRequestId });
return;
}
accountId = createResponse.Body.Account.Id;
await WaitForActiveWalletsAsync(clientId, accountId);
}
else
{
accountId = accountResponse.Body.Items.FirstOrDefault()?.Id;
}
var whitelistItemRequest = new WhitelistItemCreateRequest
{
Name = "Trading Wallet Whitelist",
Scope = new WhitelistItemScope {
BrokerAccountId = _brokerAccountId, AccountId = accountId, UserNativeId = clientId
},
Details = new WhitelistItemDetails
{
TransactionType = WhitelistTransactionType.Any, TagType = new NullableWhitelistItemTagType {
Null = NullValue.NullValue
}
},
Lifespan = new WhitelistItemLifespan {
StartsAt = Timestamp.FromDateTime(DateTime.UtcNow)
},
RequestId = $"lykke:trading_wallet:{clientId}"
};
var whitelistItemCreateResponse = await CreateWhitelistItemAsync(whitelistItemRequest);
if (whitelistItemCreateResponse == null)
{
_log.WriteWarning(nameof(CreateWalletsAsync), info: "Error creating Whitelist item",
context: new { clientId, accountId });
}
}
public async Task <IActionResult> CreateWhitelistingAsync([FromBody] CreateWhitelistingRequest request)
{
if (string.IsNullOrWhiteSpace(request.AddressBase))
{
throw LykkeApiErrorException.BadRequest(LykkeApiErrorCodes.Service.InvalidInput);
}
var check2FaResult = await _google2FaService.Check2FaAsync <string>(_requestContext.ClientId, request.Code2Fa);
if (check2FaResult != null)
{
return(Ok(check2FaResult));
}
var asset = await _assetsHelper.GetAssetAsync(request.AssetId);
var assetsAvailableToUser = await _assetsHelper.GetSetOfAssetsAvailableToClientAsync(_requestContext.ClientId, _requestContext.PartnerId, true);
if (asset == null || asset.BlockchainIntegrationType != BlockchainIntegrationType.Sirius && assetsAvailableToUser.Contains(asset.Id))
{
throw LykkeApiErrorException.BadRequest(LykkeApiErrorCodes.Service.AssetUnavailable);
}
var wallets = (await _clientAccountService.Wallets.GetClientWalletsFilteredAsync(_requestContext.ClientId,
owner: OwnerType.Spot, walletType: WalletType.Trusted)).ToList();
if (wallets.All(x => x.Id != request.WalletId))
{
throw LykkeApiErrorException.BadRequest(LykkeApiErrorCodes.Service.InvalidInput);
}
var siriusAsset = await _siriusWalletsService.GetAssetByIdAsync(asset.SiriusAssetId);
if (siriusAsset == null)
{
throw LykkeApiErrorException.BadRequest(LykkeApiErrorCodes.Service.AssetUnavailable);
}
var siriusAccount = await _siriusWalletsService.SearchAccountAsync(_requestContext.ClientId, request.WalletId);
if (siriusAccount == null)
{
throw LykkeApiErrorException.BadRequest(LykkeApiErrorCodes.Service.BlockchainWalletDepositAddressNotGenerated);
}
var whitelistedItems = await _siriusWalletsService.GetWhitelistItemsAsync(siriusAccount.Body.Items.First().Id);
if (whitelistedItems.Any(x => x.Details.Address == request.AddressBase && x.Details.Tag == request.AddressExtension))
{
throw LykkeApiErrorException.BadRequest(LykkeApiErrorCodes.Service.AddressAlreadyWhitelisted);
}
var requestId = $"lykke:hft:withdrawals:{request.WalletId}:{request.Name}:{request.AssetId}:{request.AddressBase}:{request.AddressExtension ?? string.Empty}";
var whitelistItemRequest = new WhitelistItemCreateRequest
{
Name = request.Name,
Scope = new WhitelistItemScope {
BrokerAccountId = _siriusApiServiceClientSettings.BrokerAccountId,
AccountId = siriusAccount.Body.Items.First().Id,
UserNativeId = _requestContext.ClientId
},
Details = new WhitelistItemDetails
{
AssetId = siriusAsset.Id,
BlockchainId = siriusAsset.BlockchainId,
Address = request.AddressBase,
Tag = request.AddressExtension,
TagType =
new NullableWhitelistItemTagType
{
TagType = WhitelistItemTagType.Number //TODO: specify tag type depending on the blockchain
},
TransactionType = WhitelistTransactionType.Withdrawal
},
Lifespan = new WhitelistItemLifespan {
StartsAt = Timestamp.FromDateTime(DateTime.UtcNow.Add(_whitelistingSettings.WaitingPeriod))
},
RequestId = requestId
};
var result = await _siriusWalletsService.CreateWhitelistItemAsync(whitelistItemRequest);
if (result == null)
{
throw LykkeApiErrorException.BadRequest(LykkeApiErrorCodes.Service.WhitelistingError);
}
await SendWhitelistEmail(_requestContext.ClientId, asset.DisplayId, request.AddressBase,
request.AddressExtension);
return(Ok(Google2FaResultModel <WhitelistingResponseModel> .Success(new WhitelistingResponseModel
{
Id = result.WhitelistItem.Id.ToString(),
WalletName = wallets.Single(y => y.Id == request.WalletId).Name,
AssetName = asset.DisplayId,
Status = WhitelistingStatus.Pending,
AddressBase = request.AddressBase,
AddressExtension = request.AddressExtension,
StartsAt = result.WhitelistItem.Lifespan.StartsAt.ToDateTime(),
CreatedAt = result.WhitelistItem.CreatedAt.ToDateTime(),
Name = request.Name
})));
}
