feat: add foundry test for bitmaps

.gitignore

@@ -26,4 +26,8 @@ deployments/
 **.last_conf*
 certora-logs
 certora_debug_log.txt
-resource_errors.json
+resource_errors.json
+
+out
+lcov.info
+.foundry

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "lib/forge-std"]
+	path = lib/forge-std
+	url = https://github.com/foundry-rs/forge-std

foundry.toml

@@ -0,0 +1,10 @@
+[profile.default]
+src = 'src'
+out = 'out'
+libs = ['lib']
+fuzz_runs = 10000
+optimizer = true
+
+solc = "0.8.10"
+
+# See more config options https://github.com/gakonst/foundry/tree/master/config

package.json

@@ -13,6 +13,8 @@
     "node": ">=16.0.0"
   },
   "scripts": {
+    "setup:foundry": "foundryup && forge install",
+    "install:foundry": "curl -L https://foundry.paradigm.xyz | bash",
     "size": "npm run compile && npm run hardhat size-contracts",
     "run-env": "npm i && tail -f /dev/null",
     "hardhat": "hardhat",
@@ -23,6 +25,7 @@
     "prettier:write": "prettier -w .",
     "coverage": ". ./setup-test-env.sh && COVERAGE=true npx hardhat coverage --temp temp-artifacts --testfiles test-suites/emptyrun.coverage.ts && rm -rf coverage.json coverage/ && COVERAGE=true npx hardhat coverage --temp temp-artifacts --testfiles 'test-suites/*.spec.ts'",
     "test": ". ./setup-test-env.sh && TS_NODE_TRANSPILE_ONLY=1 hardhat test test-suites/*.spec.ts",
+    "test-fuzz": "forge test",
     "test-scenarios": ". ./setup-test-env.sh && npx hardhat test test-suites/__setup.spec.ts test-suites/scenario.spec.ts",
     "test-l2pool": ". ./setup-test-env.sh && npx hardhat test test-suites/__setup.spec.ts test-suites/pool-l2.spec.ts",
     "test-subgraph:scenarios": ". ./setup-test-env.sh  && hardhat --network hardhatevm_docker test test-suites/__setup.spec.ts test-suites/subgraph-scenarios.spec.ts",
@@ -88,4 +91,4 @@
   "lint-staged": {
     "*.{ts,js,md,sol}": "prettier --write"
   }
-}
+}

src/test/CalldataLogic.t.sol

