@zoralabs/coins 0.7.1 → 0.9.0

package/test/Hooks.t.sol

@@ -0,0 +1,274 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {BaseTest} from "./utils/BaseTest.sol";
+import {BuySupplyWithSwapRouterHook} from "../src/hooks/BuySupplyWithSwapRouterHook.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IUniswapV3Pool} from "../src/interfaces/IUniswapV3Pool.sol";
+import {Coin} from "../src/Coin.sol";
+import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {ICoin} from "../src/interfaces/ICoin.sol";
+import {IHasAfterCoinDeploy} from "../src/hooks/BaseCoinDeployHook.sol";
+import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
+import {ISwapRouter} from "../src/interfaces/ISwapRouter.sol";
+import {CoinConstants} from "../src/libs/CoinConstants.sol";
+
+// Create a fake hook that doesn't support the IHasAfterCoinDeploy interface
+contract FakeHookNoInterface {
+    function supportsInterface(bytes4) external pure returns (bool) {
+        return false; // Always returns false, doesn't support any interface
+    }
+}
+
+contract HooksTest is BaseTest {
+    int24 internal constant DEFAULT_DISCOVERY_TICK_LOWER = -777000;
+    int24 internal constant DEFAULT_DISCOVERY_TICK_UPPER = 222000;
+    uint16 internal constant DEFAULT_NUM_DISCOVERY_POSITIONS = 10; // will be 11 total with tail position
+    uint256 internal constant DEFAULT_DISCOVERY_SUPPLY_SHARE = 0.495e18; // half of the 990m total pool supply
+    address constant zora = 0x1111111111166b7FE7bd91427724B487980aFc69;
+
+    function _generateDefaultPoolConfig(address currency) internal pure returns (bytes memory) {
+        return
+            _generatePoolConfig(
+                CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION,
+                currency,
+                DEFAULT_DISCOVERY_TICK_LOWER,
+                DEFAULT_DISCOVERY_TICK_UPPER,
+                DEFAULT_NUM_DISCOVERY_POSITIONS,
+                DEFAULT_DISCOVERY_SUPPLY_SHARE
+            );
+    }
+
+    function setUp() public override {
+        super.setUpWithBlockNumber(29585474);
+    }
+
+    function _deployWithHook(address hook, bytes memory hookData, address currency) internal returns (address, bytes memory) {
+        bytes memory poolConfig = _generateDefaultPoolConfig(currency);
+        return
+            factory.deployWithHook(
+                users.creator,
+                _getDefaultOwners(),
+                "https://test.com",
+                "Testcoin",
+                "TEST",
+                poolConfig,
+                users.platformReferrer,
+                hook,
+                hookData
+            );
+    }
+
+    function _encodeAfterCoinDeploy(address buyRecipient, bytes memory swapRouterCall) internal pure returns (bytes memory) {
+        return abi.encode(buyRecipient, swapRouterCall);
+    }
+
+    function _encodeExactInputSingle(address buyRecipient, ISwapRouter.ExactInputSingleParams memory params) internal pure returns (bytes memory) {
+        return _encodeAfterCoinDeploy(buyRecipient, abi.encodeWithSelector(ISwapRouter.exactInputSingle.selector, params));
+    }
+
+    function _encodeExactInput(address buyRecipient, ISwapRouter.ExactInputParams memory params) internal pure returns (bytes memory) {
+        return _encodeAfterCoinDeploy(buyRecipient, abi.encodeWithSelector(ISwapRouter.exactInput.selector, params));
+    }
+
+    function test_buySupplyWithEthUsingV3Hook_withExactInputSingle(uint256 initialOrderSize) public {
+        vm.assume(initialOrderSize > CoinConstants.MIN_ORDER_SIZE);
+        vm.assume(initialOrderSize < 1 ether);
+
+        vm.deal(users.creator, initialOrderSize);
+
+        BuySupplyWithSwapRouterHook hook = new BuySupplyWithSwapRouterHook(factory, address(swapRouter));
+
+        bytes memory hookData = _encodeExactInputSingle(
+            users.creator,
+            ISwapRouter.ExactInputSingleParams({
+                tokenIn: address(weth),
+                tokenOut: zora,
+                fee: 3000,
+                recipient: address(hook),
+                amountIn: initialOrderSize,
+                amountOutMinimum: 0,
+                sqrtPriceLimitX96: 0
+            })
+        );
+
+        vm.prank(users.creator);
+        (address coinAddress, bytes memory hookDataOut) = factory.deployWithHook{value: initialOrderSize}(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            _generateDefaultPoolConfig(zora),
+            users.platformReferrer,
+            address(hook),
+            hookData
+        );
+
+        coin = Coin(payable(coinAddress));
+        pool = IUniswapV3Pool(coin.poolAddress());
+
+        (uint256 amountCurrency, uint256 coinsPurchased) = abi.decode(hookDataOut, (uint256, uint256));
+
+        assertEq(coin.currency(), zora, "currency");
+        assertGt(amountCurrency, 0, "amountCurrency > 0");
+        assertGt(coinsPurchased, 0, "coinsPurchased > 0");
+        assertEq(coin.balanceOf(users.creator), CoinConstants.CREATOR_LAUNCH_REWARD + coinsPurchased, "balanceOf creator");
+        assertGt(IERC20(zora).balanceOf(address(pool)), 0, "Pool ZORA balance");
+    }
+
+    function test_buySupplyWithEthUsingV3Hook_withExactInputMultiHop(uint256 initialOrderSize) public {
+        vm.assume(initialOrderSize > CoinConstants.MIN_ORDER_SIZE);
+        vm.assume(initialOrderSize < 1 ether);
+
+        vm.deal(users.creator, initialOrderSize);
+
+        // lets try weth to usdc to zora
+
+        BuySupplyWithSwapRouterHook hook = new BuySupplyWithSwapRouterHook(factory, address(swapRouter));
+
+        uint24 poolFee = 3000;
+
+        bytes memory hookData = _encodeExactInput(
+            users.creator,
+            ISwapRouter.ExactInputParams({
+                path: abi.encodePacked(address(weth), poolFee, USDC_ADDRESS, poolFee, zora),
+                recipient: address(hook),
+                amountIn: initialOrderSize,
+                amountOutMinimum: 0
+            })
+        );
+
+        vm.prank(users.creator);
+        (address coinAddress, bytes memory hookDataOut) = factory.deployWithHook{value: initialOrderSize}(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            _generateDefaultPoolConfig(zora),
+            users.platformReferrer,
+            address(hook),
+            hookData
+        );
+
+        coin = Coin(payable(coinAddress));
+        pool = IUniswapV3Pool(coin.poolAddress());
+
+        (uint256 amountCurrency, uint256 coinsPurchased) = abi.decode(hookDataOut, (uint256, uint256));
+
+        assertEq(coin.currency(), zora, "currency");
+        assertGt(amountCurrency, 0, "amountCurrency > 0");
+        assertGt(coinsPurchased, 0, "coinsPurchased > 0");
+        assertEq(coin.balanceOf(users.creator), CoinConstants.CREATOR_LAUNCH_REWARD + coinsPurchased, "balanceOf creator");
+        assertGt(IERC20(zora).balanceOf(address(pool)), 0, "Pool ZORA balance");
+    }
+
+    function test_buySupplyWithEthUsingV3Hook_revertsWhenBadCall() public {
+        vm.deal(users.creator, 0.0001 ether);
+
+        BuySupplyWithSwapRouterHook hook = new BuySupplyWithSwapRouterHook(factory, address(swapRouter));
+
+        uint24 poolFee = 3000;
+
+        // exact output single is not supported
+        bytes memory hookData = _encodeAfterCoinDeploy(
+            users.creator,
+            abi.encodeWithSelector(
+                ISwapRouter.exactOutputSingle.selector,
+                ISwapRouter.ExactOutputParams({
+                    path: abi.encodePacked(address(weth), poolFee, USDC_ADDRESS, poolFee, zora),
+                    recipient: address(hook),
+                    amountOut: 0.0001 ether,
+                    amountInMaximum: 0
+                })
+            )
+        );
+
+        vm.prank(users.creator);
+        vm.expectRevert(BuySupplyWithSwapRouterHook.InvalidSwapRouterCall.selector);
+        factory.deployWithHook{value: 0.0001 ether}(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            _generateDefaultPoolConfig(zora),
+            users.platformReferrer,
+            address(hook),
+            hookData
+        );
+    }
+
+    function test_buySupplyWithEthUsingV3Hook_revertsWhenHookNotRecipient() public {
+        uint256 initialOrderSize = 0.0001 ether;
+        vm.deal(users.creator, initialOrderSize);
+
+        BuySupplyWithSwapRouterHook hook = new BuySupplyWithSwapRouterHook(factory, address(swapRouter));
+
+        bytes memory hookData = _encodeExactInputSingle(
+            users.creator,
+            ISwapRouter.ExactInputSingleParams({
+                tokenIn: address(weth),
+                tokenOut: zora,
+                fee: 3000,
+                recipient: address(users.creator),
+                amountIn: initialOrderSize,
+                amountOutMinimum: 0,
+                sqrtPriceLimitX96: 0
+            })
+        );
+
+        vm.prank(users.creator);
+        vm.expectRevert(BuySupplyWithSwapRouterHook.Erc20NotReceived.selector);
+        factory.deployWithHook{value: initialOrderSize}(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            _generateDefaultPoolConfig(zora),
+            users.platformReferrer,
+            address(hook),
+            hookData
+        );
+    }
+
+    function test_deployWithHook_revertsWhenEthAndNoHook() public {
+        uint256 initialOrderSize = 0.0001 ether;
+        vm.deal(users.creator, initialOrderSize);
+
+        vm.prank(users.creator);
+        vm.expectRevert(IZoraFactory.EthTransferInvalid.selector);
+        factory.deployWithHook{value: initialOrderSize}(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            _generateDefaultPoolConfig(zora),
+            users.platformReferrer,
+            address(0),
+            ""
+        );
+    }
+
+    function test_invalidHookReverts() public {
+        // Deploy a fake hook that doesn't support the IHasAfterCoinDeploy interface
+        FakeHookNoInterface fakeHook = new FakeHookNoInterface();
+
+        bytes memory hookData = "";
+
+        // Expect the transaction to revert with InvalidHook error
+        vm.expectRevert(IZoraFactory.InvalidHook.selector);
+        vm.prank(users.creator);
+        _deployWithHook(address(fakeHook), hookData, zora);
+    }
+
+    function test_noHookWorksAsNormal() public {
+        // Expect the transaction to revert with InvalidHook error
+        vm.prank(users.creator);
+        _deployWithHook(address(0), bytes(""), zora);
+    }
+}

