test: core specification Hardhat

Author: Thai Xuan Dang

src/core/test/CompileTrigger.sol

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: MIT
+pragma solidity =0.7.6;
+
+import "@openzeppelin/contracts/proxy/TransparentUpgradeableProxy.sol";

src/core/test/KatanaV3PoolSwapTest.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity =0.7.6;
+
+import "../interfaces/IERC20Minimal.sol";
+
+import "../interfaces/callback/IKatanaV3SwapCallback.sol";
+import "../interfaces/IKatanaV3Pool.sol";
+
+contract KatanaV3PoolSwapTest is IKatanaV3SwapCallback {
+  int256 private _amount0Delta;
+  int256 private _amount1Delta;
+
+  function getSwapResult(address pool, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96)
+    external
+    returns (int256 amount0Delta, int256 amount1Delta, uint160 nextSqrtRatio)
+  {
+    (amount0Delta, amount1Delta) =
+      IKatanaV3Pool(pool).swap(address(0), zeroForOne, amountSpecified, sqrtPriceLimitX96, abi.encode(msg.sender));
+
+    (nextSqrtRatio,,,,,,) = IKatanaV3Pool(pool).slot0();
+  }
+
+  function katanaV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external override {
+    address sender = abi.decode(data, (address));
+
+    if (amount0Delta > 0) {
+      IERC20Minimal(IKatanaV3Pool(msg.sender).token0()).transferFrom(sender, msg.sender, uint256(amount0Delta));
+    } else if (amount1Delta > 0) {
+      IERC20Minimal(IKatanaV3Pool(msg.sender).token1()).transferFrom(sender, msg.sender, uint256(amount1Delta));
+    }
+  }
+}

src/core/test/MockTimeKatanaV3Pool.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity =0.7.6;
+
+import "../KatanaV3Pool.sol";
+
+// used for testing time dependent behavior
+contract MockTimeKatanaV3Pool is KatanaV3Pool {
+  constructor(address factory, address governance) KatanaV3Pool(factory, governance) { }
+
+  // Monday, October 5, 2020 9:00:00 AM GMT-05:00
+  uint256 public time = 1601906400;
+
+  /// @inheritdoc IKatanaV3PoolImmutablesInitializable
+  function initializeImmutables(address factory, address token0, address token1, uint24 fee, int24 tickSpacing)
+    public
+    override
+  {
+    super.initializeImmutables(factory, token0, token1, fee, tickSpacing);
+    time = 1601906400;
+  }
+
+  function setFeeGrowthGlobal0X128(uint256 _feeGrowthGlobal0X128) external {
+    feeGrowthGlobal0X128 = _feeGrowthGlobal0X128;
+  }
+
+  function setFeeGrowthGlobal1X128(uint256 _feeGrowthGlobal1X128) external {
+    feeGrowthGlobal1X128 = _feeGrowthGlobal1X128;
+  }
+
+  function advanceTime(uint256 by) external {
+    time += by;
+  }
+
+  function _blockTimestamp() internal view override returns (uint32) {
+    return uint32(time);
+  }
+}

src/core/test/MockTimeKatanaV3PoolDeployer.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity =0.7.6;
+
+import "@openzeppelin/contracts/utils/Create2.sol";
+
+import "../interfaces/IKatanaV3PoolDeployer.sol";
+import "../interfaces/IKatanaV3PoolBeaconImmutables.sol";
+
+import "../KatanaV3PoolBeacon.sol";
+import "./MockTimeKatanaV3Pool.sol";
+
+contract MockTimeKatanaV3PoolDeployer is IKatanaV3PoolDeployer {
+  struct Parameters {
+    address factory;
+    address token0;
+    address token1;
+    uint24 fee;
+    int24 tickSpacing;
+  }
+
+  address public immutable override BEACON;
+
+  Parameters public override parameters;
+
+  event PoolDeployed(address pool);
+
+  constructor(address factory, address governance) {
+    address poolImplemenation = address(new MockTimeKatanaV3Pool(factory, governance));
+    BEACON = address(new KatanaV3PoolBeacon(poolImplemenation));
+  }
+
+  function deploy(address factory, address token0, address token1, uint24 fee, int24 tickSpacing)
+    external
+    returns (address pool)
+  {
+    parameters = Parameters({ factory: factory, token0: token0, token1: token1, fee: fee, tickSpacing: tickSpacing });
+    bytes memory creationCode = IKatanaV3PoolBeaconImmutables(BEACON).POOL_PROXY_INIT_CODE();
+    bytes32 salt = keccak256(abi.encode(token0, token1, fee));
+    pool = Create2.deploy(0, salt, creationCode);
+    emit PoolDeployed(pool);
+    delete parameters;
+  }
+}

