test: core libraries Hardhat

Author: Thai Xuan Dang

.gitignore

@@ -17,4 +17,8 @@ yarn-error.log
 .yarn
 .yarnrc.yml
 
-.vscode/
+.vscode/
+
+cache_hardhat/
+artifacts/
+typechain/

hardhat.config.ts

@@ -1,4 +1,8 @@
-import "hardhat-deploy";
+import "@nomicfoundation/hardhat-foundry";
+import 'hardhat-typechain'
+import '@nomiclabs/hardhat-ethers'
+import '@nomiclabs/hardhat-waffle'
+import '@nomiclabs/hardhat-etherscan'
 import {
 	HardhatUserConfig,
 	NetworkUserConfig,
@@ -28,6 +32,16 @@ const config: HardhatUserConfig = {
 		"ronin-testnet": testnet,
 		"ronin-mainnet": mainnet,
 	},
+
+	solidity: {
+    version: '0.7.6',
+    settings: {
+      optimizer: {
+        enabled: true,
+        runs: 250,
+      },
+    },
+  },
 };
 
 export default config;

package.json

@@ -3,20 +3,41 @@
     "src/**/*.sol"
   ],
   "devDependencies": {
+    "@nomicfoundation/hardhat-foundry": "^1.1.2",
+    "@nomiclabs/hardhat-ethers": "^2.0.2",
+    "@nomiclabs/hardhat-etherscan": "^2.1.8",
+    "@nomiclabs/hardhat-waffle": "^2.0.1",
+    "@typechain/ethers-v5": "^4.0.0",
+    "@types/chai": "^4.2.6",
+    "@types/mocha": "^5.2.7",
+    "chai": "^4.2.0",
+    "decimal.js": "^10.2.1",
     "dotenv": "^16.3.1",
-    "hardhat": "^2.12.7",
-    "hardhat-deploy": "0.11.29",
+    "ethereum-waffle": "^3.0.2",
+    "ethers": "^5.0.8",
+    "hardhat": "^2.2.0",
+    "hardhat-typechain": "^0.3.5",
     "husky": "^8.0.3",
     "lint-staged": "^14.0.1",
-    "ts-node": "^10.4.0",
-    "typescript": "^4.5.4"
+    "mocha": "^6.2.2",
+    "mocha-chai-jest-snapshot": "^1.1.0",
+    "prettier": "^2.0.5",
+    "prettier-plugin-solidity": "^1.0.0-alpha.59",
+    "solhint": "^3.2.1",
+    "solhint-plugin-prettier": "^0.0.5",
+    "ts-generator": "^0.1.1",
+    "ts-node": "^8.5.4",
+    "typechain": "^4.0.0",
+    "typescript": "^3.7.3"
   },
   "lint-staged": {
     "{src,script,test}/**/*.sol": [
       "forge fmt"
     ]
   },
   "scripts": {
-    "prepare": "husky install"
+    "prepare": "husky install",
+    "compile": "hardhat compile",
+    "test": "hardhat test"
   }
 }

src/core/test/BitMathTest.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity =0.7.6;
+
+import "../libraries/BitMath.sol";
+
+contract BitMathTest {
+  function mostSignificantBit(uint256 x) external pure returns (uint8 r) {
+    return BitMath.mostSignificantBit(x);
+  }
+
+  function getGasCostOfMostSignificantBit(uint256 x) external view returns (uint256) {
+    uint256 gasBefore = gasleft();
+    BitMath.mostSignificantBit(x);
+    return gasBefore - gasleft();
+  }
+
+  function leastSignificantBit(uint256 x) external pure returns (uint8 r) {
+    return BitMath.leastSignificantBit(x);
+  }
+
+  function getGasCostOfLeastSignificantBit(uint256 x) external view returns (uint256) {
+    uint256 gasBefore = gasleft();
+    BitMath.leastSignificantBit(x);
+    return gasBefore - gasleft();
+  }
+}

