public async Task TestTransferTokens()
        {
            var colorCoin = await _coinRepository.GetCoinByAddress(_tokenAdapterAddress);

            var toAddress = _settings.EthereumMainAccount;

            await CashinTokens(_externalTokenAddress, _clientTokenTransferAddress, new BigInteger(100), _tokenAdapterAddress, _clientA);

            var transferUser = await _transferContractService.GetTransferAddressUser(colorCoin.AdapterAddress, _clientTokenTransferAddress);

            var currentBalance = await _transferContractService.GetBalanceOnAdapter(colorCoin.AdapterAddress, _clientA);

            Assert.AreEqual(transferUser, _clientA.ToLower());

            var guid = Guid.NewGuid();

            EthUtils.GuidToBigInteger(guid);
            var externalSign = await _exchangeService.GetSign(guid, _tokenAdapterAddress, _clientA, toAddress, currentBalance);

            var transferHash = await _exchangeService.Transfer(guid, _tokenAdapterAddress, _clientA, toAddress,
                                                               currentBalance, externalSign);

            while (await _transactionService.GetTransactionReceipt(transferHash) == null)
            {
                await Task.Delay(100);
            }

            var currentBalanceOnAdapter = await _transferContractService.GetBalanceOnAdapter(colorCoin.AdapterAddress, _clientA);

            var newBalance = await _transferContractService.GetBalanceOnAdapter(colorCoin.AdapterAddress, toAddress);

            Assert.IsTrue(await _transactionService.IsTransactionExecuted(transferHash, Constants.GasForCoinTransaction));
            Assert.IsTrue(currentBalanceOnAdapter == 0);
            Assert.IsTrue(currentBalance <= newBalance);
        }
Example #2
0
        public async Task <IdCheckResult> CheckId(Guid guidToCheck)
        {
            var contract = _web3.Eth.GetContract(_settings.MainExchangeContract.Abi, _settings.MainExchangeContract.Address);

            var  transactionsCheck = contract.GetFunction("transactions");
            bool isInList          = true;
            Guid useNext           = guidToCheck;

            while (isInList)
            {
                var bigIntRepresentation = EthUtils.GuidToBigInteger(useNext);
                isInList = await transactionsCheck.CallAsync <bool>(bigIntRepresentation);

                if (isInList)
                {
                    useNext = Guid.NewGuid();
                }
            }

            return(new IdCheckResult()
            {
                IsFree = useNext == guidToCheck,
                ProposedId = useNext
            });
        }
Example #3
0
        public async Task <string> CashOut(Guid id, string coinAddress, string clientAddr, string toAddr, BigInteger amount, string sign)
        {
            await ThrowOnExistingId(id);

            var coinAFromDb = await GetCoinWithCheck(coinAddress);

            if (string.IsNullOrEmpty(sign))
            {
                sign = await GetSign(id, coinAddress, clientAddr, toAddr, amount);
            }

            ThrowOnWrongSignature(id, coinAddress, clientAddr, toAddr, amount, sign);

            var contract = _web3.Eth.GetContract(_settings.MainExchangeContract.Abi, _settings.MainExchangeContract.Address);
            var cashout  = contract.GetFunction("cashout");

            var convertedId = EthUtils.GuidToBigInteger(id);
            // function cashout(uint id, address coinAddress, address client, address to, uint amount, bytes client_sign, bytes params) onlyowner {
            var transactionHash = await cashout.SendTransactionAsync(Constants.AddressForRoundRobinTransactionSending,
                                                                     new HexBigInteger(Constants.GasForCoinTransaction), new HexBigInteger(0),
                                                                     convertedId, coinAFromDb.AdapterAddress, clientAddr, toAddr, amount, sign.HexToByteArray().FixByteOrder(), new byte[0]);

            await SaveUserHistory(coinAddress, amount.ToString(), clientAddr, toAddr, transactionHash, "CashOut");
            await CreatePendingTransaction(coinAddress, clientAddr, transactionHash);

            return(transactionHash);
        }
