From fce470cfb74985cd3a8a61f1d1e8330b2f38382a Mon Sep 17 00:00:00 2001 From: Hadrien Charlanes Date: Mon, 5 Jul 2021 10:03:15 +0200 Subject: [PATCH 1/6] refactor: created internal approve delegation function --- .../protocol/tokenization/base/DebtTokenBase.sol | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/contracts/protocol/tokenization/base/DebtTokenBase.sol b/contracts/protocol/tokenization/base/DebtTokenBase.sol index 4d75bc2f..11f43916 100644 --- a/contracts/protocol/tokenization/base/DebtTokenBase.sol +++ b/contracts/protocol/tokenization/base/DebtTokenBase.sol @@ -38,8 +38,7 @@ abstract contract DebtTokenBase is * force a delegator HF to go below 1) **/ function approveDelegation(address delegatee, uint256 amount) external override { - _borrowAllowances[_msgSender()][delegatee] = amount; - emit BorrowAllowanceDelegated(_msgSender(), delegatee, _getUnderlyingAssetAddress(), amount); + _approveDelegation(_msgSender(), delegatee, amount); } /** @@ -118,6 +117,15 @@ abstract contract DebtTokenBase is revert('ALLOWANCE_NOT_SUPPORTED'); } + function _approveDelegation( + address delegator, + address delegatee, + uint256 amount + ) internal { + _borrowAllowances[delegator][delegatee] = amount; + emit BorrowAllowanceDelegated(delegator, delegatee, _getUnderlyingAssetAddress(), amount); + } + function _decreaseBorrowAllowance( address delegator, address delegatee, From 3aacd06fff0b61509da3ddf8f55c9fd59da1fb41 Mon Sep 17 00:00:00 2001 From: Hadrien Charlanes Date: Mon, 5 Jul 2021 12:03:06 +0200 Subject: [PATCH 2/6] feat: added permitDelegation functions to stable and variable debt tokens --- contracts/interfaces/IStableDebtToken.sol | 20 +++++ contracts/interfaces/IVariableDebtToken.sol | 20 +++++ .../protocol/tokenization/StableDebtToken.sol | 73 +++++++++++++++++++ .../tokenization/VariableDebtToken.sol | 73 +++++++++++++++++++ 4 files changed, 186 insertions(+) diff --git a/contracts/interfaces/IStableDebtToken.sol b/contracts/interfaces/IStableDebtToken.sol index e39cf8b5..082a32db 100644 --- a/contracts/interfaces/IStableDebtToken.sol +++ b/contracts/interfaces/IStableDebtToken.sol @@ -69,6 +69,26 @@ interface IStableDebtToken is IInitializableDebtToken { uint256 rate ) external returns (bool); + /** + * @dev implements the credit delegation with ERC712 signature + * @param delegator The delegator of the credit + * @param delegatee The delegatee that can use the credit + * @param value The amount to be delegated + * @param deadline The deadline timestamp, type(uint256).max for max deadline + * @param v Signature param + * @param s Signature param + * @param r Signature param + */ + function permitDelegation( + address delegator, + address delegatee, + uint256 value, + uint256 deadline, + uint8 v, + bytes32 r, + bytes32 s + ) external; + /** * @dev Burns debt of `user` * - The resulting rate is the weighted average between the rate of the new debt diff --git a/contracts/interfaces/IVariableDebtToken.sol b/contracts/interfaces/IVariableDebtToken.sol index d88c25fc..b839f8ee 100644 --- a/contracts/interfaces/IVariableDebtToken.sol +++ b/contracts/interfaces/IVariableDebtToken.sol @@ -36,6 +36,26 @@ interface IVariableDebtToken is IScaledBalanceToken, IInitializableDebtToken { uint256 index ) external returns (bool); + /** + * @dev implements the credit delegation with ERC712 signature + * @param delegator The delegator of the credit + * @param delegatee The delegatee that can use the credit + * @param value The amount to be delegated + * @param deadline The deadline timestamp, type(uint256).max for max deadline + * @param v Signature param + * @param s Signature param + * @param r Signature param + */ + function permitDelegation( + address delegator, + address delegatee, + uint256 value, + uint256 deadline, + uint8 v, + bytes32 r, + bytes32 s + ) external; + /** * @dev Emitted when variable debt is burnt * @param user The user which debt has been burned diff --git a/contracts/protocol/tokenization/StableDebtToken.sol b/contracts/protocol/tokenization/StableDebtToken.sol index 2212e9cf..86f8607a 100644 --- a/contracts/protocol/tokenization/StableDebtToken.sol +++ b/contracts/protocol/tokenization/StableDebtToken.sol @@ -18,6 +18,14 @@ import {Errors} from '../libraries/helpers/Errors.sol'; contract StableDebtToken is IStableDebtToken, DebtTokenBase { using WadRayMath for uint256; + bytes public constant EIP712_REVISION = bytes('1'); + bytes32 internal constant EIP712_DOMAIN = + keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'); + bytes32 public constant PERMIT_DELEGATION_TYPEHASH = + keccak256( + 'PermitDelegation(address delegator,address delegatee,uint256 value,uint256 nonce,uint256 deadline)' + ); + uint256 public constant DEBT_TOKEN_REVISION = 0x1; uint256 internal _avgStableRate; @@ -29,6 +37,9 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase { address internal _underlyingAsset; IAaveIncentivesController internal _incentivesController; + mapping(address => uint256) public _nonces; + bytes32 public DOMAIN_SEPARATOR; + /** * @dev Initializes the debt token. * @param pool The address of the lending pool where this aToken will be used @@ -47,6 +58,13 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase { string memory debtTokenSymbol, bytes calldata params ) public override initializer { + uint256 chainId; + + //solium-disable-next-line + assembly { + chainId := chainid() + } + _setName(debtTokenName); _setSymbol(debtTokenSymbol); _setDecimals(debtTokenDecimals); @@ -55,6 +73,16 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase { _underlyingAsset = underlyingAsset; _incentivesController = incentivesController; + DOMAIN_SEPARATOR = keccak256( + abi.encode( + EIP712_DOMAIN, + keccak256(bytes(debtTokenName)), + keccak256(EIP712_REVISION), + chainId, + address(this) + ) + ); + emit Initialized( underlyingAsset, address(pool), @@ -256,6 +284,51 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase { emit Transfer(user, address(0), amount); } + /** + * @dev implements the credit delegation with ERC712 signature + * @param delegator The delegator of the credit + * @param delegatee The delegatee that can use the credit + * @param value The amount to be delegated + * @param deadline The deadline timestamp, type(uint256).max for max deadline + * @param v Signature param + * @param s Signature param + * @param r Signature param + */ + function permitDelegation( + address delegator, + address delegatee, + uint256 value, + uint256 deadline, + uint8 v, + bytes32 r, + bytes32 s + ) external override { + require(delegator != address(0), 'INVALID_DELEGATOR'); + //solium-disable-next-line + require(block.timestamp <= deadline, 'INVALID_EXPIRATION'); + uint256 currentValidNonce = _nonces[delegator]; + bytes32 digest = + keccak256( + abi.encodePacked( + '\x19\x01', + DOMAIN_SEPARATOR, + keccak256( + abi.encode( + PERMIT_DELEGATION_TYPEHASH, + delegator, + delegatee, + value, + currentValidNonce, + deadline + ) + ) + ) + ); + require(delegator == ecrecover(digest, v, r, s), 'INVALID_SIGNATURE'); + _nonces[delegator] = currentValidNonce.add(1); + _approveDelegation(delegator, delegatee, value); + } + /** * @dev Calculates the increase in balance since the last user interaction * @param user The address of the user for which the interest is being accumulated diff --git a/contracts/protocol/tokenization/VariableDebtToken.sol b/contracts/protocol/tokenization/VariableDebtToken.sol index a7a28176..f14a31fc 100644 --- a/contracts/protocol/tokenization/VariableDebtToken.sol +++ b/contracts/protocol/tokenization/VariableDebtToken.sol @@ -17,12 +17,23 @@ import {IAaveIncentivesController} from '../../interfaces/IAaveIncentivesControl contract VariableDebtToken is DebtTokenBase, IVariableDebtToken { using WadRayMath for uint256; + bytes public constant EIP712_REVISION = bytes('1'); + bytes32 internal constant EIP712_DOMAIN = + keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'); + bytes32 public constant PERMIT_DELEGATION_TYPEHASH = + keccak256( + 'PermitDelegation(address delegator,address delegatee,uint256 value,uint256 nonce,uint256 deadline)' + ); + uint256 public constant DEBT_TOKEN_REVISION = 0x1; ILendingPool internal _pool; address internal _underlyingAsset; IAaveIncentivesController internal _incentivesController; + mapping(address => uint256) public _nonces; + bytes32 public DOMAIN_SEPARATOR; + /** * @dev Initializes the debt token. * @param pool The address of the lending pool where this aToken will be used @@ -41,6 +52,13 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken { string memory debtTokenSymbol, bytes calldata params ) public override initializer { + uint256 chainId; + + //solium-disable-next-line + assembly { + chainId := chainid() + } + _setName(debtTokenName); _setSymbol(debtTokenSymbol); _setDecimals(debtTokenDecimals); @@ -49,6 +67,16 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken { _underlyingAsset = underlyingAsset; _incentivesController = incentivesController; + DOMAIN_SEPARATOR = keccak256( + abi.encode( + EIP712_DOMAIN, + keccak256(bytes(debtTokenName)), + keccak256(EIP712_REVISION), + chainId, + address(this) + ) + ); + emit Initialized( underlyingAsset, address(pool), @@ -135,6 +163,51 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken { emit Burn(user, amount, index); } + /** + * @dev implements the credit delegation with ERC712 signature + * @param delegator The delegator of the credit + * @param delegatee The delegatee that can use the credit + * @param value The amount to be delegated + * @param deadline The deadline timestamp, type(uint256).max for max deadline + * @param v Signature param + * @param s Signature param + * @param r Signature param + */ + function permitDelegation( + address delegator, + address delegatee, + uint256 value, + uint256 deadline, + uint8 v, + bytes32 r, + bytes32 s + ) external override { + require(delegator != address(0), 'INVALID_DELEGATOR'); + //solium-disable-next-line + require(block.timestamp <= deadline, 'INVALID_EXPIRATION'); + uint256 currentValidNonce = _nonces[delegator]; + bytes32 digest = + keccak256( + abi.encodePacked( + '\x19\x01', + DOMAIN_SEPARATOR, + keccak256( + abi.encode( + PERMIT_DELEGATION_TYPEHASH, + delegator, + delegatee, + value, + currentValidNonce, + deadline + ) + ) + ) + ); + require(delegator == ecrecover(digest, v, r, s), 'INVALID_SIGNATURE'); + _nonces[delegator] = currentValidNonce.add(1); + _approveDelegation(delegator, delegatee, value); + } + /** * @dev Returns the principal debt balance of the user from * @return The debt balance of the user since the last burn/mint action From 68e023311c6afd70353a0d1b228e8beaf1ff432c Mon Sep 17 00:00:00 2001 From: Hadrien Charlanes Date: Tue, 6 Jul 2021 09:40:31 +0200 Subject: [PATCH 3/6] test added tests for ERC712 credit delegation sig permit --- helpers/contracts-helpers.ts | 52 +++++- .../test-aave/delegation-permit.spec.ts | 170 ++++++++++++++++++ test-suites/test-aave/helpers/make-suite.ts | 14 +- 3 files changed, 227 insertions(+), 9 deletions(-) create mode 100644 test-suites/test-aave/delegation-permit.spec.ts diff --git a/helpers/contracts-helpers.ts b/helpers/contracts-helpers.ts index cb7c016e..1c43a23a 100644 --- a/helpers/contracts-helpers.ts +++ b/helpers/contracts-helpers.ts @@ -142,14 +142,8 @@ export const linkBytecode = (artifact: BuidlerArtifact | Artifact, libraries: an }; export const getParamPerNetwork = (param: iParamsPerNetwork, network: eNetwork) => { - const { - main, - ropsten, - kovan, - coverage, - buidlerevm, - tenderlyMain, - } = param as iEthereumParamsPerNetwork; + const { main, ropsten, kovan, coverage, buidlerevm, tenderlyMain } = + param as iEthereumParamsPerNetwork; const { matic, mumbai } = param as iPolygonParamsPerNetwork; const { xdai } = param as iXDaiParamsPerNetwork; 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, diff --git a/test-suites/test-aave/delegation-permit.spec.ts b/test-suites/test-aave/delegation-permit.spec.ts new file mode 100644 index 00000000..d94d1e55 --- /dev/null +++ b/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))); + }); +}); diff --git a/test-suites/test-aave/helpers/make-suite.ts b/test-suites/test-aave/helpers/make-suite.ts index 130635f1..15150cd1 100644 --- a/test-suites/test-aave/helpers/make-suite.ts +++ b/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); From f68356971c3adde7ad11dfddd7a977d4ddffe8b1 Mon Sep 17 00:00:00 2001 From: Hadrien Charlanes Date: Tue, 6 Jul 2021 11:24:37 +0200 Subject: [PATCH 4/6] version: updated debt token versions --- contracts/protocol/tokenization/StableDebtToken.sol | 2 +- contracts/protocol/tokenization/VariableDebtToken.sol | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/contracts/protocol/tokenization/StableDebtToken.sol b/contracts/protocol/tokenization/StableDebtToken.sol index 86f8607a..49ebc9c8 100644 --- a/contracts/protocol/tokenization/StableDebtToken.sol +++ b/contracts/protocol/tokenization/StableDebtToken.sol @@ -26,7 +26,7 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase { 'PermitDelegation(address delegator,address delegatee,uint256 value,uint256 nonce,uint256 deadline)' ); - uint256 public constant DEBT_TOKEN_REVISION = 0x1; + uint256 public constant DEBT_TOKEN_REVISION = 0x2; uint256 internal _avgStableRate; mapping(address => uint40) internal _timestamps; diff --git a/contracts/protocol/tokenization/VariableDebtToken.sol b/contracts/protocol/tokenization/VariableDebtToken.sol index f14a31fc..b6c590d6 100644 --- a/contracts/protocol/tokenization/VariableDebtToken.sol +++ b/contracts/protocol/tokenization/VariableDebtToken.sol @@ -25,7 +25,7 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken { 'PermitDelegation(address delegator,address delegatee,uint256 value,uint256 nonce,uint256 deadline)' ); - uint256 public constant DEBT_TOKEN_REVISION = 0x1; + uint256 public constant DEBT_TOKEN_REVISION = 0x2; ILendingPool internal _pool; address internal _underlyingAsset; From 5f352674de693e889f1439e076be3b2fc81c981c Mon Sep 17 00:00:00 2001 From: Hadrien Charlanes Date: Tue, 6 Jul 2021 11:30:01 +0200 Subject: [PATCH 5/6] fix: fixed test name typo --- test-suites/test-aave/delegation-permit.spec.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test-suites/test-aave/delegation-permit.spec.ts b/test-suites/test-aave/delegation-permit.spec.ts index d94d1e55..6f9b9754 100644 --- a/test-suites/test-aave/delegation-permit.spec.ts +++ b/test-suites/test-aave/delegation-permit.spec.ts @@ -114,7 +114,7 @@ makeSuite('Permit Delegation', (testEnv: TestEnv) => { (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 () => { + it('User 3 borrows stable interest dai on behalf of user 2 via permit', async () => { const { pool, variableDebtDai, From 91709e82e206f6c1edccab3466e320db05f69abe Mon Sep 17 00:00:00 2001 From: Hadrien Charlanes Date: Tue, 6 Jul 2021 11:54:13 +0200 Subject: [PATCH 6/6] fix: updated mocked debt contracts for upgradability tests --- contracts/mocks/upgradeability/MockStableDebtToken.sol | 2 +- contracts/mocks/upgradeability/MockVariableDebtToken.sol | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/contracts/mocks/upgradeability/MockStableDebtToken.sol b/contracts/mocks/upgradeability/MockStableDebtToken.sol index cbc66664..69f5861f 100644 --- a/contracts/mocks/upgradeability/MockStableDebtToken.sol +++ b/contracts/mocks/upgradeability/MockStableDebtToken.sol @@ -5,6 +5,6 @@ import {StableDebtToken} from '../../protocol/tokenization/StableDebtToken.sol'; contract MockStableDebtToken is StableDebtToken { function getRevision() internal pure override returns (uint256) { - return 0x2; + return 0x3; } } diff --git a/contracts/mocks/upgradeability/MockVariableDebtToken.sol b/contracts/mocks/upgradeability/MockVariableDebtToken.sol index 497682c3..01b9f05f 100644 --- a/contracts/mocks/upgradeability/MockVariableDebtToken.sol +++ b/contracts/mocks/upgradeability/MockVariableDebtToken.sol @@ -5,6 +5,6 @@ import {VariableDebtToken} from '../../protocol/tokenization/VariableDebtToken.s contract MockVariableDebtToken is VariableDebtToken { function getRevision() internal pure override returns (uint256) { - return 0x2; + return 0x3; } }