fix: build

Author: marktoda

foundry.toml

@@ -21,8 +21,7 @@ compilation_restrictions = [
   { paths = "src/PositionManager.sol", optimizer_runs = 30000 },
   { paths = "src/PositionDescriptor.sol", optimizer_runs = 1 },
   { paths = "src/hooks/V2OnV4/**", via_ir = true },
-  { paths = "test/hooks/V2OnV4/**", via_ir = true },
-  { paths = "^test/(?!hooks/V2OnV4/).*$", via_ir = false },
+  { paths = "test/**", via_ir = false }
 ]
 
 [profile.debug]

snapshots/StateViewTest.json

@@ -1,12 +1,12 @@
 {
-  "StateView_extsload_getFeeGrowthGlobals": "8703",
-  "StateView_extsload_getFeeGrowthInside": "24375",
-  "StateView_extsload_getLiquidity": "5939",
-  "StateView_extsload_getPositionInfo": "11261",
-  "StateView_extsload_getPositionLiquidity": "6191",
-  "StateView_extsload_getSlot0": "5986",
-  "StateView_extsload_getTickBitmap": "5932",
-  "StateView_extsload_getTickFeeGrowthOutside": "8990",
-  "StateView_extsload_getTickInfo": "11193",
-  "StateView_extsload_getTickLiquidity": "6186"
+  "StateView_extsload_getFeeGrowthGlobals": "2203",
+  "StateView_extsload_getFeeGrowthInside": "7875",
+  "StateView_extsload_getLiquidity": "1439",
+  "StateView_extsload_getPositionInfo": "2761",
+  "StateView_extsload_getPositionLiquidity": "1691",
+  "StateView_extsload_getSlot0": "1486",
+  "StateView_extsload_getTickBitmap": "1432",
+  "StateView_extsload_getTickFeeGrowthOutside": "2490",
+  "StateView_extsload_getTickInfo": "2693",
+  "StateView_extsload_getTickLiquidity": "1686"
 }

snapshots/V2OnV4FactoryHookTest.json

@@ -1,4 +1,4 @@
 {
-  "V2OnV4Hook_exactInput": "154039",
-  "V2OnV4Hook_initialize": "3659711"
+  "V2OnV4Hook_exactInput": "155838",
+  "V2OnV4Hook_initialize": "3817093"
 }

snapshots/V2OnV4PairTest.json

@@ -1,6 +1,6 @@
 {
-  "V2OnV4Hook_AddLiquidity": "256421",
-  "V2OnV4Hook_AddLiquidityClaim": "134487",
-  "V2OnV4Hook_Swap": "99792",
-  "V2OnV4Hook_SwapClaim": "71287"
+  "V2OnV4Hook_AddLiquidity": "257591",
+  "V2OnV4Hook_AddLiquidityClaim": "134868",
+  "V2OnV4Hook_Swap": "100831",
+  "V2OnV4Hook_SwapClaim": "71979"
 }

src/hooks/V2OnV4/V2OnV4FactoryHook.sol

@@ -2,11 +2,9 @@
 pragma solidity 0.8.26;
 
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
-import {V2OnV4Pair} from "./V2OnV4Pair.sol";
 import {
     toBeforeSwapDelta, BeforeSwapDelta, BeforeSwapDeltaLibrary
 } from "@uniswap/v4-core/src/types/BeforeSwapDelta.sol";
