@zoralabs/coins 1.1.0 → 1.1.2

package/src/hooks/CreatorCoinHook.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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.28;
 
 import {CreatorCoinConstants} from "../libs/CreatorCoinConstants.sol";

package/src/hooks/HookUpgradeGate.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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 {IHooksUpgradeGate} from "../interfaces/IHooksUpgradeGate.sol";

package/src/interfaces/ICoin.sol

@@ -23,6 +23,9 @@ struct PoolKeyStruct {
 }
 
 interface ICoin is IERC165, IERC7572, IDopplerErrors, IHasRewardsRecipients {
+    /// @notice Thrown when the name is required for the coin
+    error NameIsRequired();
+
     /// @notice Thrown when an operation is attempted with a zero address
     error AddressZero();
 

package/src/libs/CoinCommon.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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 {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";

package/src/libs/CoinConfigurationVersions.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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 {CoinConstants} from "./CoinConstants.sol";

package/src/libs/CoinConstants.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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;
 
 library CoinConstants {

package/src/libs/CoinDopplerMultiCurve.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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 {PoolConfiguration} from "../interfaces/ICoin.sol";

package/src/libs/CoinRewards.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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 {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

package/src/libs/CoinRewardsV4.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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.28;
 
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
@@ -79,6 +85,21 @@ library CoinRewardsV4 {
         lpRewardAmount = uint128(calculateReward(uint256(totalBackingAmount), LP_REWARD_BPS));
     }
 
+    function convertDeltaToPositiveUint128(int256 delta) internal pure returns (uint128) {
+        if (delta < 0) {
+            revert SafeCast.SafeCastOverflow();
+        }
+        return uint128(uint256(delta));
+    }
+
+    function getCurrencyZeroBalance(IPoolManager poolManager, PoolKey calldata key) internal view returns (uint128) {
+        return convertDeltaToPositiveUint128(TransientStateLibrary.currencyDelta(poolManager, address(this), key.currency0));
+    }
+
+    function getCurrencyOneBalance(IPoolManager poolManager, PoolKey calldata key) internal view returns (uint128) {
+        return convertDeltaToPositiveUint128(TransientStateLibrary.currencyDelta(poolManager, address(this), key.currency1));
+    }
+
     /// @notice Mints LP rewards by creating new liquidity positions from collected fees
     /// @dev Splits collected fees between LP rewards and market rewards, then mints new LP positions
     ///      with the LP reward portion. The remaining amount becomes market rewards for distribution.
@@ -99,8 +120,6 @@ library CoinRewardsV4 {
             if (lpRewardAmount0 > 0) {
                 _modifyLiquidity(poolManager, key, lpRewardAmount0, true);
             }
-
-            marketRewardsAmount0 = uint128(uint256(TransientStateLibrary.currencyDelta(poolManager, address(this), key.currency0)));
         }
 
         if (fees1 > 0) {
@@ -108,9 +127,10 @@ library CoinRewardsV4 {
             if (lpRewardAmount1 > 0) {
                 _modifyLiquidity(poolManager, key, lpRewardAmount1, false);
             }
-
-            marketRewardsAmount1 = uint128(uint256(TransientStateLibrary.currencyDelta(poolManager, address(this), key.currency1)));
         }
+
+        marketRewardsAmount0 = getCurrencyZeroBalance(poolManager, key);
+        marketRewardsAmount1 = getCurrencyOneBalance(poolManager, key);
     }
 
     /// @notice Mints a single-sided LP position

package/src/libs/CoinSetup.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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 {PoolConfigurationV4} from "../interfaces/ICoin.sol";

package/src/libs/CreatorCoinConstants.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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;
 
 library CreatorCoinConstants {

package/src/libs/CreatorCoinRewards.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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.28;
 
 import {ICreatorCoinHook} from "../interfaces/ICreatorCoinHook.sol";

package/src/libs/DopplerMath.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: BUSL-1.1
+// 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.24;
 
 import {IDopplerErrors} from "../interfaces/IDopplerErrors.sol";

package/src/libs/HooksDeployment.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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 {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
@@ -157,6 +163,19 @@ library HooksDeployment {
             );
     }
 
+    function creatorCoinCreationCode(
+        address poolManager,
+        address coinVersionLookup,
+        address[] memory trustedMessageSenders,
+        address upgradeGate
+    ) internal pure returns (bytes memory) {
+        return
+            abi.encodePacked(
+                type(CreatorCoinHook).creationCode,
+                creatorCoinConstructorArgs(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate)
+            );
+    }
+
     /// @notice Deploys or returns existing ContentCoinHook using deterministic deployment.  Ensures that if a hooks is already
     /// deployed with the provided salt, it will be returned.
     function deployContentCoinHook(

package/src/libs/PoolStateReader.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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 {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";

package/src/libs/UniV4SwapHelper.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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 {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";

package/src/libs/UniV4SwapToCurrency.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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 {Currency} from "@uniswap/v4-core/src/types/Currency.sol";

package/src/libs/V4Liquidity.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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 {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
@@ -48,6 +54,9 @@ library V4Liquidity {
     error InvalidCallbackId(uint8 callbackId);
 
     /// @notice Locks the pool, and mint initial positions to the hook
+    /// @param poolManager The pool manager.
+    /// @param poolKey The pool key.
+    /// @param positions The positions.
     function lockAndMint(IPoolManager poolManager, PoolKey memory poolKey, LpPosition[] memory positions) internal {
         bytes memory data = abi.encode(MINT_CALLBACK_ID, abi.encode(MintCallbackData({poolKey: poolKey, positions: positions})));
 
@@ -129,11 +138,35 @@ library V4Liquidity {
         return abi.encode(result);
     }
 
+    function generatePositionsFromMigratedLiquidity(
+        uint160 sqrtPriceX96,
+        BurnedPosition[] calldata migratedLiquidity
+    ) internal pure returns (LpPosition[] memory positions) {
+        positions = new LpPosition[](migratedLiquidity.length);
+
+        for (uint256 i = 0; i < migratedLiquidity.length; i++) {
+            uint128 liquidity = LiquidityAmounts.getLiquidityForAmounts(
+                sqrtPriceX96,
+                TickMath.getSqrtPriceAtTick(migratedLiquidity[i].tickLower),
+                TickMath.getSqrtPriceAtTick(migratedLiquidity[i].tickUpper),
+                migratedLiquidity[i].amount0Received,
+                migratedLiquidity[i].amount1Received
+            );
+            positions[i] = LpPosition({liquidity: liquidity, tickLower: migratedLiquidity[i].tickLower, tickUpper: migratedLiquidity[i].tickUpper});
+        }
+    }
+
     function collectFees(IPoolManager poolManager, PoolKey memory poolKey, LpPosition[] storage positions) internal returns (int128 balance0, int128 balance1) {
         ModifyLiquidityParams memory params;
         uint256 numPositions = positions.length;
 
         for (uint256 i; i < numPositions; i++) {
+            // if there is no liquidity, skip
+            uint128 liquidity = getLiquidity(poolManager, address(this), poolKey, positions[i].tickLower, positions[i].tickUpper);
+            if (liquidity == 0) {
+                continue;
+            }
+
             params = ModifyLiquidityParams({
                 tickLower: positions[i].tickLower,
                 tickUpper: positions[i].tickUpper,

package/src/types/PoolConfiguration.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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;
 
 /// @notice The configuration of the pool

package/src/utils/AutoSwapper.sol

@@ -1,4 +1,10 @@
-// SPDX-License-Identifier: MIT
+// 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.28;
 
 import {ISwapRouter} from "@zoralabs/shared-contracts/interfaces/uniswap/ISwapRouter.sol";

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 "1.1.0";
+        return "1.1.2";
     }
 }

package/test/Coin.t.sol

@@ -8,6 +8,8 @@ import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
 import {IHasRewardsRecipients} from "../src/interfaces/IHasRewardsRecipients.sol";
 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";
 
 contract CoinTest is BaseTest {
     using stdJson for string;
@@ -16,6 +18,17 @@ contract CoinTest is BaseTest {
         super.setUp();
     }
 
+    function test_contract_ierc165_support() public {
+        _deployCoin();
+        assertEq(coin.supportsInterface(type(IZoraFactory).interfaceId), false);
+        assertEq(coin.supportsInterface(bytes4(0x00000000)), false);
+        assertEq(coin.supportsInterface(type(IERC165).interfaceId), true);
+        assertEq(coin.supportsInterface(type(IERC7572).interfaceId), true);
+        assertEq(coin.supportsInterface(type(ICoin).interfaceId), true);
+        assertEq(coin.supportsInterface(type(ICoinComments).interfaceId), true);
+        assertEq(coin.supportsInterface(type(IERC7572).interfaceId), true);
+    }
+
     function test_contract_version() public {
         _deployCoin();
         string memory package = vm.readFile("./package.json");
@@ -658,4 +671,14 @@ contract CoinTest is BaseTest {
         vm.expectRevert(abi.encodeWithSelector(MultiOwnable.OnlyOwner.selector));
         coin.setNameAndSymbol(newName, newSymbol);
     }
+
+    function test_update_metadata_reverts_if_name_is_blank() public {
+        _deployCoin();
+        string memory newName = "";
+        string memory newSymbol = "NEW";
+
+        vm.prank(users.creator);
+        vm.expectRevert(abi.encodeWithSelector(ICoin.NameIsRequired.selector));
+        coin.setNameAndSymbol(newName, newSymbol);
+    }
 }

package/test/LiquidityMigration.t.sol

@@ -123,6 +123,33 @@ contract LiquidityMigrationTest is BaseTest {
         assertEq(newPoolKey.tickSpacing, poolKey.tickSpacing, "poolkey tickSpacing");
     }
 
+    function test_migrateLiquidity_enablesSwapsOnOldPoolKey() public {
+        address currency = address(mockERC20A);
+        mockERC20A.mint(address(poolManager), 1_000_000_000 ether);
+        _deployV4Coin(currency);
+
+        address trader = makeAddr("trader");
+
+        mockERC20A.mint(trader, 10 ether);
+
+        // do some swaps
+        _swapSomeCurrencyForCoin(coinV4, currency, 1 ether, trader);
+        _swapSomeCoinForCurrency(coinV4, currency, uint128(coinV4.balanceOf(trader)), trader);
+
+        address newHook = address(new LiquidityMigrationReceiver());
+
+        PoolKey memory poolKey = coinV4.getPoolKey();
+
+        registerUpgradePath(address(poolKey.hooks), address(newHook));
+
+        // migrate the liquidity
+        vm.prank(users.creator);
+        coinV4.migrateLiquidity(address(newHook), "");
+
+        // now swap using the existing pool key, it should succeed
+        _swapSomeCurrencyForCoin(poolKey, coinV4, currency, uint128(mockERC20A.balanceOf(trader)), trader);
+    }
+
     function test_migrateLiquidity_emitsLiquidityMigrated() public {
         address currency = address(mockERC20A);
         _deployV4Coin(currency);

package/test/Upgrades.t.sol

@@ -13,8 +13,20 @@ import {IWETH} from "../src/interfaces/IWETH.sol";
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {BuySupplyWithSwapRouterHook} from "../src/hooks/deployment/BuySupplyWithSwapRouterHook.sol";
-
+import {ContentCoinHook} from "../src/hooks/ContentCoinHook.sol";
 import {console} from "forge-std/console.sol";
+import {IDeployedCoinVersionLookup} from "../src/interfaces/IDeployedCoinVersionLookup.sol";
+import {IHooksUpgradeGate} from "../src/interfaces/IHooksUpgradeGate.sol";
+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 {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";
+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";
 
 contract BadImpl {
     function contractName() public pure returns (string memory) {
@@ -159,4 +171,171 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         // do some swaps to test out
         _swapSomeCoinForCurrency(ICoinV4(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 {
+        uint128 minAmountOut = uint128(0);
+
+        (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
+            currency,
+            amountIn,
+            address(_coin),
+            minAmountOut,
+            _coin.getPoolKey(),
+            bytes("")
+        );
+
+        vm.startPrank(trader);
+        UniV4SwapHelper.approveTokenWithPermit2(permit2, address(router), currency, amountIn, uint48(block.timestamp + 1 days));
+
+        // Execute the swap
+        uint256 deadline = block.timestamp + 20;
+        vm.expectRevert();
+        router.execute(commands, inputs, deadline);
+
+        vm.stopPrank();
+    }
+
+    function test_canCanFixBrokenContentCoinAndSwap() public {
+        vm.createSelectFork("base", 31835069);
+
+        address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
+
+        address contentCoin = 0x4E93A01c90f812284F71291a8d1415a904957156;
+
+        address creatorCoin = ICoinV4(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);
+
+        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);
+
+        _swapSomeCurrencyForCoin(ICoinV4(contentCoin), creatorCoin, uint128(amountIn), trader);
+    }
+
+    function test_canUpgradeBrokenContentCoinAndSwap() public {
+        vm.createSelectFork("base", 31835069);
+
+        address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
+
+        address contentCoin = 0x4E93A01c90f812284F71291a8d1415a904957156;
+
+        address creatorCoin = ICoinV4(contentCoin).currency();
+
+        address existingHook = 0xd3D133469ADC85e01A4887404D8AC12d630e9040;
+
+        uint256 amountIn = IERC20(creatorCoin).balanceOf(trader);
+
+        bytes memory creationCode = HooksDeployment.contentCoinCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+
+        (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
+
+        address[] memory baseImpls = new address[](1);
+        baseImpls[0] = existingHook;
+
+        vm.prank(Ownable(upgradeGate).owner());
+        IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
+
+        vm.prank(MultiOwnable(contentCoin).owners()[0]);
+        CoinV4(contentCoin).migrateLiquidity(address(newHook), "");
+
+        // do some swaps to test out
+        _swapSomeCurrencyForCoin(ICoinV4(contentCoin), creatorCoin, uint128(amountIn), trader);
+    }
+
+    function getPositionInfo(
+        PoolKey memory key,
+        address owner,
+        int24 tickLower,
+        int24 tickUpper
+    ) internal view returns (uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128) {
+        return StateLibrary.getPositionInfo(poolManager, key.toId(), owner, tickLower, tickUpper, bytes32(0));
+    }
+
+    function getLiquidityForPositions(PoolKey memory key, LpPosition[] memory positions) internal view returns (uint128[] memory liquidityForPositions) {
+        liquidityForPositions = new uint128[](positions.length);
+
+        for (uint256 i = 0; i < positions.length; i++) {
+            (uint128 liquidity, , ) = getPositionInfo(key, address(key.hooks), positions[i].tickLower, positions[i].tickUpper);
+            liquidityForPositions[i] = liquidity;
+        }
+    }
+
+    function getLiquidityForPoolCoin(ICoinV4 coin) internal view returns (uint128[] memory liquidityForPositions) {
+        return getLiquidityForPositions(coin.getPoolKey(), IZoraV4CoinHook(address(coin.hooks())).getPoolCoin(coin.getPoolKey()).positions);
+    }
+
+    function test_canUpgradeBrokenCreatorCoinAndSwap() public {
+        vm.createSelectFork("base", 31872861);
+
+        address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
+
+        ICoinV4 creatorCoin = ICoinV4(0x2F03aB8fD97F5874bc3274C296Bb954Ae92EdA34);
+
+        address zora = creatorCoin.currency();
+
+        address existingHook = address(creatorCoin.hooks());
+
+        bytes memory creationCode = HooksDeployment.creatorCoinCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+
+        (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
+
+        address[] memory baseImpls = new address[](1);
+        baseImpls[0] = existingHook;
+
+        vm.prank(Ownable(upgradeGate).owner());
+        IHooksUpgradeGate(upgradeGate).registerUpgradePath(baseImpls, address(newHook));
+
+        LpPosition[] memory beforePositions = IZoraV4CoinHook(address(creatorCoin.hooks())).getPoolCoin(creatorCoin.getPoolKey()).positions;
+        PoolKey memory beforeKey = creatorCoin.getPoolKey();
+
+        uint128[] memory beforeLiquidity = getLiquidityForPositions(beforeKey, beforePositions);
+        // get before price
+        uint160 beforePrice = PoolStateReader.getSqrtPriceX96(creatorCoin.getPoolKey(), poolManager);
+
+        vm.prank(MultiOwnable(address(creatorCoin)).owners()[0]);
+        CoinV4(address(creatorCoin)).migrateLiquidity(address(newHook), "");
+
+        // get liquidity of original positions after migration
+        uint128[] memory liquidityOfPositionsAfterMigration = getLiquidityForPositions(beforeKey, beforePositions);
+
+        // there should be no liquidity left in the original positions after migration
+        for (uint256 i = 0; i < liquidityOfPositionsAfterMigration.length; i++) {
+            assertEq(liquidityOfPositionsAfterMigration[i], 0);
+        }
+
+        // get liquidity of new positions after migration
+        PoolKey memory afterKey = creatorCoin.getPoolKey();
+        LpPosition[] memory afterPositions = IZoraV4CoinHook(address(afterKey.hooks)).getPoolCoin(afterKey).positions;
+        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);
+            }
+        }
+
+        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);
+
+        // now try to swap some currency for the creator coin - it should succeed
+        _swapSomeCurrencyForCoin(creatorCoin, zora, uint128(IERC20(zora).balanceOf(trader) / 2), trader);
+    }
 }