import { makeSuite, TestEnv } from './helpers/make-suite'; import { convertToCurrencyDecimals, getContract, buildPermitParams, getSignatureFromTypedData, buildLiquiditySwapParams, } from '../../helpers/contracts-helpers'; import { getMockUniswapRouter } from '../../helpers/contracts-getters'; import { deployUniswapLiquiditySwapAdapter } from '../../helpers/contracts-deployments'; import { MockUniswapV2Router02 } from '../../types/MockUniswapV2Router02'; import { Zero } from '@ethersproject/constants'; import BigNumber from 'bignumber.js'; import { DRE, evmRevert, evmSnapshot } from '../../helpers/misc-utils'; import { ethers } from 'ethers'; import { eContractid } from '../../helpers/types'; import { AToken } from '../../types/AToken'; import { BUIDLEREVM_CHAINID } from '../../helpers/buidler-constants'; import { MAX_UINT_AMOUNT } from '../../helpers/constants'; const { parseEther } = ethers.utils; const { expect } = require('chai'); makeSuite('Uniswap adapters', (testEnv: TestEnv) => { let mockUniswapRouter: MockUniswapV2Router02; let evmSnapshotId: string; before(async () => { mockUniswapRouter = await getMockUniswapRouter(); }); beforeEach(async () => { evmSnapshotId = await evmSnapshot(); }); afterEach(async () => { await evmRevert(evmSnapshotId); }); describe('UniswapLiquiditySwapAdapter', () => { describe('constructor', () => { it('should deploy with correct parameters', async () => { const { addressesProvider, weth } = testEnv; await deployUniswapLiquiditySwapAdapter([ addressesProvider.address, mockUniswapRouter.address, weth.address, ]); }); it('should revert if not valid addresses provider', async () => { const { weth } = testEnv; expect( deployUniswapLiquiditySwapAdapter([ mockUniswapRouter.address, mockUniswapRouter.address, weth.address, ]) ).to.be.reverted; }); }); describe('executeOperation', () => { beforeEach(async () => { const { users, weth, dai, usdc, pool, deployer } = testEnv; const userAddress = users[0].address; // Provide liquidity await dai.mint(parseEther('20000')); await dai.approve(pool.address, parseEther('20000')); await pool.deposit(dai.address, parseEther('20000'), deployer.address, 0); const usdcAmount = await convertToCurrencyDecimals(usdc.address, '10'); await usdc.mint(usdcAmount); await usdc.approve(pool.address, usdcAmount); await pool.deposit(usdc.address, usdcAmount, deployer.address, 0); // Make a deposit for user await weth.mint(parseEther('100')); await weth.approve(pool.address, parseEther('100')); await pool.deposit(weth.address, parseEther('100'), userAddress, 0); }); it('should correctly swap tokens and deposit the out tokens in the pool', async () => { const { users, weth, oracle, dai, aDai, aWETH, pool, uniswapLiquiditySwapAdapter, } = testEnv; const user = users[0].signer; const userAddress = users[0].address; const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmount = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); await mockUniswapRouter.setAmountToReturn(weth.address, expectedDaiAmount); // User will swap liquidity 10 aEth to aDai const liquidityToSwap = parseEther('10'); await aWETH.connect(user).approve(uniswapLiquiditySwapAdapter.address, liquidityToSwap); const userAEthBalanceBefore = await aWETH.balanceOf(userAddress); // Subtract the FL fee from the amount to be swapped 0,09% const flashloanAmount = new BigNumber(liquidityToSwap.toString()).div(1.0009).toFixed(0); const params = buildLiquiditySwapParams( [dai.address], [expectedDaiAmount], [0], [0], [0], [0], ['0x0000000000000000000000000000000000000000000000000000000000000000'], ['0x0000000000000000000000000000000000000000000000000000000000000000'], [false] ); await expect( pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [weth.address], [flashloanAmount.toString()], [0], userAddress, params, 0 ) ) .to.emit(uniswapLiquiditySwapAdapter, 'Swapped') .withArgs(weth.address, dai.address, flashloanAmount.toString(), expectedDaiAmount); const adapterWethBalance = await weth.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiBalance = await dai.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiAllowance = await dai.allowance( uniswapLiquiditySwapAdapter.address, userAddress ); const userADaiBalance = await aDai.balanceOf(userAddress); const userAEthBalance = await aWETH.balanceOf(userAddress); expect(adapterWethBalance).to.be.eq(Zero); expect(adapterDaiBalance).to.be.eq(Zero); expect(adapterDaiAllowance).to.be.eq(Zero); expect(userADaiBalance).to.be.eq(expectedDaiAmount); expect(userAEthBalance).to.be.lt(userAEthBalanceBefore); expect(userAEthBalance).to.be.gte(userAEthBalanceBefore.sub(liquidityToSwap)); }); it('should correctly swap and deposit multiple tokens', async () => { const { users, weth, oracle, dai, aDai, aWETH, usdc, pool, uniswapLiquiditySwapAdapter, } = testEnv; const user = users[0].signer; const userAddress = users[0].address; const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmountForEth = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); const amountUSDCtoSwap = await convertToCurrencyDecimals(usdc.address, '10'); const usdcPrice = await oracle.getAssetPrice(usdc.address); const collateralDecimals = (await usdc.decimals()).toString(); const principalDecimals = (await dai.decimals()).toString(); const expectedDaiAmountForUsdc = new BigNumber(amountUSDCtoSwap.toString()) .times( new BigNumber(usdcPrice.toString()).times(new BigNumber(10).pow(principalDecimals)) ) .div(new BigNumber(daiPrice.toString()).times(new BigNumber(10).pow(collateralDecimals))) .toFixed(0); // Make a deposit for user await usdc.connect(user).mint(amountUSDCtoSwap); await usdc.connect(user).approve(pool.address, amountUSDCtoSwap); await pool.connect(user).deposit(usdc.address, amountUSDCtoSwap, userAddress, 0); const aUsdcData = await pool.getReserveData(usdc.address); const aUsdc = await getContract(eContractid.AToken, aUsdcData.aTokenAddress); await mockUniswapRouter.setAmountToReturn(weth.address, expectedDaiAmountForEth); await mockUniswapRouter.setAmountToReturn(usdc.address, expectedDaiAmountForUsdc); await aWETH.connect(user).approve(uniswapLiquiditySwapAdapter.address, amountWETHtoSwap); const userAEthBalanceBefore = await aWETH.balanceOf(userAddress); await aUsdc.connect(user).approve(uniswapLiquiditySwapAdapter.address, amountUSDCtoSwap); const userAUsdcBalanceBefore = await aUsdc.balanceOf(userAddress); // Subtract the FL fee from the amount to be swapped 0,09% const wethFlashloanAmount = new BigNumber(amountWETHtoSwap.toString()) .div(1.0009) .toFixed(0); const usdcFlashloanAmount = new BigNumber(amountUSDCtoSwap.toString()) .div(1.0009) .toFixed(0); const params = buildLiquiditySwapParams( [dai.address, dai.address], [expectedDaiAmountForEth, expectedDaiAmountForUsdc], [0, 0], [0, 0], [0, 0], [0, 0], [ '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000', ], [ '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000', ], [false, false] ); await pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [weth.address, usdc.address], [wethFlashloanAmount.toString(), usdcFlashloanAmount.toString()], [0, 0], userAddress, params, 0 ); const adapterWethBalance = await weth.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiBalance = await dai.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiAllowance = await dai.allowance( uniswapLiquiditySwapAdapter.address, userAddress ); const userADaiBalance = await aDai.balanceOf(userAddress); const userAEthBalance = await aWETH.balanceOf(userAddress); const userAUsdcBalance = await aUsdc.balanceOf(userAddress); expect(adapterWethBalance).to.be.eq(Zero); expect(adapterDaiBalance).to.be.eq(Zero); expect(adapterDaiAllowance).to.be.eq(Zero); expect(userADaiBalance).to.be.eq(expectedDaiAmountForEth.add(expectedDaiAmountForUsdc)); expect(userAEthBalance).to.be.lt(userAEthBalanceBefore); expect(userAEthBalance).to.be.gte(userAEthBalanceBefore.sub(amountWETHtoSwap)); expect(userAUsdcBalance).to.be.lt(userAUsdcBalanceBefore); expect(userAUsdcBalance).to.be.gte(userAUsdcBalanceBefore.sub(amountUSDCtoSwap)); }); it('should correctly swap and deposit multiple tokens using permit', async () => { const { users, weth, oracle, dai, aDai, aWETH, usdc, pool, uniswapLiquiditySwapAdapter, } = testEnv; const user = users[0].signer; const userAddress = users[0].address; const chainId = DRE.network.config.chainId || BUIDLEREVM_CHAINID; const deadline = MAX_UINT_AMOUNT; const ownerPrivateKey = require('../../test-wallets.js').accounts[1].secretKey; if (!ownerPrivateKey) { throw new Error('INVALID_OWNER_PK'); } const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmountForEth = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); const amountUSDCtoSwap = await convertToCurrencyDecimals(usdc.address, '10'); const usdcPrice = await oracle.getAssetPrice(usdc.address); const collateralDecimals = (await usdc.decimals()).toString(); const principalDecimals = (await dai.decimals()).toString(); const expectedDaiAmountForUsdc = new BigNumber(amountUSDCtoSwap.toString()) .times( new BigNumber(usdcPrice.toString()).times(new BigNumber(10).pow(principalDecimals)) ) .div(new BigNumber(daiPrice.toString()).times(new BigNumber(10).pow(collateralDecimals))) .toFixed(0); // Make a deposit for user await usdc.connect(user).mint(amountUSDCtoSwap); await usdc.connect(user).approve(pool.address, amountUSDCtoSwap); await pool.connect(user).deposit(usdc.address, amountUSDCtoSwap, userAddress, 0); const aUsdcData = await pool.getReserveData(usdc.address); const aUsdc = await getContract(eContractid.AToken, aUsdcData.aTokenAddress); await mockUniswapRouter.setAmountToReturn(weth.address, expectedDaiAmountForEth); await mockUniswapRouter.setAmountToReturn(usdc.address, expectedDaiAmountForUsdc); const userAEthBalanceBefore = await aWETH.balanceOf(userAddress); const userAUsdcBalanceBefore = await aUsdc.balanceOf(userAddress); const wethFlashloanAmount = new BigNumber(amountWETHtoSwap.toString()) .div(1.0009) .toFixed(0); const usdcFlashloanAmount = new BigNumber(amountUSDCtoSwap.toString()) .div(1.0009) .toFixed(0); const aWethNonce = (await aWETH._nonces(userAddress)).toNumber(); const aWethMsgParams = buildPermitParams( chainId, aWETH.address, '1', await aWETH.name(), userAddress, uniswapLiquiditySwapAdapter.address, aWethNonce, deadline, amountWETHtoSwap.toString() ); const { v: aWETHv, r: aWETHr, s: aWETHs } = getSignatureFromTypedData( ownerPrivateKey, aWethMsgParams ); const aUsdcNonce = (await aUsdc._nonces(userAddress)).toNumber(); const aUsdcMsgParams = buildPermitParams( chainId, aUsdc.address, '1', await aUsdc.name(), userAddress, uniswapLiquiditySwapAdapter.address, aUsdcNonce, deadline, amountUSDCtoSwap.toString() ); const { v: aUsdcv, r: aUsdcr, s: aUsdcs } = getSignatureFromTypedData( ownerPrivateKey, aUsdcMsgParams ); const params = buildLiquiditySwapParams( [dai.address, dai.address], [expectedDaiAmountForEth, expectedDaiAmountForUsdc], [0, 0], [amountWETHtoSwap, amountUSDCtoSwap], [deadline, deadline], [aWETHv, aUsdcv], [aWETHr, aUsdcr], [aWETHs, aUsdcs], [false, false] ); await pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [weth.address, usdc.address], [wethFlashloanAmount.toString(), usdcFlashloanAmount.toString()], [0, 0], userAddress, params, 0 ); const adapterWethBalance = await weth.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiBalance = await dai.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiAllowance = await dai.allowance( uniswapLiquiditySwapAdapter.address, userAddress ); const userADaiBalance = await aDai.balanceOf(userAddress); const userAEthBalance = await aWETH.balanceOf(userAddress); const userAUsdcBalance = await aUsdc.balanceOf(userAddress); expect(adapterWethBalance).to.be.eq(Zero); expect(adapterDaiBalance).to.be.eq(Zero); expect(adapterDaiAllowance).to.be.eq(Zero); expect(userADaiBalance).to.be.eq(expectedDaiAmountForEth.add(expectedDaiAmountForUsdc)); expect(userAEthBalance).to.be.lt(userAEthBalanceBefore); expect(userAEthBalance).to.be.gte(userAEthBalanceBefore.sub(amountWETHtoSwap)); expect(userAUsdcBalance).to.be.lt(userAUsdcBalanceBefore); expect(userAUsdcBalance).to.be.gte(userAUsdcBalanceBefore.sub(amountUSDCtoSwap)); }); it('should correctly swap tokens with permit', async () => { const { users, weth, oracle, dai, aDai, aWETH, pool, uniswapLiquiditySwapAdapter, } = testEnv; const user = users[0].signer; const userAddress = users[0].address; const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmount = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); await mockUniswapRouter.setAmountToReturn(weth.address, expectedDaiAmount); // User will swap liquidity 10 aEth to aDai const liquidityToSwap = parseEther('10'); const userAEthBalanceBefore = await aWETH.balanceOf(userAddress); // Subtract the FL fee from the amount to be swapped 0,09% const flashloanAmount = new BigNumber(liquidityToSwap.toString()).div(1.0009).toFixed(0); const chainId = DRE.network.config.chainId || BUIDLEREVM_CHAINID; const deadline = MAX_UINT_AMOUNT; const nonce = (await aWETH._nonces(userAddress)).toNumber(); const msgParams = buildPermitParams( chainId, aWETH.address, '1', await aWETH.name(), userAddress, uniswapLiquiditySwapAdapter.address, nonce, deadline, liquidityToSwap.toString() ); const ownerPrivateKey = require('../../test-wallets.js').accounts[1].secretKey; if (!ownerPrivateKey) { throw new Error('INVALID_OWNER_PK'); } const { v, r, s } = getSignatureFromTypedData(ownerPrivateKey, msgParams); const params = buildLiquiditySwapParams( [dai.address], [expectedDaiAmount], [0], [liquidityToSwap], [deadline], [v], [r], [s], [false] ); await expect( pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [weth.address], [flashloanAmount.toString()], [0], userAddress, params, 0 ) ) .to.emit(uniswapLiquiditySwapAdapter, 'Swapped') .withArgs(weth.address, dai.address, flashloanAmount.toString(), expectedDaiAmount); const adapterWethBalance = await weth.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiBalance = await dai.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiAllowance = await dai.allowance( uniswapLiquiditySwapAdapter.address, userAddress ); const userADaiBalance = await aDai.balanceOf(userAddress); const userAEthBalance = await aWETH.balanceOf(userAddress); expect(adapterWethBalance).to.be.eq(Zero); expect(adapterDaiBalance).to.be.eq(Zero); expect(adapterDaiAllowance).to.be.eq(Zero); expect(userADaiBalance).to.be.eq(expectedDaiAmount); expect(userAEthBalance).to.be.lt(userAEthBalanceBefore); expect(userAEthBalance).to.be.gte(userAEthBalanceBefore.sub(liquidityToSwap)); }); it('should revert if inconsistent params', async () => { const { users, weth, oracle, dai, aWETH, pool, uniswapLiquiditySwapAdapter } = testEnv; const user = users[0].signer; const userAddress = users[0].address; const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmount = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); await mockUniswapRouter.setAmountToReturn(weth.address, expectedDaiAmount); // User will swap liquidity 10 aEth to aDai const liquidityToSwap = parseEther('10'); await aWETH.connect(user).approve(uniswapLiquiditySwapAdapter.address, liquidityToSwap); // Subtract the FL fee from the amount to be swapped 0,09% const flashloanAmount = new BigNumber(liquidityToSwap.toString()).div(1.0009).toFixed(0); const params = buildLiquiditySwapParams( [dai.address, weth.address], [expectedDaiAmount], [0], [0], [0], [0], ['0x0000000000000000000000000000000000000000000000000000000000000000'], ['0x0000000000000000000000000000000000000000000000000000000000000000'], [false] ); await expect( pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [weth.address], [flashloanAmount.toString()], [0], userAddress, params, 0 ) ).to.be.revertedWith('INCONSISTENT_PARAMS'); const params2 = buildLiquiditySwapParams( [dai.address, weth.address], [expectedDaiAmount], [0, 0], [0, 0], [0, 0], [0], ['0x0000000000000000000000000000000000000000000000000000000000000000'], ['0x0000000000000000000000000000000000000000000000000000000000000000'], [false] ); await expect( pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [weth.address], [flashloanAmount.toString()], [0], userAddress, params2, 0 ) ).to.be.revertedWith('INCONSISTENT_PARAMS'); const params3 = buildLiquiditySwapParams( [dai.address, weth.address], [expectedDaiAmount], [0, 0], [0], [0, 0], [0, 0], ['0x0000000000000000000000000000000000000000000000000000000000000000'], ['0x0000000000000000000000000000000000000000000000000000000000000000'], [false] ); await expect( pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [weth.address], [flashloanAmount.toString()], [0], userAddress, params3, 0 ) ).to.be.revertedWith('INCONSISTENT_PARAMS'); const params4 = buildLiquiditySwapParams( [dai.address, weth.address], [expectedDaiAmount], [0], [0], [0], [0], [ '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000', ], ['0x0000000000000000000000000000000000000000000000000000000000000000'], [false] ); await expect( pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [weth.address], [flashloanAmount.toString()], [0], userAddress, params4, 0 ) ).to.be.revertedWith('INCONSISTENT_PARAMS'); const params5 = buildLiquiditySwapParams( [dai.address, weth.address], [expectedDaiAmount], [0], [0], [0], [0], ['0x0000000000000000000000000000000000000000000000000000000000000000'], [ '0x0000000000000000000000000000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000000000000000000000000000', ], [false] ); await expect( pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [weth.address], [flashloanAmount.toString()], [0], userAddress, params5, 0 ) ).to.be.revertedWith('INCONSISTENT_PARAMS'); const params6 = buildLiquiditySwapParams( [dai.address, weth.address], [expectedDaiAmount, expectedDaiAmount], [0], [0], [0], [0], ['0x0000000000000000000000000000000000000000000000000000000000000000'], ['0x0000000000000000000000000000000000000000000000000000000000000000'], [false] ); await expect( pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [weth.address], [flashloanAmount.toString()], [0], userAddress, params6, 0 ) ).to.be.revertedWith('INCONSISTENT_PARAMS'); const params7 = buildLiquiditySwapParams( [dai.address], [expectedDaiAmount], [0, 0], [0], [0], [0], ['0x0000000000000000000000000000000000000000000000000000000000000000'], ['0x0000000000000000000000000000000000000000000000000000000000000000'], [false] ); await expect( pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [weth.address], [flashloanAmount.toString()], [0], userAddress, params7, 0 ) ).to.be.revertedWith('INCONSISTENT_PARAMS'); const params8 = buildLiquiditySwapParams( [dai.address], [expectedDaiAmount], [0], [0, 0], [0], [0], ['0x0000000000000000000000000000000000000000000000000000000000000000'], ['0x0000000000000000000000000000000000000000000000000000000000000000'], [false] ); await expect( pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [weth.address], [flashloanAmount.toString()], [0], userAddress, params8, 0 ) ).to.be.revertedWith('INCONSISTENT_PARAMS'); const params9 = buildLiquiditySwapParams( [dai.address], [expectedDaiAmount], [0], [0], [0], [0], ['0x0000000000000000000000000000000000000000000000000000000000000000'], ['0x0000000000000000000000000000000000000000000000000000000000000000'], [false, false] ); await expect( pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [weth.address], [flashloanAmount.toString()], [0], userAddress, params9, 0 ) ).to.be.revertedWith('INCONSISTENT_PARAMS'); }); it('should revert if caller not lending pool', async () => { const { users, weth, oracle, dai, aWETH, uniswapLiquiditySwapAdapter } = testEnv; const user = users[0].signer; const userAddress = users[0].address; const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmount = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); await mockUniswapRouter.setAmountToReturn(weth.address, expectedDaiAmount); // User will swap liquidity 10 aEth to aDai const liquidityToSwap = parseEther('10'); await aWETH.connect(user).approve(uniswapLiquiditySwapAdapter.address, liquidityToSwap); // Subtract the FL fee from the amount to be swapped 0,09% const flashloanAmount = new BigNumber(liquidityToSwap.toString()).div(1.0009).toFixed(0); const params = buildLiquiditySwapParams( [dai.address], [expectedDaiAmount], [0], [0], [0], [0], ['0x0000000000000000000000000000000000000000000000000000000000000000'], ['0x0000000000000000000000000000000000000000000000000000000000000000'], [false] ); await expect( uniswapLiquiditySwapAdapter .connect(user) .executeOperation( [weth.address], [flashloanAmount.toString()], [0], userAddress, params ) ).to.be.revertedWith('CALLER_MUST_BE_LENDING_POOL'); }); it('should work correctly with tokens of different decimals', async () => { const { users, usdc, oracle, dai, aDai, uniswapLiquiditySwapAdapter, pool, deployer, } = testEnv; const user = users[0].signer; const userAddress = users[0].address; const amountUSDCtoSwap = await convertToCurrencyDecimals(usdc.address, '10'); const liquidity = await convertToCurrencyDecimals(usdc.address, '20000'); // Provide liquidity await usdc.mint(liquidity); await usdc.approve(pool.address, liquidity); await pool.deposit(usdc.address, liquidity, deployer.address, 0); // Make a deposit for user await usdc.connect(user).mint(amountUSDCtoSwap); await usdc.connect(user).approve(pool.address, amountUSDCtoSwap); await pool.connect(user).deposit(usdc.address, amountUSDCtoSwap, userAddress, 0); const usdcPrice = await oracle.getAssetPrice(usdc.address); const daiPrice = await oracle.getAssetPrice(dai.address); // usdc 6 const collateralDecimals = (await usdc.decimals()).toString(); const principalDecimals = (await dai.decimals()).toString(); const expectedDaiAmount = new BigNumber(amountUSDCtoSwap.toString()) .times( new BigNumber(usdcPrice.toString()).times(new BigNumber(10).pow(principalDecimals)) ) .div(new BigNumber(daiPrice.toString()).times(new BigNumber(10).pow(collateralDecimals))) .toFixed(0); await mockUniswapRouter.connect(user).setAmountToReturn(usdc.address, expectedDaiAmount); const aUsdcData = await pool.getReserveData(usdc.address); const aUsdc = await getContract(eContractid.AToken, aUsdcData.aTokenAddress); const aUsdcBalance = await aUsdc.balanceOf(userAddress); await aUsdc.connect(user).approve(uniswapLiquiditySwapAdapter.address, aUsdcBalance); // Subtract the FL fee from the amount to be swapped 0,09% const flashloanAmount = new BigNumber(amountUSDCtoSwap.toString()).div(1.0009).toFixed(0); const params = buildLiquiditySwapParams( [dai.address], [expectedDaiAmount], [0], [0], [0], [0], ['0x0000000000000000000000000000000000000000000000000000000000000000'], ['0x0000000000000000000000000000000000000000000000000000000000000000'], [false] ); await expect( pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [usdc.address], [flashloanAmount.toString()], [0], userAddress, params, 0 ) ) .to.emit(uniswapLiquiditySwapAdapter, 'Swapped') .withArgs(usdc.address, dai.address, flashloanAmount.toString(), expectedDaiAmount); const adapterUsdcBalance = await usdc.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiBalance = await dai.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiAllowance = await dai.allowance( uniswapLiquiditySwapAdapter.address, userAddress ); const aDaiBalance = await aDai.balanceOf(userAddress); expect(adapterUsdcBalance).to.be.eq(Zero); expect(adapterDaiBalance).to.be.eq(Zero); expect(adapterDaiAllowance).to.be.eq(Zero); expect(aDaiBalance).to.be.eq(expectedDaiAmount); }); it('should revert when min amount to receive exceeds the max slippage amount', async () => { const { users, weth, oracle, dai, aWETH, pool, uniswapLiquiditySwapAdapter } = testEnv; const user = users[0].signer; const userAddress = users[0].address; const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmount = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); await mockUniswapRouter.setAmountToReturn(weth.address, expectedDaiAmount); const smallExpectedDaiAmount = expectedDaiAmount.div(2); // User will swap liquidity 10 aEth to aDai const liquidityToSwap = parseEther('10'); await aWETH.connect(user).approve(uniswapLiquiditySwapAdapter.address, liquidityToSwap); // Subtract the FL fee from the amount to be swapped 0,09% const flashloanAmount = new BigNumber(liquidityToSwap.toString()).div(1.0009).toFixed(0); const params = buildLiquiditySwapParams( [dai.address], [smallExpectedDaiAmount], [0], [0], [0], [0], ['0x0000000000000000000000000000000000000000000000000000000000000000'], ['0x0000000000000000000000000000000000000000000000000000000000000000'], [false] ); await expect( pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [weth.address], [flashloanAmount.toString()], [0], userAddress, params, 0 ) ).to.be.revertedWith('minAmountOut exceed max slippage'); }); it('should correctly swap tokens all the balance', async () => { const { users, weth, oracle, dai, aDai, aWETH, pool, uniswapLiquiditySwapAdapter, } = testEnv; const user = users[0].signer; const userAddress = users[0].address; const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmount = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); await mockUniswapRouter.setAmountToReturn(weth.address, expectedDaiAmount); // Remove other balance await aWETH.connect(user).transfer(users[1].address, parseEther('90')); const userAEthBalanceBefore = await aWETH.balanceOf(userAddress); // User will swap liquidity 10 aEth to aDai const liquidityToSwap = parseEther('10'); expect(userAEthBalanceBefore).to.be.eq(liquidityToSwap); await aWETH.connect(user).approve(uniswapLiquiditySwapAdapter.address, liquidityToSwap); const params = buildLiquiditySwapParams( [dai.address], [expectedDaiAmount], [1], [0], [0], [0], ['0x0000000000000000000000000000000000000000000000000000000000000000'], ['0x0000000000000000000000000000000000000000000000000000000000000000'], [false] ); // Flashloan + premium > aToken balance. Then it will only swap the balance - premium const flashloanFee = liquidityToSwap.mul(9).div(10000); const swappedAmount = liquidityToSwap.sub(flashloanFee); await expect( pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [weth.address], [liquidityToSwap.toString()], [0], userAddress, params, 0 ) ) .to.emit(uniswapLiquiditySwapAdapter, 'Swapped') .withArgs(weth.address, dai.address, swappedAmount.toString(), expectedDaiAmount); const adapterWethBalance = await weth.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiBalance = await dai.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiAllowance = await dai.allowance( uniswapLiquiditySwapAdapter.address, userAddress ); const userADaiBalance = await aDai.balanceOf(userAddress); const userAEthBalance = await aWETH.balanceOf(userAddress); const adapterAEthBalance = await aWETH.balanceOf(uniswapLiquiditySwapAdapter.address); expect(adapterWethBalance).to.be.eq(Zero); expect(adapterDaiBalance).to.be.eq(Zero); expect(adapterDaiAllowance).to.be.eq(Zero); expect(userADaiBalance).to.be.eq(expectedDaiAmount); expect(userAEthBalance).to.be.eq(Zero); expect(adapterAEthBalance).to.be.eq(Zero); }); it('should correctly swap tokens all the balance using permit', async () => { const { users, weth, oracle, dai, aDai, aWETH, pool, uniswapLiquiditySwapAdapter, } = testEnv; const user = users[0].signer; const userAddress = users[0].address; const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmount = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); await mockUniswapRouter.setAmountToReturn(weth.address, expectedDaiAmount); // Remove other balance await aWETH.connect(user).transfer(users[1].address, parseEther('90')); const userAEthBalanceBefore = await aWETH.balanceOf(userAddress); const liquidityToSwap = parseEther('10'); expect(userAEthBalanceBefore).to.be.eq(liquidityToSwap); const chainId = DRE.network.config.chainId || BUIDLEREVM_CHAINID; const deadline = MAX_UINT_AMOUNT; const nonce = (await aWETH._nonces(userAddress)).toNumber(); const msgParams = buildPermitParams( chainId, aWETH.address, '1', await aWETH.name(), userAddress, uniswapLiquiditySwapAdapter.address, nonce, deadline, liquidityToSwap.toString() ); const ownerPrivateKey = require('../../test-wallets.js').accounts[1].secretKey; if (!ownerPrivateKey) { throw new Error('INVALID_OWNER_PK'); } const { v, r, s } = getSignatureFromTypedData(ownerPrivateKey, msgParams); const params = buildLiquiditySwapParams( [dai.address], [expectedDaiAmount], [1], [liquidityToSwap], [deadline], [v], [r], [s], [false] ); // Flashloan + premium > aToken balance. Then it will only swap the balance - premium const flashloanFee = liquidityToSwap.mul(9).div(10000); const swappedAmount = liquidityToSwap.sub(flashloanFee); await expect( pool .connect(user) .flashLoan( uniswapLiquiditySwapAdapter.address, [weth.address], [liquidityToSwap.toString()], [0], userAddress, params, 0 ) ) .to.emit(uniswapLiquiditySwapAdapter, 'Swapped') .withArgs(weth.address, dai.address, swappedAmount.toString(), expectedDaiAmount); const adapterWethBalance = await weth.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiBalance = await dai.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiAllowance = await dai.allowance( uniswapLiquiditySwapAdapter.address, userAddress ); const userADaiBalance = await aDai.balanceOf(userAddress); const userAEthBalance = await aWETH.balanceOf(userAddress); const adapterAEthBalance = await aWETH.balanceOf(uniswapLiquiditySwapAdapter.address); expect(adapterWethBalance).to.be.eq(Zero); expect(adapterDaiBalance).to.be.eq(Zero); expect(adapterDaiAllowance).to.be.eq(Zero); expect(userADaiBalance).to.be.eq(expectedDaiAmount); expect(userAEthBalance).to.be.eq(Zero); expect(adapterAEthBalance).to.be.eq(Zero); }); }); describe('swapAndDeposit', () => { beforeEach(async () => { const { users, weth, dai, pool, deployer } = testEnv; const userAddress = users[0].address; // Provide liquidity await dai.mint(parseEther('20000')); await dai.approve(pool.address, parseEther('20000')); await pool.deposit(dai.address, parseEther('20000'), deployer.address, 0); // Make a deposit for user await weth.mint(parseEther('100')); await weth.approve(pool.address, parseEther('100')); await pool.deposit(weth.address, parseEther('100'), userAddress, 0); }); it('should correctly swap tokens and deposit the out tokens in the pool', async () => { const { users, weth, oracle, dai, aDai, aWETH, uniswapLiquiditySwapAdapter } = testEnv; const user = users[0].signer; const userAddress = users[0].address; const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmount = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); await mockUniswapRouter.setAmountToReturn(weth.address, expectedDaiAmount); // User will swap liquidity 10 aEth to aDai const liquidityToSwap = parseEther('10'); await aWETH.connect(user).approve(uniswapLiquiditySwapAdapter.address, liquidityToSwap); const userAEthBalanceBefore = await aWETH.balanceOf(userAddress); await expect( uniswapLiquiditySwapAdapter.connect(user).swapAndDeposit( [weth.address], [dai.address], [amountWETHtoSwap], [expectedDaiAmount], [ { amount: 0, deadline: 0, v: 0, r: '0x0000000000000000000000000000000000000000000000000000000000000000', s: '0x0000000000000000000000000000000000000000000000000000000000000000', }, ], [false] ) ) .to.emit(uniswapLiquiditySwapAdapter, 'Swapped') .withArgs(weth.address, dai.address, amountWETHtoSwap.toString(), expectedDaiAmount); const adapterWethBalance = await weth.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiBalance = await dai.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiAllowance = await dai.allowance( uniswapLiquiditySwapAdapter.address, userAddress ); const userADaiBalance = await aDai.balanceOf(userAddress); const userAEthBalance = await aWETH.balanceOf(userAddress); expect(adapterWethBalance).to.be.eq(Zero); expect(adapterDaiBalance).to.be.eq(Zero); expect(adapterDaiAllowance).to.be.eq(Zero); expect(userADaiBalance).to.be.eq(expectedDaiAmount); expect(userAEthBalance).to.be.lt(userAEthBalanceBefore); expect(userAEthBalance).to.be.gte(userAEthBalanceBefore.sub(liquidityToSwap)); }); it('should correctly swap tokens using permit', async () => { const { users, weth, oracle, dai, aDai, aWETH, uniswapLiquiditySwapAdapter } = testEnv; const user = users[0].signer; const userAddress = users[0].address; const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmount = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); await mockUniswapRouter.setAmountToReturn(weth.address, expectedDaiAmount); // User will swap liquidity 10 aEth to aDai const liquidityToSwap = parseEther('10'); const userAEthBalanceBefore = await aWETH.balanceOf(userAddress); const chainId = DRE.network.config.chainId || BUIDLEREVM_CHAINID; const deadline = MAX_UINT_AMOUNT; const nonce = (await aWETH._nonces(userAddress)).toNumber(); const msgParams = buildPermitParams( chainId, aWETH.address, '1', await aWETH.name(), userAddress, uniswapLiquiditySwapAdapter.address, nonce, deadline, liquidityToSwap.toString() ); const ownerPrivateKey = require('../../test-wallets.js').accounts[1].secretKey; if (!ownerPrivateKey) { throw new Error('INVALID_OWNER_PK'); } const { v, r, s } = getSignatureFromTypedData(ownerPrivateKey, msgParams); await expect( uniswapLiquiditySwapAdapter.connect(user).swapAndDeposit( [weth.address], [dai.address], [amountWETHtoSwap], [expectedDaiAmount], [ { amount: liquidityToSwap, deadline, v, r, s, }, ], [false] ) ) .to.emit(uniswapLiquiditySwapAdapter, 'Swapped') .withArgs(weth.address, dai.address, amountWETHtoSwap.toString(), expectedDaiAmount); const adapterWethBalance = await weth.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiBalance = await dai.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiAllowance = await dai.allowance( uniswapLiquiditySwapAdapter.address, userAddress ); const userADaiBalance = await aDai.balanceOf(userAddress); const userAEthBalance = await aWETH.balanceOf(userAddress); expect(adapterWethBalance).to.be.eq(Zero); expect(adapterDaiBalance).to.be.eq(Zero); expect(adapterDaiAllowance).to.be.eq(Zero); expect(userADaiBalance).to.be.eq(expectedDaiAmount); expect(userAEthBalance).to.be.lt(userAEthBalanceBefore); expect(userAEthBalance).to.be.gte(userAEthBalanceBefore.sub(liquidityToSwap)); }); it('should revert if inconsistent params', async () => { const { users, weth, dai, uniswapLiquiditySwapAdapter, oracle } = testEnv; const user = users[0].signer; const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmount = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); await expect( uniswapLiquiditySwapAdapter.connect(user).swapAndDeposit( [weth.address, dai.address], [dai.address], [amountWETHtoSwap], [expectedDaiAmount], [ { amount: 0, deadline: 0, v: 0, r: '0x0000000000000000000000000000000000000000000000000000000000000000', s: '0x0000000000000000000000000000000000000000000000000000000000000000', }, ], [false] ) ).to.be.revertedWith('INCONSISTENT_PARAMS'); await expect( uniswapLiquiditySwapAdapter.connect(user).swapAndDeposit( [weth.address], [dai.address, weth.address], [amountWETHtoSwap], [expectedDaiAmount], [ { amount: 0, deadline: 0, v: 0, r: '0x0000000000000000000000000000000000000000000000000000000000000000', s: '0x0000000000000000000000000000000000000000000000000000000000000000', }, ], [false] ) ).to.be.revertedWith('INCONSISTENT_PARAMS'); await expect( uniswapLiquiditySwapAdapter.connect(user).swapAndDeposit( [weth.address], [dai.address], [amountWETHtoSwap, amountWETHtoSwap], [expectedDaiAmount], [ { amount: 0, deadline: 0, v: 0, r: '0x0000000000000000000000000000000000000000000000000000000000000000', s: '0x0000000000000000000000000000000000000000000000000000000000000000', }, ], [false] ) ).to.be.revertedWith('INCONSISTENT_PARAMS'); await expect( uniswapLiquiditySwapAdapter .connect(user) .swapAndDeposit( [weth.address], [dai.address], [amountWETHtoSwap], [expectedDaiAmount], [], [false] ) ).to.be.revertedWith('INCONSISTENT_PARAMS'); await expect( uniswapLiquiditySwapAdapter.connect(user).swapAndDeposit( [weth.address], [dai.address], [amountWETHtoSwap], [expectedDaiAmount, expectedDaiAmount], [ { amount: 0, deadline: 0, v: 0, r: '0x0000000000000000000000000000000000000000000000000000000000000000', s: '0x0000000000000000000000000000000000000000000000000000000000000000', }, ], [false] ) ).to.be.revertedWith('INCONSISTENT_PARAMS'); }); it('should revert when min amount to receive exceeds the max slippage amount', async () => { const { users, weth, oracle, dai, aWETH, uniswapLiquiditySwapAdapter } = testEnv; const user = users[0].signer; const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmount = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); await mockUniswapRouter.setAmountToReturn(weth.address, expectedDaiAmount); const smallExpectedDaiAmount = expectedDaiAmount.div(2); // User will swap liquidity 10 aEth to aDai const liquidityToSwap = parseEther('10'); await aWETH.connect(user).approve(uniswapLiquiditySwapAdapter.address, liquidityToSwap); await expect( uniswapLiquiditySwapAdapter.connect(user).swapAndDeposit( [weth.address], [dai.address], [amountWETHtoSwap], [smallExpectedDaiAmount], [ { amount: 0, deadline: 0, v: 0, r: '0x0000000000000000000000000000000000000000000000000000000000000000', s: '0x0000000000000000000000000000000000000000000000000000000000000000', }, ], [false] ) ).to.be.revertedWith('minAmountOut exceed max slippage'); }); it('should correctly swap tokens and deposit multiple tokens', async () => { const { users, weth, usdc, oracle, dai, aDai, aWETH, uniswapLiquiditySwapAdapter, pool, } = testEnv; const user = users[0].signer; const userAddress = users[0].address; const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmountForEth = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); const amountUSDCtoSwap = await convertToCurrencyDecimals(usdc.address, '10'); const usdcPrice = await oracle.getAssetPrice(usdc.address); const collateralDecimals = (await usdc.decimals()).toString(); const principalDecimals = (await dai.decimals()).toString(); const expectedDaiAmountForUsdc = new BigNumber(amountUSDCtoSwap.toString()) .times( new BigNumber(usdcPrice.toString()).times(new BigNumber(10).pow(principalDecimals)) ) .div(new BigNumber(daiPrice.toString()).times(new BigNumber(10).pow(collateralDecimals))) .toFixed(0); // Make a deposit for user await usdc.connect(user).mint(amountUSDCtoSwap); await usdc.connect(user).approve(pool.address, amountUSDCtoSwap); await pool.connect(user).deposit(usdc.address, amountUSDCtoSwap, userAddress, 0); const aUsdcData = await pool.getReserveData(usdc.address); const aUsdc = await getContract(eContractid.AToken, aUsdcData.aTokenAddress); await mockUniswapRouter.setAmountToReturn(weth.address, expectedDaiAmountForEth); await mockUniswapRouter.setAmountToReturn(usdc.address, expectedDaiAmountForUsdc); await aWETH.connect(user).approve(uniswapLiquiditySwapAdapter.address, amountWETHtoSwap); const userAEthBalanceBefore = await aWETH.balanceOf(userAddress); await aUsdc.connect(user).approve(uniswapLiquiditySwapAdapter.address, amountUSDCtoSwap); const userAUsdcBalanceBefore = await aUsdc.balanceOf(userAddress); await uniswapLiquiditySwapAdapter.connect(user).swapAndDeposit( [weth.address, usdc.address], [dai.address, dai.address], [amountWETHtoSwap, amountUSDCtoSwap], [expectedDaiAmountForEth, expectedDaiAmountForUsdc], [ { amount: 0, deadline: 0, v: 0, r: '0x0000000000000000000000000000000000000000000000000000000000000000', s: '0x0000000000000000000000000000000000000000000000000000000000000000', }, { amount: 0, deadline: 0, v: 0, r: '0x0000000000000000000000000000000000000000000000000000000000000000', s: '0x0000000000000000000000000000000000000000000000000000000000000000', }, ], [false, false] ); const adapterWethBalance = await weth.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiBalance = await dai.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiAllowance = await dai.allowance( uniswapLiquiditySwapAdapter.address, userAddress ); const userADaiBalance = await aDai.balanceOf(userAddress); const userAEthBalance = await aWETH.balanceOf(userAddress); const userAUsdcBalance = await aUsdc.balanceOf(userAddress); expect(adapterWethBalance).to.be.eq(Zero); expect(adapterDaiBalance).to.be.eq(Zero); expect(adapterDaiAllowance).to.be.eq(Zero); expect(userADaiBalance).to.be.eq(expectedDaiAmountForEth.add(expectedDaiAmountForUsdc)); expect(userAEthBalance).to.be.lt(userAEthBalanceBefore); expect(userAEthBalance).to.be.gte(userAEthBalanceBefore.sub(amountWETHtoSwap)); expect(userAUsdcBalance).to.be.lt(userAUsdcBalanceBefore); expect(userAUsdcBalance).to.be.gte(userAUsdcBalanceBefore.sub(amountUSDCtoSwap)); }); it('should correctly swap tokens and deposit multiple tokens using permit', async () => { const { users, weth, usdc, oracle, dai, aDai, aWETH, uniswapLiquiditySwapAdapter, pool, } = testEnv; const user = users[0].signer; const userAddress = users[0].address; const chainId = DRE.network.config.chainId || BUIDLEREVM_CHAINID; const deadline = MAX_UINT_AMOUNT; const ownerPrivateKey = require('../../test-wallets.js').accounts[1].secretKey; if (!ownerPrivateKey) { throw new Error('INVALID_OWNER_PK'); } const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmountForEth = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); const amountUSDCtoSwap = await convertToCurrencyDecimals(usdc.address, '10'); const usdcPrice = await oracle.getAssetPrice(usdc.address); const collateralDecimals = (await usdc.decimals()).toString(); const principalDecimals = (await dai.decimals()).toString(); const expectedDaiAmountForUsdc = new BigNumber(amountUSDCtoSwap.toString()) .times( new BigNumber(usdcPrice.toString()).times(new BigNumber(10).pow(principalDecimals)) ) .div(new BigNumber(daiPrice.toString()).times(new BigNumber(10).pow(collateralDecimals))) .toFixed(0); // Make a deposit for user await usdc.connect(user).mint(amountUSDCtoSwap); await usdc.connect(user).approve(pool.address, amountUSDCtoSwap); await pool.connect(user).deposit(usdc.address, amountUSDCtoSwap, userAddress, 0); const aUsdcData = await pool.getReserveData(usdc.address); const aUsdc = await getContract(eContractid.AToken, aUsdcData.aTokenAddress); await mockUniswapRouter.setAmountToReturn(weth.address, expectedDaiAmountForEth); await mockUniswapRouter.setAmountToReturn(usdc.address, expectedDaiAmountForUsdc); const userAEthBalanceBefore = await aWETH.balanceOf(userAddress); const userAUsdcBalanceBefore = await aUsdc.balanceOf(userAddress); const aWethNonce = (await aWETH._nonces(userAddress)).toNumber(); const aWethMsgParams = buildPermitParams( chainId, aWETH.address, '1', await aWETH.name(), userAddress, uniswapLiquiditySwapAdapter.address, aWethNonce, deadline, amountWETHtoSwap.toString() ); const { v: aWETHv, r: aWETHr, s: aWETHs } = getSignatureFromTypedData( ownerPrivateKey, aWethMsgParams ); const aUsdcNonce = (await aUsdc._nonces(userAddress)).toNumber(); const aUsdcMsgParams = buildPermitParams( chainId, aUsdc.address, '1', await aUsdc.name(), userAddress, uniswapLiquiditySwapAdapter.address, aUsdcNonce, deadline, amountUSDCtoSwap.toString() ); const { v: aUsdcv, r: aUsdcr, s: aUsdcs } = getSignatureFromTypedData( ownerPrivateKey, aUsdcMsgParams ); await uniswapLiquiditySwapAdapter.connect(user).swapAndDeposit( [weth.address, usdc.address], [dai.address, dai.address], [amountWETHtoSwap, amountUSDCtoSwap], [expectedDaiAmountForEth, expectedDaiAmountForUsdc], [ { amount: amountWETHtoSwap, deadline, v: aWETHv, r: aWETHr, s: aWETHs, }, { amount: amountUSDCtoSwap, deadline, v: aUsdcv, r: aUsdcr, s: aUsdcs, }, ], [false, false] ); const adapterWethBalance = await weth.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiBalance = await dai.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiAllowance = await dai.allowance( uniswapLiquiditySwapAdapter.address, userAddress ); const userADaiBalance = await aDai.balanceOf(userAddress); const userAEthBalance = await aWETH.balanceOf(userAddress); const userAUsdcBalance = await aUsdc.balanceOf(userAddress); expect(adapterWethBalance).to.be.eq(Zero); expect(adapterDaiBalance).to.be.eq(Zero); expect(adapterDaiAllowance).to.be.eq(Zero); expect(userADaiBalance).to.be.eq(expectedDaiAmountForEth.add(expectedDaiAmountForUsdc)); expect(userAEthBalance).to.be.lt(userAEthBalanceBefore); expect(userAEthBalance).to.be.gte(userAEthBalanceBefore.sub(amountWETHtoSwap)); expect(userAUsdcBalance).to.be.lt(userAUsdcBalanceBefore); expect(userAUsdcBalance).to.be.gte(userAUsdcBalanceBefore.sub(amountUSDCtoSwap)); }); it('should correctly swap all the balance when using a bigger amount', async () => { const { users, weth, oracle, dai, aDai, aWETH, uniswapLiquiditySwapAdapter } = testEnv; const user = users[0].signer; const userAddress = users[0].address; const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmount = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); await mockUniswapRouter.setAmountToReturn(weth.address, expectedDaiAmount); // Remove other balance await aWETH.connect(user).transfer(users[1].address, parseEther('90')); const userAEthBalanceBefore = await aWETH.balanceOf(userAddress); // User will swap liquidity 10 aEth to aDai const liquidityToSwap = parseEther('10'); expect(userAEthBalanceBefore).to.be.eq(liquidityToSwap); // User will swap liquidity 10 aEth to aDai await aWETH.connect(user).approve(uniswapLiquiditySwapAdapter.address, liquidityToSwap); // Only has 10 atokens, so all the balance will be swapped const bigAmountToSwap = parseEther('100'); await expect( uniswapLiquiditySwapAdapter.connect(user).swapAndDeposit( [weth.address], [dai.address], [bigAmountToSwap], [expectedDaiAmount], [ { amount: 0, deadline: 0, v: 0, r: '0x0000000000000000000000000000000000000000000000000000000000000000', s: '0x0000000000000000000000000000000000000000000000000000000000000000', }, ], [false] ) ) .to.emit(uniswapLiquiditySwapAdapter, 'Swapped') .withArgs(weth.address, dai.address, amountWETHtoSwap.toString(), expectedDaiAmount); const adapterWethBalance = await weth.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiBalance = await dai.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiAllowance = await dai.allowance( uniswapLiquiditySwapAdapter.address, userAddress ); const userADaiBalance = await aDai.balanceOf(userAddress); const userAEthBalance = await aWETH.balanceOf(userAddress); const adapterAEthBalance = await aWETH.balanceOf(uniswapLiquiditySwapAdapter.address); expect(adapterWethBalance).to.be.eq(Zero); expect(adapterDaiBalance).to.be.eq(Zero); expect(adapterDaiAllowance).to.be.eq(Zero); expect(userADaiBalance).to.be.eq(expectedDaiAmount); expect(userAEthBalance).to.be.eq(Zero); expect(adapterAEthBalance).to.be.eq(Zero); }); it('should correctly swap all the balance when using permit', async () => { const { users, weth, oracle, dai, aDai, aWETH, uniswapLiquiditySwapAdapter } = testEnv; const user = users[0].signer; const userAddress = users[0].address; const amountWETHtoSwap = await convertToCurrencyDecimals(weth.address, '10'); const daiPrice = await oracle.getAssetPrice(dai.address); const expectedDaiAmount = await convertToCurrencyDecimals( dai.address, new BigNumber(amountWETHtoSwap.toString()).div(daiPrice.toString()).toFixed(0) ); await mockUniswapRouter.setAmountToReturn(weth.address, expectedDaiAmount); // Remove other balance await aWETH.connect(user).transfer(users[1].address, parseEther('90')); const userAEthBalanceBefore = await aWETH.balanceOf(userAddress); // User will swap liquidity 10 aEth to aDai const liquidityToSwap = parseEther('10'); expect(userAEthBalanceBefore).to.be.eq(liquidityToSwap); // Only has 10 atokens, so all the balance will be swapped const bigAmountToSwap = parseEther('100'); const chainId = DRE.network.config.chainId || BUIDLEREVM_CHAINID; const deadline = MAX_UINT_AMOUNT; const ownerPrivateKey = require('../../test-wallets.js').accounts[1].secretKey; if (!ownerPrivateKey) { throw new Error('INVALID_OWNER_PK'); } const aWethNonce = (await aWETH._nonces(userAddress)).toNumber(); const aWethMsgParams = buildPermitParams( chainId, aWETH.address, '1', await aWETH.name(), userAddress, uniswapLiquiditySwapAdapter.address, aWethNonce, deadline, bigAmountToSwap.toString() ); const { v, r, s } = getSignatureFromTypedData(ownerPrivateKey, aWethMsgParams); await expect( uniswapLiquiditySwapAdapter.connect(user).swapAndDeposit( [weth.address], [dai.address], [bigAmountToSwap], [expectedDaiAmount], [ { amount: bigAmountToSwap, deadline, v, r, s, }, ], [false] ) ) .to.emit(uniswapLiquiditySwapAdapter, 'Swapped') .withArgs(weth.address, dai.address, amountWETHtoSwap.toString(), expectedDaiAmount); const adapterWethBalance = await weth.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiBalance = await dai.balanceOf(uniswapLiquiditySwapAdapter.address); const adapterDaiAllowance = await dai.allowance( uniswapLiquiditySwapAdapter.address, userAddress ); const userADaiBalance = await aDai.balanceOf(userAddress); const userAEthBalance = await aWETH.balanceOf(userAddress); const adapterAEthBalance = await aWETH.balanceOf(uniswapLiquiditySwapAdapter.address); expect(adapterWethBalance).to.be.eq(Zero); expect(adapterDaiBalance).to.be.eq(Zero); expect(adapterDaiAllowance).to.be.eq(Zero); expect(userADaiBalance).to.be.eq(expectedDaiAmount); expect(userAEthBalance).to.be.eq(Zero); expect(adapterAEthBalance).to.be.eq(Zero); }); }); }); });