src/core/test/TestERC20.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity =0.7.6;
+
+import "../interfaces/IERC20Minimal.sol";
+
+contract TestERC20 is IERC20Minimal {
+  mapping(address => uint256) public override balanceOf;
+  mapping(address => mapping(address => uint256)) public override allowance;
+
+  constructor(uint256 amountToMint) {
+    mint(msg.sender, amountToMint);
+  }
+
+  function mint(address to, uint256 amount) public {
+    uint256 balanceNext = balanceOf[to] + amount;
+    require(balanceNext >= amount, "overflow balance");
+    balanceOf[to] = balanceNext;
+  }
+
+  function transfer(address recipient, uint256 amount) external override returns (bool) {
+    uint256 balanceBefore = balanceOf[msg.sender];
+    require(balanceBefore >= amount, "insufficient balance");
+    balanceOf[msg.sender] = balanceBefore - amount;
+
+    uint256 balanceRecipient = balanceOf[recipient];
+    require(balanceRecipient + amount >= balanceRecipient, "recipient balance overflow");
+    balanceOf[recipient] = balanceRecipient + amount;
+
+    emit Transfer(msg.sender, recipient, amount);
+    return true;
+  }
+
+  function approve(address spender, uint256 amount) external override returns (bool) {
+    allowance[msg.sender][spender] = amount;
+    emit Approval(msg.sender, spender, amount);
+    return true;
+  }
+
+  function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
+    uint256 allowanceBefore = allowance[sender][msg.sender];
+    require(allowanceBefore >= amount, "allowance insufficient");
+
+    allowance[sender][msg.sender] = allowanceBefore - amount;
+
+    uint256 balanceRecipient = balanceOf[recipient];
+    require(balanceRecipient + amount >= balanceRecipient, "overflow balance recipient");
+    balanceOf[recipient] = balanceRecipient + amount;
+    uint256 balanceSender = balanceOf[sender];
+    require(balanceSender >= amount, "underflow balance sender");
+    balanceOf[sender] = balanceSender - amount;
+
+    emit Transfer(sender, recipient, amount);
+    return true;
+  }
+}