package/test/Upgrades.t.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+import {Test} from "forge-std/Test.sol";
+import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
+import {ZoraFactoryImpl} from "../src/ZoraFactoryImpl.sol";
+
+contract BadImpl {
+    function contractName() public pure returns (string memory) {
+        return "BadImpl";
+    }
+}
+
+contract UpgradesTest is Test {
+    ZoraFactoryImpl public factoryProxy;
+
+    function test_canUpgradeFromVersionWithoutContractName() public {
+        // this test that we can upgrade from the current version, which doesn't have a contract name
+        vm.createSelectFork("base", 29675508);
+
+        factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
+
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(factoryProxy.implementation());
+
+        vm.prank(factoryProxy.owner());
+        factoryProxy.upgradeToAndCall(address(newImpl), "");
+
+        assertEq(factoryProxy.implementation(), address(newImpl));
+    }
+
+    function test_cannotUpgradeToMismatchedContractName() public {
+        // this test that we cannot upgrade to a contract with a mismatched contract name
+        // once we have upgraded to the version that checks the contract name when upgrading
+        vm.createSelectFork("base", 29675508);
+
+        factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
+
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(factoryProxy.implementation());
+
+        vm.prank(factoryProxy.owner());
+        factoryProxy.upgradeToAndCall(address(newImpl), "");
+
+        BadImpl badImpl = new BadImpl();
+
+        vm.prank(factoryProxy.owner());
+        vm.expectRevert(abi.encodeWithSelector(IZoraFactory.UpgradeToMismatchedContractName.selector, "ZoraCoinFactory", "BadImpl"));
+        factoryProxy.upgradeToAndCall(address(badImpl), "");
+    }
+
+    function test_canUpgradeToSameContractName() public {
+        // this test that we can upgrade to the same contract name, when we have already upgraded to a version that has a contract name
+        vm.createSelectFork("base", 29675508);
+
+        factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
+
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(factoryProxy.implementation());
+
+        vm.prank(factoryProxy.owner());
+        factoryProxy.upgradeToAndCall(address(newImpl), "");
+
+        ZoraFactoryImpl newImpl2 = new ZoraFactoryImpl(factoryProxy.implementation());
+
+        vm.prank(factoryProxy.owner());
+        factoryProxy.upgradeToAndCall(address(newImpl2), "");
+
+        assertEq(factoryProxy.implementation(), address(newImpl2));
+    }
+}

