From e79f59d2c5289dfdb22598136bbd507983713b3f Mon Sep 17 00:00:00 2001 From: Hadrien Charlanes Date: Fri, 4 Jun 2021 09:41:18 +0200 Subject: [PATCH] test: added tests to exposure cap --- helpers/constants.ts | 1 + test-suites/test-aave/exposure-cap.spec.ts | 269 ++++++++++++++++++++ test-suites/test-aave/helpers/make-suite.ts | 4 + 3 files changed, 274 insertions(+) create mode 100644 test-suites/test-aave/exposure-cap.spec.ts diff --git a/helpers/constants.ts b/helpers/constants.ts index f2568ee0..b25ce643 100644 --- a/helpers/constants.ts +++ b/helpers/constants.ts @@ -17,6 +17,7 @@ export const MAX_UINT_AMOUNT = '115792089237316195423570985008687907853269984665640564039457584007913129639935'; export const MAX_BORROW_CAP = '68719476735'; export const MAX_SUPPLY_CAP = '68719476735'; +export const MAX_EXPOSURE_CAP = '68719476735'; export const ONE_YEAR = '31536000'; export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'; export const ONE_ADDRESS = '0x0000000000000000000000000000000000000001'; diff --git a/test-suites/test-aave/exposure-cap.spec.ts b/test-suites/test-aave/exposure-cap.spec.ts new file mode 100644 index 00000000..e804c76e --- /dev/null +++ b/test-suites/test-aave/exposure-cap.spec.ts @@ -0,0 +1,269 @@ +import { TestEnv, makeSuite } from './helpers/make-suite'; +import { + APPROVAL_AMOUNT_LENDING_POOL, + MAX_UINT_AMOUNT, + RAY, + MAX_EXPOSURE_CAP, + MOCK_CHAINLINK_AGGREGATORS_PRICES, +} from '../../helpers/constants'; +import { ProtocolErrors } from '../../helpers/types'; +import { MintableERC20, WETH9, WETH9Mocked } from '../../types'; +import { parseEther } from '@ethersproject/units'; +import { BigNumber } from '@ethersproject/bignumber'; +import { strategyDAI } from '../../markets/amm/reservesConfigs'; +import { strategyUSDC } from '../../markets/amm/reservesConfigs'; +import { strategyWETH } from '../../markets/amm/reservesConfigs'; +import { ethers } from 'ethers'; + +const { expect } = require('chai'); +makeSuite('Exposure Cap', (testEnv: TestEnv) => { + const { + VL_COLLATERAL_EXPOSURE_CAP_EXCEEDED, + RC_INVALID_EXPOSURE_CAP, + VL_COLLATERAL_CANNOT_COVER_NEW_BORROW, + } = ProtocolErrors; + const daiPrice = Number(MOCK_CHAINLINK_AGGREGATORS_PRICES.DAI); + const usdcPrice = Number(MOCK_CHAINLINK_AGGREGATORS_PRICES.USDC); + const daiLTV = Number(strategyDAI.baseLTVAsCollateral); + const usdcLTV = Number(strategyUSDC.baseLTVAsCollateral); + + const unitParse = async (token: WETH9Mocked | MintableERC20, nb: string) => + BigNumber.from(nb).mul(BigNumber.from('10').pow((await token.decimals()) - 3)); + it('Reserves should initially have exposure cap disabled (exposureCap = 0)', async () => { + const { + configurator, + weth, + pool, + dai, + usdc, + deployer, + helpersContract, + users: [user1], + } = testEnv; + + const mintedAmount = parseEther('1000000000'); + // minting for main user + await dai.mint(mintedAmount); + await weth.mint(mintedAmount); + await usdc.mint(mintedAmount); + // minting for lp user + await dai.connect(user1.signer).mint(mintedAmount); + await weth.connect(user1.signer).mint(mintedAmount); + await usdc.connect(user1.signer).mint(mintedAmount); + + await dai.approve(pool.address, MAX_UINT_AMOUNT); + await weth.approve(pool.address, MAX_UINT_AMOUNT); + await usdc.approve(pool.address, MAX_UINT_AMOUNT); + await dai.connect(user1.signer).approve(pool.address, MAX_UINT_AMOUNT); + await weth.connect(user1.signer).approve(pool.address, MAX_UINT_AMOUNT); + await usdc.connect(user1.signer).approve(pool.address, MAX_UINT_AMOUNT); + + await pool.deposit(weth.address, mintedAmount, deployer.address, 0); + + let usdcExposureCap = (await helpersContract.getReserveCaps(usdc.address)).exposureCap; + let daiExposureCap = (await helpersContract.getReserveCaps(dai.address)).exposureCap; + + expect(usdcExposureCap).to.be.equal('0'); + expect(daiExposureCap).to.be.equal('0'); + }); + it('Deposit 10 Dai, 10 USDC, LTV for both should increase', async () => { + const { + configurator, + weth, + pool, + dai, + usdc, + deployer, + helpersContract, + users: [user1], + } = testEnv; + + const suppliedAmount = 10; + const precisionSuppliedAmount = (suppliedAmount * 1000).toString(); + + // user 1 deposit more dai and usdc to be able to borrow + let { ltv } = await pool.getUserAccountData(user1.address); + console.log(ltv.toString()); + expect(ltv.toString()).to.be.equal('0'); + await pool + .connect(user1.signer) + .deposit(dai.address, await unitParse(dai, precisionSuppliedAmount), user1.address, 0); + + ltv = (await pool.getUserAccountData(user1.address)).ltv; + console.log(ltv.toString()); + expect(ltv).to.be.equal(daiLTV); + await pool + .connect(user1.signer) + .deposit(usdc.address, await unitParse(usdc, precisionSuppliedAmount), user1.address, 0); + + ltv = (await pool.getUserAccountData(user1.address)).ltv; + console.log(ltv.toString()); + expect(Number(ltv)).to.be.equal( + Math.floor((daiLTV * daiPrice + usdcLTV * usdcPrice) / (daiPrice + usdcPrice)) + ); + }); + it('Sets the exposure cap for DAI to 10 Units', async () => { + const { + configurator, + weth, + pool, + dai, + usdc, + deployer, + helpersContract, + users: [user1], + } = testEnv; + + const newExposureCap = 10; + + await configurator.setExposureCap(dai.address, newExposureCap); + + const daiExposureCap = (await helpersContract.getReserveCaps(dai.address)).exposureCap; + + expect(daiExposureCap).to.be.equal(newExposureCap); + }); + it('should succeed to deposit 10 dai but dai ltv drops to 0', async () => { + const { + usdc, + pool, + dai, + aDai, + deployer, + helpersContract, + users: [user1], + } = testEnv; + const suppliedAmount = 10; + const precisionSuppliedAmount = (suppliedAmount * 1000).toString(); + + await pool + .connect(user1.signer) + .deposit(dai.address, await unitParse(dai, precisionSuppliedAmount), user1.address, 0); + + console.log((await aDai.totalSupply()).toString()); + + let ltv = (await pool.getUserAccountData(user1.address)).ltv; + console.log(ltv.toString()); + expect(ltv).to.be.equal(Math.floor((usdcLTV * usdcPrice) / (usdcPrice + 2 * daiPrice))); + }); + it('Should not be able to borrow 15 USD of weth', async () => { + const { + usdc, + pool, + weth, + helpersContract, + users: [user1], + } = testEnv; + const precisionBorrowedUsdAmount = 15 * 1000; + const precisionBorrowedEthAmount = ethers.BigNumber.from(precisionBorrowedUsdAmount) + .mul(daiPrice) + .div(parseEther('1.0')) + .toString(); + const borrowedAmount = await unitParse(weth, precisionBorrowedEthAmount); + + await expect( + pool.connect(user1.signer).borrow(weth.address, borrowedAmount, 1, 0, user1.address) + ).to.be.revertedWith(VL_COLLATERAL_CANNOT_COVER_NEW_BORROW); + }); + it('should be able to borrow 15 USD of weth after dai exposure cap raised to 100', async () => { + const { + usdc, + pool, + dai, + weth, + configurator, + helpersContract, + users: [user1], + } = testEnv; + + const newExposureCap = 100; + + await configurator.setExposureCap(dai.address, newExposureCap); + + const daiExposureCap = (await helpersContract.getReserveCaps(dai.address)).exposureCap; + + expect(daiExposureCap).to.be.equal(newExposureCap); + + const precisionBorrowedUsdAmount = 15 * 1000; + const precisionBorrowedEthAmount = ethers.BigNumber.from(precisionBorrowedUsdAmount) + .mul(daiPrice) + .div(parseEther('1.0')) + .toString(); + const borrowedAmount = await unitParse(weth, precisionBorrowedEthAmount); + + pool.connect(user1.signer).borrow(weth.address, borrowedAmount, 1, 0, user1.address); + }); + it('should not be able to withdraw 5 dai, transfer 5 aDai after cap decrease back to 10 (capped)', async () => { + const { + usdc, + pool, + dai, + aDai, + configurator, + helpersContract, + users: [user1], + } = testEnv; + + const newExposureCap = 10; + + await configurator.setExposureCap(dai.address, newExposureCap); + + const daiExposureCap = (await helpersContract.getReserveCaps(dai.address)).exposureCap; + + expect(daiExposureCap).to.be.equal(newExposureCap); + + const precisionWithdrawnAmount = (5 * 1000).toString(); + const withdrawnAmount = await unitParse(dai, precisionWithdrawnAmount); + + await expect( + pool.connect(user1.signer).withdraw(dai.address, withdrawnAmount, user1.address) + ).to.be.revertedWith(VL_COLLATERAL_EXPOSURE_CAP_EXCEEDED); + await expect( + aDai.connect(user1.signer).transfer(pool.address, withdrawnAmount) + ).to.be.revertedWith(VL_COLLATERAL_EXPOSURE_CAP_EXCEEDED); + }); + it('should be able to withdraw 5 and transfer 5 aUsdc', async () => { + const { + usdc, + pool, + aUsdc, + users: [user1], + } = testEnv; + + const precisionWithdrawnAmount = (5 * 1000).toString(); + const withdrawnAmount = await unitParse(usdc, precisionWithdrawnAmount); + + pool.connect(user1.signer).withdraw(usdc.address, withdrawnAmount, user1.address); + aUsdc.connect(user1.signer).transfer(pool.address, withdrawnAmount); + }); + it('should be able to withdraw 5 dai, transfer 5 aDai after repaying weth Debt', async () => { + const { + usdc, + pool, + dai, + weth, + aDai, + configurator, + helpersContract, + users: [user1], + } = testEnv; + + const precisionWithdrawnAmount = (5 * 1000).toString(); + const withdrawnAmount = await unitParse(dai, precisionWithdrawnAmount); + + await pool.connect(user1.signer).repay(weth.address, MAX_UINT_AMOUNT, 1, user1.address); + + pool.connect(user1.signer).withdraw(dai.address, withdrawnAmount, user1.address); + aDai.connect(user1.signer).transfer(pool.address, withdrawnAmount); + }); + it('Should fail to set the exposure cap for usdc and DAI to max cap + 1 Units', async () => { + const { configurator, usdc, pool, dai, deployer, helpersContract } = testEnv; + const newCap = Number(MAX_EXPOSURE_CAP) + 1; + + await expect(configurator.setExposureCap(usdc.address, newCap)).to.be.revertedWith( + RC_INVALID_EXPOSURE_CAP + ); + await expect(configurator.setExposureCap(dai.address, newCap)).to.be.revertedWith( + RC_INVALID_EXPOSURE_CAP + ); + }); +}); diff --git a/test-suites/test-aave/helpers/make-suite.ts b/test-suites/test-aave/helpers/make-suite.ts index 490aeb0b..130635f1 100644 --- a/test-suites/test-aave/helpers/make-suite.ts +++ b/test-suites/test-aave/helpers/make-suite.ts @@ -63,6 +63,7 @@ export interface TestEnv { aWETH: AToken; dai: MintableERC20; aDai: AToken; + aUsdc: AToken; usdc: MintableERC20; aave: MintableERC20; addressesProvider: LendingPoolAddressesProvider; @@ -92,6 +93,7 @@ const testEnv: TestEnv = { aWETH: {} as AToken, dai: {} as MintableERC20, aDai: {} as AToken, + aUsdc: {} as AToken, usdc: {} as MintableERC20, aave: {} as MintableERC20, addressesProvider: {} as LendingPoolAddressesProvider, @@ -138,6 +140,7 @@ export async function initializeMakeSuite() { const allTokens = await testEnv.helpersContract.getAllATokens(); const aDaiAddress = allTokens.find((aToken) => aToken.symbol === 'aDAI')?.tokenAddress; + const aUsdcAddress = allTokens.find((aToken) => aToken.symbol === 'aUSDC')?.tokenAddress; const aWEthAddress = allTokens.find((aToken) => aToken.symbol === 'aWETH')?.tokenAddress; @@ -156,6 +159,7 @@ export async function initializeMakeSuite() { } testEnv.aDai = await getAToken(aDaiAddress); + testEnv.aUsdc = await getAToken(aUsdcAddress); testEnv.aWETH = await getAToken(aWEthAddress); testEnv.dai = await getMintableERC20(daiAddress);