src/core/test/TestKatanaV3Callee.sol

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity =0.7.6;
+
+import "../interfaces/IERC20Minimal.sol";
+
+import "../libraries/SafeCast.sol";
+import "../libraries/TickMath.sol";
+
+import "../interfaces/callback/IKatanaV3MintCallback.sol";
+import "../interfaces/callback/IKatanaV3SwapCallback.sol";
+import "../interfaces/callback/IKatanaV3FlashCallback.sol";
+
+import "../interfaces/IKatanaV3Pool.sol";
+
+contract TestKatanaV3Callee is IKatanaV3MintCallback, IKatanaV3SwapCallback, IKatanaV3FlashCallback {
+  using SafeCast for uint256;
+
+  function swapExact0For1(address pool, uint256 amount0In, address recipient, uint160 sqrtPriceLimitX96) external {
+    IKatanaV3Pool(pool).swap(recipient, true, amount0In.toInt256(), sqrtPriceLimitX96, abi.encode(msg.sender));
+  }
+
+  function swap0ForExact1(address pool, uint256 amount1Out, address recipient, uint160 sqrtPriceLimitX96) external {
+    IKatanaV3Pool(pool).swap(recipient, true, -amount1Out.toInt256(), sqrtPriceLimitX96, abi.encode(msg.sender));
+  }
+
+  function swapExact1For0(address pool, uint256 amount1In, address recipient, uint160 sqrtPriceLimitX96) external {
+    IKatanaV3Pool(pool).swap(recipient, false, amount1In.toInt256(), sqrtPriceLimitX96, abi.encode(msg.sender));
+  }
+
+  function swap1ForExact0(address pool, uint256 amount0Out, address recipient, uint160 sqrtPriceLimitX96) external {
+    IKatanaV3Pool(pool).swap(recipient, false, -amount0Out.toInt256(), sqrtPriceLimitX96, abi.encode(msg.sender));
+  }
+
+  function swapToLowerSqrtPrice(address pool, uint160 sqrtPriceX96, address recipient) external {
+    IKatanaV3Pool(pool).swap(recipient, true, type(int256).max, sqrtPriceX96, abi.encode(msg.sender));
+  }
+
+  function swapToHigherSqrtPrice(address pool, uint160 sqrtPriceX96, address recipient) external {
+    IKatanaV3Pool(pool).swap(recipient, false, type(int256).max, sqrtPriceX96, abi.encode(msg.sender));
+  }
+
+  event SwapCallback(int256 amount0Delta, int256 amount1Delta);
+
+  function katanaV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external override {
+    address sender = abi.decode(data, (address));
+
+    emit SwapCallback(amount0Delta, amount1Delta);
+
+    if (amount0Delta > 0) {
+      IERC20Minimal(IKatanaV3Pool(msg.sender).token0()).transferFrom(sender, msg.sender, uint256(amount0Delta));
+    } else if (amount1Delta > 0) {
+      IERC20Minimal(IKatanaV3Pool(msg.sender).token1()).transferFrom(sender, msg.sender, uint256(amount1Delta));
+    } else {
+      // if both are not gt 0, both must be 0.
+      assert(amount0Delta == 0 && amount1Delta == 0);
+    }
+  }
+
+  function mint(address pool, address recipient, int24 tickLower, int24 tickUpper, uint128 amount) external {
+    IKatanaV3Pool(pool).mint(recipient, tickLower, tickUpper, amount, abi.encode(msg.sender));
+  }
+
+  event MintCallback(uint256 amount0Owed, uint256 amount1Owed);
+
+  function katanaV3MintCallback(uint256 amount0Owed, uint256 amount1Owed, bytes calldata data) external override {
+    address sender = abi.decode(data, (address));
+
+    emit MintCallback(amount0Owed, amount1Owed);
+    if (amount0Owed > 0) {
+      IERC20Minimal(IKatanaV3Pool(msg.sender).token0()).transferFrom(sender, msg.sender, amount0Owed);
+    }
+    if (amount1Owed > 0) {
+      IERC20Minimal(IKatanaV3Pool(msg.sender).token1()).transferFrom(sender, msg.sender, amount1Owed);
+    }
+  }
+
+  event FlashCallback(uint256 fee0, uint256 fee1);
+
+  function flash(address pool, address recipient, uint256 amount0, uint256 amount1, uint256 pay0, uint256 pay1)
+    external
+  {
+    IKatanaV3Pool(pool).flash(recipient, amount0, amount1, abi.encode(msg.sender, pay0, pay1));
+  }
+
+  function katanaV3FlashCallback(uint256 fee0, uint256 fee1, bytes calldata data) external override {
+    emit FlashCallback(fee0, fee1);
+
+    (address sender, uint256 pay0, uint256 pay1) = abi.decode(data, (address, uint256, uint256));
+
+    if (pay0 > 0) IERC20Minimal(IKatanaV3Pool(msg.sender).token0()).transferFrom(sender, msg.sender, pay0);
+    if (pay1 > 0) IERC20Minimal(IKatanaV3Pool(msg.sender).token1()).transferFrom(sender, msg.sender, pay1);
+  }
+}