-import {IUniswapV2Factory} from "briefcase/protocols/v2-core/interfaces/IUniswapV2Factory.sol";
 import {SafeCast} from "@uniswap/v4-core/src/libraries/SafeCast.sol";
 import {ModifyLiquidityParams, SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
 import {IUniswapV2Pair} from "briefcase/protocols/v2-core/interfaces/IUniswapV2Pair.sol";
@@ -17,13 +15,15 @@ import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
 import {UniswapV2Library} from "./UniswapV2Library.sol";
 import {V2OnV4PairDeployer} from "./V2OnV4PairDeployer.sol";
+import {IV2OnV4Pair} from "../../interfaces/IV2OnV4Pair.sol";
+import {IV2OnV4Factory} from "../../interfaces/IV2OnV4Factory.sol";
 import {BaseHook} from "../../utils/BaseHook.sol";
 
 /// @title V2OnV4FactoryHook
 /// @author Uniswap Labs
 /// @notice Factory contract that enables Uniswap V2-style AMM pools to run on Uniswap V4 infrastructure
 /// @dev Implements the IUniswapV2Factory interface while leveraging V4's hook system for pool management
-contract V2OnV4FactoryHook is BaseHook, V2OnV4PairDeployer, IUniswapV2Factory {
+contract V2OnV4FactoryHook is BaseHook, V2OnV4PairDeployer, IV2OnV4Factory {
     using CurrencyLibrary for Currency;
     using SafeCast for int256;
     using SafeCast for uint256;
@@ -32,27 +32,17 @@ contract V2OnV4FactoryHook is BaseHook, V2OnV4PairDeployer, IUniswapV2Factory {
     address public feeTo;
 
     /// @notice Fixed swap fee of 0.3% (3000 basis points) matching V2's fee structure
-    uint24 public constant SWAP_FEE = 3000;
+    uint24 public constant override SWAP_FEE = 3000;
 
     /// @notice Minimum tick spacing for V4 pools (1 tick = finest granularity)
-    int24 public constant TICK_SPACING = 1;
+    int24 public constant override TICK_SPACING = 1;
 
     /// @notice Returns the address of the pair for tokenA and tokenB, if it exists
     /// @dev getPair[tokenA][tokenB] and getPair[tokenB][tokenA] return the same pair address
-    mapping(address => mapping(address => address)) public getPair;
+    mapping(address => mapping(address => address)) public override getPair;
 
     /// @notice Array of all created pair addresses for enumeration
-    address[] public allPairs;
-
-    error InvalidFee();
-    error LiquidityNotAllowed();
-    error InvalidTickSpacing();
-    error InvalidToken();
-    error IdenticalAddresses();
-    error ZeroAddress();
-    error PairExists();
-    error Forbidden();
-    error FeeToSetterLocked();
+    address[] public override allPairs;
 
     /// @notice Deploys the V2OnV4 factory hook
     /// @param _manager The Uniswap V4 pool manager contract
@@ -80,7 +70,7 @@ contract V2OnV4FactoryHook is BaseHook, V2OnV4PairDeployer, IUniswapV2Factory {
 
     /// @notice Returns the total number of pairs created
     /// @return The length of the allPairs array
-    function allPairsLength() external view returns (uint256) {
+    function allPairsLength() external view override returns (uint256) {
         return allPairs.length;
     }
 
@@ -89,7 +79,7 @@ contract V2OnV4FactoryHook is BaseHook, V2OnV4PairDeployer, IUniswapV2Factory {
     /// @param tokenB Address of the second token
     /// @return pair Address of the newly created pair contract
     /// @dev Tokens are sorted, and the pair is deployed deterministically
-    function createPair(address tokenA, address tokenB) public returns (address pair) {
+    function createPair(address tokenA, address tokenB) public override returns (address pair) {
         require(tokenA != tokenB, IdenticalAddresses());
         (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
         require(token0 != address(0), ZeroAddress());
@@ -104,20 +94,20 @@ contract V2OnV4FactoryHook is BaseHook, V2OnV4PairDeployer, IUniswapV2Factory {
     /// @notice Returns the address authorized to set the fee recipient
     /// @return The protocol fee controller from the V4 pool manager
     /// @dev Delegates fee setter authority to V4's protocol fee controller
-    function feeToSetter() public view returns (address) {
+    function feeToSetter() public view override returns (address) {
         return poolManager.protocolFeeController();
     }
 
     /// @notice Prevents changing the fee setter (locked to V4's protocol controller)
     /// @dev Always reverts as fee setter is managed by V4 pool manager
-    function setFeeToSetter(address) external pure {
+    function setFeeToSetter(address) external pure override {
         revert FeeToSetterLocked();
     }
 
     /// @notice Sets the address that receives protocol fees
     /// @param _feeTo The address to receive protocol fees (or address(0) to disable)
     /// @dev Only callable by the current fee setter
-    function setFeeTo(address _feeTo) external {
+    function setFeeTo(address _feeTo) external override {
         require(msg.sender == feeToSetter(), Forbidden());
         feeTo = _feeTo;
     }
@@ -162,7 +152,7 @@ contract V2OnV4FactoryHook is BaseHook, V2OnV4PairDeployer, IUniswapV2Factory {
         override
         returns (bytes4, BeforeSwapDelta swapDelta, uint24)
     {
-        V2OnV4Pair pair = V2OnV4Pair(getPair[Currency.unwrap(poolKey.currency0)][Currency.unwrap(poolKey.currency1)]);
+        IV2OnV4Pair pair = IV2OnV4Pair(getPair[Currency.unwrap(poolKey.currency0)][Currency.unwrap(poolKey.currency1)]);
 
         (Currency tokenIn, Currency tokenOut, uint256 reserveIn, uint256 reserveOut, uint256 amountSpecified) =
             _parseSwap(poolKey, params, pair);
@@ -200,7 +190,7 @@ contract V2OnV4FactoryHook is BaseHook, V2OnV4PairDeployer, IUniswapV2Factory {
     /// @return reserveIn Input token reserves
     /// @return reserveOut Output token reserves
     /// @return amountSpecified Absolute value of the specified swap amount
-    function _parseSwap(PoolKey calldata poolKey, SwapParams calldata params, V2OnV4Pair pair)
+    function _parseSwap(PoolKey calldata poolKey, SwapParams calldata params, IV2OnV4Pair pair)
         private
         view
         returns (Currency tokenIn, Currency tokenOut, uint256 reserveIn, uint256 reserveOut, uint256 amountSpecified)

src/hooks/V2OnV4/V2OnV4Pair.sol

@@ -15,6 +15,7 @@ import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
 import {BaseHook} from "../../utils/BaseHook.sol";
 import {V2OnV4PairDeployer} from "./V2OnV4PairDeployer.sol";
 import {UQ112x112} from "./UQ112x112.sol";
+import {IV2OnV4Pair} from "../../interfaces/IV2OnV4Pair.sol";
 
 enum UnlockCallbackAction {
     MINT,
@@ -32,7 +33,7 @@ struct UnlockCallback {
 /// @author Uniswap Labs
 /// @notice A V2-style AMM pair contract that operates on Uniswap V4 infrastructure
 /// @dev Implements constant product (x*y=k) AMM logic while leveraging V4's singleton pool manager
-contract V2OnV4Pair is ERC20, ReentrancyGuardTransient {
+contract V2OnV4Pair is IV2OnV4Pair, ERC20, ReentrancyGuardTransient {
     using UQ112x112 for uint224;
     using SafeTransferLib for ERC20;
     using CurrencyLibrary for Currency;
@@ -79,29 +80,6 @@ contract V2OnV4Pair is ERC20, ReentrancyGuardTransient {
         _;
     }
 
-    error K();
-    error Forbidden();
-    error NotPoolManager();
-    error InvalidUnlockCallbackData();
-    error InsufficientLiquidityBurned();
-    error InsufficientLiquidityMinted();
-    error InsufficientOutputAmount();
-    error InsufficientInputAmount();
-    error InsufficientLiquidity();
-    error InvalidTo();
-
-    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
-    event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
-    event Swap(
-        address indexed sender,
-        uint256 amount0In,
-        uint256 amount1In,
-        uint256 amount0Out,
-        uint256 amount1Out,
-        address indexed to
-    );
-    event Sync(uint112 reserve0, uint112 reserve1);
-
     /// @notice Deploys a new V2 pair on V4
     /// @dev Called by the factory with deployment parameters
     constructor() ERC20("Uniswap V2", "UNI-V2", 18) {
@@ -118,8 +96,13 @@ contract V2OnV4Pair is ERC20, ReentrancyGuardTransient {
     /// @dev Low-level function that should be called through a router with proper safety checks
     /// @param to Address to receive the minted LP tokens
     /// @return liquidity Amount of LP tokens minted
-    function mint(address to) external nonReentrant returns (uint256 liquidity) {
-        poolManager.unlock(abi.encode(UnlockCallback({action: UnlockCallbackAction.MINT, to: to, data: new bytes(0)})));
+    function mint(address to) external override nonReentrant returns (uint256 liquidity) {
+        (liquidity) = abi.decode(
+            poolManager.unlock(
+                abi.encode(UnlockCallback({action: UnlockCallbackAction.MINT, to: to, data: new bytes(0)}))
+            ),
+            (uint256)
+        );
     }
 
     /// @notice Internal mint function that handles ERC20 token deposits and liquidity creation
@@ -128,18 +111,23 @@ contract V2OnV4Pair is ERC20, ReentrancyGuardTransient {
     /// @return liquidity Amount of LP tokens minted
     function _mint(address to) internal returns (uint256 liquidity) {
         // transform ERC20 tokens into claims
-        (uint256 amount0, uint256 amount1) = _slurp();
+        _slurp();
         // Then mint liquidity as normal with those claims
-        _mintClaims(to);
+        liquidity = _mintClaims(to);
     }
 
     /// @notice Burns liquidity tokens and returns underlying assets
     /// @dev Low-level function that should be called through a router with proper safety checks
     /// @param to Address to receive the underlying tokens
     /// @return amount0 Amount of token0 returned
     /// @return amount1 Amount of token1 returned
-    function burn(address to) external nonReentrant returns (uint256 amount0, uint256 amount1) {
-        poolManager.unlock(abi.encode(UnlockCallback({action: UnlockCallbackAction.BURN, to: to, data: new bytes(0)})));
+    function burn(address to) external override nonReentrant returns (uint256 amount0, uint256 amount1) {
+        (amount0, amount1) = abi.decode(
+            poolManager.unlock(
+                abi.encode(UnlockCallback({action: UnlockCallbackAction.BURN, to: to, data: new bytes(0)}))
+            ),
+            (uint256, uint256)
+        );
     }
 
     /// @notice Internal burn function that redeems LP tokens for underlying assets
@@ -158,7 +146,11 @@ contract V2OnV4Pair is ERC20, ReentrancyGuardTransient {
     /// @param amount1Out Amount of token1 to send
     /// @param to Address to receive output tokens
     /// @param data Callback data for flash swaps
-    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external nonReentrant {
+    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data)
+        external
+        override
+        nonReentrant
+    {
         poolManager.unlock(
             abi.encode(
                 UnlockCallback({
@@ -207,7 +199,7 @@ contract V2OnV4Pair is ERC20, ReentrancyGuardTransient {
     /// @param to Address to receive the minted LP tokens
     /// @return liquidity Amount of LP tokens minted
     function mintClaims(address to) external nonReentrant returns (uint256 liquidity) {
-        _mintClaims(to);
+        return _mintClaims(to);
     }
 
     /// @notice Burns liquidity and returns claims directly
@@ -216,7 +208,7 @@ contract V2OnV4Pair is ERC20, ReentrancyGuardTransient {
     /// @return amount0 Amount of token0 claims returned
     /// @return amount1 Amount of token1 claims returned
     function burnClaims(address to) external nonReentrant returns (uint256 amount0, uint256 amount1) {
-        _burnClaims(to, true);
+        return _burnClaims(to, true);
     }
 
     /// @notice Executes a swap using V4 claims directly
@@ -239,13 +231,15 @@ contract V2OnV4Pair is ERC20, ReentrancyGuardTransient {
     function unlockCallback(bytes calldata data) external onlyPoolManager returns (bytes memory) {
         UnlockCallback memory callbackData = abi.decode(data, (UnlockCallback));
         if (callbackData.action == UnlockCallbackAction.MINT) {
-            _mint(callbackData.to);
+            return abi.encode(_mint(callbackData.to));
         } else if (callbackData.action == UnlockCallbackAction.BURN) {
-            _burn(callbackData.to);
+            (uint256 amount0, uint256 amount1) = _burn(callbackData.to);
+            return abi.encode(amount0, amount1);
         } else if (callbackData.action == UnlockCallbackAction.SWAP) {
             (uint256 amount0Out, uint256 amount1Out, bytes memory swapData) =
                 abi.decode(callbackData.data, (uint256, uint256, bytes));
             _swap(amount0Out, amount1Out, callbackData.to, swapData);
+            return new bytes(0); // no return data needed for swap
         } else {
             revert InvalidUnlockCallbackData();
         }

src/interfaces/IV2OnV4Factory.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {IUniswapV2Factory} from "briefcase/protocols/v2-core/interfaces/IUniswapV2Factory.sol";
+import {IERC20} from "forge-std/interfaces/IERC20.sol";
+
+/// @title IV2OnV4Factory
+/// @notice Interface for V2-style AMM pair contracts operating on Uniswap V4 infrastructure
+interface IV2OnV4Factory is IUniswapV2Factory {
+    function SWAP_FEE() external pure returns (uint24);
+    function TICK_SPACING() external pure returns (int24);
+
+    error InvalidFee();
+    error LiquidityNotAllowed();
+    error InvalidTickSpacing();
+    error InvalidToken();
+    error IdenticalAddresses();
+    error ZeroAddress();
+    error PairExists();
+    error Forbidden();
+    error FeeToSetterLocked();
+}