package/test/utils/BaseTest.sol

@@ -12,7 +12,6 @@ import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IER
 import {ZoraFactoryImpl} from "../../src/ZoraFactoryImpl.sol";
 import {ZoraFactory} from "../../src/proxy/ZoraFactory.sol";
 import {Coin} from "../../src/Coin.sol";
-import {CoinConstants} from "../../src/utils/CoinConstants.sol";
 import {MultiOwnable} from "../../src/utils/MultiOwnable.sol";
 import {ICoin} from "../../src/interfaces/ICoin.sol";
 import {IERC7572} from "../../src/interfaces/IERC7572.sol";
@@ -25,7 +24,8 @@ import {IUniswapV3Pool} from "../../src/interfaces/IUniswapV3Pool.sol";
 import {IProtocolRewards} from "../../src/interfaces/IProtocolRewards.sol";
 import {ProtocolRewards} from "../utils/ProtocolRewards.sol";
 import {MarketConstants} from "../../src/libs/MarketConstants.sol";
-contract BaseTest is Test, CoinConstants {
+
+contract BaseTest is Test {
     using stdStorage for StdStorage;
 
     address internal constant PROTOCOL_REWARDS = 0x7777777F279eba3d3Ad8F4E708545291A6fDBA8B;
@@ -65,7 +65,11 @@ contract BaseTest is Test, CoinConstants {
     IUniswapV3Pool internal pool;
 
     function setUp() public virtual {
-        forkId = vm.createSelectFork("base", 28415528);
+        setUpWithBlockNumber(28415528);
+    }
+
+    function setUpWithBlockNumber(uint256 forkBlockNumber) public {
+        forkId = vm.createSelectFork("base", forkBlockNumber);
 
         weth = IWETH(WETH_ADDRESS);
         usdc = IERC20Metadata(USDC_ADDRESS);
@@ -202,4 +206,15 @@ contract BaseTest is Test, CoinConstants {
     function dopplerFeeRecipient() internal view returns (address) {
         return airlock.owner();
     }
+
+    function _generatePoolConfig(
+        uint8 version_,
+        address currency_,
+        int24 tickLower_,
+        int24 tickUpper_,
+        uint16 numDiscoveryPositions_,
+        uint256 maxDiscoverySupplyShare_
+    ) internal pure returns (bytes memory) {
+        return abi.encode(version_, currency_, tickLower_, tickUpper_, numDiscoveryPositions_, maxDiscoverySupplyShare_);
+    }
 }

package/wagmi.config.ts

@@ -5,18 +5,15 @@ export default defineConfig({
   out: "package/wagmiGenerated.ts",
   plugins: [
     foundry({
-      deployments: {
-        ZoraFactoryImpl: {
-          84532: "0x777777751622c0d3258f214F9DF38E35BF45baF3",
-          8453: "0x777777751622c0d3258f214F9DF38E35BF45baF3",
-        },
-      },
       forge: {
         build: false,
       },
-      include: ["Coin", "ZoraFactoryImpl", "IUniswapV3Pool"].map(
-        (contractName) => `${contractName}.json`,
-      ),
+      include: [
+        "Coin",
+        "ZoraFactoryImpl",
+        "IUniswapV3Pool",
+        "BuySupplyWithSwapRouterHook",
+      ].map((contractName) => `${contractName}.json`),
     }),
   ],
 });

package/src/libs/CoinSetup.sol

@@ -1,37 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.23;
-
-import {PoolConfiguration} from "../interfaces/ICoin.sol";
-import {CoinLegacy} from "./CoinLegacy.sol";
-import {CoinDopplerUniV3} from "./CoinDopplerUniV3.sol";
-import {CoinConfigurationVersions} from "./CoinConfigurationVersions.sol";
-import {LpPosition} from "../types/LpPosition.sol";
-
-library CoinSetup {
-    error InvalidPoolVersion();
-
-    function setupPoolWithVersion(
-        uint8 version,
-        bytes memory poolConfig_,
-        bool isCoinToken0,
-        address weth
-    ) internal pure returns (uint160 sqrtPriceX96, PoolConfiguration memory poolConfiguration) {
-        if (version == CoinConfigurationVersions.LEGACY_POOL_VERSION) {
-            (sqrtPriceX96, poolConfiguration) = CoinLegacy.setupPool(isCoinToken0, poolConfig_, weth);
-        } else if (version == CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION) {
-            (sqrtPriceX96, poolConfiguration) = CoinDopplerUniV3.setupPool(isCoinToken0, poolConfig_);
-        } else {
-            revert InvalidPoolVersion();
-        }
-    }
-
-    function calculatePositions(bool isCoinToken0, PoolConfiguration memory poolConfiguration) internal pure returns (LpPosition[] memory positions) {
-        if (poolConfiguration.version == CoinConfigurationVersions.LEGACY_POOL_VERSION) {
-            positions = CoinLegacy.calculatePositions(isCoinToken0, poolConfiguration);
-        } else if (poolConfiguration.version == CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION) {
-            positions = CoinDopplerUniV3.calculatePositions(isCoinToken0, poolConfiguration);
-        } else {
-            revert InvalidPoolVersion();
-        }
-    }
-}