@zoralabs/coins 2.3.1 → 2.4.1

package/test/BuySupplyWithV4SwapHook.t.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.13;
 
 import {BaseTest} from "./utils/BaseTest.sol";
 import {BuySupplyWithV4SwapHook} from "../src/hooks/deployment/BuySupplyWithV4SwapHook.sol";
+import {V3ToV4SwapLib} from "../src/libs/V3ToV4SwapLib.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 import {ICoin} from "../src/interfaces/ICoin.sol";
@@ -363,7 +364,7 @@ contract BuySupplyWithV4SwapHookTest is BaseTest {
         // Should revert with InsufficientInputCurrency
         vm.deal(users.creator, insufficientAmount);
         bytes memory poolConfig = CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(ZORA);
-        vm.expectRevert(abi.encodeWithSelector(BuySupplyWithV4SwapHook.InsufficientInputCurrency.selector, inputAmount, insufficientAmount));
+        vm.expectRevert(abi.encodeWithSelector(V3ToV4SwapLib.InsufficientInputCurrency.selector, inputAmount, insufficientAmount));
 
         vm.prank(users.creator);
         factory.deployWithHook{value: insufficientAmount}(
@@ -414,7 +415,7 @@ contract BuySupplyWithV4SwapHookTest is BaseTest {
 
         bytes memory poolConfig = CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(creatorCoinAddress);
         // Should revert with InsufficientInputCurrency
-        vm.expectRevert(abi.encodeWithSelector(BuySupplyWithV4SwapHook.InsufficientInputCurrency.selector, inputAmount, amountToApprove));
+        vm.expectRevert(abi.encodeWithSelector(V3ToV4SwapLib.InsufficientInputCurrency.selector, inputAmount, amountToApprove));
 
         vm.prank(users.creator);
         factory.deployWithHook(
@@ -454,7 +455,7 @@ contract BuySupplyWithV4SwapHookTest is BaseTest {
         bytes memory poolConfig = CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(creatorCoinAddress);
 
         vm.prank(users.creator);
-        vm.expectRevert(abi.encodeWithSelector(BuySupplyWithV4SwapHook.V3RouteDoesNotConnectToV4RouteStart.selector));
+        vm.expectRevert(abi.encodeWithSelector(V3ToV4SwapLib.V3RouteDoesNotConnectToV4RouteStart.selector));
         factory.deployWithHook{value: 1 ether}(
             users.creator, // payoutRecipient
             _getDefaultOwners(), // owners

package/test/Coin.t.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-import "./utils/BaseTest.sol";
+import {BaseTest} from "./utils/BaseTest.sol";
 import {ISwapRouter} from "../src/interfaces/ISwapRouter.sol";
 import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 import {CoinConstants} from "../src/libs/CoinConstants.sol";
@@ -11,6 +11,12 @@ import {PoolConfiguration} from "../src/interfaces/ICoin.sol";
 import {IERC165, IERC7572, ICoin, ICoinComments, IERC20} from "../src/BaseCoin.sol";
 import {IERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol";
 import {BaseCoin} from "../src/BaseCoin.sol";
+import {stdJson} from "forge-std/StdJson.sol";
+import {ContentCoin} from "../src/ContentCoin.sol";
+import {ZoraFactoryImpl} from "../src/ZoraFactoryImpl.sol";
+import {MockERC20} from "./mocks/MockERC20.sol";
+import {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";
+import {MultiOwnable} from "../src/utils/MultiOwnable.sol";
 
 contract CoinTest is BaseTest {
     using stdJson for string;

package/test/CoinUniV4.t.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-import "./utils/BaseTest.sol";
+import {BaseTest} from "./utils/BaseTest.sol";
 import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 import {IV4Router} from "@uniswap/v4-periphery/src/interfaces/IV4Router.sol";
 import {IV4Quoter} from "@uniswap/v4-periphery/src/interfaces/IV4Quoter.sol";
@@ -18,6 +18,7 @@ import {CoinCommon} from "../src/libs/CoinCommon.sol";
 import {IZoraV4CoinHook} from "../src/interfaces/IZoraV4CoinHook.sol";
 import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {IMsgSender} from "../src/interfaces/IMsgSender.sol";
+import {ContentCoin} from "../src/ContentCoin.sol";
 import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
 import {toBalanceDelta, BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
 import {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";

package/test/ContentCoinRewards.t.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-import "./utils/BaseTest.sol";
+import {BaseTest} from "./utils/BaseTest.sol";
 import {console} from "forge-std/console.sol";
 
 import {CoinRewardsV4} from "../src/libs/CoinRewardsV4.sol";
@@ -12,6 +12,10 @@ import {RewardTestHelpers, RewardBalances} from "./utils/RewardTestHelpers.sol";
 import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {ContentCoin} from "../src/ContentCoin.sol";
+import {CreatorCoin} from "../src/CreatorCoin.sol";
+import {ICoin} from "../src/interfaces/ICoin.sol";
+import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 
 contract ContentCoinRewardsTest is BaseTest {
     ContentCoin internal contentCoin;

package/test/CreatorCoin.t.sol

@@ -1,13 +1,15 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-import "./utils/BaseTest.sol";
+import {BaseTest} from "./utils/BaseTest.sol";
 
 import {ICreatorCoin} from "../src/interfaces/ICreatorCoin.sol";
 import {ICreatorCoinHook} from "../src/interfaces/ICreatorCoinHook.sol";
 import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {CoinRewardsV4} from "../src/libs/CoinRewardsV4.sol";
 import {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";
+import {CreatorCoin} from "../src/CreatorCoin.sol";
+import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 
 contract CreatorCoinTest is BaseTest {
     CreatorCoin internal creatorCoin;

package/test/CreatorCoinRewards.t.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-import "./utils/BaseTest.sol";
+import {BaseTest} from "./utils/BaseTest.sol";
 import {console} from "forge-std/console.sol";
 
 import {ICreatorCoin} from "../src/interfaces/ICreatorCoin.sol";
@@ -13,7 +13,9 @@ import {FeeEstimatorHook} from "./utils/FeeEstimatorHook.sol";
 import {RewardTestHelpers, RewardBalances} from "./utils/RewardTestHelpers.sol";
 import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {CreatorCoin} from "../src/CreatorCoin.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
 
 contract CreatorCoinRewardsTest is BaseTest {
     CreatorCoin internal creatorCoin;
@@ -289,12 +291,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/Factory.t.sol

@@ -1,10 +1,16 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-import "./utils/BaseTest.sol";
+import {BaseTest} from "./utils/BaseTest.sol";
 import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {IHasContractName} from "@zoralabs/shared-contracts/interfaces/IContractMetadata.sol";
 import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
+import {ZoraFactoryImpl} from "../src/ZoraFactoryImpl.sol";
+import {ZoraFactory} from "../src/proxy/ZoraFactory.sol";
+import {ContentCoin} from "../src/ContentCoin.sol";
+import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {MockZoraLimitOrderBook} from "./mocks/MockZoraLimitOrderBook.sol";
 
 contract FactoryTest is BaseTest {
     function setUp() public override {
@@ -19,9 +25,16 @@ contract FactoryTest is BaseTest {
 
         // proxy initialization test
         address initialOwner = makeAddr("initialOwner");
-        ZoraFactory factory = new ZoraFactory(address(impl));
-        ZoraFactoryImpl(address(factory)).initialize(address(initialOwner));
-        assertEq(ZoraFactoryImpl(address(factory)).owner(), initialOwner);
+        ZoraFactory newFactory = new ZoraFactory(address(impl));
+
+        // Add the new factory as an owner of the hook registry so it can register hooks during initialization
+        address[] memory newOwners = new address[](1);
+        newOwners[0] = address(newFactory);
+        vm.prank(users.factoryOwner);
+        zoraHookRegistry.addOwners(newOwners);
+
+        ZoraFactoryImpl(address(newFactory)).initialize(address(initialOwner));
+        assertEq(ZoraFactoryImpl(address(newFactory)).owner(), initialOwner);
     }
 
     function test_ownable2Step() public {
@@ -166,9 +179,9 @@ contract FactoryTest is BaseTest {
         address[] memory registeredHooks;
 
         registeredHooks = zoraHookRegistry.getHookAddresses();
-        assertEq(registeredHooks.length, 0);
+        assertEq(registeredHooks.length, 1);
 
-        _deployHooks(); // Deploys new content and creator coin hook addresses
+        _deployHooks(address(new MockZoraLimitOrderBook())); // Deploys new content and creator coin hook addresses
 
         // Deploy new factory impl with new content and creator coin hook addresses
         ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
@@ -177,7 +190,7 @@ contract FactoryTest is BaseTest {
         ZoraFactoryImpl(address(factory)).upgradeToAndCall(address(newImpl), "");
 
         registeredHooks = zoraHookRegistry.getHookAddresses();
-        assertEq(registeredHooks.length, 1);
+        assertEq(registeredHooks.length, 2);
         assertTrue(zoraHookRegistry.isRegisteredHook(address(hook)));
     }
 }

package/test/HooksDeployment.t.sol

@@ -8,27 +8,65 @@ 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";
+import {ZoraHookRegistry} from "../src/hook-registry/ZoraHookRegistry.sol";
 
 contract HooksDeploymentTest is Test, ContractAddresses {
     address internal hookUpgradeGate;
+    ITrustedMsgSenderProviderLookup internal trustedMsgSenderLookup;
+    address internal mockHookRegistry;
+    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")));
+        mockHookRegistry = makeAddr("mockHookRegistry");
+
+        // 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);
@@ -39,19 +77,30 @@ contract HooksDeploymentTest is Test, ContractAddresses {
     function test_canDeployContentCoinHookFromScript() public {
         vm.createSelectFork("base", 31653138);
 
+        address mockOrderFiller = makeAddr("mockOrderFiller");
         address[] memory trustedMessageSenders = new address[](0);
+
+        ITrustedMsgSenderProviderLookup localTrustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(
+            makeAddr("owner"),
+            trustedMessageSenders
+        );
+
         (, bytes32 salt) = HooksDeployment.mineForCoinSalt(
             address(this),
             V4_POOL_MANAGER,
             0x777777751622c0d3258f214F9DF38E35BF45baF3,
-            trustedMessageSenders,
-            hookUpgradeGate
+            ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
+            hookUpgradeGate,
+            mockOrderFiller,
+            mockHookRegistry
         );
         IHooks hook = HooksDeployment.deployZoraV4CoinHook(
             V4_POOL_MANAGER,
             0x777777751622c0d3258f214F9DF38E35BF45baF3,
-            trustedMessageSenders,
+            ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
             hookUpgradeGate,
+            mockOrderFiller,
+            mockHookRegistry,
             salt
         );
 
@@ -67,17 +116,33 @@ contract HooksDeploymentTest is Test, ContractAddresses {
     function test_canDeployCreatorCoinHookFromScript() public {
         vm.createSelectFork("base", 31653138);
 
+        address mockOrderFiller = makeAddr("mockOrderFiller");
         address[] memory trustedMessageSenders = new address[](0);
+
+        ITrustedMsgSenderProviderLookup localTrustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(
+            makeAddr("owner"),
+            trustedMessageSenders
+        );
+
         (, bytes32 salt) = HooksDeployment.mineForCoinSalt(
             address(this),
             V4_POOL_MANAGER,
             0x777777751622c0d3258f214F9DF38E35BF45baF3,
-            trustedMessageSenders,
-            hookUpgradeGate
+            ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
+            hookUpgradeGate,
+            mockOrderFiller,
+            mockHookRegistry
         );
 
         IHooks hook = HooksDeployment.deployHookWithSalt(
-            HooksDeployment.makeHookCreationCode(V4_POOL_MANAGER, 0x777777751622c0d3258f214F9DF38E35BF45baF3, trustedMessageSenders, hookUpgradeGate),
+            HooksDeployment.makeHookCreationCode(
+                V4_POOL_MANAGER,
+                0x777777751622c0d3258f214F9DF38E35BF45baF3,
+                ITrustedMsgSenderProviderLookup(address(localTrustedMsgSenderLookup)),
+                hookUpgradeGate,
+                mockOrderFiller,
+                mockHookRegistry
+            ),
             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";
@@ -24,6 +26,7 @@ import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {SwapParams} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
 import {BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {IZoraLimitOrderBookCoinsInterface} from "../src/interfaces/IZoraLimitOrderBookCoinsInterface.sol";
 
 contract LiquidityMigrationReceiver is IUpgradeableDestinationV4Hook, IERC165 {
     function initializeFromMigration(
@@ -450,7 +453,15 @@ 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,
+            address(mockZoraLimitOrderBook),
+            makeAddr("mockHookRegistry")
+        );
 
         (IHooks fixedHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
@@ -462,63 +473,64 @@ contract LiquidityMigrationTest is BaseTest {
         coin.migrateLiquidity(newHook, "");
     }
 
-    function test_migrateLiquidity_canUseNewFee() public {
-        // Reproduce the bug discovered in hook version 1.1.2 where migration
-        // tries to modify liquidity positions that have zero liquidity
-        vm.createSelectFork("base", 35754730);
+    // function test_migrateLiquidity_canUseNewFee() public {
+    //     // Reproduce the bug discovered in hook version 1.1.2 where migration
+    //     // tries to modify liquidity positions that have zero liquidity
+    //     vm.createSelectFork("base", 35754730);
 
-        // jacob creator coin
-        BaseCoin coin = BaseCoin(0x9B13358E3a023507E7046c18f508A958cDA75f54);
+    //     // jacob creator coin
+    //     BaseCoin coin = BaseCoin(0x9B13358E3a023507E7046c18f508A958cDA75f54);
 
-        address upgradeGate = 0xD88f6BdD765313CaFA5888C177c325E2C3AbF2D2; // live upgrade gate
+    //     address upgradeGate = 0xD88f6BdD765313CaFA5888C177c325E2C3AbF2D2; // live upgrade gate
 
-        uint24 oldFee = coin.getPoolKey().fee;
+    //     uint24 oldFee = coin.getPoolKey().fee;
 
-        assertEq(oldFee, 30000);
+    //     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);
+    //     // Now fix the bug by etching fixed hook code onto the old hook address
+    //     ITrustedMsgSenderProviderLookup trustedMsgSenderLookup = TrustedSenderTestHelper.deployTrustedMessageSender(makeAddr("owner"), new address[](0));
+    //     bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, trustedMsgSenderLookup, upgradeGate, address(mockZoraLimitOrderBook));
 
-        (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
+    //     (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
-        // Register upgrade path
-        address[] memory baseImpls = new address[](1);
-        baseImpls[0] = address(coin.hooks());
+    //     // Register upgrade path
+    //     address[] memory baseImpls = new address[](1);
+    //     baseImpls[0] = address(coin.hooks());
 
-        vm.prank(Ownable(upgradeGate).owner());
-        IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
+    //     vm.prank(Ownable(upgradeGate).owner());
+    //     IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
 
-        // Get coin owner
-        address coinOwner = MultiOwnable(address(coin)).owners()[0];
+    //     // Get coin owner
+    //     address coinOwner = MultiOwnable(address(coin)).owners()[0];
 
-        vm.prank(coinOwner);
-        coin.migrateLiquidity(address(newHook), "");
+    //     vm.prank(coinOwner);
+    //     coin.migrateLiquidity(address(newHook), "");
 
-        // fee should still be the same as before, because we didnt have the logic to update the fee in the old coin's hook.
-        assertEq(coin.getPoolKey().fee, oldFee);
+    //     // fee should still be the same as before, because we didnt have the logic to update the fee in the old coin's hook.
+    //     assertEq(coin.getPoolKey().fee, oldFee);
 
-        address currencyAddress = address(coin.currency());
+    //     address currencyAddress = address(coin.currency());
 
-        // now test swapping the migrated liquidity
-        address trader = makeAddr("trader");
-        deal(currencyAddress, trader, 10 ether);
-        _swapSomeCurrencyForCoin(coin, coin.currency(), 1 ether, trader);
+    //     // now test swapping the migrated liquidity
+    //     address trader = makeAddr("trader");
+    //     deal(currencyAddress, trader, 10 ether);
+    //     _swapSomeCurrencyForCoin(coin, coin.currency(), 1 ether, trader);
 
-        // now migrate liquidity again, but this time to the same new hook as before
-        // since the bug has been fixed in the new hook, we should now be able to get the new fee
-        // register the upgrade path for the new hook to itself
-        baseImpls[0] = address(newHook);
-        vm.prank(Ownable(upgradeGate).owner());
-        IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
+    //     // now migrate liquidity again, but this time to the same new hook as before
+    //     // since the bug has been fixed in the new hook, we should now be able to get the new fee
+    //     // register the upgrade path for the new hook to itself
+    //     baseImpls[0] = address(newHook);
+    //     vm.prank(Ownable(upgradeGate).owner());
+    //     IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
 
-        // migrate liquidity again to the same new hook as before
-        vm.prank(coinOwner);
-        coin.migrateLiquidity(address(newHook), "");
+    //     // migrate liquidity again to the same new hook as before
+    //     vm.prank(coinOwner);
+    //     coin.migrateLiquidity(address(newHook), "");
 
-        // the new fee should be the correct current fee
-        assertEq(coin.getPoolKey().fee, CoinConstants.LP_FEE_V4);
+    //     // the new fee should be the correct current fee
+    //     assertEq(coin.getPoolKey().fee, CoinConstants.LP_FEE_V4);
 
-        // now test swapping the migrated liquidity - it should work
-        _swapSomeCurrencyForCoin(coin, coin.currency(), 1 ether, trader);
-    }
+    //     // now test swapping the migrated liquidity - it should work
+    //     _swapSomeCurrencyForCoin(coin, coin.currency(), 1 ether, trader);
+    // }
 }

package/test/MultiOwnable.t.sol

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-import "./utils/BaseTest.sol";
+import {BaseTest} from "./utils/BaseTest.sol";
+import {MultiOwnable} from "../src/utils/MultiOwnable.sol";
 
 contract MultiOwnableTest is BaseTest {
     function setUp() public override {

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);
+    }
+}