@@ -0,0 +1,293 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.10;
+
+import {DataTypes} from './../../contracts/protocol/libraries/types/DataTypes.sol';
+import {ReserveConfiguration} from './../../contracts/protocol/libraries/configuration/ReserveConfiguration.sol';
+
+import {CalldataLogic} from './../../contracts/protocol/libraries/logic/CalldataLogic.sol';
+import {L2Encoder} from './../../contracts/misc/L2Encoder.sol';
+
+import {Test} from 'forge-std/Test.sol';
+
+contract CalldataLogicTest is Test {
+  using ReserveConfiguration for DataTypes.ReserveConfigurationMap;
+
+  mapping(uint256 => address) reservesList;
+
+  uint256 constant RESERVE_COUNT = 128;
+
+  function setUp() public {
+    for (uint256 i = 0; i < RESERVE_COUNT; i++) {
+      reservesList[i] = address(uint160(400 + i));
+    }
+  }
+
+  function testDecodeSupplyParams(uint8 assetId, uint128 amount, uint16 referralCode) public view {
+    vm.assume(assetId < RESERVE_COUNT);
+
+    bytes32 args;
+    assembly {
+      args := add(assetId, add(shl(16, amount), shl(144, referralCode)))
+    }
+
+    (address _asset, uint256 _amount, uint16 _referralCode) = CalldataLogic.decodeSupplyParams(
+      reservesList,
+      args
+    );
+
+    assertEq(_asset, reservesList[assetId]);
+    assertNotEq(_asset, address(0));
+    assertEq(_amount, amount);
+    assertEq(_referralCode, referralCode);
+  }
+
+  function testDecodeSupplyWithPermitParams(
+    uint8 assetId,
+    uint128 amount,
+    uint16 referralCode,
+    uint32 deadLine,
+    uint8 permitV
+  ) public view {
+    vm.assume(assetId < RESERVE_COUNT);
+
+    bytes32 args;
+    assembly {
+      args := add(
+        assetId,
+        add(
+          shl(16, amount),
+          add(shl(144, referralCode), add(shl(160, deadLine), shl(192, permitV)))
+        )
+      )
+    }
+
+    (
+      address _asset,
+      uint256 _amount,
+      uint16 _referralCode,
+      uint256 _deadLine,
+      uint8 _permitV
+    ) = CalldataLogic.decodeSupplyWithPermitParams(reservesList, args);
+
+    assertEq(_asset, reservesList[assetId]);
+    assertNotEq(_asset, address(0));
+    assertEq(_amount, amount);
+    assertEq(_referralCode, referralCode);
+    assertEq(_deadLine, deadLine);
+    assertEq(_permitV, permitV);
+  }
+
+  function testDecodeWithdrawParams(uint8 assetId, uint128 amount) public view {
+    vm.assume(assetId < RESERVE_COUNT);
+    bytes32 args;
+    assembly {
+      args := add(assetId, shl(16, amount))
+    }
+
+    (address _asset, uint256 _amount) = CalldataLogic.decodeWithdrawParams(reservesList, args);
+
+    uint256 expectedAmount = amount == type(uint128).max ? type(uint256).max : uint256(amount);
+
+    assertEq(_asset, reservesList[assetId]);
+    assertNotEq(_asset, address(0));
+    assertEq(_amount, expectedAmount);
+  }
+
+  function testDecodeBorrowParams(
+    uint8 assetId,
+    uint128 amount,
+    bool stableRateMode,
+    uint16 referralCode
+  ) public view {
+    vm.assume(assetId < RESERVE_COUNT);
+    uint256 interestRateMode = stableRateMode ? 1 : 2;
+
+    bytes32 args;
+    assembly {
+      args := add(
+        assetId,
+        add(shl(16, amount), add(shl(144, interestRateMode), shl(152, referralCode)))
+      )
+    }
+
+    (
+      address _asset,
+      uint256 _amount,
+      uint256 _interestRateMode,
+      uint16 _referralCode
+    ) = CalldataLogic.decodeBorrowParams(reservesList, args);
+
+    assertEq(_asset, reservesList[assetId]);
+    assertNotEq(_asset, address(0));
+    assertEq(_amount, amount);
+    assertEq(_interestRateMode, interestRateMode);
+    assertEq(_referralCode, referralCode);
+  }
+
+  function testDecodeRepayParams(uint8 assetId, uint128 amount, bool stableRateMode) public view {
+    vm.assume(assetId < RESERVE_COUNT);
+    uint256 interestRateMode = stableRateMode ? 1 : 2;
+    uint256 expectedAmount = amount == type(uint128).max ? type(uint256).max : amount;
+
+    bytes32 args;
+    assembly {
+      args := add(assetId, add(shl(16, amount), shl(144, interestRateMode)))
+    }
+
+    (address _asset, uint256 _amount, uint256 _interestRateMode) = CalldataLogic.decodeRepayParams(
+      reservesList,
+      args
+    );
+
+    assertEq(_asset, reservesList[assetId]);
+    assertNotEq(_asset, address(0));
+    assertEq(_amount, expectedAmount);
+    assertEq(_interestRateMode, interestRateMode);
+  }
+
+  struct DecodeRepayWithPermitHelper {
+    uint256 expectedAmount;
+    address _asset;
+    uint256 _amount;
+    uint256 _interestRateMode;
+    uint256 _deadline;
+    uint8 _permitV;
+  }
+
+  function testDecodeRepayWithPermitParams(
+    uint8 assetId,
+    uint128 amount,
+    bool stableRateMode,
+    uint32 deadline,
+    uint8 permitV
+  ) public view {
+    vm.assume(assetId < RESERVE_COUNT);
+    DecodeRepayWithPermitHelper memory vars;
+
+    vars.expectedAmount = amount == type(uint128).max ? type(uint256).max : amount;
+
+    bytes32 args;
+    assembly {
+      args := add(
+        assetId,
+        add(
+          shl(16, amount),
+          add(shl(144, sub(2, stableRateMode)), add(shl(152, deadline), shl(184, permitV)))
+        )
+      )
+    }
+
+    (
+      vars._asset,
+      vars._amount,
+      vars._interestRateMode,
+      vars._deadline,
+      vars._permitV
+    ) = CalldataLogic.decodeRepayWithPermitParams(reservesList, args);
+
+    assertEq(vars._asset, reservesList[assetId]);
+    assertNotEq(vars._asset, address(0));
+    assertEq(vars._amount, vars.expectedAmount);
+    assertEq(vars._interestRateMode, stableRateMode ? 1 : 2);
+    assertEq(vars._deadline, uint256(deadline));
+    assertEq(vars._permitV, permitV);
+  }
+
+  function testDecodeSwapBorrowRateModeParams(uint8 assetId, bool stableRateMode) public view {
+    vm.assume(assetId < RESERVE_COUNT);
+    uint256 interestRateMode = stableRateMode ? 1 : 2;
+    bytes32 args;
+    assembly {
+      args := add(assetId, shl(16, interestRateMode))
+    }
+
+    (address _asset, uint256 _interestRateMode) = CalldataLogic.decodeSwapBorrowRateModeParams(
+      reservesList,
+      args
+    );
+
+    assertEq(_asset, reservesList[assetId]);
+    assertNotEq(_asset, address(0));
+    assertEq(_interestRateMode, interestRateMode);
+  }
+
+  function testDecodeRebalanceStableBorrowRateParams(uint8 assetId, address user) public view {
+    vm.assume(assetId < RESERVE_COUNT);
+    bytes32 args;
+    assembly {
+      args := add(assetId, shl(16, user))
+    }
+
+    (address _asset, address _user) = CalldataLogic.decodeRebalanceStableBorrowRateParams(
+      reservesList,
+      args
+    );
+    assertEq(_asset, reservesList[assetId]);
+    assertNotEq(_asset, address(0));
+    assertEq(_user, user);
+  }
+
+  function testDecodeSetUserUseReserveAsCollateralParams(
+    uint8 assetId,
+    bool useAsCollateral
+  ) public view {
+    vm.assume(assetId < RESERVE_COUNT);
+    bytes32 args;
+    assembly {
+      args := add(assetId, shl(16, useAsCollateral))
+    }
+
+    (address _asset, bool _useAsCollateral) = CalldataLogic
+      .decodeSetUserUseReserveAsCollateralParams(reservesList, args);
+
+    assertEq(_asset, reservesList[assetId]);
+    assertNotEq(_asset, address(0));
+    assertEq(_useAsCollateral, useAsCollateral);
+  }
+
+  struct DecodeLiquidationCallParamsHelper {
+    uint256 expectedDebtToCover;
+    address collateralAsset;
+    address debtAsset;
+    address user;
+    uint256 debtToCover;
+    bool receiveAToken;
+  }
+
+  function testDecodeLiquidationCallParams(
+    uint8 collateralAssetId,
+    uint8 debtAssetId,
+    address user,
+    uint128 debtToCover,
+    bool receiveAToken
+  ) public view {
+    vm.assume(collateralAssetId < RESERVE_COUNT && debtAssetId < RESERVE_COUNT);
+    DecodeLiquidationCallParamsHelper memory vars;
+
+    bytes32 args1;
+    bytes32 args2;
+
+    vars.expectedDebtToCover = debtToCover == type(uint128).max ? type(uint256).max : debtToCover;
+
+    assembly {
+      args1 := add(add(collateralAssetId, shl(16, debtAssetId)), shl(32, user))
+      args2 := add(debtToCover, shl(128, receiveAToken))
+    }
+
+    (
+      vars.collateralAsset,
+      vars.debtAsset,
+      vars.user,
+      vars.debtToCover,
+      vars.receiveAToken
+    ) = CalldataLogic.decodeLiquidationCallParams(reservesList, args1, args2);
+
+    assertEq(vars.collateralAsset, reservesList[collateralAssetId]);
+    assertNotEq(vars.collateralAsset, address(0));
+    assertEq(vars.debtAsset, reservesList[debtAssetId]);
+    assertNotEq(vars.debtAsset, address(0));
+    assertEq(vars.user, user);
+    assertEq(vars.debtToCover, vars.expectedDebtToCover);
+    assertEq(vars.receiveAToken, receiveAToken);
+  }
+}

