From 1dea821af3b0969082ca353f8611afc3fb9c4598 Mon Sep 17 00:00:00 2001 From: Alexey Date: Thu, 3 Oct 2019 21:42:48 +0300 Subject: [PATCH] uniswap integration --- contracts/ERC20Mixer.sol | 44 ++++++++-- contracts/IUniswapExchange.sol | 70 ++++++++++++++++ contracts/Mocks/UniswapMock.sol | 67 +++++++++++++++ migrations/5_deploy_erc20_mixer.js | 21 +++-- test/GSNsupport.test.js | 128 ++++++++++++++++++++++++++++- 5 files changed, 316 insertions(+), 14 deletions(-) create mode 100644 contracts/IUniswapExchange.sol create mode 100644 contracts/Mocks/UniswapMock.sol diff --git a/contracts/ERC20Mixer.sol b/contracts/ERC20Mixer.sol index 8a815c5..8d30bbf 100644 --- a/contracts/ERC20Mixer.sol +++ b/contracts/ERC20Mixer.sol @@ -11,12 +11,15 @@ pragma solidity ^0.5.8; -import "./Mixer.sol"; +import "./GSNMixer.sol"; +import "./IUniswapExchange.sol"; +import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; -contract ERC20Mixer is Mixer { +contract ERC20Mixer is GSNMixer { address public token; // ether value to cover network fee (for relayer) and to have some ETH on a brand new address uint256 public userEther; + IUniswapExchange public uniswap; constructor( address _verifier, @@ -25,10 +28,13 @@ contract ERC20Mixer is Mixer { uint256 _emptyElement, address payable _operator, address _token, - uint256 _mixDenomination - ) Mixer(_verifier, _mixDenomination, _merkleTreeHeight, _emptyElement, _operator) public { + uint256 _mixDenomination, + IUniswapExchange _uniswap + ) GSNMixer(_verifier, _mixDenomination, _merkleTreeHeight, _emptyElement, _operator) public { token = _token; userEther = _userEther; + uniswap = _uniswap; + ERC20(token).approve(address(uniswap), 2**256 - 1); } function _processDeposit() internal { @@ -45,6 +51,32 @@ contract ERC20Mixer is Mixer { } } + // this func is called by RelayerHub right after calling a target func + function postRelayedCall(bytes memory context, bool /*success*/, uint actualCharge, bytes32 /*preRetVal*/) public onlyHub { + // this require allows to protect againt malicious relay hub that can drain the mixer + require(couldBeWithdrawn, "could be called only after withdrawViaRelayer"); + couldBeWithdrawn = false; + + IRelayHub relayHub = IRelayHub(getHubAddr()); + address payable recipient; + uint256 nullifierHash; + assembly { + recipient := mload(add(context, 32)) + nullifierHash := mload(add(context, 64)) + } + + uint256 tokensToSell = uniswap.getTokenToEthOutputPrice(actualCharge); + // require(tokensToSell <= mixDenomination, "price is too high"); + + // tokensToSell = tokensToSell.add(tokensToSell.div(50)); // add 2% slippage + uint256 actualSold = uniswap.tokenToEthSwapOutput(actualCharge, tokensToSell, now); + //require(actualSold == tokensToSell, "uniswap lies about its prices"); + + safeErc20Transfer(recipient, mixDenomination - actualSold); + relayHub.depositFor.value(actualCharge)(address(this)); + emit Withdraw(recipient, nullifierHash, tx.origin, actualCharge); + } + function safeErc20TransferFrom(address from, address to, uint256 amount) internal { bool success; bytes memory data; @@ -62,7 +94,7 @@ contract ERC20Mixer is Mixer { assembly { success := mload(add(data, 0x20)) } - require(success, "not enough allowed tokens"); + require(success, "not enough allowed tokens. Token returns false."); } } @@ -83,7 +115,7 @@ contract ERC20Mixer is Mixer { assembly { success := mload(add(data, 0x20)) } - require(success, "not enough tokens"); + require(success, "not enough tokens. Token returns false."); } } } diff --git a/contracts/IUniswapExchange.sol b/contracts/IUniswapExchange.sol new file mode 100644 index 0000000..c926e12 --- /dev/null +++ b/contracts/IUniswapExchange.sol @@ -0,0 +1,70 @@ +pragma solidity ^0.5.0; + +contract IUniswapExchange { + // Address of ERC20 token sold on this excha + function tokenAddress() external view returns (address token) {} + // Address of Uniswap Factory + function factoryAddress() external view returns (address factory) {} + // Provide Liquidity + function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256) {} + + function removeLiquidity(uint256 amount, uint256 min_eth, uint256 min_tokens, uint256 deadline) external returns (uint256, uint256) {} + // Get Prices + function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought) {} + + function getEthToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256 eth_sold) {} + + function getTokenToEthInputPrice(uint256 tokens_sold) external view returns (uint256 eth_bought) {} + + function getTokenToEthOutputPrice(uint256 eth_bought) external view returns (uint256 tokens_sold) {} + // Trade ETH to ERC20 + function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought) {} + + function ethToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns (uint256 tokens_bought) {} + + function ethToTokenSwapOutput(uint256 tokens_bought, uint256 deadline) external payable returns (uint256 eth_sold) {} + + function ethToTokenTransferOutput(uint256 tokens_bought, uint256 deadline, address recipient) external payable returns (uint256 eth_sold) {} + // Trade ERC20 to ETH + function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought) {} + + function tokenToEthTransferInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline, address recipient) external returns (uint256 eth_bought) {} + + function tokenToEthSwapOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline) external returns (uint256 tokens_sold) {} + + function tokenToEthTransferOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline, address recipient) external returns (uint256 tokens_sold) {} + // Trade ERC20 to ERC20 + function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought) {} + + function tokenToTokenTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_bought) {} + + function tokenToTokenSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address token_addr) external returns (uint256 tokens_sold) {} + + function tokenToTokenTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_sold) {} + // Trade ERC20 to Custom Pool + function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought) {} + + function tokenToExchangeTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_bought) {} + + function tokenToExchangeSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address exchange_addr) external returns (uint256 tokens_sold) {} + + function tokenToExchangeTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_sold) {} + // ERC20 comaptibility for liquidity tokens + bytes32 public name; + bytes32 public symbol; + uint256 public decimals; + + function transfer(address _to, uint256 _value) external returns (bool) {} + + function transferFrom(address _from, address _to, uint256 value) external returns (bool) {} + + function approve(address _spender, uint256 _value) external returns (bool) {} + + function allowance(address _owner, address _spender) external view returns (uint256) {} + + function balanceOf(address _owner) external view returns (uint256) {} + + function totalSupply() external view returns (uint256) {} + // Never use + function setup(address token_addr) external {} +} diff --git a/contracts/Mocks/UniswapMock.sol b/contracts/Mocks/UniswapMock.sol new file mode 100644 index 0000000..df04fbf --- /dev/null +++ b/contracts/Mocks/UniswapMock.sol @@ -0,0 +1,67 @@ +pragma solidity ^0.5.0; + +import "./ERC20Mock.sol"; +import "../IUniswapExchange.sol"; + +contract UniswapMock is IUniswapExchange { + + ERC20Mock public token; + uint256 public price; + + // EthPurchase: event({buyer: indexed(address), tokens_sold: indexed(uint256), eth_bought: indexed(uint256(wei))}) + event EthPurchase(address buyer, uint256 tokens_sold, uint256 eth_bought); + + constructor(ERC20Mock _token, uint256 _price) public payable { + token = _token; + price = _price; // in wei + } + + + /* + * @notice Convert Tokens to ETH. + * @dev User specifies maximum input and exact output. + * @param eth_bought Amount of ETH purchased. + * @param max_tokens Maximum Tokens sold. + * @param deadline Time after which this transaction can no longer be executed. + * @return Amount of Tokens sold. + * @public + * def tokenToEthSwapOutput(eth_bought: uint256(wei), max_tokens: uint256, deadline: timestamp) -> uint256: + */ + function tokenToEthSwapOutput(uint256 eth_bought, uint256 /*max_tokens*/, uint256 /*deadline*/) public returns(uint256 tokens_sold) { + tokens_sold = getTokenToEthOutputPrice(eth_bought); + token.transferFrom(msg.sender, address(this), tokens_sold); + msg.sender.transfer(eth_bought); + emit EthPurchase(msg.sender, tokens_sold, eth_bought); + return eth_bought; + } + + function getTokenToEthOutputPrice(uint256 eth_bought) public view returns (uint256) { + return eth_bought * price / 10**18; + } + + // /* + // * @notice Convert Tokens to ETH. + // * @dev User specifies exact input and minimum output. + // * @param tokens_sold Amount of Tokens sold. + // * @param min_eth Minimum ETH purchased. + // * @param deadline Time after which this transaction can no longer be executed. + // * @return Amount of ETH bought. + // * def tokenToEthSwapInput(tokens_sold: uint256, min_eth: uint256(wei), deadline: timestamp) -> uint256(wei): + // */ + // function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) public returns(uint256) { + // token.transferFrom(msg.sender, address(this), tokens_sold); + // uint256 eth_bought = getTokenToEthInputPrice(tokens_sold); + // msg.sender.transfer(eth_bought); + // return eth_bought; + // } + + // function getTokenToEthInputPrice(uint256 tokens_sold /* in wei */) public view returns (uint256 eth_bought) { + // return tokens_sold * price / 10**18; + // } + + function setPrice(uint256 _price) external { + price = _price; + } + + function() external payable {} +} diff --git a/migrations/5_deploy_erc20_mixer.js b/migrations/5_deploy_erc20_mixer.js index 8ee907c..ae98781 100644 --- a/migrations/5_deploy_erc20_mixer.js +++ b/migrations/5_deploy_erc20_mixer.js @@ -4,6 +4,9 @@ const ERC20Mixer = artifacts.require('ERC20Mixer') const Verifier = artifacts.require('Verifier') const MiMC = artifacts.require('MiMC') const ERC20Mock = artifacts.require('ERC20Mock') +const UniswapMock = artifacts.require('UniswapMock') +const { toBN, toWei } = require('web3-utils') +const eth2daiPrice = toBN('174552286079977583324') // cause 1 ETH == 174.55 DAI module.exports = function(deployer, network, accounts) { @@ -12,10 +15,15 @@ module.exports = function(deployer, network, accounts) { const verifier = await Verifier.deployed() const miMC = await MiMC.deployed() await ERC20Mixer.link(MiMC, miMC.address) - let token = ERC20_TOKEN - if(token === '') { - const tokenInstance = await deployer.deploy(ERC20Mock) - token = tokenInstance.address + let tokenAddress = ERC20_TOKEN + let uniswapAddress + if (network === 'development') { + if(tokenAddress === '') { // means we want to test with mock + const tokenInstance = await deployer.deploy(ERC20Mock) + tokenAddress = tokenInstance.address + } + const uniswap = await deployer.deploy(UniswapMock, tokenAddress, eth2daiPrice, { value: toWei('0.5') }) + uniswapAddress = uniswap.address } const mixer = await deployer.deploy( ERC20Mixer, @@ -24,8 +32,9 @@ module.exports = function(deployer, network, accounts) { MERKLE_TREE_HEIGHT, EMPTY_ELEMENT, accounts[0], - token, - TOKEN_AMOUNT + tokenAddress, + TOKEN_AMOUNT, + uniswapAddress ) console.log('ERC20Mixer\'s address ', mixer.address) }) diff --git a/test/GSNsupport.test.js b/test/GSNsupport.test.js index 69f0e5f..b96e8fa 100644 --- a/test/GSNsupport.test.js +++ b/test/GSNsupport.test.js @@ -6,15 +6,18 @@ require('chai') const fs = require('fs') const Web3 = require('web3') -const { toBN, toHex, toChecksumAddress, toWei } = require('web3-utils') +const { toBN, toHex, toChecksumAddress, toWei, fromWei } = require('web3-utils') const { takeSnapshot, revertSnapshot } = require('../lib/ganacheHelper') const { deployRelayHub, fundRecipient } = require('@openzeppelin/gsn-helpers') const { GSNDevProvider, GSNProvider, utils } = require('@openzeppelin/gsn-provider') const { ephemeral } = require('@openzeppelin/network') const Mixer = artifacts.require('./ETHMixer.sol') +const ERC20Mixer = artifacts.require('./ERC20Mixer.sol') const RelayHub = artifacts.require('./IRelayHub.sol') -const { ETH_AMOUNT, MERKLE_TREE_HEIGHT, EMPTY_ELEMENT } = process.env +const Token = artifacts.require('./ERC20Mock.sol') +const Uniswap = artifacts.require('./UniswapMock.sol') +const { ETH_AMOUNT, MERKLE_TREE_HEIGHT, EMPTY_ELEMENT, ERC20_TOKEN, TOKEN_AMOUNT } = process.env const websnarkUtils = require('websnark/src/utils') const buildGroth16 = require('websnark/src/groth16') @@ -48,16 +51,21 @@ function getRandomReceiver() { contract('GSN support', accounts => { let mixer + let ercMixer let gsnMixer let hubInstance let relayHubAddress + let token + let uniswap const sender = accounts[0] const operator = accounts[0] + const user = accounts[3] const relayerOwnerAddress = accounts[8] const relayerAddress = accounts[9]// '0x714992E1acbc7f888Be2A1784F0D23e73f4A1ead' const levels = MERKLE_TREE_HEIGHT || 16 const zeroValue = EMPTY_ELEMENT || 1337 const value = ETH_AMOUNT || '1000000000000000000' // 1 ether + let tokenDenomination = TOKEN_AMOUNT || '1000000000000000000' // 1 ether let snapshotId let prefix = 'test' let tree @@ -73,6 +81,10 @@ contract('GSN support', accounts => { const postRelayedCallMaxGas = 100000 const recipientCallsAtomicOverhead = 5000 let postRelayMaxGas = toBN(postRelayedCallMaxGas + recipientCallsAtomicOverhead) + // this price is for tokenToEthSwapInput stategy + // const eth2daiPriceInput = toBN(toWei('1')).mul(toBN(10e18)).div(toBN('174552286079977583324')) // cause 1 ETH == 174.55 DAI + // this price is for tokenToEthSwapOutput stategy + const eth2daiPrice = toBN('174552286079977583324') // cause 1 ETH == 174.55 DAI before(async () => { tree = new MerkleTree( @@ -82,12 +94,15 @@ contract('GSN support', accounts => { prefix, ) mixer = await Mixer.deployed() + ercMixer = await ERC20Mixer.deployed() relayHubAddress = toChecksumAddress(await deployRelayHub(web3, { from: sender })) await fundRecipient(web3, { recipient: mixer.address, relayHubAddress }) + await fundRecipient(web3, { recipient: ercMixer.address, relayHubAddress }) const currentHub = await mixer.getHubAddr() + await ercMixer.upgradeRelayHub(relayHubAddress) if (relayHubAddress !== currentHub) { await mixer.upgradeRelayHub(relayHubAddress) } @@ -95,6 +110,15 @@ contract('GSN support', accounts => { await hubInstance.stake(relayerAddress, unstakeDelay , { from: relayerOwnerAddress, value: toWei('1') }) await hubInstance.registerRelay(relayerTxFee, 'http://gsn-dev-relayer.openzeppelin.com/', { from: relayerAddress }) + if (ERC20_TOKEN) { + token = await Token.at(ERC20_TOKEN) + // uniswap = await Uniswap.at() + } else { + token = await Token.deployed() + await token.mint(user, tokenDenomination) + uniswap = await Uniswap.deployed() + } + snapshotId = await takeSnapshot() groth16 = await buildGroth16() circuit = require('../build/circuits/withdraw.json') @@ -280,6 +304,106 @@ contract('GSN support', accounts => { }) console.log('tx succeed', tx.status) }) + + it('uniswap mock test', async () => { + const valueToBuy = toBN(toWei('0.04')) + await token.approve(uniswap.address, tokenDenomination, { from: user, gasPrice: 0 }) + const tokens = await uniswap.getTokenToEthOutputPrice(valueToBuy) + const balanceBefore = await web3.eth.getBalance(user) + const tokenBalanceBefore = await token.balanceOf(user) + await uniswap.tokenToEthSwapOutput(valueToBuy, 1, 2, { from: user, gasPrice: 0 }) + const balanceAfter = await web3.eth.getBalance(user) + const tokenBalanceAfter = await token.balanceOf(user) + balanceBefore.should.be.eq.BN(toBN(balanceAfter).sub(valueToBuy)) + tokenBalanceBefore.should.be.eq.BN(toBN(tokenBalanceAfter).add(toBN(tokens))) + valueToBuy.mul(eth2daiPrice).div(toBN(toWei('1'))).should.be.eq.BN(tokens) + }) + + it.only('should work for token', async () => { + const gasPrice = toBN('1') + const deposit = generateDeposit() + const user = accounts[4] + await tree.insert(deposit.commitment) + + await token.mint(user, tokenDenomination) + await token.approve(ercMixer.address, tokenDenomination, { from: user }) + await ercMixer.deposit(toBN(deposit.commitment.toString()), { value, from: user, gasPrice }) + + const { root, path_elements, path_index } = await tree.path(0) + + // Circuit input + const input = stringifyBigInts({ + // public + root, + nullifierHash: pedersenHash(deposit.nullifier.leInt2Buff(31)), + receiver, + relayer: operator, // this value wont be taken into account + fee: bigInt(1), // this value wont be taken into account + + // private + nullifier: deposit.nullifier, + secret: deposit.secret, + pathElements: path_elements, + pathIndex: path_index, + }) + + + const proof = await websnarkUtils.genWitnessAndProve(groth16, input, circuit, proving_key) + const { pi_a, pi_b, pi_c, publicSignals } = websnarkUtils.toSolidityInput(proof) + + const balanceMixerBefore = await web3.eth.getBalance(ercMixer.address) + const balanceHubBefore = await web3.eth.getBalance(relayHubAddress) + const balanceRelayerBefore = await web3.eth.getBalance(relayerAddress) + const balanceRelayerOwnerBefore = await web3.eth.getBalance(relayerOwnerAddress) + const balanceRecieverBefore = await web3.eth.getBalance(toHex(receiver.toString())) + + gsnProvider = new GSNDevProvider('http://localhost:8545', { + signKey, + relayerOwner: relayerOwnerAddress, + relayerAddress, + verbose: true, + txFee: relayerTxFee + }) + gsnWeb3 = new Web3(gsnProvider, null, { transactionConfirmationBlocks: 1 }) + gsnMixer = new gsnWeb3.eth.Contract(ercMixer.abi, ercMixer.address) + + const tx = await gsnMixer.methods.withdrawViaRelayer(pi_a, pi_b, pi_c, publicSignals).send({ + from: signKey.address, + gas: 3e6, + gasPrice, + value: 0 + }) + console.log('tx', tx) + const { gasUsed } = tx + const balanceMixerAfter = await web3.eth.getBalance(ercMixer.address) + const balanceHubAfter = await web3.eth.getBalance(relayHubAddress) + const balanceRelayerAfter = await web3.eth.getBalance(relayerAddress) + const balanceRelayerOwnerAfter = await web3.eth.getBalance(relayerOwnerAddress) + const balanceRecieverAfter = await web3.eth.getBalance(toHex(receiver.toString())) + // console.log('balanceMixerBefore, balanceMixerAfter', balanceMixerBefore.toString(), balanceMixerAfter.toString()) + // console.log('balanceRecieverBefore, balanceRecieverAfter', balanceRecieverBefore.toString(), balanceRecieverAfter.toString()) + // console.log('balanceHubBefore, balanceHubAfter', balanceHubBefore.toString(), balanceHubAfter.toString()) + // console.log('balanceRelayerBefore, balanceRelayerAfter', balanceRelayerBefore.toString(), balanceRelayerAfter.toString(), toBN(balanceRelayerBefore).sub(toBN(balanceRelayerAfter)).toString()) + // console.log('balanceRelayerOwnerBefore, balanceRelayerOwnerAfter', balanceRelayerOwnerBefore.toString(), balanceRelayerOwnerAfter.toString()) + balanceMixerAfter.should.be.eq.BN(toBN(balanceMixerBefore).sub(toBN(value))) + const networkFee = toBN(gasUsed).mul(gasPrice) + const chargedFee = networkFee.add(networkFee.div(toBN(relayerTxFee))) + // console.log('networkFee :', networkFee.toString()) + // console.log('calculated chargedFee :', chargedFee.toString()) + const actualFee = toBN(value).sub(toBN(balanceRecieverAfter)) + // console.log('actual fee :', actualFee.toString()) + // const postRelayMaxCost = postRelayMaxGas.mul(gasPrice) + // const actualFeeWithoutPostCall = actualFee.sub(postRelayMaxCost) + // console.log('actualFeeWithoutPostCall :', actualFeeWithoutPostCall.toString()) + networkFee.should.be.lt.BN(chargedFee) + chargedFee.should.be.lt.BN(actualFee) + + balanceRelayerAfter.should.be.eq.BN(toBN(balanceRelayerBefore).sub(networkFee)) + balanceRelayerOwnerAfter.should.be.eq.BN(toBN(balanceRelayerOwnerBefore)) + balanceRecieverAfter.should.be.gt.BN(toBN(balanceRecieverBefore)) + balanceRecieverAfter.should.be.lt.BN(toBN(value).sub(chargedFee)) + balanceHubAfter.should.be.eq.BN(toBN(balanceHubBefore).add(actualFee)) + }) }) afterEach(async () => {