Example #4
0
        public async Task <string> Transfer(Guid id, string coinAddress, string from, string to, BigInteger amount, string sign)
        {
            await ThrowOnExistingId(id);

            var coinAFromDb = await GetCoinWithCheck(coinAddress);

            if (string.IsNullOrEmpty(sign))
            {
                sign = await GetSign(id, coinAddress, from, to, amount);
            }

            ThrowOnWrongSignature(id, coinAddress, from, to, amount, sign);

            var contract         = _web3.Eth.GetContract(_settings.MainExchangeContract.Abi, _settings.MainExchangeContract.Address);
            var transferFunction = contract.GetFunction("transfer");

            var convertedId     = EthUtils.GuidToBigInteger(id);
            var transactionHash = await transferFunction.SendTransactionAsync(Constants.AddressForRoundRobinTransactionSending,
                                                                              new HexBigInteger(Constants.HalfGasLimit), new HexBigInteger(0),
                                                                              convertedId, coinAFromDb.AdapterAddress, from, to, amount, sign.HexToByteArray().FixByteOrder(), new byte[0]);

            await SaveUserHistory(coinAddress, amount.ToString(), from, to, transactionHash, "Transfer");
            await CreatePendingTransaction(coinAddress, from, transactionHash);

            return(transactionHash);
        }
Example #5
0
        public async Task <OperationEstimationResult> EstimateCashoutGas(Guid id, string coinAdapterAddress, string fromAddress, string toAddress, BigInteger amount, string sign)
        {
            var blackListedAddress = await _blackListAddressesRepository.GetAsync(toAddress);

            var whiteListedAddress = await _whiteListAddressesRepository.GetAsync(toAddress);

            if (blackListedAddress != null && whiteListedAddress == null)
            {
                return(new OperationEstimationResult()
                {
                    GasAmount = Constants.GasForCoinTransaction,
                    IsAllowed = false
                });
            }

            //It is ok.
            if (ChaosKitty.MeowButLogically())
            {
                return(new OperationEstimationResult()
                {
                    GasAmount = 50000,
                    IsAllowed = true
                });
            }

            var coinAFromDb = await GetCoinWithCheck(coinAdapterAddress);

            if (string.IsNullOrEmpty(sign))
            {
                sign = await GetSign(id, coinAdapterAddress, fromAddress, toAddress, amount);
            }

            ThrowOnWrongSignature(id, coinAdapterAddress, fromAddress, toAddress, amount, sign);

            var contract    = _web3.Eth.GetContract(_settings.MainExchangeContract.Abi, _settings.MainExchangeContract.Address);
            var cashout     = contract.GetFunction("cashout");
            var convertedId = EthUtils.GuidToBigInteger(id);
            //ACTION
            var estimatedGasForOperation = await cashout.EstimateGasAsync(_settings.EthereumMainAccount,
                                                                          new HexBigInteger(Constants.GasForCoinTransaction), new HexBigInteger(0),
                                                                          convertedId,
                                                                          _addressUtil.ConvertToChecksumAddress(coinAFromDb.AdapterAddress),
                                                                          fromAddress,
                                                                          toAddress,
                                                                          amount,
                                                                          sign.HexToByteArray(),
                                                                          new byte[0]);

            return(new OperationEstimationResult()
            {
                GasAmount = estimatedGasForOperation.Value,
                IsAllowed = estimatedGasForOperation.Value < Constants.GasForCoinTransaction
            });
        }
Example #6
0
        private async Task ThrowOnExistingId(Guid id)
        {
            var contract             = _web3.Eth.GetContract(_settings.MainExchangeContract.Abi, _settings.MainExchangeContract.Address);
            var transactionsCheck    = contract.GetFunction("transactions");
            var bigIntRepresentation = EthUtils.GuidToBigInteger(id);

            bool isInList = await transactionsCheck.CallAsync <bool>(bigIntRepresentation);

            if (isInList)
            {
                throw new ClientSideException(ExceptionType.OperationWithIdAlreadyExists, $"operation with guid {id}");
            }
        }
