@zoralabs/coins 1.1.0 → 1.1.1

package/src/libs/V4Liquidity.sol

@@ -48,6 +48,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 +132,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/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.1";
     }
 }

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

package/test/utils/BaseTest.sol

@@ -190,6 +190,10 @@ contract BaseTest is Test, ContractAddresses {
     }
 
     function _swapSomeCurrencyForCoin(ICoinV4 _coin, address currency, uint128 amountIn, address trader) internal {
+        _swapSomeCurrencyForCoin(_coin.getPoolKey(), _coin, currency, amountIn, trader);
+    }
+
+    function _swapSomeCurrencyForCoin(PoolKey memory poolKey, ICoinV4 _coin, address currency, uint128 amountIn, address trader) internal {
         uint128 minAmountOut = uint128(0);
 
         (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
@@ -197,7 +201,7 @@ contract BaseTest is Test, ContractAddresses {
             amountIn,
             address(_coin),
             minAmountOut,
-            _coin.getPoolKey(),
+            poolKey,
             bytes("")
         );