@zoralabs/coins 2.0.0 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoralabs/coins",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -35,9 +35,9 @@
     "tsx": "^3.13.0",
     "typescript": "^5.2.2",
     "viem": "^2.21.18",
-    "@zoralabs/shared-contracts": "^0.0.5",
+    "@zoralabs/tsconfig": "^0.0.1",
     "@zoralabs/shared-scripts": "^0.0.0",
-    "@zoralabs/tsconfig": "^0.0.1"
+    "@zoralabs/shared-contracts": "^0.0.5"
   },
   "scripts": {
     "build": "pnpm run wagmi:generate && pnpm run copy-abis && pnpm run prettier:write && tsup",

package/script/DeployPostDeploymentHooks.s.sol

@@ -10,9 +10,9 @@ contract DeployHooks is CoinsDeployerBase {
 
         vm.startBroadcast();
 
-        address buySupplyWithSwapRouterHook = address(deployBuySupplyWithSwapRouterHook(deployment));
+        // address buySupplyWithSwapRouterHook = address(deployBuySupplyWithSwapRouterHook(deployment));
 
-        deployment.buySupplyWithSwapRouterHook = buySupplyWithSwapRouterHook;
+        // deployment.buySupplyWithSwapRouterHook = buySupplyWithSwapRouterHook;
 
         vm.stopBroadcast();
 

package/script/TestBackingCoinSwap.s.sol

@@ -16,7 +16,7 @@ import {MockERC20} from "../test/mocks/MockERC20.sol";
 import {MarketConstants} from "../src/libs/MarketConstants.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {ICoinV4} from "../src/interfaces/ICoinV4.sol";
+import {ICoin} from "../src/interfaces/ICoin.sol";
 
 import {console} from "forge-std/console.sol";
 
@@ -34,7 +34,7 @@ contract TestV4Swap is CoinsDeployerBase {
         string memory uri,
         address createReferral,
         bytes32 salt
-    ) internal returns (ICoinV4 coin) {
+    ) internal returns (ICoin coin) {
         CoinsDeployment memory deployment = readDeployment();
         address[] memory owners = new address[](1);
         owners[0] = creator;
@@ -54,10 +54,10 @@ contract TestV4Swap is CoinsDeployerBase {
             salt
         );
 
-        coin = ICoinV4(coinAddress);
+        coin = ICoin(coinAddress);
     }
 
-    function _swap(address currencyIn, uint128 amountIn, ICoinV4 coin, address trader, address tradeReferral) internal returns (uint256 amountOut) {
+    function _swap(address currencyIn, uint128 amountIn, ICoin coin, address trader, address tradeReferral) internal returns (uint256 amountOut) {
         uint128 minAmountOut = 0;
 
         PoolKey memory poolKey = coin.getPoolKey();
@@ -106,8 +106,8 @@ contract TestV4Swap is CoinsDeployerBase {
         address createReferral = 0xC077e4cC02fa01A5b7fAca1acE9BBe9f5ac5Af9F;
         address tradeReferral = 0xC077e4cC02fa01A5b7fAca1acE9BBe9f5ac5Af9F;
 
-        ICoinV4 backingCoin = _deployCoin(zora, trader, "Backing Coin", "BACK", "https://testc.com", createReferral, bytes32("creator"));
-        ICoinV4 contentCoin = _deployCoin(
+        ICoin backingCoin = _deployCoin(zora, trader, "Backing Coin", "BACK", "https://testc.com", createReferral, bytes32("creator"));
+        ICoin contentCoin = _deployCoin(
             address(backingCoin),
             trader,
             "Content Coin",
@@ -116,8 +116,8 @@ contract TestV4Swap is CoinsDeployerBase {
             createReferral,
             bytes32("content coin")
         );
-        // ICoinV4 backingCoin = ICoinV4(0xeA734b5997F35cD469921cCa7BB9A03C104f2f64);
-        // ICoinV4 contentCoin = ICoinV4(0x72218BFEEc7D556BD3Dd8eFf2a317CEd49533769);
+        // ICoin backingCoin = ICoin(0xeA734b5997F35cD469921cCa7BB9A03C104f2f64);
+        // ICoin contentCoin = ICoin(0x72218BFEEc7D556BD3Dd8eFf2a317CEd49533769);
 
         console.log("backingCoin", address(backingCoin));
         console.log("contentCoin", address(contentCoin));

package/script/TestV4Swap.s.sol

@@ -16,7 +16,7 @@ import {MockERC20} from "../test/mocks/MockERC20.sol";
 import {MarketConstants} from "../src/libs/MarketConstants.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {ICoinV4} from "../src/interfaces/ICoinV4.sol";
+import {ICoin} from "../src/interfaces/ICoin.sol";
 
 import {console} from "forge-std/console.sol";
 
@@ -31,7 +31,7 @@ contract TestV4Swap is CoinsDeployerBase {
         currency.mint(getUniswapV4PoolManager(), 1000000 ether);
     }
 
-    function _deployMockCoin(address currency, address creator, address createReferral, bytes32 salt) internal returns (ICoinV4 coin) {
+    function _deployMockCoin(address currency, address creator, address createReferral, bytes32 salt) internal returns (ICoin coin) {
         CoinsDeployment memory deployment = readDeployment();
         address[] memory owners = new address[](1);
         owners[0] = creator;
@@ -51,10 +51,10 @@ contract TestV4Swap is CoinsDeployerBase {
             salt
         );
 
-        coin = ICoinV4(coinAddress);
+        coin = ICoin(coinAddress);
     }
 
-    function _swap(address currencyIn, uint128 amountIn, ICoinV4 coin, address trader, address tradeReferral) internal returns (uint256 amountOut) {
+    function _swap(address currencyIn, uint128 amountIn, ICoin coin, address trader, address tradeReferral) internal returns (uint256 amountOut) {
         uint128 minAmountOut = 0;
 
         PoolKey memory poolKey = coin.getPoolKey();
@@ -101,12 +101,12 @@ contract TestV4Swap is CoinsDeployerBase {
 
         // MockERC20 currency = _deployMockCurrency();
 
-        // ICoinV4 backingCoin = _deployMockCoin(address(currency), trader, createReferral, bytes32("backing coin"));
-        // ICoinV4 contentCoin = _deployMockCoin(address(backingCoin), trader, createReferral, bytes32("content coin"));
+        // ICoin backingCoin = _deployMockCoin(address(currency), trader, createReferral, bytes32("backing coin"));
+        // ICoin contentCoin = _deployMockCoin(address(backingCoin), trader, createReferral, bytes32("content coin"));
 
         MockERC20 currency = MockERC20(0x1b183Bd0E2c03Fc830F4d813bA37E82F9F97cA21);
-        ICoinV4 backingCoin = ICoinV4(0x7D74416C4c295A592Fc6F9232911C945354b253C);
-        ICoinV4 contentCoin = ICoinV4(0xf6d6660bcdA588F7f99e2961f279f500fB501730);
+        ICoin backingCoin = ICoin(0x7D74416C4c295A592Fc6F9232911C945354b253C);
+        ICoin contentCoin = ICoin(0xf6d6660bcdA588F7f99e2961f279f500fB501730);
 
         console.log("currency", address(currency));
         console.log("backingCoin", address(backingCoin));

package/script/UpgradeFactoryImpl.s.sol

@@ -11,7 +11,6 @@ contract UpgradeFactoryImpl is CoinsDeployerBase {
         vm.startBroadcast();
 
         ZoraFactoryImpl zoraFactoryImpl = deployZoraFactoryImpl(
-            deployment.coinV3Impl,
             deployment.coinV4Impl,
             deployment.creatorCoinImpl,
             deployment.zoraV4CoinHook,

package/src/BaseCoin.sol

@@ -19,6 +19,15 @@ import {IAirlock} from "./interfaces/IAirlock.sol";
 import {IProtocolRewards} from "./interfaces/IProtocolRewards.sol";
 import {IWETH} from "./interfaces/IWETH.sol";
 
+import {IPoolManager, PoolKey, Currency, IHooks} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {IHasPoolKey, IHasSwapPath} from "./interfaces/ICoin.sol";
+import {PoolConfiguration} from "./types/PoolConfiguration.sol";
+import {UniV4SwapToCurrency} from "./libs/UniV4SwapToCurrency.sol";
+import {PathKey} from "@uniswap/v4-periphery/src/libraries/PathKey.sol";
+import {IDeployedCoinVersionLookup} from "./interfaces/IDeployedCoinVersionLookup.sol";
+import {IUpgradeableV4Hook} from "./interfaces/IUpgradeableV4Hook.sol";
+import {CoinCommon} from "./libs/CoinCommon.sol";
+
 import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 import {ERC20PermitUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PermitUpgradeable.sol";
 import {ERC165Upgradeable} from "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
@@ -33,8 +42,6 @@ import {CoinConstants} from "./libs/CoinConstants.sol";
 import {MarketConstants} from "./libs/MarketConstants.sol";
 import {LpPosition} from "./types/LpPosition.sol";
 import {PoolState} from "./types/PoolState.sol";
-import {CoinSetupV3, UniV3Config, CoinV3Config} from "./libs/CoinSetupV3.sol";
-import {UniV3BuySell, CoinConfig} from "./libs/UniV3BuySell.sol";
 
 /*
      $$$$$$\   $$$$$$\  $$$$$$\ $$\   $$\ 
@@ -56,6 +63,15 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
     /// @notice The address of the Airlock contract, ownership is used for a protocol fee split.
     address public immutable airlock;
 
+    /// @notice The Uniswap v4 pool manager singleton contract reference.
+    IPoolManager public immutable poolManager;
+
+    /// @notice The pool key for the coin. Type from Uniswap V4 core.
+    PoolKey internal poolKey;
+
+    /// @notice The configuration for the pool.
+    PoolConfiguration internal poolConfiguration;
+
     /// @notice The metadata URI
     string public tokenURI;
     /// @notice The address of the coin creator
@@ -76,24 +92,53 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
      * @param _protocolRewards The address of the protocol rewards contract
      * @param _airlock The address of the Airlock contract
      */
-    constructor(address _protocolRewardRecipient, address _protocolRewards, address _airlock) initializer {
+    constructor(address _protocolRewardRecipient, address _protocolRewards, IPoolManager poolManager_, address _airlock) initializer {
         if (_protocolRewardRecipient == address(0)) {
             revert AddressZero();
         }
         if (_protocolRewards == address(0)) {
             revert AddressZero();
         }
-
+        if (address(poolManager_) == address(0)) {
+            revert AddressZero();
+        }
         if (_airlock == address(0)) {
             revert AddressZero();
         }
 
         protocolRewardRecipient = _protocolRewardRecipient;
         protocolRewards = _protocolRewards;
+        poolManager = poolManager_;
         airlock = _airlock;
     }
 
-    /// @notice Initializes a new coin
+    /// @inheritdoc ICoin
+    function initialize(
+        address payoutRecipient_,
+        address[] memory owners_,
+        string memory tokenURI_,
+        string memory name_,
+        string memory symbol_,
+        address platformReferrer_,
+        address currency_,
+        PoolKey memory poolKey_,
+        uint160 sqrtPriceX96,
+        PoolConfiguration memory poolConfiguration_
+    ) public virtual initializer {
+        currency = currency_;
+        // we need to set this before initialization, because
+        // distributing currency relies on the poolkey being set since the hooks
+        // are retrieved from there
+        poolKey = poolKey_;
+        poolConfiguration = poolConfiguration_;
+
+        _initialize(payoutRecipient_, owners_, tokenURI_, name_, symbol_, platformReferrer_);
+
+        // initialize the pool - the hook will mint its positions in the afterInitialize callback
+        poolManager.initialize(poolKey, sqrtPriceX96);
+    }
+
+    /// @notice Initializes a new coin (internal version)
     /// @param payoutRecipient_ The address of the coin creator
     /// @param tokenURI_ The metadata URI
     /// @param name_ The coin name
@@ -210,7 +255,9 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
             interfaceId == type(ICoin).interfaceId ||
             interfaceId == type(ICoinComments).interfaceId ||
             interfaceId == type(IERC7572).interfaceId ||
-            interfaceId == type(IHasRewardsRecipients).interfaceId;
+            interfaceId == type(IHasRewardsRecipients).interfaceId ||
+            interfaceId == type(IHasPoolKey).interfaceId ||
+            type(IHasSwapPath).interfaceId == interfaceId;
     }
 
     /// @dev Overrides ERC20's _update function to emit a superset `CoinTransfer` event
@@ -245,4 +292,60 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
     function dopplerFeeRecipient() public view returns (address) {
         return IAirlock(airlock).owner();
     }
+
+    /// @inheritdoc IHasPoolKey
+    function getPoolKey() public view returns (PoolKey memory) {
+        return poolKey;
+    }
+
+    /// @inheritdoc ICoin
+    function getPoolConfiguration() public view returns (PoolConfiguration memory) {
+        return poolConfiguration;
+    }
+
+    /// @inheritdoc ICoin
+    function hooks() external view returns (IHooks) {
+        return poolKey.hooks;
+    }
+
+    /// @notice Migrate liquidity from current hook to a new hook implementation
+    /// @param newHook Address of the new hook implementation
+    /// @param additionalData Additional data to pass to the new hook during initialization
+    function migrateLiquidity(address newHook, bytes calldata additionalData) external onlyOwner returns (PoolKey memory newPoolKey) {
+        newPoolKey = IUpgradeableV4Hook(address(poolKey.hooks)).migrateLiquidity(newHook, poolKey, additionalData);
+
+        emit LiquidityMigrated(poolKey, CoinCommon.hashPoolKey(poolKey), newPoolKey, CoinCommon.hashPoolKey(newPoolKey));
+
+        poolKey = newPoolKey;
+    }
+
+    /// @inheritdoc IHasSwapPath
+    function getPayoutSwapPath(IDeployedCoinVersionLookup coinVersionLookup) external view returns (IHasSwapPath.PayoutSwapPath memory payoutSwapPath) {
+        // if to swap in is this currency,
+        // if backing currency is a coin, then recursively get the path from the coin
+        payoutSwapPath.currencyIn = Currency.wrap(address(this));
+
+        // swap to backing currency
+        PathKey memory thisPathKey = PathKey({
+            intermediateCurrency: Currency.wrap(currency),
+            fee: poolKey.fee,
+            tickSpacing: poolKey.tickSpacing,
+            hooks: poolKey.hooks,
+            hookData: ""
+        });
+
+        // get backing currency swap path - if the backing currency is a v4 coin and has a swap path.
+        PathKey[] memory subPath = UniV4SwapToCurrency.getSubSwapPath(currency, coinVersionLookup);
+
+        if (subPath.length > 0) {
+            payoutSwapPath.path = new PathKey[](1 + subPath.length);
+            payoutSwapPath.path[0] = thisPathKey;
+            for (uint256 i = 0; i < subPath.length; i++) {
+                payoutSwapPath.path[i + 1] = subPath[i];
+            }
+        } else {
+            payoutSwapPath.path = new PathKey[](1);
+            payoutSwapPath.path[0] = thisPathKey;
+        }
+    }
 }

package/src/ContentCoin.sol

@@ -8,15 +8,15 @@
 pragma solidity ^0.8.23;
 
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
-import {BaseCoinV4} from "./BaseCoinV4.sol";
+import {BaseCoin} from "./BaseCoin.sol";
 import {CoinConstants} from "./libs/CoinConstants.sol";
 
 /**
  * @title ContentCoin
  * @notice Content coin implementation that uses creator coins as backing currency
- * @dev Inherits from BaseCoinV4 and implements content-specific distribution logic
+ * @dev Inherits from BaseCoin and implements content-specific distribution logic
  */
-contract ContentCoin is BaseCoinV4 {
+contract ContentCoin is BaseCoin {
     /// @notice The constructor for the static ContentCoin contract deployment shared across all content coins.
     /// @dev All arguments are required and cannot be set to the 0 address.
     /// @param protocolRewardRecipient_ The address of the protocol reward recipient
@@ -28,7 +28,7 @@ contract ContentCoin is BaseCoinV4 {
         address protocolRewards_,
         IPoolManager poolManager_,
         address airlock_
-    ) BaseCoinV4(protocolRewardRecipient_, protocolRewards_, poolManager_, airlock_) {}
+    ) BaseCoin(protocolRewardRecipient_, protocolRewards_, poolManager_, airlock_) {}
 
     /// @dev The initial mint and distribution of the coin supply.
     ///      Implements content coin specific distribution: 990M to liquidity pool, 10M to creator.

package/src/CreatorCoin.sol

@@ -9,11 +9,11 @@ pragma solidity ^0.8.28;
 
 import {ICreatorCoin} from "./interfaces/ICreatorCoin.sol";
 import {CreatorCoinConstants} from "./libs/CreatorCoinConstants.sol";
-import {IHooks, PoolConfiguration, PoolKey, ICoinV4} from "./interfaces/ICoinV4.sol";
+import {IHooks, PoolConfiguration, PoolKey, ICoin} from "./interfaces/ICoin.sol";
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
-import {BaseCoinV4} from "./BaseCoinV4.sol";
+import {BaseCoin} from "./BaseCoin.sol";
 
-contract CreatorCoin is ICreatorCoin, BaseCoinV4 {
+contract CreatorCoin is ICreatorCoin, BaseCoin {
     uint256 public vestingStartTime;
     uint256 public vestingEndTime;
     uint256 public totalClaimed;
@@ -23,7 +23,7 @@ contract CreatorCoin is ICreatorCoin, BaseCoinV4 {
         address _protocolRewards,
         IPoolManager _poolManager,
         address _airlock
-    ) BaseCoinV4(_protocolRewardRecipient, _protocolRewards, _poolManager, _airlock) initializer {}
+    ) BaseCoin(_protocolRewardRecipient, _protocolRewards, _poolManager, _airlock) initializer {}
 
     function initialize(
         address payoutRecipient_,
@@ -36,7 +36,7 @@ contract CreatorCoin is ICreatorCoin, BaseCoinV4 {
         PoolKey memory poolKey_,
         uint160 sqrtPriceX96,
         PoolConfiguration memory poolConfiguration_
-    ) public override(BaseCoinV4, ICoinV4) {
+    ) public override(BaseCoin, ICoin) {
         require(currency_ == CreatorCoinConstants.CURRENCY, InvalidCurrency());
 
         super.initialize(payoutRecipient_, owners_, tokenURI_, name_, symbol_, platformReferrer_, currency_, poolKey_, sqrtPriceX96, poolConfiguration_);

package/src/ZoraFactoryImpl.sol

@@ -20,18 +20,13 @@ import {IWETH} from "./interfaces/IWETH.sol";
 import {IZoraFactory} from "./interfaces/IZoraFactory.sol";
 import {IHasAfterCoinDeploy} from "./hooks/deployment/BaseCoinDeployHook.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
-import {Coin} from "./Coin.sol";
-import {ContentCoin} from "./ContentCoin.sol";
 import {ICoin, PoolKeyStruct} from "./interfaces/ICoin.sol";
-import {ICoinV3} from "./interfaces/ICoinV3.sol";
-import {ICoinV4} from "./interfaces/ICoinV4.sol";
+import {ICoin} from "./interfaces/ICoin.sol";
 import {IHasContractName} from "@zoralabs/shared-contracts/interfaces/IContractMetadata.sol";
 import {ContractVersionBase} from "./version/ContractVersionBase.sol";
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 import {CoinCommon} from "./libs/CoinCommon.sol";
-import {UniV3Config} from "./libs/CoinSetupV3.sol";
-import {CoinSetupV3} from "./libs/CoinSetupV3.sol";
 import {PoolConfiguration} from "./types/PoolConfiguration.sol";
 import {LpPosition} from "./types/LpPosition.sol";
 import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersionedContract.sol";
@@ -53,16 +48,14 @@ contract ZoraFactoryImpl is
     using SafeERC20 for IERC20;
 
     /// @notice The coin contract implementation address
-    address public immutable coinImpl;
     address public immutable coinV4Impl;
     address public immutable creatorCoinImpl;
     address public immutable contentCoinHook;
     address public immutable creatorCoinHook;
 
-    constructor(address _coinImpl, address _coinV4Impl, address _creatorCoinImpl, address _contentCoinHook, address _creatorCoinHook) {
+    constructor(address _coinV4Impl, address _creatorCoinImpl, address _contentCoinHook, address _creatorCoinHook) {
         _disableInitializers();
 
-        coinImpl = _coinImpl;
         coinV4Impl = _coinV4Impl;
         creatorCoinImpl = _creatorCoinImpl;
         contentCoinHook = _contentCoinHook;
@@ -180,13 +173,13 @@ contract ZoraFactoryImpl is
         string memory symbol,
         bytes memory poolConfig,
         address platformReferrer,
-        uint256 orderSize
+        uint256 /*orderSize*/
     ) public payable nonReentrant returns (address, uint256) {
         bytes32 salt = _randomSalt(payoutRecipient, uri, bytes32(0));
 
         ICoin coin = _createAndInitializeCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, salt);
 
-        uint256 coinsPurchased = _handleFirstOrder(coin, orderSize);
+        uint256 coinsPurchased = 0;
 
         return (address(coin), coinsPurchased);
     }
@@ -225,15 +218,11 @@ contract ZoraFactoryImpl is
 
         ICoin coin = _createAndInitializeCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, salt);
 
-        uint256 coinsPurchased = _handleFirstOrder(coin, orderSize);
-
-        return (address(coin), coinsPurchased);
+        return (address(coin), 0);
     }
 
     function getCoinImpl(uint8 version) internal view returns (address) {
-        if (CoinConfigurationVersions.isV3(version)) {
-            return coinImpl;
-        } else if (CoinConfigurationVersions.isV4(version)) {
+        if (CoinConfigurationVersions.isV4(version)) {
             return coinV4Impl;
         }
 
@@ -244,44 +233,8 @@ contract ZoraFactoryImpl is
         return payable(Clones.cloneDeterministic(getCoinImpl(version), salt));
     }
 
-    function _setupV3Coin(
-        ICoinV3 coin,
-        address currency,
-        bool isCoinToken0,
-        uint160 sqrtPriceX96,
-        PoolConfiguration memory poolConfiguration,
-        address payoutRecipient,
-        address[] memory owners,
-        string memory uri,
-        string memory name,
-        string memory symbol,
-        address platformReferrer
-    ) internal {
-        address v3Factory = coin.v3Factory();
-
-        address poolAddress = CoinSetupV3.createV3Pool(address(coin), currency, isCoinToken0, sqrtPriceX96, v3Factory);
-
-        LpPosition[] memory positions = CoinDopplerMultiCurve.calculatePositions(isCoinToken0, poolConfiguration, MarketConstants.POOL_LAUNCH_SUPPLY);
-
-        // Initialize coin with pre-configured pool
-        coin.initialize(payoutRecipient, owners, uri, name, symbol, platformReferrer, currency, poolAddress, poolConfiguration, positions);
-
-        emit CoinCreated(
-            msg.sender,
-            payoutRecipient,
-            platformReferrer,
-            currency,
-            uri,
-            name,
-            symbol,
-            address(coin),
-            poolAddress,
-            IVersionedContract(address(coin)).contractVersion()
-        );
-    }
-
     function _setupV4Coin(
-        ICoinV4 coin,
+        ICoin coin,
         address currency,
         bool isCoinToken0,
         uint160 sqrtPriceX96,
@@ -335,9 +288,10 @@ contract ZoraFactoryImpl is
         );
 
         if (CoinConfigurationVersions.isV3(version)) {
-            _setupV3Coin(ICoinV3(coin), currency, isCoinToken0, sqrtPriceX96, poolConfiguration, payoutRecipient, owners, uri, name, symbol, platformReferrer);
+            // V3 is no longer supported
+            revert ICoin.InvalidPoolVersion();
         } else if (CoinConfigurationVersions.isV4(version)) {
-            _setupV4Coin(ICoinV4(coin), currency, isCoinToken0, sqrtPriceX96, poolConfiguration, payoutRecipient, owners, uri, name, symbol, platformReferrer);
+            _setupV4Coin(ICoin(coin), currency, isCoinToken0, sqrtPriceX96, poolConfiguration, payoutRecipient, owners, uri, name, symbol, platformReferrer);
         } else {
             revert ICoin.InvalidPoolVersion();
         }
@@ -375,43 +329,6 @@ contract ZoraFactoryImpl is
             );
     }
 
-    /// @dev Handles the first buy of a newly created coin
-    /// @param coin The newly created coin contract
-    /// @param orderSize The size of the first buy order; must match msg.value for ETH/WETH pairs
-    function _handleFirstOrder(ICoin coin, uint256 orderSize) internal returns (uint256 coinsPurchased) {
-        if (msg.value > 0 || orderSize > 0) {
-            address currency = coin.currency();
-            address payoutRecipient = coin.payoutRecipient();
-
-            if (currency != Coin(payable(address(coin))).WETH()) {
-                if (msg.value != 0) {
-                    revert EthTransferInvalid();
-                }
-
-                _handleIncomingCurrency(currency, orderSize);
-
-                IERC20(currency).approve(address(coin), orderSize);
-
-                (, coinsPurchased) = Coin(payable(address(coin))).buy(payoutRecipient, orderSize, 0, 0, address(0));
-            } else {
-                (, coinsPurchased) = Coin(payable(address(coin))).buy{value: msg.value}(payoutRecipient, orderSize, 0, 0, address(0));
-            }
-        }
-    }
-
-    /// @dev Safely transfers ERC20 tokens from the caller to this contract to be sent to the newly created coin
-    /// @param currency The ERC20 token address to transfer
-    /// @param orderSize The amount of tokens to transfer for the order
-    function _handleIncomingCurrency(address currency, uint256 orderSize) internal {
-        uint256 beforeBalance = IERC20(currency).balanceOf(address(this));
-        IERC20(currency).safeTransferFrom(msg.sender, address(this), orderSize);
-        uint256 afterBalance = IERC20(currency).balanceOf(address(this));
-
-        if ((afterBalance - beforeBalance) != orderSize) {
-            revert ERC20TransferAmountMismatch();
-        }
-    }
-
     /// @notice Initializes the factory proxy contract
     /// @param initialOwner Address of the contract owner
     /// @dev Can only be called once due to initializer modifier

package/src/deployment/CoinsDeployerBase.sol

@@ -6,9 +6,8 @@ import "forge-std/Script.sol";
 import {ProxyDeployerScript, DeterministicContractConfig, DeterministicDeployerAndCaller} from "@zoralabs/shared-contracts/deployment/ProxyDeployerScript.sol";
 import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import {ZoraFactoryImpl} from "../ZoraFactoryImpl.sol";
-import {Coin} from "../Coin.sol";
 import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersionedContract.sol";
-import {BuySupplyWithSwapRouterHook} from "../hooks/deployment/BuySupplyWithSwapRouterHook.sol";
+// import {BuySupplyWithSwapRouterHook} from "../hooks/deployment/BuySupplyWithSwapRouterHook.sol";
 import {IZoraFactory} from "../interfaces/IZoraFactory.sol";
 import {ContentCoin} from "../ContentCoin.sol";
 import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
@@ -102,18 +101,6 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         deployment.hookUpgradeGate = readAddressOrDefaultToZero(json, "HOOK_UPGRADE_GATE");
     }
 
-    function deployCoinV3Impl() internal returns (Coin) {
-        return
-            new Coin({
-                protocolRewardRecipient_: getZoraRecipient(),
-                protocolRewards_: PROTOCOL_REWARDS,
-                weth_: getWeth(),
-                v3Factory_: getUniswapV3Factory(),
-                swapRouter_: getUniswapSwapRouter(),
-                airlock_: getDopplerAirlock()
-            });
-    }
-
     function deployCoinV4Impl(address zoraV4CoinHook) internal returns (ContentCoin) {
         return
             new ContentCoin({
@@ -135,7 +122,6 @@ contract CoinsDeployerBase is ProxyDeployerScript {
     }
 
     function deployZoraFactoryImpl(
-        address _coinV3Impl,
         address _coinV4Impl,
         address _creatorCoinImpl,
         address _contentCoinHook,
@@ -143,7 +129,6 @@ contract CoinsDeployerBase is ProxyDeployerScript {
     ) internal returns (ZoraFactoryImpl) {
         return
             new ZoraFactoryImpl({
-                _coinImpl: _coinV3Impl,
                 _coinV4Impl: _coinV4Impl,
                 _creatorCoinImpl: _creatorCoinImpl,
                 _contentCoinHook: _contentCoinHook,
@@ -151,14 +136,14 @@ contract CoinsDeployerBase is ProxyDeployerScript {
             });
     }
 
-    function deployBuySupplyWithSwapRouterHook(CoinsDeployment memory deployment) internal returns (BuySupplyWithSwapRouterHook) {
-        return
-            new BuySupplyWithSwapRouterHook({
-                _factory: IZoraFactory(deployment.zoraFactory),
-                _swapRouter: getUniswapSwapRouter(),
-                _poolManager: getUniswapV4PoolManager()
-            });
-    }
+    // function deployBuySupplyWithSwapRouterHook(CoinsDeployment memory deployment) internal returns (BuySupplyWithSwapRouterHook) {
+    //     return
+    //         new BuySupplyWithSwapRouterHook({
+    //             _factory: IZoraFactory(deployment.zoraFactory),
+    //             _swapRouter: getUniswapSwapRouter(),
+    //             _poolManager: getUniswapV4PoolManager()
+    //         });
+    // }
 
     function deployUpgradeGate(CoinsDeployment memory deployment) internal returns (CoinsDeployment memory) {
         deployment.hookUpgradeGate = address(new HookUpgradeGate(getProxyAdmin()));
@@ -205,7 +190,6 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         return
             address(
                 deployZoraFactoryImpl({
-                    _coinV3Impl: deployment.coinV3Impl,
                     _coinV4Impl: deployment.coinV4Impl,
                     _creatorCoinImpl: deployment.creatorCoinImpl,
                     _contentCoinHook: deployment.zoraV4CoinHook,
@@ -216,7 +200,6 @@ contract CoinsDeployerBase is ProxyDeployerScript {
 
     function deployImpls(CoinsDeployment memory deployment) internal returns (CoinsDeployment memory) {
         // Deploy implementation contracts
-        deployment.coinV3Impl = address(deployCoinV3Impl());
 
         // Deploy hook first, then use its address for coin v4 impl
         console.log("deploying content coin hook");
@@ -233,7 +216,7 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         deployment.creatorCoinImpl = address(deployCreatorCoinImpl(deployment.creatorCoinHook));
         deployment.zoraFactoryImpl = deployFactoryImpl(deployment);
         deployment.coinVersion = IVersionedContract(deployment.coinV4Impl).contractVersion();
-        deployment.buySupplyWithSwapRouterHook = address(deployBuySupplyWithSwapRouterHook(deployment));
+        // deployment.buySupplyWithSwapRouterHook = address(deployBuySupplyWithSwapRouterHook(deployment));
 
         return deployment;
     }