Example #7
0
        public async Task <string> CashIn(Guid id, string coinAddress, string receiver, BigInteger amount)
        {
            var web3 = new Web3(_settings.EthereumUrl);

            await web3.Personal.UnlockAccount.SendRequestAsync(_settings.EthereumMainAccount, _settings.EthereumMainAccountPassword, 120);

            var coinAFromDb = await _coinRepository.GetCoinByAddress(coinAddress);

            if (coinAFromDb == null)
            {
                throw new Exception($"Coin with address {coinAddress} deos not exist");
            }

            Contract contract;

            if (coinAFromDb.ContainsEth)
            {
                contract = web3.Eth.GetContract(_settings.EthAdapterContract.Abi, coinAFromDb.AdapterAddress);
            }
            else
            {
                contract = web3.Eth.GetContract(_settings.TokenAdapterContract.Abi, coinAFromDb.AdapterAddress);
            }

            var convertedAmountA = amount;

            var convertedId = EthUtils.GuidToBigInteger(id);

            var cashin = contract.GetFunction("cashin");
            var res    = await cashin.CallAsync <bool>(_settings.EthereumMainAccount, new HexBigInteger(Constants.GasForCoinTransaction),
                                                       new HexBigInteger(0), receiver, convertedAmountA);

            string tr;

            if (coinAFromDb.ContainsEth)
            {
                tr = await cashin.SendTransactionAsync(_settings.EthereumMainAccount, new HexBigInteger(Constants.GasForCoinTransaction),
                                                       new HexBigInteger(convertedAmountA), receiver, convertedAmountA);
            }
            else
            {
                tr = await cashin.SendTransactionAsync(_settings.EthereumMainAccount, new HexBigInteger(Constants.GasForCoinTransaction),
                                                       new HexBigInteger(0), receiver, convertedAmountA);
            }

            return(tr);
        }
        public async Task TestCheckSign_IsWrong()
        {
            var guid   = Guid.NewGuid();
            var amount = 50;

            EthUtils.GuidToBigInteger(guid);
            var strForHash = EthUtils.GuidToByteArray(guid).ToHex() +
                             _ethereumAdapterAddress.HexToByteArray().ToHex() +
                             _clientA.HexToByteArray().ToHex() +
                             _clientA.HexToByteArray().ToHex() +
                             EthUtils.BigIntToArrayWithPadding(new BigInteger(amount)).ToHex();

            var hash   = new Sha3Keccack().CalculateHash(strForHash.HexToByteArray());
            var sign   = Sign(hash, _privateKeyA).ToHex();
            var result = _exchangeService.CheckSign(guid, _ethereumAdapterAddress, _clientA, _clientA, new BigInteger(amount - 1), sign);

            Assert.IsFalse(result);
        }
Example #9
0
        public async Task <string> CashinOverTransferContract(Guid id, string coin, string receiver, decimal amount)
        {
            var coinDb = await _coinRepository.GetCoin(coin);

            if (!coinDb.BlockchainDepositEnabled)
            {
                throw new ClientSideException(ExceptionType.WrongParams, "Coin must be payable");
            }
            var contract = _web3.Eth.GetContract(_settings.TokenTransferContract.Abi, _settings.TokenTransferContract.Address);
            var cashin   = contract.GetFunction("cashin");

            var blockchainAmount = amount.ToBlockchainAmount(coinDb.Multiplier);
            var convertedId      = EthUtils.GuidToBigInteger(id);
            var tr = await cashin.SendTransactionAsync(_settings.EthereumMainAccount, new HexBigInteger(Constants.GasForCoinTransaction),
                                                       new HexBigInteger(0), convertedId, coinDb.AdapterAddress, receiver, blockchainAmount, Constants.GasForCoinTransaction, new byte[0]);

            return(tr);
        }
