@zoralabs/coins 0.9.0 → 1.0.1

package/test/utils/BaseTest.sol

@@ -8,10 +8,12 @@ import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import {IZoraFactory} from "../../src/interfaces/IZoraFactory.sol";
 import {ZoraFactoryImpl} from "../../src/ZoraFactoryImpl.sol";
 import {ZoraFactory} from "../../src/proxy/ZoraFactory.sol";
 import {Coin} from "../../src/Coin.sol";
+import {CoinV4} from "../../src/CoinV4.sol";
 import {MultiOwnable} from "../../src/utils/MultiOwnable.sol";
 import {ICoin} from "../../src/interfaces/ICoin.sol";
 import {IERC7572} from "../../src/interfaces/IERC7572.sol";
@@ -24,17 +26,35 @@ 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";
+import {CoinConfigurationVersions} from "../../src/libs/CoinConfigurationVersions.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {ZoraV4CoinHook} from "../../src/hooks/ZoraV4CoinHook.sol";
+import {HooksDeployment} from "../../src/libs/HooksDeployment.sol";
+import {CoinConstants} from "../../src/libs/CoinConstants.sol";
+import {ProxyShim} from "./ProxyShim.sol";
+import {ICoinV4} from "../../src/interfaces/ICoinV4.sol";
+import {UniV4SwapHelper} from "../../src/libs/UniV4SwapHelper.sol";
+import {IPermit2} from "permit2/src/interfaces/IPermit2.sol";
+import {IUniversalRouter} from "@uniswap/universal-router/contracts/interfaces/IUniversalRouter.sol";
+import {Commands} from "@uniswap/universal-router/contracts/libraries/Commands.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {Actions} from "@uniswap/v4-periphery/src/libraries/Actions.sol";
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
 contract BaseTest is Test {
     using stdStorage for StdStorage;
 
-    address internal constant PROTOCOL_REWARDS = 0x7777777F279eba3d3Ad8F4E708545291A6fDBA8B;
     address internal constant WETH_ADDRESS = 0x4200000000000000000000000000000000000006;
     address internal constant V3_FACTORY = 0x33128a8fC17869897dcE68Ed026d694621f6FDfD;
     address internal constant NONFUNGIBLE_POSITION_MANAGER = 0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1;
     address internal constant SWAP_ROUTER = 0x2626664c2603336E57B271c5C0b26F421741e481;
     address internal constant DOPPLER_AIRLOCK = 0x660eAaEdEBc968f8f3694354FA8EC0b4c5Ba8D12;
     address internal constant USDC_ADDRESS = 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913;
+    address internal constant V4_POOL_MANAGER = 0x498581fF718922c3f8e6A244956aF099B2652b2b;
+    address internal constant V4_POSITION_MANAGER = 0x7C5f5A4bBd8fD63184577525326123B519429bDc;
+    address internal constant V4_PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
+    address internal constant V4_QUOTER = 0x0d5e0F971ED27FBfF6c2837bf31316121532048D;
+    address internal constant UNIVERSAL_ROUTER = 0x6fF5693b99212Da76ad316178A184AB56D299b43;
     int24 internal constant USDC_TICK_LOWER = 57200;
 
     struct Users {
@@ -54,15 +74,125 @@ contract BaseTest is Test {
     ProtocolRewards internal protocolRewards;
     IUniswapV3Factory internal v3Factory;
     INonfungiblePositionManager internal nonfungiblePositionManager;
+    IPermit2 internal permit2;
+    IUniversalRouter internal router;
+
     ISwapRouter internal swapRouter;
     IAirlock internal airlock;
     Users internal users;
 
-    Coin internal coinImpl;
+    Coin internal coinV3Impl;
+    CoinV4 internal coinV4Impl;
     ZoraFactoryImpl internal factoryImpl;
-    ZoraFactoryImpl internal factory;
+    IZoraFactory internal factory;
+    ZoraV4CoinHook internal zoraV4CoinHook;
     Coin internal coin;
+
     IUniswapV3Pool internal pool;
+    int24 internal constant DEFAULT_DISCOVERY_TICK_LOWER = CoinConstants.DEFAULT_DISCOVERY_TICK_LOWER;
+    int24 internal constant DEFAULT_DISCOVERY_TICK_UPPER = CoinConstants.DEFAULT_DISCOVERY_TICK_UPPER;
+    uint16 internal constant DEFAULT_NUM_DISCOVERY_POSITIONS = CoinConstants.DEFAULT_NUM_DISCOVERY_POSITIONS;
+    uint256 internal constant DEFAULT_DISCOVERY_SUPPLY_SHARE = CoinConstants.DEFAULT_DISCOVERY_SUPPLY_SHARE;
+
+    function _deployCoin() internal {
+        bytes memory poolConfig_ = _generatePoolConfig(
+            CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION,
+            address(weth),
+            DEFAULT_DISCOVERY_TICK_LOWER,
+            DEFAULT_DISCOVERY_TICK_UPPER,
+            DEFAULT_NUM_DISCOVERY_POSITIONS,
+            DEFAULT_DISCOVERY_SUPPLY_SHARE
+        );
+        vm.prank(users.creator);
+        (address coinAddress, ) = factory.deploy(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            poolConfig_,
+            users.platformReferrer,
+            0
+        );
+
+        coin = Coin(payable(coinAddress));
+        pool = IUniswapV3Pool(coin.poolAddress());
+
+        vm.label(address(coin), "COIN");
+        vm.label(address(pool), "POOL");
+    }
+
+    function _deployCoinUSDCPair() internal {
+        bytes memory poolConfig_ = _generatePoolConfig(
+            CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION,
+            USDC_ADDRESS,
+            DEFAULT_DISCOVERY_TICK_LOWER,
+            DEFAULT_DISCOVERY_TICK_UPPER,
+            DEFAULT_NUM_DISCOVERY_POSITIONS,
+            DEFAULT_DISCOVERY_SUPPLY_SHARE
+        );
+        vm.prank(users.creator);
+        (address coinAddress, ) = factory.deploy(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            poolConfig_,
+            users.platformReferrer,
+            0
+        );
+
+        coin = Coin(payable(coinAddress));
+        pool = IUniswapV3Pool(coin.poolAddress());
+
+        vm.label(address(coin), "COIN");
+        vm.label(address(pool), "POOL");
+    }
+
+    function _swapSomeCurrencyForCoin(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;
+        router.execute(commands, inputs, deadline);
+
+        vm.stopPrank();
+    }
+
+    function _swapSomeCoinForCurrency(ICoinV4 _coin, address currency, uint128 amountIn, address trader) internal {
+        uint128 minAmountOut = uint128(0);
+
+        (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
+            address(_coin),
+            amountIn,
+            currency,
+            minAmountOut,
+            _coin.getPoolKey(),
+            bytes("")
+        );
+
+        vm.startPrank(trader);
+        UniV4SwapHelper.approveTokenWithPermit2(permit2, address(router), address(_coin), amountIn, uint48(block.timestamp + 1 days));
+
+        // Execute the swap
+        uint256 deadline = block.timestamp + 20;
+        router.execute(commands, inputs, deadline);
+
+        vm.stopPrank();
+    }
 
     function setUp() public virtual {
         setUpWithBlockNumber(28415528);
@@ -78,7 +208,8 @@ contract BaseTest is Test {
         swapRouter = ISwapRouter(SWAP_ROUTER);
         airlock = IAirlock(DOPPLER_AIRLOCK);
         protocolRewards = new ProtocolRewards();
-
+        permit2 = IPermit2(V4_PERMIT2);
+        router = IUniversalRouter(UNIVERSAL_ROUTER);
         users = Users({
             factoryOwner: makeAddr("factoryOwner"),
             feeRecipient: makeAddr("feeRecipient"),
@@ -90,11 +221,21 @@ contract BaseTest is Test {
             tradeReferrer: makeAddr("tradeReferrer")
         });
 
-        coinImpl = new Coin(users.feeRecipient, address(protocolRewards), WETH_ADDRESS, V3_FACTORY, SWAP_ROUTER, DOPPLER_AIRLOCK);
-        factoryImpl = new ZoraFactoryImpl(address(coinImpl));
-        factory = ZoraFactoryImpl(address(new ZoraFactory(address(factoryImpl))));
+        address[] memory trustedMessageSenders = new address[](2);
+        trustedMessageSenders[0] = UNIVERSAL_ROUTER;
+        trustedMessageSenders[1] = V4_POSITION_MANAGER;
 
-        ZoraFactoryImpl(factory).initialize(users.factoryOwner);
+        ProxyShim mockUpgradeableImpl = new ProxyShim();
+        factory = IZoraFactory(address(new ZoraFactory(address(mockUpgradeableImpl))));
+        zoraV4CoinHook = ZoraV4CoinHook(address(HooksDeployment.deployZoraV4CoinHookFromContract(V4_POOL_MANAGER, address(factory), trustedMessageSenders)));
+        coinV3Impl = new Coin(users.feeRecipient, address(protocolRewards), WETH_ADDRESS, V3_FACTORY, SWAP_ROUTER, DOPPLER_AIRLOCK);
+        coinV4Impl = new CoinV4(users.feeRecipient, address(protocolRewards), IPoolManager(V4_POOL_MANAGER), DOPPLER_AIRLOCK, zoraV4CoinHook);
+        factoryImpl = new ZoraFactoryImpl(address(coinV3Impl), address(coinV4Impl));
+        UUPSUpgradeable(address(factory)).upgradeToAndCall(address(factoryImpl), "");
+        factory = IZoraFactory(address(factory));
+        // factory = ZoraFactoryImpl(address(new ZoraFactory(address(factoryImpl))));
+
+        ZoraFactoryImpl(address(factory)).initialize(users.factoryOwner);
 
         vm.label(address(factory), "ZORA_FACTORY");
         vm.label(address(protocolRewards), "PROTOCOL_REWARDS");
@@ -120,54 +261,6 @@ contract BaseTest is Test {
         uint256 protocol;
     }
 
-    function _deployCoin() internal {
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
-
-        vm.prank(users.creator);
-        (address coinAddress, ) = factory.deploy(
-            users.creator,
-            owners,
-            "https://test.com",
-            "Testcoin",
-            "TEST",
-            users.platformReferrer,
-            address(weth),
-            MarketConstants.LP_TICK_LOWER_WETH,
-            0
-        );
-
-        coin = Coin(payable(coinAddress));
-        pool = IUniswapV3Pool(coin.poolAddress());
-
-        vm.label(address(coin), "COIN");
-        vm.label(address(pool), "POOL");
-    }
-
-    function _deployCoinUSDCPair() internal {
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
-
-        vm.prank(users.creator);
-        (address coinAddress, ) = factory.deploy(
-            users.creator,
-            owners,
-            "https://testusdccoin.com",
-            "Testusdccoin",
-            "TESTUSDCCOIN",
-            users.platformReferrer,
-            USDC_ADDRESS,
-            USDC_TICK_LOWER,
-            0
-        );
-
-        coin = Coin(payable(coinAddress));
-        pool = IUniswapV3Pool(coin.poolAddress());
-
-        vm.label(address(coin), "COIN");
-        vm.label(address(pool), "POOL");
-    }
-
     function _calculateTradeRewards(uint256 ethAmount) internal pure returns (TradeRewards memory) {
         return
             TradeRewards({
@@ -207,6 +300,18 @@ contract BaseTest is Test {
         return airlock.owner();
     }
 
+    function _generatePoolConfig(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 _generatePoolConfig(
         uint8 version_,
         address currency_,

package/test/utils/DeployedCoinVersionLookup.t.sol

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {BaseTest} from "../utils/BaseTest.sol";
+import {DeployedCoinVersionLookup} from "../../src/utils/DeployedCoinVersionLookup.sol";
+
+contract TestDeployedCoinVersionLookupImplementation is DeployedCoinVersionLookup {
+    function setVersionForTesting(address coin, uint8 version) external {
+        _setVersionForDeployedCoin(coin, version);
+    }
+}
+
+/**
+ * @title Mock implementation with different namespace
+ * @dev Used to verify that different namespaces don't collide
+ */
+contract DifferentNamespaceVersionLookup {
+    /// @custom:storage-location erc7201:different.namespace
+    struct DeployedCoinVersionStorage {
+        mapping(address => uint8) deployedCoinWithVersion;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("different.namespace")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant DEPLOYED_COIN_VERSION_STORAGE_LOCATION = 0xf0ec9c7ea8b861b539967dd0659fb8887a9724eca55e932839a2a8e01f50c400;
+
+    function _getDeployedCoinVersionStorage() private pure returns (DeployedCoinVersionStorage storage $) {
+        assembly {
+            $.slot := DEPLOYED_COIN_VERSION_STORAGE_LOCATION
+        }
+    }
+
+    function getVersionForDeployedCoin(address coin) public view returns (uint8) {
+        return _getDeployedCoinVersionStorage().deployedCoinWithVersion[coin];
+    }
+
+    function setVersionForTesting(address coin, uint8 version) external {
+        _getDeployedCoinVersionStorage().deployedCoinWithVersion[coin] = version;
+    }
+}
+
+contract DeployedCoinVersionLookupTest is BaseTest {
+    TestDeployedCoinVersionLookupImplementation public versionLookup;
+    DifferentNamespaceVersionLookup public differentNamespaceLookup;
+    address public testCoin1;
+    address public testCoin2;
+    address public testContractAddress;
+
+    function setUp() public override {
+        super.setUp();
+        versionLookup = new TestDeployedCoinVersionLookupImplementation();
+        differentNamespaceLookup = new DifferentNamespaceVersionLookup();
+        testCoin1 = makeAddr("testCoin1");
+        testCoin2 = makeAddr("testCoin2");
+        testContractAddress = makeAddr("testContractAddress");
+    }
+
+    function test_getAndSetVersionForDeployedCoin() public {
+        // Default version should be 0
+        assertEq(versionLookup.getVersionForDeployedCoin(testCoin1), 0);
+
+        // Set version and verify
+        versionLookup.setVersionForTesting(testCoin1, 1);
+        assertEq(versionLookup.getVersionForDeployedCoin(testCoin1), 1);
+
+        // Set version for a different coin
+        versionLookup.setVersionForTesting(testCoin2, 2);
+        assertEq(versionLookup.getVersionForDeployedCoin(testCoin2), 2);
+
+        // First coin's version should remain unchanged
+        assertEq(versionLookup.getVersionForDeployedCoin(testCoin1), 1);
+
+        // Update version and verify
+        versionLookup.setVersionForTesting(testCoin1, 3);
+        assertEq(versionLookup.getVersionForDeployedCoin(testCoin1), 3);
+    }
+
+    function test_differentNamespaceIndependence() public {
+        // First deploy the original implementation at a fixed address
+        TestDeployedCoinVersionLookupImplementation originalImpl = new TestDeployedCoinVersionLookupImplementation();
+        bytes memory originalBytecode = address(originalImpl).code;
+
+        // Deploy a different implementation
+        DifferentNamespaceVersionLookup differentImpl = new DifferentNamespaceVersionLookup();
+        bytes memory differentBytecode = address(differentImpl).code;
+
+        // Etch the original implementation to the test address
+        vm.etch(testContractAddress, originalBytecode);
+
+        // Test setting values with the first implementation
+        TestDeployedCoinVersionLookupImplementation(testContractAddress).setVersionForTesting(testCoin1, 42);
+        assertEq(TestDeployedCoinVersionLookupImplementation(testContractAddress).getVersionForDeployedCoin(testCoin1), 42);
+
+        // Save the bytecode location for the first implementation
+        bytes32 firstSlot = vm.load(
+            testContractAddress,
+            bytes32(uint256(keccak256(abi.encode(testCoin1, 0x9a79df0b86f39d0543c14aee714123562f798115071e932933bcc3e29cc86f00))))
+        );
+        assertEq(uint256(firstSlot), 42);
+
+        // Now replace the code with the different namespace implementation
+        vm.etch(testContractAddress, differentBytecode);
+
+        // Set a value with the different implementation
+        DifferentNamespaceVersionLookup(testContractAddress).setVersionForTesting(testCoin1, 99);
+
+        // This should use a different storage slot, so it shouldn't affect the original value
+        assertEq(DifferentNamespaceVersionLookup(testContractAddress).getVersionForDeployedCoin(testCoin1), 99);
+
+        // Verify the original storage slot still has the original value
+        bytes32 secondSlot = vm.load(
+            testContractAddress,
+            bytes32(uint256(keccak256(abi.encode(testCoin1, 0xf0ec9c7ea8b861b539967dd0659fb8887a9724eca55e932839a2a8e01f50c400))))
+        );
+        assertEq(uint256(secondSlot), 99);
+
+        // Switch back to the original implementation to verify its storage is unchanged
+        vm.etch(testContractAddress, originalBytecode);
+        assertEq(TestDeployedCoinVersionLookupImplementation(testContractAddress).getVersionForDeployedCoin(testCoin1), 42);
+
+        // Change the value in the original implementation
+        TestDeployedCoinVersionLookupImplementation(testContractAddress).setVersionForTesting(testCoin1, 123);
+
+        // Switch back to the different namespace implementation to verify its storage is unchanged
+        vm.etch(testContractAddress, differentBytecode);
+        assertEq(DifferentNamespaceVersionLookup(testContractAddress).getVersionForDeployedCoin(testCoin1), 99);
+    }
+}

package/test/utils/FeeEstimatorHook.sol

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {ZoraV4CoinHook} from "../../src/hooks/ZoraV4CoinHook.sol";
+import {IPoolManager, PoolKey} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {IDeployedCoinVersionLookup} from "../../src/interfaces/IDeployedCoinVersionLookup.sol";
+import {IHasRewardsRecipients} from "../../src/interfaces/ICoin.sol";
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
+import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {CoinCommon} from "../../src/libs/CoinCommon.sol";
+import {V4Liquidity} from "../../src/libs/V4Liquidity.sol";
+import {BaseHook} from "@uniswap/v4-periphery/src/utils/BaseHook.sol";
+import {ICoinV4, IHasSwapPath} from "../../src/interfaces/ICoinV4.sol";
+import {UniV4SwapToCurrency} from "../../src/libs/UniV4SwapToCurrency.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {CoinRewardsV4} from "../../src/libs/CoinRewardsV4.sol";
+
+/// @dev Test util - meant to be able to etched where a normal zora hook is, to gather the fees from swaps but not distribute them
+contract FeeEstimatorHook is ZoraV4CoinHook {
+    struct FeeEstimatorState {
+        uint128 fees0;
+        uint128 fees1;
+        Currency afterSwapCurrency;
+        uint128 afterSwapCurrencyAmount;
+        BalanceDelta lastDelta;
+        SwapParams lastSwapParams;
+        uint256 currencyBalanceChange;
+        uint256 coinBalanceChange;
+    }
+
+    constructor(IPoolManager _poolManager, IDeployedCoinVersionLookup _coinVersionLookup) ZoraV4CoinHook(_poolManager, _coinVersionLookup, new address[](0)) {}
+
+    FeeEstimatorState public feeState;
+
+    function getFeeState() public view returns (FeeEstimatorState memory) {
+        return feeState;
+    }
+
+    function _afterSwap(
+        address,
+        PoolKey calldata key,
+        SwapParams calldata params,
+        BalanceDelta _delta,
+        bytes calldata
+    ) internal override returns (bytes4, int128) {
+        bytes32 poolKeyHash = CoinCommon.hashPoolKey(key);
+
+        // get the coin address and positions for the pool key; they must have been set in the afterInitialize callback
+        address coin = poolCoins[poolKeyHash].coin;
+        require(coin != address(0), NoCoinForHook(key));
+
+        {
+            uint256 coinBalanceBefore = IERC20(coin).balanceOf(address(this));
+            uint256 currencyBalanceBefore = IERC20(ICoinV4(coin).currency()).balanceOf(address(this));
+
+            IHasSwapPath.PayoutSwapPath memory payoutSwapPath = IHasSwapPath(coin).getPayoutSwapPath(coinVersionLookup);
+
+            int128 fee0;
+            int128 fee1;
+
+            (fee0, fee1, feeState.afterSwapCurrency, feeState.afterSwapCurrencyAmount) = CoinRewardsV4.collectFeesAndConvertToPayout(
+                poolManager,
+                key,
+                poolCoins[poolKeyHash].positions,
+                payoutSwapPath
+            );
+
+            feeState.fees0 += uint128(fee0);
+            feeState.fees1 += uint128(fee1);
+
+            uint256 coinBalanceAfter = IERC20(coin).balanceOf(address(this));
+            uint256 currencyBalanceAfter = IERC20(ICoinV4(coin).currency()).balanceOf(address(this));
+
+            feeState.coinBalanceChange = coinBalanceAfter - coinBalanceBefore;
+            feeState.currencyBalanceChange = currencyBalanceAfter - currencyBalanceBefore;
+        }
+
+        feeState.lastDelta = _delta;
+        feeState.lastSwapParams = params;
+
+        return (BaseHook.afterSwap.selector, 0);
+    }
+}

package/test/utils/ProxyShim.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
+/// Used to deploy the factory before we know the impl address
+contract ProxyShim is UUPSUpgradeable {
+    address immutable canUpgrade;
+
+    constructor() {
+        canUpgrade = msg.sender;
+    }
+
+    function _authorizeUpgrade(address) internal view override {
+        require(msg.sender == canUpgrade, "not authorized");
+    }
+}

package/wagmi.config.ts

@@ -10,9 +10,13 @@ export default defineConfig({
       },
       include: [
         "Coin",
+        "CoinV4",
         "ZoraFactoryImpl",
         "IUniswapV3Pool",
         "BuySupplyWithSwapRouterHook",
+        "IPoolConfigEncoding",
+        "IUniversalRouter",
+        "IPermit2",
       ].map((contractName) => `${contractName}.json`),
     }),
   ],

package/.env

@@ -1 +0,0 @@
-ALCHEMY_KEY=Ebx4-biYR4T-p-1BOId9DozVRrr3nHu4

package/.turbo/turbo-update-contract-version.log

@@ -1,22 +0,0 @@
-
-
-> @zoralabs/coins@0.8.0 update-contract-version /Users/danovedzora/source/zora-protocol/packages/coins
-> pnpm exec update-contract-version
-
-updating contract version to  0.8.0
-generated contract version code: // This file is automatically generated by code; do not manually update
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.23;
-
-import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersionedContract.sol";
-
-/// @title ContractVersionBase
-/// @notice Base contract for versioning contracts
-contract ContractVersionBase is IVersionedContract {
-    /// @notice The version of the contract
-    function contractVersion() external pure override returns (string memory) {
-        return "0.8.0";
-    }
-}
-
-writing file to /Users/danovedzora/source/zora-protocol/packages/coins/src/version/ContractVersionBase.sol

package/abis/CoinSetupV3.json

@@ -1,7 +0,0 @@
-[
-  {
-    "type": "error",
-    "name": "InvalidPoolVersion",
-    "inputs": []
-  }
-]

package/abis/HookDeployer.json

@@ -1,68 +0,0 @@
-[
-  {
-    "type": "function",
-    "name": "deployZoraV4CoinHookFromContract",
-    "inputs": [
-      {
-        "name": "poolManager",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "hook",
-        "type": "address",
-        "internalType": "contract IHooks"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "error",
-    "name": "Create2EmptyBytecode",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "Create2FailedDeployment",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "Create2InsufficientBalance",
-    "inputs": [
-      {
-        "name": "balance",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "needed",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ]
-  },
-  {
-    "type": "error",
-    "name": "HookNotDeployed",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InvalidHookAddress",
-    "inputs": [
-      {
-        "name": "expected",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "actual",
-        "type": "address",
-        "internalType": "address"
-      }
-    ]
-  }
-]

package/abis/IHookDeployer.json

@@ -1,42 +0,0 @@
-[
-  {
-    "type": "function",
-    "name": "deployZoraV4CoinHookFromContract",
-    "inputs": [
-      {
-        "name": "poolManager",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "hook",
-        "type": "address",
-        "internalType": "contract IHooks"
-      }
-    ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "error",
-    "name": "HookNotDeployed",
-    "inputs": []
-  },
-  {
-    "type": "error",
-    "name": "InvalidHookAddress",
-    "inputs": [
-      {
-        "name": "expected",
-        "type": "address",
-        "internalType": "address"
-      },
-      {
-        "name": "actual",
-        "type": "address",
-        "internalType": "address"
-      }
-    ]
-  }
-]