src/core/test/FullMathTest.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity =0.7.6;
+
+import "../libraries/FullMath.sol";
+
+contract FullMathTest {
+  function mulDiv(uint256 x, uint256 y, uint256 z) external pure returns (uint256) {
+    return FullMath.mulDiv(x, y, z);
+  }
+
+  function mulDivRoundingUp(uint256 x, uint256 y, uint256 z) external pure returns (uint256) {
+    return FullMath.mulDivRoundingUp(x, y, z);
+  }
+}

src/core/test/LiquidityMathTest.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity =0.7.6;
+
+import "../libraries/LiquidityMath.sol";
+
+contract LiquidityMathTest {
+  function addDelta(uint128 x, int128 y) external pure returns (uint128 z) {
+    return LiquidityMath.addDelta(x, y);
+  }
+
+  function getGasCostOfAddDelta(uint128 x, int128 y) external view returns (uint256) {
+    uint256 gasBefore = gasleft();
+    LiquidityMath.addDelta(x, y);
+    return gasBefore - gasleft();
+  }
+}

src/core/test/SqrtPriceMathTest.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity =0.7.6;
+
+import "../libraries/SqrtPriceMath.sol";
+
+contract SqrtPriceMathTest {
+  function getNextSqrtPriceFromInput(uint160 sqrtP, uint128 liquidity, uint256 amountIn, bool zeroForOne)
+    external
+    pure
+    returns (uint160 sqrtQ)
+  {
+    return SqrtPriceMath.getNextSqrtPriceFromInput(sqrtP, liquidity, amountIn, zeroForOne);
+  }
+
+  function getGasCostOfGetNextSqrtPriceFromInput(uint160 sqrtP, uint128 liquidity, uint256 amountIn, bool zeroForOne)
+    external
+    view
+    returns (uint256)
+  {
+    uint256 gasBefore = gasleft();
+    SqrtPriceMath.getNextSqrtPriceFromInput(sqrtP, liquidity, amountIn, zeroForOne);
+    return gasBefore - gasleft();
+  }
+
+  function getNextSqrtPriceFromOutput(uint160 sqrtP, uint128 liquidity, uint256 amountOut, bool zeroForOne)
+    external
+    pure
+    returns (uint160 sqrtQ)
+  {
+    return SqrtPriceMath.getNextSqrtPriceFromOutput(sqrtP, liquidity, amountOut, zeroForOne);
+  }
+
+  function getGasCostOfGetNextSqrtPriceFromOutput(uint160 sqrtP, uint128 liquidity, uint256 amountOut, bool zeroForOne)
+    external
+    view
+    returns (uint256)
+  {
+    uint256 gasBefore = gasleft();
+    SqrtPriceMath.getNextSqrtPriceFromOutput(sqrtP, liquidity, amountOut, zeroForOne);
+    return gasBefore - gasleft();
+  }
+
+  function getAmount0Delta(uint160 sqrtLower, uint160 sqrtUpper, uint128 liquidity, bool roundUp)
+    external
+    pure
+    returns (uint256 amount0)
+  {
+    return SqrtPriceMath.getAmount0Delta(sqrtLower, sqrtUpper, liquidity, roundUp);
+  }
+
+  function getAmount1Delta(uint160 sqrtLower, uint160 sqrtUpper, uint128 liquidity, bool roundUp)
+    external
+    pure
+    returns (uint256 amount1)
+  {
+    return SqrtPriceMath.getAmount1Delta(sqrtLower, sqrtUpper, liquidity, roundUp);
+  }
+
+  function getGasCostOfGetAmount0Delta(uint160 sqrtLower, uint160 sqrtUpper, uint128 liquidity, bool roundUp)
+    external
+    view
+    returns (uint256)
+  {
+    uint256 gasBefore = gasleft();
+    SqrtPriceMath.getAmount0Delta(sqrtLower, sqrtUpper, liquidity, roundUp);
+    return gasBefore - gasleft();
+  }
+
+  function getGasCostOfGetAmount1Delta(uint160 sqrtLower, uint160 sqrtUpper, uint128 liquidity, bool roundUp)
+    external
+    view
+    returns (uint256)
+  {
+    uint256 gasBefore = gasleft();
+    SqrtPriceMath.getAmount1Delta(sqrtLower, sqrtUpper, liquidity, roundUp);
+    return gasBefore - gasleft();
+  }
+}

