validate proxy addrs are valid hooks, don't bother with the implementation's addr

Author: hoytech

src/UniswapHook.sol

@@ -35,6 +35,8 @@ contract UniswapHook is BaseHook {
     }
 
     function activateHook(IEulerSwap.Params memory p) internal {
+        Hooks.validateHookPermissions(this, getHookPermissions());
+
         address asset0Addr = IEVault(p.vault0).asset();
         address asset1Addr = IEVault(p.vault1).asset();
 
@@ -58,6 +60,11 @@ contract UniswapHook is BaseHook {
         return _poolKey;
     }
 
+    /// @dev Prevent hook address validation in constructor, which is not needed
+    /// because hook instances are proxies. Instead, the address is validated
+    /// in activateHook().
+    function validateHookAddress(BaseHook _this) internal pure override {}
+
     function _beforeSwap(address, PoolKey calldata key, IPoolManager.SwapParams calldata params, bytes calldata)
         internal
         override

test/EulerSwapTestBase.t.sol

@@ -9,7 +9,6 @@ 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/utils/MetaProxyDeployer.sol";
 
@@ -38,18 +37,7 @@ contract EulerSwapTestBase is EVaultTestBase {
     }
 
     function deployEulerSwap(address poolManager_) public {
-        // use the canonical miner to find a valid 'implementation' address
-        (, bytes32 salt) = v4HookMiner.find(
-            address(this),
-            uint160(
-                Hooks.BEFORE_INITIALIZE_FLAG | 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_));
+        eulerSwapImpl = address(new EulerSwap(address(evc), poolManager_));
         eulerSwapFactory = new EulerSwapFactory(address(evc), address(factory), eulerSwapImpl, address(this));
         periphery = new EulerSwapPeriphery();
     }

test/FactoryTest.t.sol

@@ -41,6 +41,18 @@ contract FactoryTest is EulerSwapTestBase {
         (hookAddress, salt) = HookMiner.find(address(eulerSwapFactory), holder, flags, creationCode);
     }
 
+    function mineBadSalt(IEulerSwap.Params memory poolParams)
+        internal
+        view
+        returns (address hookAddress, bytes32 salt)
+    {
+        // missing BEFORE_ADD_LIQUIDITY_FLAG
+        uint160 flags =
+            uint160(Hooks.BEFORE_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG);
+        bytes memory creationCode = MetaProxyDeployer.creationCodeMetaProxy(eulerSwapImpl, abi.encode(poolParams));
+        (hookAddress, salt) = HookMiner.find(address(eulerSwapFactory), holder, flags, creationCode);
+    }
+
     function testDeployPool() public {
         uint256 allPoolsLengthBefore = eulerSwapFactory.poolsLength();
 
@@ -117,6 +129,18 @@ contract FactoryTest is EulerSwapTestBase {
         evc.batch(items);
     }
 
+    function testBadSalt() public {
+        (IEulerSwap.Params memory poolParams, IEulerSwap.InitialState memory initialState) = getBasicParams();
+        (address hookAddress, bytes32 salt) = mineBadSalt(poolParams);
+
+        vm.prank(holder);
+        evc.setAccountOperator(holder, hookAddress, true);
+
+        vm.expectRevert(abi.encodeWithSelector(Hooks.HookAddressNotValid.selector, hookAddress));
+        vm.prank(holder);
+        eulerSwapFactory.deployPool(poolParams, initialState, salt);
+    }
+
     function testInvalidPoolsSliceOutOfBounds() public {
         vm.expectRevert(EulerSwapFactory.SliceOutOfBounds.selector);
         eulerSwapFactory.poolsSlice(1, 0);