public async Task UpdateAssetFeesSettings(AssetFees settings)
{
using var action = MyTelemetry.StartActivity("Update Asset Fees Settings");
settings.AddToActivityAsJsonTag("settings");
try
{
_logger.LogInformation("Update Asset Fees Setting: {jsonText}",
JsonConvert.SerializeObject(settings));
ValidateSettings(settings);
var entity = AssetFeesNoSqlEntity.Create(settings);
var existingItem = await _writer.GetAsync(entity.PartitionKey, entity.RowKey);
if (existingItem == null)
{
throw new Exception("Cannot update Asset Fees Settings. Do not exist");
}
await _writer.InsertOrReplaceAsync(entity);
_logger.LogInformation("Updated Asset Fees Setting: {jsonText}",
JsonConvert.SerializeObject(settings));
}
catch (Exception ex)
{
_logger.LogError(ex, "Cannot update ExternalMarketSettings: {requestJson}",
JsonConvert.SerializeObject(settings));
ex.FailActivity();
throw;
}
}
public static AssetFeesNoSqlEntity Create(AssetFees assetFees)
{
return(new AssetFeesNoSqlEntity()
{
PartitionKey = GeneratePartitionKey(assetFees.BrokerId, assetFees.ProfileId),
RowKey = GenerateRowKey(assetFees.AssetId, assetFees.OperationType),
BrokerId = assetFees.BrokerId,
AssetId = assetFees.AssetId,
OperationType = assetFees.OperationType,
AssetFees = assetFees
});
}
public async Task <NullableValue <AssetFees> > GetAssetFees(GetAssetFeesRequest request)
{
try
{
var fees = _client.GetAssetFees(request.BrokerId, request.GroupId, request.AssetId, request.OperationType);
return(fees == null ? null : new NullableValue <AssetFees>(AssetFees.Create(fees)));
}
catch (Exception ex)
{
if (ex.Message == "Unknown HTTP result CodeNotFound. Message: Row not found")
{
return(new NullableValue <AssetFees>());
}
throw;
}
}
private static void ValidateSettings(AssetFees settings)
{
if (string.IsNullOrEmpty(settings.BrokerId))
{
throw new Exception("Cannot add settings with empty broker");
}
if (string.IsNullOrEmpty(settings.ProfileId))
{
throw new Exception("Cannot add settings with empty profile");
}
if (string.IsNullOrEmpty(settings.AssetId))
{
throw new Exception("Cannot add settings with empty asset");
}
if (settings.FeeSize < 0)
{
throw new Exception("Cannot add settings with negative fee size");
}
}
public static Fee ConvertAssetFee(AssetFees assetFees)
{
var fee = new Fee {
Type = ConvertFeeType(assetFees.FeeType)
};
if (fee.Type == FeeType.NoFee)
{
return(fee);
}
fee.SizeType = ConvertFeeSizeType(assetFees.FeeSizeType);
fee.Size = assetFees.FeeSize.ToString(CultureInfo.InvariantCulture);
fee.TargetAccountId = assetFees.AccountId;
fee.TargetWalletId = assetFees.WalletId;
if (!string.IsNullOrEmpty(assetFees.FeeAssetId))
{
fee.AssetId.Add(assetFees.FeeAssetId);
}
return(fee);
}
private async Task <ChangeBalanceGrpcResponse> ChangeBalanceAsync(string transactionId,
string walletId, decimal amount, string assetSymbol, string brokerId, string eventType, AssetFees assetFees)
{
var asset = _assetsDictionaryClient.GetAssetById(new AssetIdentity()
{
BrokerId = brokerId,
Symbol = assetSymbol
});
if (asset == null)
{
return(new ChangeBalanceGrpcResponse()
{
TransactionId = transactionId,
Result = false,
ErrorMessage = "Cannot change balance, asset do not found",
ErrorCode = ChangeBalanceGrpcResponse.ErrorCodeEnum.AssetDoNotFound
});
}
if (!asset.IsEnabled)
{
return(new ChangeBalanceGrpcResponse()
{
TransactionId = transactionId,
Result = false,
ErrorMessage = "Cannot change balance, asset is Disabled.",
ErrorCode = ChangeBalanceGrpcResponse.ErrorCodeEnum.AssetIsDisabled
});
}
var balanceChangeRequest = new ExBalanceUpdateInstruction
{
OperationId = transactionId,
EventType = eventType,
Timestamp = DateTime.UtcNow,
Updates = new List <ExBalanceUpdateInstruction.BalanceUpdate>
{
new ExBalanceUpdateInstruction.BalanceUpdate
{
WalletId = walletId,
AssetId = asset.Symbol,
Number = 1,
Amount = (decimal)amount,
ReserveAmount = 0
}
}
};
if (assetFees != null && assetFees.FeeType != FeeType.NoFee && assetFees.FeeAssetId != assetSymbol)
{
//decimal check amount and fee, ensure that amount does not include fee
return(new ChangeBalanceGrpcResponse()
{
TransactionId = transactionId,
Result = false,
ErrorMessage = $"Fee asset {assetFees.FeeAssetId} is not equal to asset {assetSymbol}",
ErrorCode = ChangeBalanceGrpcResponse.ErrorCodeEnum.Error
});
}
if (assetFees != null && assetFees.FeeType != FeeType.NoFee)
{
balanceChangeRequest.Updates.Add(new ExBalanceUpdateInstruction.BalanceUpdate
{
WalletId = assetFees.WalletId,
AssetId = assetFees.AssetId,
Number = 2,
Amount = (decimal)assetFees.FeeSize,
ReserveAmount = 0
});
}
var balanceResponse = await _balanceOperationService.ProcessBalanceUpdate(balanceChangeRequest);
_logger.LogInformation("BalanceService call. Request: {requestText}. Response: {responseText}",
JsonConvert.SerializeObject(balanceChangeRequest), JsonConvert.SerializeObject(balanceResponse));
if (balanceResponse.Result != ExBalanceUpdate.BalanceUpdateResult.Ok)
{
return(new ChangeBalanceGrpcResponse()
{
TransactionId = transactionId,
Result = false,
ErrorMessage = $"Cannot change balance, error: {balanceResponse.Result}",
ErrorCode = balanceResponse.Result == ExBalanceUpdate.BalanceUpdateResult.LowBalance
? ChangeBalanceGrpcResponse.ErrorCodeEnum.LowBalance
: ChangeBalanceGrpcResponse.ErrorCodeEnum.Error
});
}
return(new ChangeBalanceGrpcResponse()
{
TransactionId = transactionId,
Result = true,
ErrorCode = ChangeBalanceGrpcResponse.ErrorCodeEnum.Ok
});
}
public async Task <ChangeBalanceGrpcResponse> BlockchainWithdrawalAsync(BlockchainWithdrawalGrpcRequest request)
{
_logger.LogInformation($"Blockchain withdrawal request: {JsonConvert.SerializeObject(request)}");
request.ClientId.AddToActivityAsTag("clientId");
request.BrokerId.AddToActivityAsTag("brokerId");
request.WalletId.AddToActivityAsTag("walletId");
if (request.Amount >= 0)
{
_logger.LogError(
"Blockchain withdrawal cannot increase balance. Amount: {amount}, TransactionId: {transactionId}",
request.Amount, request.TransactionId);
Activity.Current?.SetStatus(Status.Error);
Activity.Current?.AddTag("message", "Blockchain withdrawal cannot increase balance");
return(new ChangeBalanceGrpcResponse()
{
Result = false,
TransactionId = request.TransactionId,
ErrorMessage = "Blockchain withdrawal cannot increase balance.",
ErrorCode = ChangeBalanceGrpcResponse.ErrorCodeEnum.BadRequest
});
}
var fee = new AssetFees()
{
FeeType = FeeType.NoFee
};
if (request.FeeAmount != 0)
{
if (string.IsNullOrWhiteSpace(request.FeeWalletId))
{
_logger.LogError(
"Can not send withdrawal without FeeWalletId. TransactionId: {transactionId}, walletId {walletId}",
request.TransactionId, request.WalletId);
Activity.Current?.SetStatus(Status.Error);
Activity.Current?.AddTag("message", "Can not send withdrawal without FeeWalletId");
return(new ChangeBalanceGrpcResponse()
{
Result = false,
TransactionId = request.TransactionId,
ErrorMessage = "Can not send withdrawal without FeeWalletId.",
ErrorCode = ChangeBalanceGrpcResponse.ErrorCodeEnum.BadRequest
});
}
fee = new AssetFees
{
BrokerId = request.BrokerId,
AssetId = request.FeeAssetSymbol,
OperationType = OperationType.Withdrawal,
FeeType = FeeType.ClientFee,
FeeSizeType = FeeSizeType.Absolute,
FeeSize = request.FeeAmount,
WalletId = request.FeeWalletId,
FeeAssetId = request.FeeAssetSymbol
};
}
var result = await ChangeBalanceAsync(request.TransactionId, request.WalletId,
request.Amount, request.AssetSymbol, request.BrokerId, "Blockchain Withdrawal", fee);
if (!result.Result)
{
_logger.LogError(
$"Cannot apply 'Blockchain withdrawal'. Message: {result.ErrorMessage}. Request: {JsonConvert.SerializeObject(request)}");
Activity.Current?.SetStatus(Status.Error);
Activity.Current?.AddTag("message", "Cannot apply 'Blockchain deposit'");
result.AddToActivityAsJsonTag("change-balance-response");
}
return(result);
}
