Example #1
0
        public async Task <BlockchainTransferResult> TransferAsync(BlockchainTransferCommand transfer)
        {
            BlockchainTransferResult result = new BlockchainTransferResult {
                Blockchain = BlockchainType.Ethereum
            };

            string lykkeAssetId = await _lykkeAssetsResolver.GetLykkeId(transfer.AssetId);

            Asset asset = await _assetsLocalCache.GetAssetByIdAsync(lykkeAssetId);

            if (asset.Type != AssetType.Erc20Token || !asset.IsTradable)
            {
                throw new AssetNotSupportedException(asset.Name);
            }

            ListOfErc20Token tokenSpecification =
                await _assetsService.Erc20TokenGetBySpecificationAsync(new Erc20TokenSpecification { Ids = new[] { asset.Id } });

            string tokenAddress = tokenSpecification?.Items.SingleOrDefault(x => x.AssetId == asset.Id)?.Address;

            foreach (TransferAmount transferAmount in transfer.Amounts)
            {
                var transferRequest = Mapper.Map <TransferFromDepositRequest>(transferAmount,
                                                                              opts => opts.Items["TokenAddress"] = tokenAddress);

                object response = await _ethereumServiceClient.ApiLykkePayErc20depositsTransferPostAsync(
                    _ethereumSettings.ApiKey, transferRequest);

                var errorMessage = string.Empty;

                var operationId = string.Empty;

                if (response is ApiException ex)
                {
                    await _log.WriteWarningAsync(nameof(TransferAsync), transferAmount.ToJson(), ex.Error?.ToJson());

                    errorMessage = ex.Error?.Message;
                }
                else if (response is OperationIdResponse op)
                {
                    operationId = op.OperationId;
                }
                else
                {
                    throw new UnrecognizedApiResponse(response?.GetType().FullName ?? "Response object is null");
                }

                result.Transactions.Add(new BlockchainTransactionResult
                {
                    Amount       = transferAmount.Amount,
                    AssetId      = asset.Name,
                    Hash         = string.Empty,
                    IdentityType = TransactionIdentityType.Specific,
                    Identity     = operationId,
                    Sources      = new List <string> {
                        transferAmount.Source
                    },
                    Destinations = new List <string> {
                        transferAmount.Destination
                    },
                    Error = errorMessage
                });
            }

            return(result);
        }
        public async Task <BlockchainTransferResult> TransferAsync(BlockchainTransferCommand transfer)
        {
            BlockchainTransferResult result = new BlockchainTransferResult {
                Blockchain = BlockchainType.EthereumIata
            };

            string lykkeAssetId = await _lykkeAssetsResolver.GetLykkeId(transfer.AssetId);

            Asset asset = await _assetsLocalCache.GetAssetByIdAsync(lykkeAssetId);

            if (asset.Type != AssetType.Erc20Token)
            {
                throw new AssetNotSupportedException(asset.Name);
            }

            ListOfErc20Token tokenSpecification =
                await _assetsService.Erc20TokenGetBySpecificationAsync(new Erc20TokenSpecification
                                                                       { Ids = new[] { asset.Id } });

            string tokenAddress = tokenSpecification?.Items.SingleOrDefault(x => x.AssetId == asset.Id)?.Address;

            foreach (TransferAmount transferAmount in transfer.Amounts)
            {
                var transferRequest = Mapper.Map <AirlinesTransferFromDepositRequest>(transferAmount,
                                                                                      opts =>
                {
                    opts.Items["TokenAddress"]    = tokenAddress;
                    opts.Items["AssetMultiplier"] = asset.MultiplierPower;
                    opts.Items["AssetAccuracy"]   = asset.Accuracy;
                });

                object response = await _retryPolicy.ExecuteAsync(() => InvokeTransfer(transferRequest));

                var ex = response as ApiException;

                var operation = response as OperationIdResponse;

                if (ex != null)
                {
                    _log.Warning(ex.Error?.Message);
                }

                if (ex == null && operation == null)
                {
                    throw new UnrecognizedApiResponse(response?.GetType().FullName ?? "Response object is null");
                }

                result.Transactions.Add(new BlockchainTransactionResult
                {
                    Amount       = transferAmount.Amount ?? 0,
                    AssetId      = asset.DisplayId,
                    Hash         = string.Empty,
                    IdentityType = TransactionIdentityType.Specific,
                    Identity     = operation?.OperationId ?? string.Empty,
                    Sources      = new List <string> {
                        transferAmount.Source
                    },
                    Destinations = new List <string> {
                        transferAmount.Destination
                    },
                    Error     = ex?.Error?.Message ?? string.Empty,
                    ErrorType = ex.GetDomainError()
                });
            }

            return(result);
        }