@zoralabs/coins 1.1.2 → 2.1.0

package/test/LiquidityMigration.t.sol

@@ -13,9 +13,11 @@ import {LpPosition} from "../src/types/LpPosition.sol";
 import {V4Liquidity} from "../src/libs/V4Liquidity.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {IZoraV4CoinHook} from "../src/interfaces/IZoraV4CoinHook.sol";
-import {ICoinV4} from "../src/interfaces/ICoinV4.sol";
+import {ICoin} from "../src/interfaces/ICoin.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {CoinCommon} from "../src/libs/CoinCommon.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {IHooksUpgradeGate} from "../src/interfaces/IHooksUpgradeGate.sol";
 
 contract LiquidityMigrationReceiver is IUpgradeableDestinationV4Hook, IERC165 {
     function initializeFromMigration(
@@ -175,7 +177,7 @@ contract LiquidityMigrationTest is BaseTest {
         // migrate the liquidity
         vm.prank(users.creator);
         vm.expectEmit(true, true, true, true);
-        emit ICoinV4.LiquidityMigrated(poolKey, fromPoolKeyHash, newPoolKey, toPoolKeyHash);
+        emit ICoin.LiquidityMigrated(poolKey, fromPoolKeyHash, newPoolKey, toPoolKeyHash);
         coinV4.migrateLiquidity(address(newHook), "");
     }
 
@@ -230,4 +232,160 @@ contract LiquidityMigrationTest is BaseTest {
         vm.expectRevert(abi.encodeWithSelector(IZoraV4CoinHook.OnlyCoin.selector, users.creator, address(coinV4)));
         IUpgradeableV4Hook(originalHook).migrateLiquidity(address(newHook), poolKey, "");
     }
+
+    // Hook Upgrade Gate Tests
+    function test_hookUpgradeGate_removeUpgradePath() public {
+        address baseImpl = makeAddr("baseImpl");
+        address upgradeImpl = makeAddr("upgradeImpl");
+
+        // First register the upgrade path
+        address[] memory baseImpls = new address[](1);
+        baseImpls[0] = baseImpl;
+
+        vm.prank(hookUpgradeGate.owner());
+        hookUpgradeGate.registerUpgradePath(baseImpls, upgradeImpl);
+
+        // Verify it's registered
+        assertTrue(hookUpgradeGate.isRegisteredUpgradePath(baseImpl, upgradeImpl));
+
+        // Remove the upgrade path
+        vm.prank(hookUpgradeGate.owner());
+        vm.expectEmit(true, true, false, false);
+        emit IHooksUpgradeGate.UpgradeRemoved(baseImpl, upgradeImpl);
+        hookUpgradeGate.removeUpgradePath(baseImpl, upgradeImpl);
+
+        // Verify it's removed
+        assertFalse(hookUpgradeGate.isRegisteredUpgradePath(baseImpl, upgradeImpl));
+    }
+
+    function test_hookUpgradeGate_removeUpgradePath_onlyOwner() public {
+        address baseImpl = makeAddr("baseImpl");
+        address upgradeImpl = makeAddr("upgradeImpl");
+        address nonOwner = makeAddr("nonOwner");
+
+        // Try to remove upgrade path as non-owner
+        vm.prank(nonOwner);
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, nonOwner));
+        hookUpgradeGate.removeUpgradePath(baseImpl, upgradeImpl);
+    }
+
+    function test_hookUpgradeGate_registerUpgradePath_onlyOwner() public {
+        address baseImpl = makeAddr("baseImpl");
+        address upgradeImpl = makeAddr("upgradeImpl");
+        address nonOwner = makeAddr("nonOwner");
+
+        address[] memory baseImpls = new address[](1);
+        baseImpls[0] = baseImpl;
+
+        // Try to register upgrade path as non-owner
+        vm.prank(nonOwner);
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, nonOwner));
+        hookUpgradeGate.registerUpgradePath(baseImpls, upgradeImpl);
+    }
+
+    function test_hookUpgradeGate_registerMultipleUpgradePaths() public {
+        address baseImpl1 = makeAddr("baseImpl1");
+        address baseImpl2 = makeAddr("baseImpl2");
+        address baseImpl3 = makeAddr("baseImpl3");
+        address upgradeImpl = makeAddr("upgradeImpl");
+
+        address[] memory baseImpls = new address[](3);
+        baseImpls[0] = baseImpl1;
+        baseImpls[1] = baseImpl2;
+        baseImpls[2] = baseImpl3;
+
+        // Register multiple upgrade paths at once
+        vm.prank(hookUpgradeGate.owner());
+        vm.expectEmit(true, true, false, false);
+        emit IHooksUpgradeGate.UpgradeRegistered(baseImpl1, upgradeImpl);
+        vm.expectEmit(true, true, false, false);
+        emit IHooksUpgradeGate.UpgradeRegistered(baseImpl2, upgradeImpl);
+        vm.expectEmit(true, true, false, false);
+        emit IHooksUpgradeGate.UpgradeRegistered(baseImpl3, upgradeImpl);
+        hookUpgradeGate.registerUpgradePath(baseImpls, upgradeImpl);
+
+        // Verify all paths are registered
+        assertTrue(hookUpgradeGate.isRegisteredUpgradePath(baseImpl1, upgradeImpl));
+        assertTrue(hookUpgradeGate.isRegisteredUpgradePath(baseImpl2, upgradeImpl));
+        assertTrue(hookUpgradeGate.isRegisteredUpgradePath(baseImpl3, upgradeImpl));
+    }
+
+    function test_hookUpgradeGate_registerEmptyArray() public {
+        address upgradeImpl = makeAddr("upgradeImpl");
+        address[] memory baseImpls = new address[](0);
+
+        // Register with empty array - should succeed but do nothing
+        vm.prank(hookUpgradeGate.owner());
+        hookUpgradeGate.registerUpgradePath(baseImpls, upgradeImpl);
+
+        // No events should be emitted, no state changes
+    }
+
+    function test_hookUpgradeGate_removeNonexistentUpgradePath() public {
+        address baseImpl = makeAddr("baseImpl");
+        address upgradeImpl = makeAddr("upgradeImpl");
+
+        // Try to remove a path that was never registered
+        vm.prank(hookUpgradeGate.owner());
+        vm.expectEmit(true, true, false, false);
+        emit IHooksUpgradeGate.UpgradeRemoved(baseImpl, upgradeImpl);
+        hookUpgradeGate.removeUpgradePath(baseImpl, upgradeImpl);
+
+        // Should still be false (was already false)
+        assertFalse(hookUpgradeGate.isRegisteredUpgradePath(baseImpl, upgradeImpl));
+    }
+
+    function test_hookUpgradeGate_registerSamePathTwice() public {
+        address baseImpl = makeAddr("baseImpl");
+        address upgradeImpl = makeAddr("upgradeImpl");
+
+        address[] memory baseImpls = new address[](1);
+        baseImpls[0] = baseImpl;
+
+        // Register once
+        vm.prank(hookUpgradeGate.owner());
+        hookUpgradeGate.registerUpgradePath(baseImpls, upgradeImpl);
+        assertTrue(hookUpgradeGate.isRegisteredUpgradePath(baseImpl, upgradeImpl));
+
+        // Register again - should succeed and overwrite (true -> true)
+        vm.prank(hookUpgradeGate.owner());
+        vm.expectEmit(true, true, false, false);
+        emit IHooksUpgradeGate.UpgradeRegistered(baseImpl, upgradeImpl);
+        hookUpgradeGate.registerUpgradePath(baseImpls, upgradeImpl);
+        assertTrue(hookUpgradeGate.isRegisteredUpgradePath(baseImpl, upgradeImpl));
+    }
+
+    function test_hookUpgradeGate_zeroAddressHandling() public {
+        address[] memory baseImpls = new address[](2);
+        baseImpls[0] = address(0);
+        baseImpls[1] = makeAddr("baseImpl");
+        address upgradeImpl = address(0);
+
+        // Should allow zero addresses (no validation in contract)
+        vm.prank(hookUpgradeGate.owner());
+        hookUpgradeGate.registerUpgradePath(baseImpls, upgradeImpl);
+
+        assertTrue(hookUpgradeGate.isRegisteredUpgradePath(address(0), address(0)));
+        assertTrue(hookUpgradeGate.isRegisteredUpgradePath(makeAddr("baseImpl"), address(0)));
+    }
+
+    function test_hookUpgradeGate_isAllowedHookUpgradeMapping() public {
+        address baseImpl = makeAddr("baseImpl");
+        address upgradeImpl = makeAddr("upgradeImpl");
+
+        // Test direct mapping access
+        assertFalse(hookUpgradeGate.isAllowedHookUpgrade(baseImpl, upgradeImpl));
+
+        // Register upgrade path
+        address[] memory baseImpls = new address[](1);
+        baseImpls[0] = baseImpl;
+        vm.prank(hookUpgradeGate.owner());
+        hookUpgradeGate.registerUpgradePath(baseImpls, upgradeImpl);
+
+        // Test direct mapping access
+        assertTrue(hookUpgradeGate.isAllowedHookUpgrade(baseImpl, upgradeImpl));
+
+        // Should match isRegisteredUpgradePath
+        assertEq(hookUpgradeGate.isAllowedHookUpgrade(baseImpl, upgradeImpl), hookUpgradeGate.isRegisteredUpgradePath(baseImpl, upgradeImpl));
+    }
 }

