Sepolia v2.0 beta.4 (#66)

* Fix PoolMock * Fix PoolMock * Deploy v2.0-beta.4
SizeCredit · Mar 20, 2024 · 2fa72e5 · 2fa72e5
1 parent acefb6e
commit 2fa72e5
Show file tree

Hide file tree

Showing 6 changed files with 4,338 additions and 113 deletions.
diff --git a/broadcast/Deploy.s.sol/11155111/run-1710964505.json b/broadcast/Deploy.s.sol/11155111/run-1710964505.json
diff --git a/broadcast/Deploy.s.sol/11155111/run-1710968526.json b/broadcast/Deploy.s.sol/11155111/run-1710968526.json
diff --git a/broadcast/Deploy.s.sol/11155111/run-latest.json b/broadcast/Deploy.s.sol/11155111/run-latest.json
diff --git a/deployments/11155111.json b/deployments/11155111.json
@@ -0,0 +1,18 @@
+{
+  "commit": "5d8bcc5",
+  "deployments": {
+    "PriceFeed": "0xa399A4503A85760D7e8556ac76fAD0714501eF2e",
+    "Size-implementation": "0x08977464D34667a59D6B6AEd40F6c5DA61F9C15D",
+    "Size-proxy": "0x00B67a7183d55ddE964c28aB5Cc74b8C5A671085",
+    "VariablePool": "0xc4b88906c5d9AcF5d239A82DC7dEA332DF847cBa",
+    "VariablePoolBorrowRateFeed": "0x8EA6115c5E5BEAA1d837720c11e2939a7EC06Fe6"
+  },
+  "networkName": "Sepolia",
+  "parameters": {
+    "owner": "0xf0c7f57f5f889d546f032e50fba953bd7c026350",
+    "usdc": "0x94a9d9ac8a22534e3faca9f4e7f2e2cf85d5e4c8",
+    "usdcAggregator": "0x0000000000000000000000000000000000000000",
+    "weth": "0xfff9976782d46cc05630d1f6ebab18b2324d6b14",
+    "wethAggregator": "0x0000000000000000000000000000000000000000"
+  }
+}
diff --git a/script/Deploy.sol b/script/Deploy.sol
@@ -48,9 +48,8 @@ abstract contract Deploy {
         variablePoolBorrowRateFeed = new VariablePoolBorrowRateFeedMock(owner);
         weth = new WETH();
         usdc = new USDC(owner);
-        variablePool = IPool(address(new PoolMock(priceFeed)));
+        variablePool = IPool(address(new PoolMock()));
         PoolMock(address(variablePool)).setLiquidityIndex(address(usdc), WadRayMath.RAY);
-        PoolMock(address(variablePool)).setLiquidityIndex(address(weth), WadRayMath.RAY, true);
         f = InitializeFeeConfigParams({
             repayFeeAPR: 0.005e18,
             earlyLenderExitFee: 5e6,
@@ -135,9 +134,8 @@ abstract contract Deploy {
 
     function setupChainWithMocks(address _owner, address _weth, address _usdc) internal {
         priceFeed = new PriceFeedMock(_owner);
-        variablePool = IPool(address(new PoolMock(priceFeed)));
+        variablePool = IPool(address(new PoolMock()));
         PoolMock(address(variablePool)).setLiquidityIndex(address(_usdc), WadRayMath.RAY);
-        PoolMock(address(variablePool)).setLiquidityIndex(address(_weth), WadRayMath.RAY, true);
         PriceFeedMock(address(priceFeed)).setPrice(2468e18);
         variablePoolBorrowRateFeed = new VariablePoolBorrowRateFeedMock(_owner);
         VariablePoolBorrowRateFeedMock(address(variablePoolBorrowRateFeed)).setVariableBorrowRate(0.0724e18);

diff --git a/test/mocks/PoolMock.sol b/test/mocks/PoolMock.sol
@@ -14,157 +14,80 @@ import {VariableDebtToken} from "@aave/protocol/tokenization/VariableDebtToken.s
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import {EnumerableMap} from "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
-import {Math} from "@src/libraries/Math.sol";
-import {IPriceFeed} from "@src/oracle/IPriceFeed.sol";
 
 contract PoolMock is Ownable {
     using SafeERC20 for IERC20Metadata;
-    using EnumerableMap for EnumerableMap.AddressToUintMap;
 
-    EnumerableMap.AddressToUintMap internal reserveIndexes;
-    PoolAddressesProvider internal immutable addressesProvider;
-    IPriceFeed internal immutable priceFeed;
-
-    // https://github.com/foundry-rs/foundry/issues/4615
-    bool public IS_TEST = true;
+    struct Data {
+        AToken aToken;
+        VariableDebtToken debtToken;
+        uint256 reserveIndex;
+    }
 
-    mapping(address asset => AToken aToken) internal aTokens;
-    mapping(address asset => VariableDebtToken) internal debtTokens;
-    mapping(address asset => bool) internal isCollateralToken;
-    MockIncentivesController internal incentivesController;
+    PoolAddressesProvider private immutable addressesProvider;
+    mapping(address asset => Data data) private datas;
 
-    constructor(IPriceFeed _priceFeed) Ownable(msg.sender) {
+    constructor() Ownable(msg.sender) {
         addressesProvider = new PoolAddressesProvider("", address(this));
-        priceFeed = _priceFeed;
-    }
-
-    function setLiquidityIndex(address asset, uint256 index, bool isCollateral) external onlyOwner {
-        setLiquidityIndex(asset, index);
-        isCollateralToken[asset] = isCollateral;
     }
 
     function setLiquidityIndex(address asset, uint256 index) public onlyOwner {
-        (bool exists,) = reserveIndexes.tryGet(asset);
-        if (!exists) {
-            aTokens[asset] = new AToken(IPool(address(this)));
-            debtTokens[asset] = new VariableDebtToken(IPool(address(this)));
-
-            aTokens[asset].initialize(
+        Data storage data = datas[asset];
+        if (data.reserveIndex == 0) {
+            data.aToken = new AToken(IPool(address(this)));
+            data.debtToken = new VariableDebtToken(IPool(address(this)));
+            MockIncentivesController incentivesController = new MockIncentivesController();
+            uint8 decimals = IERC20Metadata(asset).decimals();
+            string memory name = IERC20Metadata(asset).name();
+            string memory symbol = IERC20Metadata(asset).symbol();
+
+            data.aToken.initialize(
                 IPool(address(this)),
                 owner(),
                 asset,
                 incentivesController,
-                IERC20Metadata(asset).decimals(),
-                string.concat("Size aToken ", IERC20Metadata(asset).name()),
+                decimals,
+                string.concat("Size aToken ", name),
                 string.concat("asz", IERC20Metadata(asset).symbol()),
                 ""
             );
-            debtTokens[asset].initialize(
+            data.debtToken.initialize(
                 IPool(address(this)),
                 asset,
                 incentivesController,
-                IERC20Metadata(asset).decimals(),
-                string.concat("Size variableDebtToken ", IERC20Metadata(asset).name()),
-                string.concat("dsz", IERC20Metadata(asset).symbol()),
+                decimals,
+                string.concat("Size variableDebtToken ", name),
+                string.concat("dsz", symbol),
                 ""
             );
         }
-        reserveIndexes.set(asset, index);
+        data.reserveIndex = index;
     }
 
     function supply(address asset, uint256 amount, address onBehalfOf, uint16) external {
+        Data memory data = datas[asset];
         IERC20Metadata(asset).transferFrom(msg.sender, address(this), amount);
-        aTokens[asset].mint(address(this), onBehalfOf, amount, reserveIndexes.get(asset));
+        data.aToken.mint(address(this), onBehalfOf, amount, data.reserveIndex);
     }
 
     function withdraw(address asset, uint256 amount, address to) external returns (uint256) {
-        aTokens[asset].burn(msg.sender, address(aTokens[asset]), amount, reserveIndexes.get(asset));
+        Data memory data = datas[asset];
+        data.aToken.burn(msg.sender, address(data.aToken), amount, data.reserveIndex);
         IERC20Metadata(asset).safeTransfer(to, amount);
         return amount;
     }
 
-    function borrow(address asset, uint256 amount, uint256, uint16, address) external {
-        debtTokens[asset].mint(msg.sender, msg.sender, amount, reserveIndexes.get(asset));
-        IERC20Metadata(asset).safeTransfer(msg.sender, amount);
-    }
-
-    function repay(address asset, uint256 amount, uint256, address onBehalfOf) external returns (uint256) {
-        debtTokens[asset].burn(onBehalfOf, amount, reserveIndexes.get(asset));
-        IERC20Metadata(asset).transferFrom(msg.sender, address(this), amount);
-        return amount;
-    }
-
-    function repayWithATokens(address asset, uint256 amount, uint256) external returns (uint256) {
-        amount = Math.min(amount, debtTokens[asset].balanceOf(msg.sender));
-        debtTokens[asset].burn(msg.sender, amount, reserveIndexes.get(asset));
-        aTokens[asset].burn(msg.sender, address(aTokens[asset]), amount, reserveIndexes.get(asset));
-        return amount;
-    }
-
-    function liquidationCall(address collateralAsset, address debtAsset, address user, uint256 debtToCover, bool)
-        public
-    {
-        uint8 decimals = IERC20Metadata(collateralAsset).decimals() - IERC20Metadata(debtAsset).decimals();
-        uint256 collateralAmount = debtToCover * 10 ** decimals * (10 ** priceFeed.decimals()) / priceFeed.getPrice();
-        IERC20Metadata(debtAsset).transferFrom(msg.sender, address(this), debtToCover);
-        aTokens[collateralAsset].transferOnLiquidation(user, msg.sender, collateralAmount);
-        debtTokens[debtAsset].burn(user, debtToCover, reserveIndexes.get(debtAsset));
-    }
-
-    function getUserAccountData(address user)
-        external
-        view
-        returns (
-            uint256 totalCollateralBase,
-            uint256 totalDebtBase,
-            uint256 availableBorrowsBase,
-            uint256 currentLiquidationThreshold,
-            uint256 ltv,
-            uint256 healthFactor
-        )
-    {
-        availableBorrowsBase = 0;
-        currentLiquidationThreshold = 0;
-        ltv = 0;
-        uint256 length = reserveIndexes.length();
-        address collateralAsset;
-        address debtAsset;
-        for (uint256 i = 0; i < length; i++) {
-            (address asset,) = reserveIndexes.at(i);
-            if (isCollateralToken[asset]) {
-                collateralAsset = asset;
-            } else {
-                debtAsset = asset;
-            }
-        }
-
-        uint8 decimals = IERC20Metadata(collateralAsset).decimals() - IERC20Metadata(debtAsset).decimals();
-        totalCollateralBase = aTokens[collateralAsset].balanceOf(user);
-        totalDebtBase = debtTokens[debtAsset].balanceOf(user);
-        healthFactor = totalCollateralBase * priceFeed.getPrice() / (totalDebtBase * 10 ** decimals);
-    }
-
     function getReserveNormalizedIncome(address asset) external view returns (uint256) {
-        return reserveIndexes.get(asset);
+        return datas[asset].reserveIndex;
     }
 
-    function getReserveNormalizedVariableDebt(address asset) external view returns (uint256) {
-        return reserveIndexes.get(asset);
-    }
-
-    function getReserveData(address asset) external view returns (DataTypes.ReserveData memory) {
-        DataTypes.ReserveData memory data;
-        data.aTokenAddress = address(aTokens[asset]);
-        data.variableDebtTokenAddress = address(debtTokens[asset]);
-        return data;
+    function getReserveData(address asset) external view returns (DataTypes.ReserveData memory reserveData) {
+        reserveData.aTokenAddress = address(datas[asset].aToken);
     }
 
     function ADDRESSES_PROVIDER() external view returns (IPoolAddressesProvider) {
         return addressesProvider;
     }
 
     function finalizeTransfer(address, address, address, uint256, uint256, uint256) external pure {}
-
-    function setUserUseReserveAsCollateral(address, bool) external pure {}
 }