test added tests for ERC712 credit delegation sig permit

helpers/contracts-helpers.ts

@@ -142,14 +142,8 @@ export const linkBytecode = (artifact: BuidlerArtifact | Artifact, libraries: an
 };
 
 export const getParamPerNetwork = <T>(param: iParamsPerNetwork<T>, network: eNetwork) => {
-  const {
+  const { main, ropsten, kovan, coverage, buidlerevm, tenderlyMain } =
-    main,
+    param as iEthereumParamsPerNetwork<T>;
-    ropsten,
-    kovan,
-    coverage,
-    buidlerevm,
-    tenderlyMain,
-  } = param as iEthereumParamsPerNetwork<T>;
   const { matic, mumbai } = param as iPolygonParamsPerNetwork<T>;
   const { xdai } = param as iXDaiParamsPerNetwork<T>;
   if (process.env.FORK) {
@@ -327,6 +321,48 @@ export const buildFlashLiquidationAdapterParams = (
   );
 };
 
+export const buildPermitDelegationParams = (
+  chainId: number,
+  token: tEthereumAddress,
+  revision: string,
+  tokenName: string,
+  delegator: tEthereumAddress,
+  delegatee: tEthereumAddress,
+  nonce: number,
+  deadline: string,
+  value: tStringTokenSmallUnits
+) => ({
+  types: {
+    EIP712Domain: [
+      { name: 'name', type: 'string' },
+      { name: 'version', type: 'string' },
+      { name: 'chainId', type: 'uint256' },
+      { name: 'verifyingContract', type: 'address' },
+    ],
+    PermitDelegation: [
+      { name: 'delegator', type: 'address' },
+      { name: 'delegatee', type: 'address' },
+      { name: 'value', type: 'uint256' },
+      { name: 'nonce', type: 'uint256' },
+      { name: 'deadline', type: 'uint256' },
+    ],
+  },
+  primaryType: 'PermitDelegation' as const,
+  domain: {
+    name: tokenName,
+    version: revision,
+    chainId: chainId,
+    verifyingContract: token,
+  },
+  message: {
+    delegator,
+    delegatee,
+    value,
+    nonce,
+    deadline,
+  },
+});
+
 export const verifyContract = async (
   id: string,
   instance: Contract,

test-suites/test-aave/delegation-permit.spec.ts

@@ -0,0 +1,170 @@
+import { MAX_UINT_AMOUNT, ZERO_ADDRESS } from '../../helpers/constants';
+import { BUIDLEREVM_CHAINID } from '../../helpers/buidler-constants';
+import {
+  buildPermitDelegationParams,
+  buildPermitParams,
+  convertToCurrencyDecimals,
+  getSignatureFromTypedData,
+} from '../../helpers/contracts-helpers';
+import { expect } from 'chai';
+import { BigNumber, ethers } from 'ethers';
+import { makeSuite, TestEnv } from './helpers/make-suite';
+import { DRE } from '../../helpers/misc-utils';
+import { waitForTx } from '../../helpers/misc-utils';
+import { _TypedDataEncoder } from 'ethers/lib/utils';
+
+const { parseEther } = ethers.utils;
+
+makeSuite('Permit Delegation', (testEnv: TestEnv) => {
+  const mintedAmount = '1000';
+  let daiMintedAmount: BigNumber;
+  let wethMintedAmount: BigNumber;
+
+  it('Checks the domain separator', async () => {
+    const { variableDebtDai, stableDebtDai, weth, dai } = testEnv;
+    const variableSeparator = await variableDebtDai.DOMAIN_SEPARATOR();
+    const stableSeparator = await stableDebtDai.DOMAIN_SEPARATOR();
+
+    const variableDomain = {
+      name: await variableDebtDai.name(),
+      version: '1',
+      chainId: DRE.network.config.chainId,
+      verifyingContract: variableDebtDai.address,
+    };
+    const stableDomain = {
+      name: await stableDebtDai.name(),
+      version: '1',
+      chainId: DRE.network.config.chainId,
+      verifyingContract: stableDebtDai.address,
+    };
+    const variableDomainSeparator = _TypedDataEncoder.hashDomain(variableDomain);
+    const stableDomainSeparator = _TypedDataEncoder.hashDomain(stableDomain);
+
+    expect(variableSeparator).to.be.equal(
+      variableDomainSeparator,
+      'Invalid variable domain separator'
+    );
+    expect(stableSeparator).to.be.equal(stableDomainSeparator, 'Invalid stable domain separator');
+  });
+
+  it('Setup the lending pool', async () => {
+    const {
+      pool,
+      weth,
+      dai,
+      deployer: user1,
+      users: [user2, user3],
+    } = testEnv;
+    daiMintedAmount = await convertToCurrencyDecimals(dai.address, mintedAmount);
+    wethMintedAmount = await convertToCurrencyDecimals(weth.address, mintedAmount);
+    await dai.mint(daiMintedAmount);
+    await dai.approve(pool.address, daiMintedAmount);
+    await pool.deposit(dai.address, daiMintedAmount, user1.address, 0);
+    await weth.connect(user2.signer).mint(wethMintedAmount);
+    await weth.connect(user2.signer).approve(pool.address, wethMintedAmount);
+    await pool.connect(user2.signer).deposit(weth.address, wethMintedAmount, user2.address, 0);
+  });
+  it('User 3 borrows variable interest dai on behalf of user 2 via permit', async () => {
+    const {
+      pool,
+      variableDebtDai,
+      stableDebtDai,
+      weth,
+      dai,
+      deployer: user1,
+      users: [user2, user3],
+    } = testEnv;
+
+    const chainId = DRE.network.config.chainId || BUIDLEREVM_CHAINID;
+    const expiration = MAX_UINT_AMOUNT;
+    const nonce = (await variableDebtDai._nonces(user2.address)).toNumber();
+    const permitAmount = daiMintedAmount.div(3);
+    const msgParams = buildPermitDelegationParams(
+      chainId,
+      variableDebtDai.address,
+      '1',
+      await variableDebtDai.name(),
+      user2.address,
+      user3.address,
+      nonce,
+      expiration,
+      permitAmount.toString()
+    );
+
+    const user2PrivateKey = require('../../test-wallets.js').accounts[1].secretKey;
+    if (!user2PrivateKey) {
+      throw new Error('INVALID_OWNER_PK');
+    }
+    expect(
+      (await variableDebtDai.borrowAllowance(user2.address, user3.address)).toString()
+    ).to.be.equal('0');
+
+    const { v, r, s } = getSignatureFromTypedData(user2PrivateKey, msgParams);
+
+    await variableDebtDai
+      .connect(user1.signer)
+      .permitDelegation(user2.address, user3.address, permitAmount, expiration, v, r, s);
+
+    expect(
+      (await variableDebtDai.borrowAllowance(user2.address, user3.address)).toString()
+    ).to.be.equal(permitAmount);
+
+    await pool.connect(user3.signer).borrow(dai.address, permitAmount, 2, 0, user2.address);
+    expect(
+      (await variableDebtDai.borrowAllowance(user2.address, user3.address)).toString()
+    ).to.be.equal('0');
+  });
+  it('User 3 borrows variable interest dai on behalf of user 2 via permit', async () => {
+    const {
+      pool,
+      variableDebtDai,
+      stableDebtDai,
+      weth,
+      dai,
+      deployer: user1,
+      users: [user2, user3],
+    } = testEnv;
+
+    const chainId = DRE.network.config.chainId || BUIDLEREVM_CHAINID;
+    const expiration = MAX_UINT_AMOUNT;
+    const nonce = (await stableDebtDai._nonces(user2.address)).toNumber();
+    const permitAmount = daiMintedAmount.div(3);
+    const msgParams = buildPermitDelegationParams(
+      chainId,
+      stableDebtDai.address,
+      '1',
+      await stableDebtDai.name(),
+      user2.address,
+      user3.address,
+      nonce,
+      expiration,
+      permitAmount.toString()
+    );
+
+    const user2PrivateKey = require('../../test-wallets.js').accounts[1].secretKey;
+    if (!user2PrivateKey) {
+      throw new Error('INVALID_OWNER_PK');
+    }
+    expect(
+      (await stableDebtDai.borrowAllowance(user2.address, user3.address)).toString()
+    ).to.be.equal('0');
+
+    const { v, r, s } = getSignatureFromTypedData(user2PrivateKey, msgParams);
+
+    await stableDebtDai
+      .connect(user1.signer)
+      .permitDelegation(user2.address, user3.address, permitAmount, expiration, v, r, s);
+
+    expect(
+      (await stableDebtDai.borrowAllowance(user2.address, user3.address)).toString()
+    ).to.be.equal(permitAmount);
+
+    await pool
+      .connect(user3.signer)
+      .borrow(dai.address, daiMintedAmount.div(10), 1, 0, user2.address);
+
+    expect(
+      (await stableDebtDai.borrowAllowance(user2.address, user3.address)).toString()
+    ).to.be.equal(permitAmount.sub(daiMintedAmount.div(10)));
+  });
+});

test-suites/test-aave/helpers/make-suite.ts

@@ -14,6 +14,8 @@ import {
   getUniswapLiquiditySwapAdapter,
   getUniswapRepayAdapter,
   getFlashLiquidationAdapter,
+  getVariableDebtToken,
+  getStableDebtToken,
 } from '../../../helpers/contracts-getters';
 import { eEthereumNetwork, eNetwork, tEthereumAddress } from '../../../helpers/types';
 import { LendingPool } from '../../../types/LendingPool';
@@ -37,7 +39,7 @@ import { WETH9Mocked } from '../../../types/WETH9Mocked';
 import { WETHGateway } from '../../../types/WETHGateway';
 import { solidity } from 'ethereum-waffle';
 import { AaveConfig } from '../../../markets/aave';
-import { FlashLiquidationAdapter } from '../../../types';
+import { FlashLiquidationAdapter, StableDebtToken, VariableDebtToken } from '../../../types';
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
 import { usingTenderly } from '../../../helpers/tenderly-utils';
 
@@ -63,6 +65,8 @@ export interface TestEnv {
   aWETH: AToken;
   dai: MintableERC20;
   aDai: AToken;
+  variableDebtDai: VariableDebtToken;
+  stableDebtDai: StableDebtToken;
   aUsdc: AToken;
   usdc: MintableERC20;
   aave: MintableERC20;
@@ -93,6 +97,8 @@ const testEnv: TestEnv = {
   aWETH: {} as AToken,
   dai: {} as MintableERC20,
   aDai: {} as AToken,
+  variableDebtDai: {} as VariableDebtToken,
+  stableDebtDai: {} as StableDebtToken,
   aUsdc: {} as AToken,
   usdc: {} as MintableERC20,
   aave: {} as MintableERC20,
@@ -147,6 +153,10 @@ export async function initializeMakeSuite() {
   const reservesTokens = await testEnv.helpersContract.getAllReservesTokens();
 
   const daiAddress = reservesTokens.find((token) => token.symbol === 'DAI')?.tokenAddress;
+  const {
+    variableDebtTokenAddress: variableDebtDaiAddress,
+    stableDebtTokenAddress: stableDebtDaiAddress,
+  } = await testEnv.helpersContract.getReserveTokensAddresses(daiAddress || '');
   const usdcAddress = reservesTokens.find((token) => token.symbol === 'USDC')?.tokenAddress;
   const aaveAddress = reservesTokens.find((token) => token.symbol === 'AAVE')?.tokenAddress;
   const wethAddress = reservesTokens.find((token) => token.symbol === 'WETH')?.tokenAddress;
@@ -159,6 +169,8 @@ export async function initializeMakeSuite() {
   }
 
   testEnv.aDai = await getAToken(aDaiAddress);
+  testEnv.variableDebtDai = await getVariableDebtToken(variableDebtDaiAddress);
+  testEnv.stableDebtDai = await getStableDebtToken(stableDebtDaiAddress);
   testEnv.aUsdc = await getAToken(aUsdcAddress);
   testEnv.aWETH = await getAToken(aWEthAddress);