package/test/MultiOwnable.t.sol

@@ -7,13 +7,13 @@ contract MultiOwnableTest is BaseTest {
     function setUp() public override {
         super.setUp();
 
-        _deployCoin();
+        _deployV4Coin();
     }
 
     function test_initial_owners() public view {
-        assertEq(coin.owners().length, 1);
-        assertEq(coin.owners()[0], users.creator);
-        assertEq(coin.isOwner(users.creator), true);
+        assertEq(coinV4.owners().length, 1);
+        assertEq(coinV4.owners()[0], users.creator);
+        assertEq(coinV4.isOwner(users.creator), true);
     }
 
     function test_add_owners() public {
@@ -22,21 +22,21 @@ contract MultiOwnableTest is BaseTest {
         newOwners[1] = makeAddr("NewOwner2");
 
         vm.prank(users.creator);
-        coin.addOwners(newOwners);
+        coinV4.addOwners(newOwners);
 
-        assertEq(coin.owners().length, 3);
-        assertEq(coin.isOwner(users.creator), true);
-        assertEq(coin.isOwner(newOwners[0]), true);
-        assertEq(coin.isOwner(newOwners[1]), true);
+        assertEq(coinV4.owners().length, 3);
+        assertEq(coinV4.isOwner(users.creator), true);
+        assertEq(coinV4.isOwner(newOwners[0]), true);
+        assertEq(coinV4.isOwner(newOwners[1]), true);
     }
 
     function test_add_owner() public {
         vm.prank(users.creator);
-        coin.addOwner(address(this));
+        coinV4.addOwner(address(this));
 
-        assertEq(coin.owners().length, 2);
-        assertEq(coin.isOwner(users.creator), true);
-        assertEq(coin.isOwner(address(this)), true);
+        assertEq(coinV4.owners().length, 2);
+        assertEq(coinV4.isOwner(users.creator), true);
+        assertEq(coinV4.isOwner(address(this)), true);
     }
 
     function test_remove_owners() public {
@@ -45,67 +45,67 @@ contract MultiOwnableTest is BaseTest {
         newOwners[1] = makeAddr("NewOwner2");
 
         vm.prank(users.creator);
-        coin.addOwners(newOwners);
+        coinV4.addOwners(newOwners);
 
         vm.prank(users.creator);
-        coin.removeOwners(newOwners);
+        coinV4.removeOwners(newOwners);
 
-        assertEq(coin.owners().length, 1);
-        assertEq(coin.isOwner(users.creator), true);
-        assertEq(coin.isOwner(newOwners[0]), false);
-        assertEq(coin.isOwner(newOwners[1]), false);
+        assertEq(coinV4.owners().length, 1);
+        assertEq(coinV4.isOwner(users.creator), true);
+        assertEq(coinV4.isOwner(newOwners[0]), false);
+        assertEq(coinV4.isOwner(newOwners[1]), false);
     }
 
     function test_remove_owner() public {
         vm.prank(users.creator);
-        coin.addOwner(address(this));
+        coinV4.addOwner(address(this));
 
         vm.prank(address(this));
-        coin.removeOwner(users.creator);
+        coinV4.removeOwner(users.creator);
 
-        assertEq(coin.owners().length, 1);
-        assertEq(coin.isOwner(users.creator), false);
-        assertEq(coin.isOwner(address(this)), true);
+        assertEq(coinV4.owners().length, 1);
+        assertEq(coinV4.isOwner(users.creator), false);
+        assertEq(coinV4.isOwner(address(this)), true);
     }
 
     function test_revert_only_owner_can_add() public {
         vm.expectRevert(abi.encodeWithSelector(MultiOwnable.OnlyOwner.selector));
-        coin.addOwner(address(this));
+        coinV4.addOwner(address(this));
     }
 
     function test_revert_only_owner_can_remove() public {
         vm.expectRevert(abi.encodeWithSelector(MultiOwnable.OnlyOwner.selector));
 
         vm.prank(address(this));
-        coin.removeOwner(users.creator);
+        coinV4.removeOwner(users.creator);
     }
 
     function test_revert_cannot_remove_not_owner() public {
         vm.expectRevert(abi.encodeWithSelector(MultiOwnable.NotOwner.selector));
         vm.prank(users.creator);
-        coin.removeOwner(address(this));
+        coinV4.removeOwner(address(this));
     }
 
     function test_revert_last_owner_must_revoke() public {
         address newOwner = makeAddr("NewOwner1");
 
         vm.prank(users.creator);
-        coin.addOwner(newOwner);
+        coinV4.addOwner(newOwner);
 
         vm.prank(newOwner);
-        coin.removeOwner(users.creator);
+        coinV4.removeOwner(users.creator);
 
         vm.prank(newOwner);
         vm.expectRevert(abi.encodeWithSelector(MultiOwnable.UseRevokeOwnershipToRemoveSelf.selector));
-        coin.removeOwner(newOwner);
+        coinV4.removeOwner(newOwner);
     }
 
     function test_revoke_ownership() public {
         vm.prank(users.creator);
-        coin.revokeOwnership();
+        coinV4.revokeOwnership();
 
-        assertEq(coin.owners().length, 0);
-        assertEq(coin.isOwner(users.creator), false);
+        assertEq(coinV4.owners().length, 0);
+        assertEq(coinV4.isOwner(users.creator), false);
     }
 
     function test_revert_add_owners_with_zero_address() public {
@@ -116,7 +116,7 @@ contract MultiOwnableTest is BaseTest {
 
         vm.prank(users.creator);
         vm.expectRevert(MultiOwnable.OwnerCannotBeAddressZero.selector);
-        coin.addOwners(newOwners);
+        coinV4.addOwners(newOwners);
     }
 
     function test_revert_add_owners_with_duplicate() public {
@@ -126,11 +126,11 @@ contract MultiOwnableTest is BaseTest {
         newOwners[1] = newOwner;
 
         vm.prank(users.creator);
-        coin.addOwner(newOwner);
+        coinV4.addOwner(newOwner);
 
         vm.expectRevert(MultiOwnable.AlreadyOwner.selector);
         vm.prank(users.creator);
-        coin.addOwners(newOwners);
+        coinV4.addOwners(newOwners);
     }
 
     function test_revert_init_with_zero_owners() public {

package/test/Upgrades.t.sol

@@ -6,7 +6,7 @@ import {ZoraFactoryImpl} from "../src/ZoraFactoryImpl.sol";
 import {BaseTest} from "./utils/BaseTest.sol";
 import {CoinsDeployerBase} from "../src/deployment/CoinsDeployerBase.sol";
 import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
-import {ICoinV4} from "../src/interfaces/ICoinV4.sol";
+import {ICoin} from "../src/interfaces/ICoin.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {ISwapRouter} from "../src/interfaces/ISwapRouter.sol";
 import {IWETH} from "../src/interfaces/IWETH.sol";
@@ -21,7 +21,7 @@ import {HooksDeployment} from "../src/libs/HooksDeployment.sol";
 import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
 import {MultiOwnable} from "../src/utils/MultiOwnable.sol";
-import {CoinV4} from "../src/CoinV4.sol";
+import {ContentCoin} from "../src/ContentCoin.sol";
 import {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";
 import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
 import {IZoraV4CoinHook} from "../src/interfaces/IZoraV4CoinHook.sol";
@@ -43,13 +43,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
 
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(
-            factoryProxy.coinImpl(),
-            address(coinV4Impl),
-            address(creatorCoinImpl),
-            address(contentCoinHook),
-            address(creatorCoinHook)
-        );
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
 
         vm.prank(factoryProxy.owner());
         factoryProxy.upgradeToAndCall(address(newImpl), "");
@@ -64,13 +58,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
 
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(
-            factoryProxy.coinImpl(),
-            address(coinV4Impl),
-            address(creatorCoinImpl),
-            address(contentCoinHook),
-            address(creatorCoinHook)
-        );
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
 
         vm.prank(factoryProxy.owner());
         factoryProxy.upgradeToAndCall(address(newImpl), "");
@@ -88,19 +76,12 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
 
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(
-            factoryProxy.coinImpl(),
-            address(coinV4Impl),
-            address(creatorCoinImpl),
-            address(contentCoinHook),
-            address(creatorCoinHook)
-        );
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
 
         vm.prank(factoryProxy.owner());
         factoryProxy.upgradeToAndCall(address(newImpl), "");
 
         ZoraFactoryImpl newImpl2 = new ZoraFactoryImpl(
-            factoryProxy.coinImpl(),
             factoryProxy.coinV4Impl(),
             factoryProxy.creatorCoinImpl(),
             address(contentCoinHook),
@@ -166,16 +147,16 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         );
 
         // do some swaps to test out
-        _swapSomeCurrencyForCoin(ICoinV4(coinAddress), ZORA, uint128(IERC20(ZORA).balanceOf(trader)), trader);
+        _swapSomeCurrencyForCoin(ICoin(coinAddress), ZORA, uint128(IERC20(ZORA).balanceOf(trader)), trader);
 
         // do some swaps to test out
-        _swapSomeCoinForCurrency(ICoinV4(coinAddress), ZORA, uint128(IERC20(coinAddress).balanceOf(trader)), trader);
+        _swapSomeCoinForCurrency(ICoin(coinAddress), ZORA, uint128(IERC20(coinAddress).balanceOf(trader)), trader);
     }
 
     address coinVersionLookup = 0x777777751622c0d3258f214F9DF38E35BF45baF3;
     address upgradeGate = 0xD88f6BdD765313CaFA5888C177c325E2C3AbF2D2;
 
-    function _swapSomeCurrencyForCoinAndExpectRevert(ICoinV4 _coin, address currency, uint128 amountIn, address trader) internal {
+    function _swapSomeCurrencyForCoinAndExpectRevert(ICoin _coin, address currency, uint128 amountIn, address trader) internal {
         uint128 minAmountOut = uint128(0);
 
         (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
@@ -205,42 +186,42 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         address contentCoin = 0x4E93A01c90f812284F71291a8d1415a904957156;
 
-        address creatorCoin = ICoinV4(contentCoin).currency();
+        address creatorCoin = ICoin(contentCoin).currency();
 
         uint256 amountIn = IERC20(creatorCoin).balanceOf(trader);
 
         require(amountIn > 0, "no balance");
 
         // this swap should revert because the content coin is broken
-        _swapSomeCurrencyForCoinAndExpectRevert(ICoinV4(contentCoin), creatorCoin, uint128(amountIn), trader);
+        _swapSomeCurrencyForCoinAndExpectRevert(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
 
         bytes memory creationCode = HooksDeployment.contentCoinCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
         // etch new hook into the content coin, it shouldn't revert anymore when swapping
-        vm.etch(address(ICoinV4(contentCoin).hooks()), address(newHook).code);
+        vm.etch(address(ICoin(contentCoin).hooks()), address(newHook).code);
 
-        _swapSomeCurrencyForCoin(ICoinV4(contentCoin), creatorCoin, uint128(amountIn), trader);
+        _swapSomeCurrencyForCoin(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
     }
 
     function test_canUpgradeBrokenContentCoinAndSwap() public {
-        vm.createSelectFork("base", 31835069);
+        vm.createSelectFork("base", 32613149);
 
         address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
 
-        address contentCoin = 0x4E93A01c90f812284F71291a8d1415a904957156;
+        address contentCoin = 0xB9799C839818bF50240CE683363D00c43a2E23b8;
 
-        address creatorCoin = ICoinV4(contentCoin).currency();
+        address creatorCoin = ICoin(contentCoin).currency();
 
-        address existingHook = 0xd3D133469ADC85e01A4887404D8AC12d630e9040;
-
-        uint256 amountIn = IERC20(creatorCoin).balanceOf(trader);
+        uint256 amountIn = 0.000111 ether;
 
         bytes memory creationCode = HooksDeployment.contentCoinCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
+        address existingHook = address(ICoin(contentCoin).hooks());
+
         address[] memory baseImpls = new address[](1);
         baseImpls[0] = existingHook;
 
@@ -248,10 +229,10 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
 
         vm.prank(MultiOwnable(contentCoin).owners()[0]);
-        CoinV4(contentCoin).migrateLiquidity(address(newHook), "");
+        ContentCoin(contentCoin).migrateLiquidity(address(newHook), "");
 
         // do some swaps to test out
-        _swapSomeCurrencyForCoin(ICoinV4(contentCoin), creatorCoin, uint128(amountIn), trader);
+        _swapSomeCurrencyForCoin(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
     }
 
     function getPositionInfo(
@@ -272,7 +253,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         }
     }
 
-    function getLiquidityForPoolCoin(ICoinV4 coin) internal view returns (uint128[] memory liquidityForPositions) {
+    function getLiquidityForPoolCoin(ICoin coin) internal view returns (uint128[] memory liquidityForPositions) {
         return getLiquidityForPositions(coin.getPoolKey(), IZoraV4CoinHook(address(coin.hooks())).getPoolCoin(coin.getPoolKey()).positions);
     }
 
@@ -281,7 +262,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
 
-        ICoinV4 creatorCoin = ICoinV4(0x2F03aB8fD97F5874bc3274C296Bb954Ae92EdA34);
+        ICoin creatorCoin = ICoin(0x2F03aB8fD97F5874bc3274C296Bb954Ae92EdA34);
 
         address zora = creatorCoin.currency();
 
@@ -305,7 +286,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         uint160 beforePrice = PoolStateReader.getSqrtPriceX96(creatorCoin.getPoolKey(), poolManager);
 
         vm.prank(MultiOwnable(address(creatorCoin)).owners()[0]);
-        CoinV4(address(creatorCoin)).migrateLiquidity(address(newHook), "");
+        ContentCoin(address(creatorCoin)).migrateLiquidity(address(newHook), "");
 
         // get liquidity of original positions after migration
         uint128[] memory liquidityOfPositionsAfterMigration = getLiquidityForPositions(beforeKey, beforePositions);