merge in upstream; fix conflicts

Author: saucepoint

TODO

@@ -3,7 +3,6 @@
   ! document that periphery depends on non-malicious eulerSwap instances
   ! limitations of getLimits
 * update deploy scripts
-* TODOs in UniswapHook.sol
 * small cleanups in CurveLib
 ? tighten up getLimits bounds
 

src/QuoteLib.sol

@@ -29,6 +29,8 @@ library QuoteLib {
         view
         returns (uint256)
     {
+        if (amount == 0) return 0;
+
         require(IEVC(evc).isAccountOperatorAuthorized(p.eulerAccount, address(this)), OperatorNotInstalled());
         require(amount <= type(uint112).max, SwapLimitExceeded());
 

src/UniswapHook.sol

@@ -27,6 +27,8 @@ contract UniswapHook is BaseHook {
 
     PoolKey internal _poolKey;
 
+    error NativeConcentratedLiquidityUnsupported();
+
     constructor(address evc_, address _poolManager) BaseHook(IPoolManager(_poolManager)) {
         evc = evc_;
     }
@@ -42,7 +44,7 @@ contract UniswapHook is BaseHook {
             currency0: Currency.wrap(asset0Addr),
             currency1: Currency.wrap(asset1Addr),
             fee: fee,
-            tickSpacing: 60, // TODO: fix arbitrary tick spacing
+            tickSpacing: 1, // hard-coded tick spacing, as its unused
             hooks: IHooks(address(this))
         });
 
@@ -90,7 +92,6 @@ contract UniswapHook is BaseHook {
 
             // take the input token, from the PoolManager to the Euler vault
             // the debt will be paid by the swapper via the swap router
-            // TODO: can we optimize the transfer by pulling from PoolManager directly to Euler?
             poolManager.take(params.zeroForOne ? key.currency0 : key.currency1, address(this), amountIn);
             amountInWithoutFee = FundsLib.depositAssets(evc, p, params.zeroForOne ? p.vault0 : p.vault1);
 
@@ -117,7 +118,31 @@ contract UniswapHook is BaseHook {
         return (BaseHook.beforeSwap.selector, returnDelta, 0);
     }
 
-    // TODO: fix salt mining & verification for the hook
-    function getHookPermissions() public pure override returns (Hooks.Permissions memory) {}
-    function validateHookAddress(BaseHook) internal pure override {}
+    function _beforeAddLiquidity(address, PoolKey calldata, IPoolManager.ModifyLiquidityParams calldata, bytes calldata)
+        internal
+        pure
+        override
+        returns (bytes4)
+    {
+        revert NativeConcentratedLiquidityUnsupported();
+    }
+
+    function getHookPermissions() public pure override returns (Hooks.Permissions memory) {
+        return Hooks.Permissions({
+            beforeInitialize: false,
+            afterInitialize: false,
+            beforeAddLiquidity: true,
+            afterAddLiquidity: false,
+            beforeRemoveLiquidity: false,
+            afterRemoveLiquidity: false,
+            beforeSwap: true,
+            afterSwap: false,
+            beforeDonate: false,
+            afterDonate: false,
+            beforeSwapReturnDelta: true,
+            afterSwapReturnDelta: false,
+            afterAddLiquidityReturnDelta: false,
+            afterRemoveLiquidityReturnDelta: false
+        });
+    }
 }

test/EulerSwapTestBase.t.sol

@@ -9,6 +9,7 @@ import {EulerSwapFactory} from "../src/EulerSwapFactory.sol";
 import {EulerSwapPeriphery} from "../src/EulerSwapPeriphery.sol";
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {HookMiner} from "./utils/HookMiner.sol";
+import {HookMiner as v4HookMiner} from "v4-periphery/src/utils/HookMiner.sol";
 import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
 import {MetaProxyDeployer} from "../src/MetaProxyDeployer.sol";
 
@@ -37,7 +38,15 @@ contract EulerSwapTestBase is EVaultTestBase {
     }
 
     function deployEulerSwap(address poolManager_) public {
-        eulerSwapImpl = address(new EulerSwap(address(evc), poolManager_));
+        // use the canonical miner to find a valid 'implementation' address
+        (, bytes32 salt) = v4HookMiner.find(
+            address(this),
+            uint160(Hooks.BEFORE_SWAP_FLAG | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.BEFORE_ADD_LIQUIDITY_FLAG),
+            type(EulerSwap).creationCode,
+            abi.encode(address(evc), poolManager_)
+        );
+
+        eulerSwapImpl = address(new EulerSwap{salt: salt}(address(evc), poolManager_));
         eulerSwapFactory = new EulerSwapFactory(address(evc), address(factory), eulerSwapImpl, address(this));
         periphery = new EulerSwapPeriphery();
     }
@@ -199,7 +208,7 @@ contract EulerSwapTestBase is EVaultTestBase {
         (address predictedAddr, bytes32 salt) = HookMiner.find(
             address(eulerSwapFactory),
             holder,
-            uint160(Hooks.BEFORE_SWAP_FLAG | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG),
+            uint160(Hooks.BEFORE_SWAP_FLAG | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.BEFORE_ADD_LIQUIDITY_FLAG),
             creationCode
         );
 

test/FactoryTest.t.sol

@@ -33,7 +33,8 @@ contract FactoryTest is EulerSwapTestBase {
     }
 
     function mineSalt(IEulerSwap.Params memory poolParams) internal view returns (address hookAddress, bytes32 salt) {
-        uint160 flags = uint160(Hooks.BEFORE_SWAP_FLAG | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG);
+        uint160 flags =
+            uint160(Hooks.BEFORE_SWAP_FLAG | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.BEFORE_ADD_LIQUIDITY_FLAG);
         bytes memory creationCode = MetaProxyDeployer.creationCodeMetaProxy(eulerSwapImpl, abi.encode(poolParams));
         (hookAddress, salt) = HookMiner.find(address(eulerSwapFactory), holder, flags, creationCode);
     }

test/HookSwaps.t.sol

@@ -4,15 +4,20 @@ pragma solidity ^0.8.24;
 import {EulerSwapTestBase, EulerSwap, EulerSwapPeriphery, IEulerSwap} from "./EulerSwapTestBase.t.sol";
 import {TestERC20} from "evk-test/unit/evault/EVaultTestBase.t.sol";
 import {EulerSwap} from "../src/EulerSwap.sol";
+import {UniswapHook} from "../src/UniswapHook.sol";
 
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {IPoolManager, PoolManagerDeployer} from "./utils/PoolManagerDeployer.sol";
 import {PoolSwapTest} from "@uniswap/v4-core/src/test/PoolSwapTest.sol";
 import {MinimalRouter} from "./utils/MinimalRouter.sol";
+import {PoolModifyLiquidityTest} from "@uniswap/v4-core/src/test/PoolModifyLiquidityTest.sol";
 import {Currency, CurrencyLibrary} from "@uniswap/v4-core/src/types/Currency.sol";
 import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
 import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
 import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {CustomRevert} from "@uniswap/v4-core/src/libraries/CustomRevert.sol";
+import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
+import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
 
 contract HookSwapsTest is EulerSwapTestBase {
     using StateLibrary for IPoolManager;
@@ -22,6 +27,7 @@ contract HookSwapsTest is EulerSwapTestBase {
     IPoolManager public poolManager;
     PoolSwapTest public swapRouter;
     MinimalRouter public minimalRouter;
+    PoolModifyLiquidityTest public liquidityManager;
 
     PoolSwapTest.TestSettings public settings = PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false});
 
@@ -31,6 +37,7 @@ contract HookSwapsTest is EulerSwapTestBase {
         poolManager = PoolManagerDeployer.deploy(address(this));
         swapRouter = new PoolSwapTest(poolManager);
         minimalRouter = new MinimalRouter(poolManager);
+        liquidityManager = new PoolModifyLiquidityTest(poolManager);
 
         deployEulerSwap(address(poolManager));
 
@@ -119,6 +126,35 @@ contract HookSwapsTest is EulerSwapTestBase {
         vm.stopPrank();
     }
 
+    /// @dev adding liquidity as a concentrated liquidity position will revert
+    function test_revertAddConcentratedLiquidity() public {
+        assetTST.mint(anyone, 10000e18);
+        assetTST2.mint(anyone, 10000e18);
+
+        vm.startPrank(anyone);
+        assetTST.approve(address(liquidityManager), 1e18);
+        assetTST2.approve(address(liquidityManager), 1e18);
+
+        PoolKey memory poolKey = eulerSwap.poolKey();
+
+        // hook intentionally reverts to prevent v3-CLAMM positions
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                CustomRevert.WrappedError.selector,
+                address(eulerSwap),
+                IHooks.beforeAddLiquidity.selector,
+                abi.encodeWithSelector(UniswapHook.NativeConcentratedLiquidityUnsupported.selector),
+                abi.encodeWithSelector(Hooks.HookCallFailed.selector)
+            )
+        );
+        liquidityManager.modifyLiquidity(
+            poolKey,
+            IPoolManager.ModifyLiquidityParams({tickLower: -10, tickUpper: 10, liquidityDelta: 1000, salt: bytes32(0)}),
+            ""
+        );
+        vm.stopPrank();
+    }
+
     function _swap(PoolKey memory key, bool zeroForOne, bool exactInput, uint256 amount) internal {
         IPoolManager.SwapParams memory swapParams = IPoolManager.SwapParams({
             zeroForOne: zeroForOne,

test/Periphery.t.sol

@@ -120,4 +120,12 @@ contract PeripheryTest is EulerSwapTestBase {
 
         assertEq(assetTST2.balanceOf(anyone), amountOut);
     }
+
+    function test_SwapZeroAmounts() public view {
+        assertEq(periphery.quoteExactInput(address(eulerSwap), address(assetTST), address(assetTST2), 0), 0);
+        assertEq(periphery.quoteExactInput(address(eulerSwap), address(assetTST2), address(assetTST), 0), 0);
+
+        assertEq(periphery.quoteExactOutput(address(eulerSwap), address(assetTST), address(assetTST2), 0), 0);
+        assertEq(periphery.quoteExactOutput(address(eulerSwap), address(assetTST2), address(assetTST), 0), 0);
+    }
 }