@zoralabs/coins 2.3.1 → 2.4.0

package/src/libs/V4Liquidity.sol

@@ -269,13 +269,14 @@ library V4Liquidity {
                 salt: 0
             });
 
-            (BalanceDelta liquidityDelta, BalanceDelta feesAccrued) = poolManager.modifyLiquidity(poolKey, params, "");
+            // callerDelta already includes fees, feesAccrued is informational only
+            (BalanceDelta callerDelta, ) = poolManager.modifyLiquidity(poolKey, params, "");
 
             burnedPositions[i] = BurnedPosition({
                 tickLower: positions[i].tickLower,
                 tickUpper: positions[i].tickUpper,
-                amount0Received: uint128(liquidityDelta.amount0() + feesAccrued.amount0()),
-                amount1Received: uint128(liquidityDelta.amount1() + feesAccrued.amount1())
+                amount0Received: uint128(callerDelta.amount0()),
+                amount1Received: uint128(callerDelta.amount1())
             });
         }
     }
@@ -315,20 +316,63 @@ library V4Liquidity {
         feeGrowthInside1DeltaX128 = feeGrowthInside1X128 - feeGrowthInside1LastX128;
     }
 
+    /// @notice Mints liquidity positions into the pool
+    /// @dev Uses a defensive balance check to prevent ERC20InsufficientBalance errors during migration.
+    /// When burning positions from an old hook, the amounts received may not exactly match what's needed
+    /// to mint the same liquidity in the new hook due to:
+    ///   1. Rounding in getLiquidityForAmounts() when converting between liquidity and token amounts
+    ///   2. Price movements between burn and mint operations
+    ///   3. Any accumulated dust from previous operations
+    /// By capping each position's liquidity at what's actually mintable with remaining balances,
+    /// we ensure the migration never reverts due to insufficient tokens.
     function mintPositions(IPoolManager poolManager, PoolKey memory poolKey, LpPosition[] memory positions) internal returns (int128 amount0, int128 amount1) {
-        ModifyLiquidityParams memory params;
         uint256 numPositions = positions.length;
 
+        // Track remaining token balances throughout minting.
+        // These balances decrease as each position consumes tokens.
+        uint256 balance0 = poolKey.currency0.balanceOf(address(this));
+        uint256 balance1 = poolKey.currency1.balanceOf(address(this));
+
+        // Cache sqrt price once for all liquidity calculations
+        (uint160 sqrtPriceX96, , , ) = StateLibrary.getSlot0(poolManager, poolKey.toId());
+
         for (uint256 i; i < numPositions; i++) {
-            params = ModifyLiquidityParams({
+            if (positions[i].liquidity == 0) {
+                continue;
+            }
+
+            // Calculate the maximum liquidity we can mint given our remaining token balances.
+            // This is the key defensive check: even if the requested liquidity would require
+            // more tokens than we have (due to rounding), we cap it at what's actually possible.
+            uint128 maxLiquidity = LiquidityAmounts.getLiquidityForAmounts(
+                sqrtPriceX96,
+                TickMath.getSqrtPriceAtTick(positions[i].tickLower),
+                TickMath.getSqrtPriceAtTick(positions[i].tickUpper),
+                balance0,
+                balance1
+            );
+
+            // Use the lesser of requested liquidity and what we can actually afford
+            uint128 liquidityToMint = positions[i].liquidity < maxLiquidity ? positions[i].liquidity : maxLiquidity;
+
+            if (liquidityToMint == 0) {
+                continue;
+            }
+
+            ModifyLiquidityParams memory params = ModifyLiquidityParams({
                 tickLower: positions[i].tickLower,
                 tickUpper: positions[i].tickUpper,
-                liquidityDelta: SafeCast.toInt256(positions[i].liquidity),
+                liquidityDelta: SafeCast.toInt256(liquidityToMint),
                 salt: 0
             });
 
             (BalanceDelta delta, ) = poolManager.modifyLiquidity(poolKey, params, "");
 
+            // Update remaining balances for next iteration.
+            // delta.amount0/1 are negative when minting (tokens flow out), so adding them decreases our balance.
+            balance0 = uint256(int256(balance0) + int256(delta.amount0()));
+            balance1 = uint256(int256(balance1) + int256(delta.amount1()));
+
             amount0 += delta.amount0();
             amount1 += delta.amount1();
         }

package/src/utils/TrustedMsgSenderProviderLookup.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: ZORA-DELAYED-OSL-v1
+// This software is licensed under the Zora Delayed Open Source License.
+// Under this license, you may use, copy, modify, and distribute this software for
+// non-commercial purposes only. Commercial use and competitive products are prohibited
+// until the "Open Date" (3 years from first public distribution or earlier at Zora's discretion),
+// at which point this software automatically becomes available under the MIT License.
+// Full license terms available at: https://docs.zora.co/coins/license
+pragma solidity ^0.8.23;
+
+import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {ContractVersionBase} from "../version/ContractVersionBase.sol";
+import {ITrustedMsgSenderProviderLookup} from "../interfaces/ITrustedMsgSenderProviderLookup.sol";
+
+/// @title TrustedMsgSenderProviderLookup
+/// @notice Contract for ITrustedMsgSenderProviderLookup that manages trusted message senders
+/// @dev This contract allows the owner to add/remove trusted senders and provides lookup functionality
+contract TrustedMsgSenderProviderLookup is ITrustedMsgSenderProviderLookup, ContractVersionBase, Ownable2Step {
+    /// @notice Emitted when a trusted sender is added
+    /// @param sender The address that was added as trusted
+    event TrustedSenderAdded(address indexed sender);
+
+    /// @notice Emitted when a trusted sender is removed
+    /// @param sender The address that was removed from trusted
+    event TrustedSenderRemoved(address indexed sender);
+
+    /// @notice Mapping of addresses to their trusted sender status
+    mapping(address => bool) private trustedSenders;
+
+    /// @notice Constructor that initializes the contract with trusted senders and sets the owner
+    /// @param trustedMessageSenders Array of addresses to mark as trusted senders initially
+    /// @param initialOwner The address that will own this contract
+    constructor(address[] memory trustedMessageSenders, address initialOwner) Ownable(initialOwner) {
+        for (uint256 i = 0; i < trustedMessageSenders.length; i++) {
+            trustedSenders[trustedMessageSenders[i]] = true;
+            emit TrustedSenderAdded(trustedMessageSenders[i]);
+        }
+    }
+
+    /// @notice Checks if an address is a trusted message sender provider
+    /// @param sender The address to check
+    /// @return true if the sender is trusted, false otherwise
+    function isTrustedMsgSenderProvider(address sender) external view override returns (bool) {
+        return trustedSenders[sender];
+    }
+
+    /// @notice Adds multiple trusted senders in a single transaction (only callable by owner)
+    /// @param senders Array of addresses to add as trusted
+    function addTrustedMsgSenderProviders(address[] calldata senders) external onlyOwner {
+        for (uint256 i = 0; i < senders.length; i++) {
+            address sender = senders[i];
+            require(sender != address(0), "Cannot add zero address as trusted sender");
+
+            if (!trustedSenders[sender]) {
+                trustedSenders[sender] = true;
+                emit TrustedSenderAdded(sender);
+            }
+        }
+    }
+
+    /// @notice Removes multiple trusted senders in a single transaction (only callable by owner)
+    /// @param senders Array of addresses to remove from trusted
+    function removeTrustedMsgSenderProviders(address[] calldata senders) external onlyOwner {
+        for (uint256 i = 0; i < senders.length; i++) {
+            address sender = senders[i];
+
+            if (trustedSenders[sender]) {
+                trustedSenders[sender] = false;
+                emit TrustedSenderRemoved(sender);
+            }
+        }
+    }
+}

package/src/version/ContractVersionBase.sol

@@ -9,6 +9,6 @@ import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersion
 contract ContractVersionBase is IVersionedContract {
     /// @notice The version of the contract
     function contractVersion() external pure override returns (string memory) {
-        return "2.3.1";
+        return "2.4.0";
     }
 }

package/test/CreatorCoinRewards.t.sol

@@ -289,12 +289,16 @@ contract CreatorCoinRewardsTest is BaseTest {
     function test_buy_then_sell_both_referrers() public {
         uint128 buyAmount = 100 ether; // Fixed amount
 
+        console.log("deploying creator coin with platform referrer");
         // Deploy CreatorCoin with platform referrer
         _deployCreatorCoin(true);
 
+        console.log("buying creator coin with both referrers");
         // Step 1: Buy creator coin (ZORA -> Creator Coin)
         _buyCreatorCoin(buyAmount, true);
 
+        console.log("buyer's creator coin balance", creatorCoin.balanceOf(users.buyer));
+
         // Get buyer's creator coin balance after purchase
         uint256 creatorCoinBalance = creatorCoin.balanceOf(users.buyer);
         require(creatorCoinBalance > 0, "Buyer must have creator coin balance to sell");

package/test/HooksDeployment.t.sol

@@ -8,27 +8,62 @@ import {ContractAddresses} from "./utils/ContractAddresses.sol";
 import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
 import {HookUpgradeGate} from "../src/hooks/HookUpgradeGate.sol";
+import {ITrustedMsgSenderProviderLookup} from "../src/interfaces/ITrustedMsgSenderProviderLookup.sol";
+import {TrustedSenderTestHelper} from "./utils/TrustedSenderTestHelper.sol";
 
 contract HooksDeploymentTest is Test, ContractAddresses {
     address internal hookUpgradeGate;
+    ITrustedMsgSenderProviderLookup internal trustedMsgSenderLookup;
+    address internal owner;
+    address internal nonOwner;
+    address internal trustedSender1;
+    address internal trustedSender2;
+    address internal nonTrustedSender;
 
     function setUp() public {
         vm.createSelectFork("base", 31653138);
 
+        owner = makeAddr("owner");
+        nonOwner = makeAddr("nonOwner");
+        trustedSender1 = makeAddr("trustedSender1");
+        trustedSender2 = makeAddr("trustedSender2");
+        nonTrustedSender = makeAddr("nonTrustedSender");
+
         hookUpgradeGate = address(new HookUpgradeGate(makeAddr("factoryOwner")));
+
+        // Initialize with one trusted sender
+        address[] memory initialTrustedSenders = new address[](1);
+        initialTrustedSenders[0] = trustedSender1;
+
+        trustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(owner, initialTrustedSenders);
     }
 
     function test_canMineAndCacheSalt() public {
         address[] memory trustedMessageSenders = new address[](0);
 
+        ITrustedMsgSenderProviderLookup localTrustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(
+            makeAddr("owner"),
+            trustedMessageSenders
+        );
+
         (bytes32 salt, ) = HooksDeployment.mineAndCacheSalt(
             address(this),
-            abi.encode(V4_POOL_MANAGER, 0x777777751622c0d3258f214F9DF38E35BF45baF3, trustedMessageSenders, address(hookUpgradeGate))
+            abi.encode(
+                V4_POOL_MANAGER,
+                0x777777751622c0d3258f214F9DF38E35BF45baF3,
+                ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
+                address(hookUpgradeGate)
+            )
         );
 
         (bytes32 salt2, bool wasCached2) = HooksDeployment.mineAndCacheSalt(
             address(this),
-            abi.encode(V4_POOL_MANAGER, 0x777777751622c0d3258f214F9DF38E35BF45baF3, trustedMessageSenders, address(hookUpgradeGate))
+            abi.encode(
+                V4_POOL_MANAGER,
+                0x777777751622c0d3258f214F9DF38E35BF45baF3,
+                ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
+                address(hookUpgradeGate)
+            )
         );
 
         assertEq(salt, salt2);
@@ -40,17 +75,23 @@ contract HooksDeploymentTest is Test, ContractAddresses {
         vm.createSelectFork("base", 31653138);
 
         address[] memory trustedMessageSenders = new address[](0);
+
+        ITrustedMsgSenderProviderLookup localTrustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(
+            makeAddr("owner"),
+            trustedMessageSenders
+        );
+
         (, bytes32 salt) = HooksDeployment.mineForCoinSalt(
             address(this),
             V4_POOL_MANAGER,
             0x777777751622c0d3258f214F9DF38E35BF45baF3,
-            trustedMessageSenders,
+            ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
             hookUpgradeGate
         );
         IHooks hook = HooksDeployment.deployZoraV4CoinHook(
             V4_POOL_MANAGER,
             0x777777751622c0d3258f214F9DF38E35BF45baF3,
-            trustedMessageSenders,
+            ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
             hookUpgradeGate,
             salt
         );
@@ -68,16 +109,27 @@ contract HooksDeploymentTest is Test, ContractAddresses {
         vm.createSelectFork("base", 31653138);
 
         address[] memory trustedMessageSenders = new address[](0);
+
+        ITrustedMsgSenderProviderLookup localTrustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(
+            makeAddr("owner"),
+            trustedMessageSenders
+        );
+
         (, bytes32 salt) = HooksDeployment.mineForCoinSalt(
             address(this),
             V4_POOL_MANAGER,
             0x777777751622c0d3258f214F9DF38E35BF45baF3,
-            trustedMessageSenders,
+            ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
             hookUpgradeGate
         );
 
         IHooks hook = HooksDeployment.deployHookWithSalt(
-            HooksDeployment.makeHookCreationCode(V4_POOL_MANAGER, 0x777777751622c0d3258f214F9DF38E35BF45baF3, trustedMessageSenders, hookUpgradeGate),
+            HooksDeployment.makeHookCreationCode(
+                V4_POOL_MANAGER,
+                0x777777751622c0d3258f214F9DF38E35BF45baF3,
+                ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
+                hookUpgradeGate
+            ),
             salt
         );
 

package/test/LiquidityMigration.t.sol

@@ -4,6 +4,8 @@ pragma solidity ^0.8.23;
 import {MockERC20} from "./mocks/MockERC20.sol";
 import {BaseTest} from "./utils/BaseTest.sol";
 import {HooksDeployment} from "../src/libs/HooksDeployment.sol";
+import {TrustedSenderTestHelper} from "./utils/TrustedSenderTestHelper.sol";
+import {ITrustedMsgSenderProviderLookup} from "../src/interfaces/ITrustedMsgSenderProviderLookup.sol";
 import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 import {IUpgradeableV4Hook, IUpgradeableDestinationV4Hook, BurnedPosition} from "../src/interfaces/IUpgradeableV4Hook.sol";
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
@@ -450,7 +452,8 @@ contract LiquidityMigrationTest is BaseTest {
         coin.migrateLiquidity(newHook, "");
 
         // Now fix the bug by etching fixed hook code onto the old hook address
-        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup, upgradeGate);
 
         (IHooks fixedHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
@@ -477,7 +480,8 @@ contract LiquidityMigrationTest is BaseTest {
         assertEq(oldFee, 30000);
 
         // Now fix the bug by etching fixed hook code onto the old hook address
-        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup, upgradeGate);
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 

package/test/TrustedMsgSenderProviderLookup.t.sol

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "forge-std/Test.sol";
+import {TrustedMsgSenderProviderLookup} from "../src/utils/TrustedMsgSenderProviderLookup.sol";
+import {ITrustedMsgSenderProviderLookup} from "../src/interfaces/ITrustedMsgSenderProviderLookup.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";
+
+contract TrustedMsgSenderProviderLookupTest is Test {
+    ITrustedMsgSenderProviderLookup internal trustedMsgSenderLookup;
+
+    address internal owner;
+    address internal nonOwner;
+    address internal trustedSender1;
+    address internal trustedSender2;
+
+    event TrustedSenderAdded(address indexed sender);
+    event TrustedSenderRemoved(address indexed sender);
+
+    function setUp() public {
+        owner = makeAddr("owner");
+        nonOwner = makeAddr("nonOwner");
+        trustedSender1 = makeAddr("trustedSender1");
+        trustedSender2 = makeAddr("trustedSender2");
+    }
+
+    function deployAndInitializeLookup(address[] memory initialTrustedSenders, address initialOwner) internal returns (ITrustedMsgSenderProviderLookup) {
+        // Deploy the contract directly using constructor
+        TrustedMsgSenderProviderLookup lookup = new TrustedMsgSenderProviderLookup(initialTrustedSenders, initialOwner);
+        return ITrustedMsgSenderProviderLookup(address(lookup));
+    }
+
+    function test_constructor_initializesCorrectly() public {
+        address[] memory initialTrustedSenders = new address[](2);
+        initialTrustedSenders[0] = trustedSender1;
+        initialTrustedSenders[1] = trustedSender2;
+
+        trustedMsgSenderLookup = deployAndInitializeLookup(initialTrustedSenders, owner);
+
+        assertEq(Ownable2Step(address(trustedMsgSenderLookup)).owner(), owner);
+        assertTrue(trustedMsgSenderLookup.isTrustedMsgSenderProvider(trustedSender1));
+        assertTrue(trustedMsgSenderLookup.isTrustedMsgSenderProvider(trustedSender2));
+    }
+
+    function test_isTrustedMsgSenderProvider_returnsCorrectValues() public {
+        address[] memory initialTrustedSenders = new address[](1);
+        initialTrustedSenders[0] = trustedSender1;
+
+        trustedMsgSenderLookup = deployAndInitializeLookup(initialTrustedSenders, owner);
+
+        assertTrue(trustedMsgSenderLookup.isTrustedMsgSenderProvider(trustedSender1));
+        assertFalse(trustedMsgSenderLookup.isTrustedMsgSenderProvider(trustedSender2));
+        assertFalse(trustedMsgSenderLookup.isTrustedMsgSenderProvider(address(0)));
+    }
+
+    function test_addTrustedMsgSenderProviders_worksCorrectly() public {
+        address[] memory emptyTrustedSenders = new address[](0);
+        trustedMsgSenderLookup = deployAndInitializeLookup(emptyTrustedSenders, owner);
+
+        address[] memory sendersToAdd = new address[](2);
+        sendersToAdd[0] = trustedSender1;
+        sendersToAdd[1] = trustedSender2;
+
+        vm.prank(owner);
+        TrustedMsgSenderProviderLookup(address(trustedMsgSenderLookup)).addTrustedMsgSenderProviders(sendersToAdd);
+
+        assertTrue(trustedMsgSenderLookup.isTrustedMsgSenderProvider(trustedSender1));
+        assertTrue(trustedMsgSenderLookup.isTrustedMsgSenderProvider(trustedSender2));
+    }
+
+    function test_addTrustedMsgSenderProviders_onlyOwnerCanAdd() public {
+        address[] memory emptyTrustedSenders = new address[](0);
+        trustedMsgSenderLookup = deployAndInitializeLookup(emptyTrustedSenders, owner);
+
+        address[] memory sendersToAdd = new address[](1);
+        sendersToAdd[0] = trustedSender1;
+
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, nonOwner));
+        vm.prank(nonOwner);
+        TrustedMsgSenderProviderLookup(address(trustedMsgSenderLookup)).addTrustedMsgSenderProviders(sendersToAdd);
+    }
+
+    function test_removeTrustedMsgSenderProviders_worksCorrectly() public {
+        address[] memory initialTrustedSenders = new address[](2);
+        initialTrustedSenders[0] = trustedSender1;
+        initialTrustedSenders[1] = trustedSender2;
+        trustedMsgSenderLookup = deployAndInitializeLookup(initialTrustedSenders, owner);
+
+        address[] memory sendersToRemove = new address[](1);
+        sendersToRemove[0] = trustedSender1;
+
+        vm.prank(owner);
+        TrustedMsgSenderProviderLookup(address(trustedMsgSenderLookup)).removeTrustedMsgSenderProviders(sendersToRemove);
+
+        assertFalse(trustedMsgSenderLookup.isTrustedMsgSenderProvider(trustedSender1));
+        assertTrue(trustedMsgSenderLookup.isTrustedMsgSenderProvider(trustedSender2));
+    }
+
+    function test_removeTrustedMsgSenderProviders_onlyOwnerCanRemove() public {
+        address[] memory initialTrustedSenders = new address[](1);
+        initialTrustedSenders[0] = trustedSender1;
+        trustedMsgSenderLookup = deployAndInitializeLookup(initialTrustedSenders, owner);
+
+        address[] memory sendersToRemove = new address[](1);
+        sendersToRemove[0] = trustedSender1;
+
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, nonOwner));
+        vm.prank(nonOwner);
+        TrustedMsgSenderProviderLookup(address(trustedMsgSenderLookup)).removeTrustedMsgSenderProviders(sendersToRemove);
+    }
+}

package/test/Upgrades.t.sol

@@ -28,6 +28,8 @@ import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
 import {IZoraV4CoinHook} from "../src/interfaces/IZoraV4CoinHook.sol";
 import {PoolStateReader} from "../src/libs/PoolStateReader.sol";
 import {LpPosition} from "../src/types/LpPosition.sol";
+import {ITrustedMsgSenderProviderLookup} from "../src/interfaces/ITrustedMsgSenderProviderLookup.sol";
+import {TrustedSenderTestHelper} from "./utils/TrustedSenderTestHelper.sol";
 
 contract BadImpl {
     function contractName() public pure returns (string memory) {
@@ -195,7 +197,9 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         uint256 amountIn = 0.000111 ether;
 
-        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup2 = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup2, upgradeGate);
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
@@ -247,7 +251,9 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         address existingHook = address(creatorCoin.hooks());
 
-        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup3 = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup3, upgradeGate);
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
@@ -281,19 +287,17 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         uint128[] memory afterLiquidity = getLiquidityForPositions(afterKey, afterPositions);
 
         for (uint256 i = 0; i < beforeLiquidity.length; i++) {
-            // we added any extra liquidity to the last position, so we don't expect it to be the same
-            if (i != beforeLiquidity.length - 1) {
-                assertApproxEqAbs(beforeLiquidity[i], afterLiquidity[i], 200);
-            }
+            assertApproxEqAbs(beforeLiquidity[i], afterLiquidity[i], 200);
         }
 
         uint160 afterPrice = PoolStateReader.getSqrtPriceX96(creatorCoin.getPoolKey(), poolManager);
 
         assertEq(beforePrice, afterPrice);
 
-        // make sure that the new hook has no balance of 0 or 1
-        assertApproxEqAbs(creatorCoin.getPoolKey().currency0.balanceOf(address(newHook)), 0, 10);
-        assertApproxEqAbs(creatorCoin.getPoolKey().currency1.balanceOf(address(newHook)), 0, 10);
+        // Small amounts of dust from rounding may remain in the hook as burned tokens
+        // This is expected and saves on code size by not minting them back into the pool
+        assertApproxEqAbs(creatorCoin.getPoolKey().currency0.balanceOf(address(newHook)), 0, 0.1 ether);
+        assertApproxEqAbs(creatorCoin.getPoolKey().currency1.balanceOf(address(newHook)), 0, 0.1 ether);
 
         // now try to swap some currency for the creator coin - it should succeed
         _swapSomeCurrencyForCoin(creatorCoin, zora, uint128(IERC20(zora).balanceOf(trader) / 2), trader);
@@ -315,7 +319,8 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         // this swap should revert because the content coin is broken
         _swapSomeCurrencyForCoinAndExpectRevert(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
 
-        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup2 = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup2, upgradeGate);
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 

package/test/utils/BaseTest.sol

@@ -44,6 +44,9 @@ import {ContractAddresses} from "./ContractAddresses.sol";
 import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 import {HookUpgradeGate} from "../../src/hooks/HookUpgradeGate.sol";
 import {ZoraHookRegistry} from "../../src/hook-registry/ZoraHookRegistry.sol";
+import {TrustedMsgSenderProviderLookup} from "../../src/utils/TrustedMsgSenderProviderLookup.sol";
+import {ITrustedMsgSenderProviderLookup} from "../../src/interfaces/ITrustedMsgSenderProviderLookup.sol";
+import {TrustedSenderTestHelper} from "./TrustedSenderTestHelper.sol";
 
 // Hookmate imports for non-forked testing
 import {V4PoolManagerDeployer} from "./hookmate/artifacts/V4PoolManager.sol";
@@ -215,13 +218,23 @@ contract BaseTest is Test, ContractAddresses {
     }
 
     function _deployFeeEstimatorHook(address hooks) internal {
-        deployCodeTo("FeeEstimatorHook.sol", abi.encode(address(poolManager), address(factory), hookUpgradeGate), hooks);
+        // Deploy a new lookup with the same trusted senders
+        address[] memory trustedMessageSenders = new address[](2);
+        trustedMessageSenders[0] = UNIVERSAL_ROUTER;
+        trustedMessageSenders[1] = V4_POSITION_MANAGER;
+        ITrustedMsgSenderProviderLookup newLookup = TrustedSenderTestHelper.deployTrustedMessageSender(users.factoryOwner, trustedMessageSenders);
+
+        deployCodeTo(
+            "FeeEstimatorHook.sol",
+            HooksDeployment.hookConstructorArgs(address(poolManager), address(factory), newLookup, address(hookUpgradeGate)),
+            hooks
+        );
     }
 
-    function getSalt(address[] memory trustedMessageSenders) public returns (bytes32 hookSalt) {
+    function getSalt(ITrustedMsgSenderProviderLookup trustedMsgSenderLookup) public returns (bytes32 hookSalt) {
         address deployer = address(this);
 
-        (, hookSalt) = HooksDeployment.mineForCoinSalt(deployer, V4_POOL_MANAGER, address(factory), trustedMessageSenders, address(hookUpgradeGate));
+        (, hookSalt) = HooksDeployment.mineForCoinSalt(deployer, V4_POOL_MANAGER, address(factory), trustedMsgSenderLookup, address(hookUpgradeGate));
     }
 
     function _deployHooks() internal {
@@ -229,13 +242,20 @@ contract BaseTest is Test, ContractAddresses {
         trustedMessageSenders[0] = UNIVERSAL_ROUTER;
         trustedMessageSenders[1] = V4_POSITION_MANAGER;
 
-        bytes32 hookSalt = getSalt(trustedMessageSenders);
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(users.factoryOwner, trustedMessageSenders);
+
+        bytes32 hookSalt = getSalt(trustedMsgSenderLookup);
 
         hook = ZoraV4CoinHook(
             payable(
                 address(
                     HooksDeployment.deployHookWithSalt(
-                        HooksDeployment.makeHookCreationCode(V4_POOL_MANAGER, address(factory), trustedMessageSenders, address(hookUpgradeGate)),
+                        HooksDeployment.makeHookCreationCode(
+                            V4_POOL_MANAGER,
+                            address(factory),
+                            ITrustedMsgSenderProviderLookup(address(trustedMsgSenderLookup)),
+                            address(hookUpgradeGate)
+                        ),
                         hookSalt
                     )
                 )
@@ -360,7 +380,7 @@ contract BaseTest is Test, ContractAddresses {
         zoraHookRegistry.initialize(initialOwners);
 
         // Deploy hooks for non-forked environment
-        _deployHooksNonForked(address(mockAirlock));
+        _deployHooksNonForked();
 
         // Deploy coin implementations
         coinV4Impl = new ContentCoin(users.feeRecipient, address(protocolRewards), poolManager, address(mockAirlock));
@@ -406,6 +426,7 @@ contract BaseTest is Test, ContractAddresses {
         }
 
         permit2 = IPermit2(permit2Address);
+        vm.label(address(permit2), "V4_PERMIT2");
     }
 
     function _deployPoolManagerNonForked() internal {
@@ -416,10 +437,12 @@ contract BaseTest is Test, ContractAddresses {
         }
 
         deal(address(poolManager), 10000 ether);
+        vm.label(address(poolManager), "V4_POOL_MANAGER");
     }
 
     function _deployQuoterNonForked() internal {
         quoter = IV4Quoter(V4QuoterDeployer.deploy(address(poolManager)));
+        vm.label(address(quoter), "V4_QUOTER");
     }
 
     function _deployUniversalRouterNonForked() internal {
@@ -435,20 +458,23 @@ contract BaseTest is Test, ContractAddresses {
             v4PositionManager: address(0)
         });
         router = IUniversalRouter(UniversalRouterDeployer.deploy(params));
+        vm.label(address(router), "UNIVERSAL_ROUTER");
     }
 
-    function _deployHooksNonForked(address airlockAddress) internal {
+    function _deployHooksNonForked() internal {
         address[] memory trustedMessageSenders = new address[](1);
         trustedMessageSenders[0] = address(router);
 
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(users.factoryOwner, trustedMessageSenders);
+
         // Use proper salt mining for hook deployment
         address deployer = address(this);
-        (, bytes32 salt) = HooksDeployment.mineForCoinSalt(deployer, address(poolManager), address(factory), trustedMessageSenders, address(hookUpgradeGate));
+        (, bytes32 salt) = HooksDeployment.mineForCoinSalt(deployer, address(poolManager), address(factory), trustedMsgSenderLookup, address(hookUpgradeGate));
 
         bytes memory hookCreationCode = HooksDeployment.makeHookCreationCode(
             address(poolManager),
             address(factory),
-            trustedMessageSenders,
+            trustedMsgSenderLookup,
             address(hookUpgradeGate)
         );
 

package/test/utils/FeeEstimatorHook.sol

@@ -16,6 +16,7 @@ import {UniV4SwapToCurrency} from "../../src/libs/UniV4SwapToCurrency.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {CoinRewardsV4} from "../../src/libs/CoinRewardsV4.sol";
 import {IHooksUpgradeGate} from "../../src/interfaces/IHooksUpgradeGate.sol";
+import {ITrustedMsgSenderProviderLookup} from "../../src/interfaces/ITrustedMsgSenderProviderLookup.sol";
 
 /// @dev Test util - meant to be able to etched where a normal zora hook is, to gather the fees from swaps but not distribute them
 contract FeeEstimatorHook is ZoraV4CoinHook {
@@ -33,8 +34,9 @@ contract FeeEstimatorHook is ZoraV4CoinHook {
     constructor(
         IPoolManager _poolManager,
         IDeployedCoinVersionLookup _coinVersionLookup,
+        ITrustedMsgSenderProviderLookup trustedMsgSenderLookup,
         IHooksUpgradeGate upgradeGate
-    ) ZoraV4CoinHook(_poolManager, _coinVersionLookup, new address[](0), upgradeGate) {}
+    ) ZoraV4CoinHook(_poolManager, _coinVersionLookup, trustedMsgSenderLookup, upgradeGate) {}
 
     FeeEstimatorState public feeState;