src/core/test/TestKatanaV3ReentrantCallee.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity =0.7.6;
+
+import "../libraries/TickMath.sol";
+
+import "../interfaces/callback/IKatanaV3SwapCallback.sol";
+
+import "../interfaces/IKatanaV3Pool.sol";
+
+contract TestKatanaV3ReentrantCallee is IKatanaV3SwapCallback {
+  string private constant expectedReason = "LOK";
+
+  function swapToReenter(address pool) external {
+    IKatanaV3Pool(pool).swap(address(0), false, 1, TickMath.MAX_SQRT_RATIO - 1, new bytes(0));
+  }
+
+  function katanaV3SwapCallback(int256, int256, bytes calldata) external override {
+    // try to reenter swap
+    try IKatanaV3Pool(msg.sender).swap(address(0), false, 1, 0, new bytes(0)) { }
+    catch Error(string memory reason) {
+      require(keccak256(abi.encode(reason)) == keccak256(abi.encode(expectedReason)));
+    }
+
+    // try to reenter mint
+    try IKatanaV3Pool(msg.sender).mint(address(0), 0, 0, 0, new bytes(0)) { }
+    catch Error(string memory reason) {
+      require(keccak256(abi.encode(reason)) == keccak256(abi.encode(expectedReason)));
+    }
+
+    // try to reenter collect
+    try IKatanaV3Pool(msg.sender).collect(address(0), 0, 0, 0, 0) { }
+    catch Error(string memory reason) {
+      require(keccak256(abi.encode(reason)) == keccak256(abi.encode(expectedReason)));
+    }
+
+    // try to reenter burn
+    try IKatanaV3Pool(msg.sender).burn(0, 0, 0) { }
+    catch Error(string memory reason) {
+      require(keccak256(abi.encode(reason)) == keccak256(abi.encode(expectedReason)));
+    }
+
+    // try to reenter flash
+    try IKatanaV3Pool(msg.sender).flash(address(0), 0, 0, new bytes(0)) { }
+    catch Error(string memory reason) {
+      require(keccak256(abi.encode(reason)) == keccak256(abi.encode(expectedReason)));
+    }
+
+    // try to reenter collectProtocol
+    try IKatanaV3Pool(msg.sender).collectProtocol(address(0), 0, 0) { }
+    catch Error(string memory reason) {
+      require(keccak256(abi.encode(reason)) == keccak256(abi.encode(expectedReason)));
+    }
+
+    require(false, "Unable to reenter");
+  }
+}

src/core/test/TestKatanaV3Router.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity =0.7.6;
+
+import "../libraries/SafeCast.sol";
+import "../libraries/TickMath.sol";
+
+import "../interfaces/IERC20Minimal.sol";
+import "../interfaces/callback/IKatanaV3SwapCallback.sol";
+import "../interfaces/IKatanaV3Pool.sol";
+
+contract TestKatanaV3Router is IKatanaV3SwapCallback {
+  using SafeCast for uint256;
+
+  // flash swaps for an exact amount of token0 in the output pool
+  function swapForExact0Multi(address recipient, address poolInput, address poolOutput, uint256 amount0Out) external {
+    address[] memory pools = new address[](1);
+    pools[0] = poolInput;
+    IKatanaV3Pool(poolOutput).swap(
+      recipient, false, -amount0Out.toInt256(), TickMath.MAX_SQRT_RATIO - 1, abi.encode(pools, msg.sender)
+    );
+  }
+
+  // flash swaps for an exact amount of token1 in the output pool
+  function swapForExact1Multi(address recipient, address poolInput, address poolOutput, uint256 amount1Out) external {
+    address[] memory pools = new address[](1);
+    pools[0] = poolInput;
+    IKatanaV3Pool(poolOutput).swap(
+      recipient, true, -amount1Out.toInt256(), TickMath.MIN_SQRT_RATIO + 1, abi.encode(pools, msg.sender)
+    );
+  }
+
+  event SwapCallback(int256 amount0Delta, int256 amount1Delta);
+
+  function katanaV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) public override {
+    emit SwapCallback(amount0Delta, amount1Delta);
+
+    (address[] memory pools, address payer) = abi.decode(data, (address[], address));
+
+    if (pools.length == 1) {
+      // get the address and amount of the token that we need to pay
+      address tokenToBePaid = amount0Delta > 0 ? IKatanaV3Pool(msg.sender).token0() : IKatanaV3Pool(msg.sender).token1();
+      int256 amountToBePaid = amount0Delta > 0 ? amount0Delta : amount1Delta;
+
+      bool zeroForOne = tokenToBePaid == IKatanaV3Pool(pools[0]).token1();
+      IKatanaV3Pool(pools[0]).swap(
+        msg.sender,
+        zeroForOne,
+        -amountToBePaid,
+        zeroForOne ? TickMath.MIN_SQRT_RATIO + 1 : TickMath.MAX_SQRT_RATIO - 1,
+        abi.encode(new address[](0), payer)
+      );
+    } else {
+      if (amount0Delta > 0) {
+        IERC20Minimal(IKatanaV3Pool(msg.sender).token0()).transferFrom(payer, msg.sender, uint256(amount0Delta));
+      } else {
+        IERC20Minimal(IKatanaV3Pool(msg.sender).token1()).transferFrom(payer, msg.sender, uint256(amount1Delta));
+      }
+    }
+  }
+}