Example #10
0
        //Main Exchange contract should be migrated to use the function below in an appropriate way.
        public async Task <string> TransferWithoutSignCheck(Guid id, string coinAddress, string from, string to, BigInteger amount, string sign = "01")
        {
            await ThrowOnExistingId(id);

            var coinAFromDb = await GetCoinWithCheck(coinAddress);

            var contract         = _web3.Eth.GetContract(_settings.MainExchangeContract.Abi, _settings.MainExchangeContract.Address);
            var transferFunction = contract.GetFunction("transfer");

            var convertedId     = EthUtils.GuidToBigInteger(id);
            var transactionHash = await transferFunction.SendTransactionAsync(_settings.EthereumMainAccount,
                                                                              new HexBigInteger(Constants.GasForCoinTransaction), new HexBigInteger(0),
                                                                              convertedId, coinAFromDb.AdapterAddress, from, to, amount, sign.HexToByteArray(), new byte[0]);

            await SaveUserHistory(coinAddress, amount.ToString(), from, to, transactionHash, "TransferWithoutSignCheck");

            return(transactionHash);
        }
        public async Task TestCheckSign_IsCorrect()
        {
            var guid   = Guid.NewGuid();
            var amount = 50;

            EthUtils.GuidToBigInteger(guid);
            var strForHash = EthUtils.GuidToByteArray(guid).ToHex() +
                             _tokenAdapterAddress.HexToByteArray().ToHex() +
                             _clientA.HexToByteArray().ToHex() +
                             _clientA.HexToByteArray().ToHex() +
                             EthUtils.BigIntToArrayWithPadding(new BigInteger(amount)).ToHex();

            var hash = new Sha3Keccack().CalculateHash(strForHash.HexToByteArray());
            var sign = Sign(hash, _privateKeyA).ToHex();
            //var externalSign = await _exchangeService.GetSign(guid, _tokenAdapterAddress, ClientA, ClientA, new BigInteger(amount));
            var result = _exchangeService.CheckSign(guid, _tokenAdapterAddress, _clientA, _clientA, new BigInteger(amount), sign);

            Assert.IsTrue(result);
        }
Example #12
0
        public async Task <string> TransferWithChange(Guid id, string coinAddress, string from, string to, BigInteger amount,
                                                      string signFrom, BigInteger change, string signTo)
        {
            if (amount <= change)
            {
                throw new ClientSideException(ExceptionType.WrongParams, "Amount can't be less or equal than change");
            }

            await ThrowOnExistingId(id);

            var coinAFromDb = await GetCoinWithCheck(coinAddress);

            if (string.IsNullOrEmpty(signFrom))
            {
                signFrom = await GetSign(id, coinAddress, from, to, amount);
            }

            if (string.IsNullOrEmpty(signTo))
            {
                signTo = await GetSign(id, coinAddress, to, from, change);
            }

            ThrowOnWrongSignature(id, coinAddress, from, to, amount, signFrom);
            ThrowOnWrongSignature(id, coinAddress, to, from, change, signTo);

            var contract         = _web3.Eth.GetContract(_settings.MainExchangeContract.Abi, _settings.MainExchangeContract.Address);
            var transferFunction = contract.GetFunction("transferWithChange");
            var convertedId      = EthUtils.GuidToBigInteger(id);
            var transactionHash  = await transferFunction.SendTransactionAsync(Constants.AddressForRoundRobinTransactionSending,
                                                                               new HexBigInteger(Constants.HalfGasLimit), new HexBigInteger(0),
                                                                               convertedId, coinAFromDb.AdapterAddress, from, to, amount, change,
                                                                               signFrom.HexToByteArray().FixByteOrder(), signTo.HexToByteArray().FixByteOrder(), new byte[0]);

            var difference = (amount - change);

            await SaveUserHistory(coinAddress, difference.ToString(), from, to, transactionHash, "TransferWithChange");
            await CreatePendingTransaction(coinAddress, from, transactionHash);

            return(transactionHash);
        }