src/test/PercentageMath.t.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.10;
+
+import {PercentageMath} from './../../contracts/protocol/libraries/math/PercentageMath.sol';
+
+import {Test} from 'forge-std/Test.sol';
+
+contract PercentageMathTest is Test {
+  using PercentageMath for uint256;
+
+  function testPercentMul(uint256 a, uint256 b) public pure {
+    bool safe = b == 0 || a <= (type(uint256).max - PercentageMath.HALF_PERCENTAGE_FACTOR) / b;
+    vm.assume(safe);
+    assertEq(
+      a.percentMul(b),
+      (a * b + PercentageMath.HALF_PERCENTAGE_FACTOR) / PercentageMath.PERCENTAGE_FACTOR
+    );
+  }
+
+  function testPercentDiv(uint256 a, uint256 b) public pure {
+    bool safe = b != 0 && a <= (type(uint256).max - b / 2) / PercentageMath.PERCENTAGE_FACTOR;
+    vm.assume(safe);
+    assertEq(a.percentDiv(b), (a * PercentageMath.PERCENTAGE_FACTOR + b / 2) / b);
+  }
+
+  /// NEGATIVES ///
+
+  function testFailPercentMul(uint256 a, uint256 b) public pure {
+    bool safe = b == 0 || a <= (type(uint256).max - PercentageMath.HALF_PERCENTAGE_FACTOR) / b;
+    vm.assume(!safe);
+    a.percentMul(b);
+  }
+
+  function testFailPercentDiv(uint256 a, uint256 b) public pure {
+    bool safe = b != 0 && a <= (type(uint256).max - b / 2) / PercentageMath.PERCENTAGE_FACTOR;
+    vm.assume(!safe);
+    a.percentDiv(b);
+  }
+}