src/core/test/SwapMathTest.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity =0.7.6;
+
+import "../libraries/SwapMath.sol";
+
+contract SwapMathTest {
+  function computeSwapStep(
+    uint160 sqrtP,
+    uint160 sqrtPTarget,
+    uint128 liquidity,
+    int256 amountRemaining,
+    uint24 feePips
+  ) external pure returns (uint160 sqrtQ, uint256 amountIn, uint256 amountOut, uint256 feeAmount) {
+    return SwapMath.computeSwapStep(sqrtP, sqrtPTarget, liquidity, amountRemaining, feePips);
+  }
+
+  function getGasCostOfComputeSwapStep(
+    uint160 sqrtP,
+    uint160 sqrtPTarget,
+    uint128 liquidity,
+    int256 amountRemaining,
+    uint24 feePips
+  ) external view returns (uint256) {
+    uint256 gasBefore = gasleft();
+    SwapMath.computeSwapStep(sqrtP, sqrtPTarget, liquidity, amountRemaining, feePips);
+    return gasBefore - gasleft();
+  }
+}

src/core/test/TickBitmapTest.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity =0.7.6;
+
+import "../libraries/TickBitmap.sol";
+
+contract TickBitmapTest {
+  using TickBitmap for mapping(int16 => uint256);
+
+  mapping(int16 => uint256) public bitmap;
+
+  function flipTick(int24 tick) external {
+    bitmap.flipTick(tick, 1);
+  }
+
+  function getGasCostOfFlipTick(int24 tick) external returns (uint256) {
+    uint256 gasBefore = gasleft();
+    bitmap.flipTick(tick, 1);
+    return gasBefore - gasleft();
+  }
+
+  function nextInitializedTickWithinOneWord(int24 tick, bool lte) external view returns (int24 next, bool initialized) {
+    return bitmap.nextInitializedTickWithinOneWord(tick, 1, lte);
+  }
+
+  function getGasCostOfNextInitializedTickWithinOneWord(int24 tick, bool lte) external view returns (uint256) {
+    uint256 gasBefore = gasleft();
+    bitmap.nextInitializedTickWithinOneWord(tick, 1, lte);
+    return gasBefore - gasleft();
+  }
+
+  // returns whether the given tick is initialized
+  function isInitialized(int24 tick) external view returns (bool) {
+    (int24 next, bool initialized) = bitmap.nextInitializedTickWithinOneWord(tick, 1, true);
+    return next == tick ? initialized : false;
+  }
+}

src/core/test/TickMathTest.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity =0.7.6;
+
+import "../libraries/TickMath.sol";
+
+contract TickMathTest {
+  function getSqrtRatioAtTick(int24 tick) external pure returns (uint160) {
+    return TickMath.getSqrtRatioAtTick(tick);
+  }
+
+  function getGasCostOfGetSqrtRatioAtTick(int24 tick) external view returns (uint256) {
+    uint256 gasBefore = gasleft();
+    TickMath.getSqrtRatioAtTick(tick);
+    return gasBefore - gasleft();
+  }
+
+  function getTickAtSqrtRatio(uint160 sqrtPriceX96) external pure returns (int24) {
+    return TickMath.getTickAtSqrtRatio(sqrtPriceX96);
+  }
+
+  function getGasCostOfGetTickAtSqrtRatio(uint160 sqrtPriceX96) external view returns (uint256) {
+    uint256 gasBefore = gasleft();
+    TickMath.getTickAtSqrtRatio(sqrtPriceX96);
+    return gasBefore - gasleft();
+  }
+
+  function MIN_SQRT_RATIO() external pure returns (uint160) {
+    return TickMath.MIN_SQRT_RATIO;
+  }
+
+  function MAX_SQRT_RATIO() external pure returns (uint160) {
+    return TickMath.MAX_SQRT_RATIO;
+  }
+}