Example #13
0
        private async Task ThrowOnExistingId(Guid id)
        {
            //Check Old contract(Prevent old transactions from executing)
            var addresses = new string[]
            {
                _settings.MainExchangeContract.Address,
                _settings.PreviousMainExchangeContractAddress
            };

            foreach (var address in addresses)
            {
                var contract             = _web3.Eth.GetContract(_settings.MainExchangeContract.Abi, address);
                var transactionsCheck    = contract.GetFunction("transactions");
                var bigIntRepresentation = EthUtils.GuidToBigInteger(id);

                bool isInList = await transactionsCheck.CallAsync <bool>(bigIntRepresentation);

                if (isInList)
                {
                    throw new ClientSideException(ExceptionType.OperationWithIdAlreadyExists, $"operation with guid {id}");
                }
            }
        }
Example #14
0
        //public async Task<string> Swap(Guid id, string clientA, string clientB, string coinA, string coinB, decimal amountA, decimal amountB, string signAHex,
        //    string signBHex)
        //{
        //    var web3 = new Web3(_settings.EthereumUrl);

        //    await web3.Personal.UnlockAccount.SendRequestAsync(_settings.EthereumMainAccount, _settings.EthereumMainAccountPassword, new HexBigInteger(120));

        //    var contract = web3.Eth.GetContract(_settings.MainExchangeContract.Abi, _settings.MainExchangeContract.Address);

        //    var coinAFromDb = await _coinRepository.GetCoin(coinA);
        //    var coinBFromDb = await _coinRepository.GetCoin(coinB);

        //    var convertedAmountA = amountA.ToBlockchainAmount(coinAFromDb.Multiplier);
        //    var convertedAmountB = amountB.ToBlockchainAmount(coinBFromDb.Multiplier);

        //    var convertedId = EthUtils.GuidToBigInteger(id);

        //    var swap = contract.GetFunction("swap");
        //    var tr = await swap.SendTransactionAsync(_settings.EthereumMainAccount, new HexBigInteger(Constants.GasForCoinTransaction), new HexBigInteger(0),
        //            convertedId, clientA, clientB, coinAFromDb.AdapterAddress, coinBFromDb.AdapterAddress, convertedAmountA, convertedAmountB, signAHex.HexToByteArray().FixByteOrder(), signBHex.HexToByteArray().FixByteOrder(), new byte[0]);
        //    await _cointTransactionService.PutTransactionToQueue(tr);
        //    return tr;
        //}
        public async Task <OperationEstimationResult> EstimateCashoutGas(Guid id, string coinAdapterAddress, string fromAddress, string toAddress, BigInteger amount, string sign)
        {
            var coinAFromDb = await GetCoinWithCheck(coinAdapterAddress);

            if (string.IsNullOrEmpty(sign))
            {
                sign = await GetSign(id, coinAdapterAddress, fromAddress, toAddress, amount);
            }

            ThrowOnWrongSignature(id, coinAdapterAddress, fromAddress, toAddress, amount, sign);

            var contract    = _web3.Eth.GetContract(_settings.MainExchangeContract.Abi, _settings.MainExchangeContract.Address);
            var cashout     = contract.GetFunction("cashout");
            var convertedId = EthUtils.GuidToBigInteger(id);
            //ACTION
            var estimatedGasForOperation = await cashout.EstimateGasAsync(_settings.EthereumMainAccount,
                                                                          new HexBigInteger(Constants.GasForCoinTransaction), new HexBigInteger(0), convertedId, coinAFromDb.AdapterAddress, fromAddress, toAddress, amount, sign.HexToByteArray().FixByteOrder(), new byte[0]);

            return(new OperationEstimationResult()
            {
                GasAmount = estimatedGasForOperation.Value,
                IsAllowed = estimatedGasForOperation.Value < Constants.GasForCoinTransaction
            });
        }