public Task <TransferResultModel> GetElixirTime(TransferModel model)
{
var result = new TransferResultModel()
{
TransferTime = new DateTime(2016, 1, 1, 10, 0, 0)
};
return(Task.FromResult(result));
}
public async Task <TransferResultModel> TransferToInternalAsync(
string privateWalletAddress,
string publicWalletAddress,
Money18 amount,
BigInteger publicTransferId)
{
#region Validation
if (string.IsNullOrEmpty(privateWalletAddress))
{
return(TransferResultModel.Failed(TransferError.PrivateWalletMissing));
}
if (string.IsNullOrEmpty(publicWalletAddress))
{
return(TransferResultModel.Failed(TransferError.PublicWalletMissing));
}
if (amount <= 0)
{
return(TransferResultModel.Failed(TransferError.InvalidAmount));
}
#endregion
return(await _transactionScopeHandler.WithTransactionAsync(async() =>
{
if (!string.IsNullOrEmpty(publicTransferId.ToString()))
{
var isDuplicate = await _deduplicationLog.IsDuplicateAsync(publicTransferId.ToString());
if (isDuplicate)
{
_log.Warning("There is already transfer to internal operation with the same request id", context: publicTransferId);
return TransferResultModel.Failed(TransferError.DuplicateRequest);
}
}
var result = await _operationRequestsProducer.AddAsync(
OperationType.TransferToInternal,
new TransferToInternalContext
{
PrivateWalletAddress = privateWalletAddress,
Amount = amount,
PublicTransferId = publicTransferId,
PublicWalletAddress = publicWalletAddress,
});
return TransferResultModel.Succeeded(result);
}));
}
public async Task <TransferResultModel> P2PTransferAsync(
string senderId,
string recipientId,
Money18 amount,
string transferRequestId)
{
#region Validation
if (string.IsNullOrEmpty(recipientId))
{
return(TransferResultModel.Failed(TransferError.InvalidRecipientId));
}
if (string.IsNullOrEmpty(senderId))
{
return(TransferResultModel.Failed(TransferError.InvalidSenderId));
}
if (amount <= 0)
{
return(TransferResultModel.Failed(TransferError.InvalidAmount));
}
var senderAddressResult = await _walletsService.GetCustomerWalletAsync(senderId);
var senderAddressValidationResultError = ValidateSenderAddress(senderAddressResult.Error);
if (senderAddressValidationResultError != TransferError.None)
{
return(TransferResultModel.Failed(senderAddressValidationResultError));
}
var recipientAddressResult = await _walletsService.GetCustomerWalletAsync(recipientId);
var recipientAddressValidationResultError = ValidateRecipientAddress(recipientAddressResult.Error);
if (recipientAddressValidationResultError != TransferError.None)
{
return(TransferResultModel.Failed(recipientAddressValidationResultError));
}
var senderBalanceValidationError = await ValidateSenderBalance(senderId, amount);
if (senderBalanceValidationError != TransferError.None)
{
return(TransferResultModel.Failed(senderBalanceValidationError));
}
#endregion
return(await _transactionScopeHandler.WithTransactionAsync(async() =>
{
if (!string.IsNullOrEmpty(transferRequestId))
{
var isDuplicate = await _deduplicationLog.IsDuplicateAsync(transferRequestId);
if (isDuplicate)
{
_log.Warning("There is already transfer operation with the same request id", context: transferRequestId);
return TransferResultModel.Failed(TransferError.DuplicateRequest);
}
}
var result = await _operationRequestsProducer.AddAsync(
senderId,
OperationType.TokensTransfer,
new TokensTransferContext
{
SenderWalletAddress = senderAddressResult.WalletAddress,
RecipientWalletAddress = recipientAddressResult.WalletAddress,
Amount = amount,
RequestId = transferRequestId,
},
senderAddressResult.WalletAddress);
return TransferResultModel.Succeeded(result);
}));
}
public async Task <TransferResultModel> TransferToExternalAsync(
string senderId,
string recipientAddress,
Money18 amount,
Money18 fee,
string transferRequestId)
{
#region Validation
if (string.IsNullOrEmpty(recipientAddress))
{
return(TransferResultModel.Failed(TransferError.RecipientWalletMissing));
}
if (string.IsNullOrEmpty(senderId))
{
return(TransferResultModel.Failed(TransferError.InvalidSenderId));
}
if (fee < 0)
{
return(TransferResultModel.Failed(TransferError.InvalidFeeAmount));
}
if (amount <= 0)
{
return(TransferResultModel.Failed(TransferError.InvalidAmount));
}
var senderAddressResult = await _walletsService.GetCustomerWalletAsync(senderId);
var senderAddressValidationResultError = ValidateSenderAddress(senderAddressResult.Error);
if (senderAddressValidationResultError != TransferError.None)
{
return(TransferResultModel.Failed(senderAddressValidationResultError));
}
var totalAmountAndFee = amount + fee;
var senderBalanceValidationError = await ValidateSenderBalance(senderId, totalAmountAndFee);
if (senderBalanceValidationError != TransferError.None)
{
return(TransferResultModel.Failed(senderBalanceValidationError));
}
#endregion
return(await _transactionScopeHandler.WithTransactionAsync(async() =>
{
if (!string.IsNullOrEmpty(transferRequestId))
{
var isDuplicate = await _deduplicationLog.IsDuplicateAsync(transferRequestId);
if (isDuplicate)
{
_log.Warning("There is already transfer to external operation with the same request id", context: transferRequestId);
return TransferResultModel.Failed(TransferError.DuplicateRequest);
}
}
var result = await _operationRequestsProducer.AddAsync(
senderId,
OperationType.TransferToExternal,
new TransferToExternalContext
{
PrivateWalletAddress = senderAddressResult.WalletAddress,
Amount = amount,
RecipientContractAddress = recipientAddress,
},
senderAddressResult.WalletAddress);
return TransferResultModel.Succeeded(result);
}));
}
