@zoralabs/coins 0.7.1 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoralabs/coins",
-  "version": "0.7.1",
+  "version": "1.0.0",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -21,16 +21,21 @@
     "@types/node": "^20.1.2",
     "@wagmi/cli": "^1.0.1",
     "@solidity-parser/parser": "0.19.0",
+    "@uniswap/v4-core": "https://github.com/Uniswap/v4-core#a7cf038cd568801a79a9b4cf92cd5b52c95c8585",
+    "@uniswap/v4-periphery": "https://github.com/Uniswap/v4-periphery#eeb3eff28dd5f5f17aa94180fa3610ff59b0e1c8",
+    "@uniswap/universal-router": "https://github.com/Uniswap/universal-router#3663f6db6e2fe121753cd2d899699c2dc75dca86",
+    "@uniswap/permit2": "https://github.com/Uniswap/permit2#cc56ad0f3439c502c246fc5cfcc3db92bb8b7219",
     "ds-test": "https://github.com/dapphub/ds-test#cd98eff28324bfac652e63a239a60632a761790b",
     "forge-std": "https://github.com/foundry-rs/forge-std#v1.9.1",
     "prettier": "^3.0.3",
     "prettier-plugin-solidity": "^1.4.1",
     "solady": "0.0.132",
+    "solmate": "6.8.0",
     "tsup": "^7.2.0",
     "tsx": "^3.13.0",
     "typescript": "^5.2.2",
     "viem": "^2.21.18",
-    "@zoralabs/shared-contracts": "^0.0.2",
+    "@zoralabs/shared-contracts": "^0.0.3",
     "@zoralabs/shared-scripts": "^0.0.0",
     "@zoralabs/tsconfig": "^0.0.1"
   },

package/remappings.txt

@@ -2,4 +2,9 @@ ds-test/=node_modules/ds-test/src/
 forge-std/=node_modules/forge-std/src/
 @openzeppelin/=node_modules/@openzeppelin/
 @zoralabs/shared-contracts/=node_modules/@zoralabs/shared-contracts/src/
-solady/=node_modules/solady/src/ 
+solady/=node_modules/solady/src/ 
+@uniswap/v4-core/=node_modules/@uniswap/v4-core/
+@uniswap/v4-periphery/=node_modules/@uniswap/v4-periphery/
+permit2/src/=node_modules/@uniswap/permit2/src/
+@uniswap/universal-router/contracts/=node_modules/@uniswap/universal-router/contracts/
+solmate/=node_modules/solmate/src/

package/script/CoinsDeployerBase.sol

@@ -8,6 +8,15 @@ import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/U
 import {ZoraFactoryImpl} from "../src/ZoraFactoryImpl.sol";
 import {Coin} from "../src/Coin.sol";
 import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersionedContract.sol";
+import {BuySupplyWithSwapRouterHook} from "../src/hooks/deployment/BuySupplyWithSwapRouterHook.sol";
+import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
+import {CoinV4} from "../src/CoinV4.sol";
+import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
+import {ZoraV4CoinHook} from "../src/hooks/ZoraV4CoinHook.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {ZoraFactory} from "../src/proxy/ZoraFactory.sol";
+import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
+import {HooksDeployment} from "../src/libs/HooksDeployment.sol";
 
 contract CoinsDeployerBase is ProxyDeployerScript {
     address internal constant PROTOCOL_REWARDS = 0x7777777F279eba3d3Ad8F4E708545291A6fDBA8B;
@@ -19,8 +28,14 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         address zoraFactory;
         address zoraFactoryImpl;
         // Implementation
-        address coinImpl;
+        address coinV3Impl;
+        address coinV4Impl;
         string coinVersion;
+        // hooks
+        address buySupplyWithSwapRouterHook;
+        address zoraV4CoinHook;
+        address devFactory;
+        address trustedMessageSenders;
     }
 
     function addressesFile() internal view returns (string memory) {
@@ -33,7 +48,12 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         vm.serializeAddress(objectKey, "ZORA_FACTORY", deployment.zoraFactory);
         vm.serializeAddress(objectKey, "ZORA_FACTORY_IMPL", deployment.zoraFactoryImpl);
         vm.serializeString(objectKey, "COIN_VERSION", deployment.coinVersion);
-        string memory result = vm.serializeAddress(objectKey, "COIN_IMPL", deployment.coinImpl);
+        vm.serializeAddress(objectKey, "BUY_SUPPLY_WITH_SWAP_ROUTER_HOOK", deployment.buySupplyWithSwapRouterHook);
+        vm.serializeAddress(objectKey, "COIN_V3_IMPL", deployment.coinV3Impl);
+        vm.serializeAddress(objectKey, "DEV_FACTORY", deployment.devFactory);
+        vm.serializeAddress(objectKey, "ZORA_V4_COIN_HOOK", deployment.zoraV4CoinHook);
+        vm.serializeAddress(objectKey, "TRUSTED_MESSAGE_SENDERS", deployment.trustedMessageSenders);
+        string memory result = vm.serializeAddress(objectKey, "COIN_V4_IMPL", deployment.coinV4Impl);
 
         vm.writeJson(result, addressesFile());
     }
@@ -47,23 +67,67 @@ contract CoinsDeployerBase is ProxyDeployerScript {
 
         deployment.zoraFactory = readAddressOrDefaultToZero(json, "ZORA_FACTORY");
         deployment.zoraFactoryImpl = readAddressOrDefaultToZero(json, "ZORA_FACTORY_IMPL");
-        deployment.coinImpl = readAddressOrDefaultToZero(json, "COIN_IMPL");
+        deployment.coinV3Impl = readAddressOrDefaultToZero(json, "COIN_V3_IMPL");
+        deployment.coinV4Impl = readAddressOrDefaultToZero(json, "COIN_V4_IMPL");
         deployment.coinVersion = readStringOrDefaultToEmpty(json, "COIN_VERSION");
+        deployment.buySupplyWithSwapRouterHook = readAddressOrDefaultToZero(json, "BUY_SUPPLY_WITH_SWAP_ROUTER_HOOK");
+        deployment.zoraV4CoinHook = readAddressOrDefaultToZero(json, "ZORA_V4_COIN_HOOK");
+        deployment.devFactory = readAddressOrDefaultToZero(json, "DEV_FACTORY");
+        deployment.trustedMessageSenders = readAddressOrDefaultToZero(json, "TRUSTED_MESSAGE_SENDERS");
     }
 
-    function deployCoinImpl() internal returns (Coin) {
-        return new Coin(getZoraRecipient(), PROTOCOL_REWARDS, getWeth(), getUniswapV3Factory(), getUniswapSwapRouter(), getDopplerAirlock());
+    function deployCoinV3Impl() internal returns (Coin) {
+        return
+            new Coin({
+                protocolRewardRecipient_: getZoraRecipient(),
+                protocolRewards_: PROTOCOL_REWARDS,
+                weth_: getWeth(),
+                v3Factory_: getUniswapV3Factory(),
+                swapRouter_: getUniswapSwapRouter(),
+                airlock_: getDopplerAirlock()
+            });
     }
 
-    function deployZoraFactoryImpl(address coinImpl) internal returns (ZoraFactoryImpl) {
-        return new ZoraFactoryImpl(coinImpl);
+    function deployCoinV4Impl(address zoraV4CoinHook) internal returns (CoinV4) {
+        return
+            new CoinV4({
+                protocolRewardRecipient_: getZoraRecipient(),
+                protocolRewards_: PROTOCOL_REWARDS,
+                poolManager_: IPoolManager(getUniswapV4PoolManager()),
+                airlock_: getDopplerAirlock(),
+                hooks_: IHooks(zoraV4CoinHook)
+            });
+    }
+
+    function deployZoraFactoryImpl(address coinV3Impl, address coinV4Impl) internal returns (ZoraFactoryImpl) {
+        return new ZoraFactoryImpl(coinV3Impl, coinV4Impl);
+    }
+
+    function deployBuySupplyWithSwapRouterHook(CoinsDeployment memory deployment) internal returns (BuySupplyWithSwapRouterHook) {
+        return new BuySupplyWithSwapRouterHook(IZoraFactory(deployment.zoraFactory), getUniswapSwapRouter());
+    }
+
+    function deployZoraV4CoinHook(address zoraFactory) internal returns (IHooks) {
+        return HooksDeployment.deployZoraV4CoinHookFromScript(getUniswapV4PoolManager(), zoraFactory, getDefaultTrustedMessageSenders());
+    }
+
+    function getDefaultTrustedMessageSenders() internal view returns (address[] memory) {
+        address[] memory trustedMessageSenders = new address[](2);
+        trustedMessageSenders[0] = getUniswapUniversalRouter();
+        trustedMessageSenders[1] = getUniswapV4PositionManager();
+        return trustedMessageSenders;
     }
 
     function deployImpls(CoinsDeployment memory deployment) internal returns (CoinsDeployment memory) {
+        address zoraFactoryImpl = address(deployZoraFactoryImpl(deployment.coinV3Impl, deployment.coinV4Impl));
+
         // Deploy implementation contracts
-        deployment.coinImpl = address(deployCoinImpl());
-        deployment.zoraFactoryImpl = address(deployZoraFactoryImpl(deployment.coinImpl));
-        deployment.coinVersion = IVersionedContract(deployment.coinImpl).contractVersion();
+        deployment.coinV3Impl = address(deployCoinV3Impl());
+        deployment.zoraV4CoinHook = address(deployZoraV4CoinHook(zoraFactoryImpl));
+        deployment.coinV4Impl = address(deployCoinV4Impl(deployment.zoraV4CoinHook));
+        deployment.zoraFactoryImpl = zoraFactoryImpl;
+        deployment.coinVersion = IVersionedContract(deployment.coinV3Impl).contractVersion();
+        deployment.buySupplyWithSwapRouterHook = address(deployBuySupplyWithSwapRouterHook(deployment));
 
         return deployment;
     }
@@ -101,4 +165,35 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         // validate that the zora factory owner is the proxy admin
         require(ZoraFactoryImpl(deployment.zoraFactory).owner() == getProxyAdmin(), "Zora factory owner is not the proxy admin");
     }
+
+    function deployDevFactory(CoinsDeployment memory deployment) internal returns (ZoraFactory devFactory) {
+        address owner = 0x63545B401283c993320A5b886ecF0fc6CB5668a9;
+
+        devFactory = new ZoraFactory(deployment.zoraFactoryImpl);
+
+        ZoraFactoryImpl(address(devFactory)).initialize(owner);
+
+        deployment.devFactory = address(devFactory);
+    }
+
+    function printUpgradeFactoryCommand(CoinsDeployment memory deployment) internal view {
+        // build upgrade to and call for factory, with init call
+        bytes memory call = abi.encodeWithSelector(UUPSUpgradeable.upgradeToAndCall.selector, deployment.zoraFactoryImpl, "");
+
+        address proxyAdmin = getProxyAdmin();
+
+        address target = address(deployment.zoraFactory);
+
+        // print the details for upgrading:
+
+        console.log("To upgrade the factory, this is the call information:");
+
+        console.log("Multisig:", proxyAdmin);
+        console.log("Target (the factory proxy):", target);
+        console.log("Upgrade call:");
+        console.logBytes(call);
+        console.log("Function to call: upgradeToAndCall");
+        // concat the args into a string, factoryImpl, ""
+        console.log("Args: ", string.concat(vm.toString(deployment.zoraFactoryImpl), ",", '"'));
+    }
 }

package/script/DeployDevFactory.s.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {ProxyDeployerScript, DeterministicDeployerAndCaller} from "@zoralabs/shared-contracts/deployment/ProxyDeployerScript.sol";
+import {CoinsDeployerBase} from "./CoinsDeployerBase.sol";
+
+contract DeployScript is CoinsDeployerBase {
+    function run() public {
+        CoinsDeployment memory deployment = readDeployment();
+
+        vm.startBroadcast();
+
+        // get deployer contract
+        deployDevFactory(deployment);
+
+        vm.stopBroadcast();
+
+        // save the deployment json
+        saveDeployment(deployment);
+    }
+}

package/script/DeployHooks.s.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {CoinsDeployerBase} from "./CoinsDeployerBase.sol";
+import {ZoraFactoryImpl} from "../src/ZoraFactoryImpl.sol";
+
+contract DeployHooks is CoinsDeployerBase {
+    function run() public {
+        CoinsDeployment memory deployment = readDeployment();
+
+        vm.startBroadcast();
+
+        address buySupplyWithSwapRouterHook = address(deployBuySupplyWithSwapRouterHook(deployment));
+
+        deployment.buySupplyWithSwapRouterHook = buySupplyWithSwapRouterHook;
+
+        vm.stopBroadcast();
+
+        // save the deployment json
+        saveDeployment(deployment);
+    }
+}

package/script/PrintUpgradeCommand.s.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {ProxyDeployerScript, DeterministicDeployerAndCaller} from "@zoralabs/shared-contracts/deployment/ProxyDeployerScript.sol";
+import {CoinsDeployerBase} from "./CoinsDeployerBase.sol";
+
+contract PrintUpgradeCommand is CoinsDeployerBase {
+    function run() public {
+        CoinsDeployment memory deployment = readDeployment();
+
+        printUpgradeFactoryCommand(deployment);
+    }
+}

package/script/Simulate.s.sol

@@ -3,12 +3,13 @@ pragma solidity ^0.8.13;
 
 import {Script, console} from "forge-std/Script.sol";
 
-import {Coin, CoinConstants} from "../src/Coin.sol";
+import {Coin} from "../src/Coin.sol";
+import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {ZoraFactoryImpl} from "../src/ZoraFactoryImpl.sol";
 import {ZoraFactory} from "../src/proxy/ZoraFactory.sol";
 
 /// @dev For simulating pre-buys -- eg `forge script script/Simulate.s.sol --private-key $DEPLOYER_PK --rpc-url $BASE_MAINNET_RPC_URL -vvvv`
-contract Simulate is Script, CoinConstants {
+contract Simulate is Script {
     // https://basescan.org/address/0x02B2705500096Ff83F9eF78873ca5DFB06C00Ddc
     address internal constant TEST_ZORA_FACTORY_ADDRESS_BASE_MAINNET = 0x02B2705500096Ff83F9eF78873ca5DFB06C00Ddc;
     address internal constant WETH_ADDRESS = 0x4200000000000000000000000000000000000006;
@@ -41,16 +42,7 @@ contract Simulate is Script, CoinConstants {
 
         // Prebuy order size
         uint256 orderSize = 0.000111 ether;
-        (address coinAddress, uint256 coinsPurchased) = factory.deploy{value: orderSize}(
-            payoutAddress,
-            owners,
-            uri,
-            name,
-            symbol,
-            poolConfig,
-            payoutAddress,
-            orderSize
-        );
+        factory.deploy{value: orderSize}(payoutAddress, owners, uri, name, symbol, poolConfig, payoutAddress, orderSize);
 
         vm.stopBroadcast();
     }

package/script/TestBackingCoinSwap.s.sol

@@ -0,0 +1,146 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {ProxyDeployerScript, DeterministicDeployerAndCaller} from "@zoralabs/shared-contracts/deployment/ProxyDeployerScript.sol";
+import {CoinsDeployerBase} from "./CoinsDeployerBase.sol";
+
+import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
+import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
+import {MarketConstants} from "../src/libs/MarketConstants.sol";
+import {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";
+import {CoinV4} from "../src/CoinV4.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {IUniversalRouter} from "@uniswap/universal-router/contracts/interfaces/IUniversalRouter.sol";
+import {IPermit2} from "permit2/src/interfaces/IPermit2.sol";
+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 {console} from "forge-std/console.sol";
+
+contract TestV4Swap is CoinsDeployerBase {
+    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; //
+
+    function _deployCoin(
+        address currency,
+        address creator,
+        string memory name,
+        string memory symbol,
+        string memory uri,
+        address createReferral,
+        bytes32 salt
+    ) internal returns (ICoinV4 coin) {
+        CoinsDeployment memory deployment = readDeployment();
+        address[] memory owners = new address[](1);
+        owners[0] = creator;
+
+        bytes memory poolConfig = CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(address(currency));
+
+        (address coinAddress, ) = IZoraFactory(deployment.devFactory).deploy(
+            creator,
+            owners,
+            uri,
+            name,
+            symbol,
+            poolConfig,
+            createReferral,
+            address(0),
+            "",
+            salt
+        );
+
+        coin = ICoinV4(coinAddress);
+    }
+
+    function _swap(address currencyIn, uint128 amountIn, ICoinV4 coin, address trader, address tradeReferral) internal returns (uint256 amountOut) {
+        uint128 minAmountOut = 0;
+
+        PoolKey memory poolKey = coin.getPoolKey();
+
+        bytes memory hookData = tradeReferral != address(0) ? abi.encode(tradeReferral) : bytes("");
+
+        address currencyOut = Currency.unwrap(Currency.unwrap(poolKey.currency0) == currencyIn ? poolKey.currency1 : poolKey.currency0);
+
+        // now we need to swap some currency into the coin
+        // first let
+        (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
+            currencyIn,
+            amountIn,
+            currencyOut,
+            minAmountOut,
+            poolKey,
+            hookData
+        );
+
+        UniV4SwapHelper.approveTokenWithPermit2(
+            IPermit2(getUniswapPermit2()),
+            getUniswapUniversalRouter(),
+            currencyIn,
+            amountIn,
+            uint48(block.timestamp + 1 days)
+        );
+
+        uint256 balanceBefore = IERC20(currencyOut).balanceOf(trader);
+
+        // Execute the swap
+        uint256 deadline = block.timestamp + 1 days;
+        IUniversalRouter(getUniswapUniversalRouter()).execute(commands, inputs, deadline);
+
+        amountOut = IERC20(currencyOut).balanceOf(trader) - balanceBefore;
+    }
+
+    function run() public {
+        address trader = vm.envAddress("TRADER");
+
+        require(block.chainid == 8453, "only on base");
+
+        address zora = 0x1111111111166b7FE7bd91427724B487980aFc69;
+
+        vm.startBroadcast(trader);
+
+        // address createReferral = 0xC077e4cC02fa01A5b7fAca1acE9BBe9f5ac5Af9F;
+        address tradeReferral = 0xC077e4cC02fa01A5b7fAca1acE9BBe9f5ac5Af9F;
+        // ICoinV4 backingCoin = _deployCoin(zora, trader, "TestCCoin", "CRE", "https://testc.com", createReferral, bytes32("creator"));
+        // ICoinV4 contentCoin = _deployCoin(
+        //     address(backingCoin),
+        //     trader,
+        //     "Content Coin",
+        //     "CONTENT",
+        //     "https://content.com",
+        //     createReferral,
+        //     bytes32("content coin")
+        // );
+        ICoinV4 backingCoin = ICoinV4(0xeA734b5997F35cD469921cCa7BB9A03C104f2f64);
+        ICoinV4 contentCoin = ICoinV4(0x72218BFEEc7D556BD3Dd8eFf2a317CEd49533769);
+
+        console.log("backingCoin", address(backingCoin));
+        console.log("contentCoin", address(contentCoin));
+        // console.log("currency", address(currency));
+
+        // (MockERC20 currency, address coinAddress) = _deployMockCurrencyAndCoin(trader, createReferral);
+
+        // address coinAddress = vm.parseAddress("0x58c0d8803Ae97bEF212EdFA8ba2FE303670cca9D");
+        // console.log("currency", address(currency));
+        // console.log("coinAddress", coinAddress);
+
+        // swap in 2 ether of currency into the coin
+        uint128 amountIn = uint128(IERC20(zora).balanceOf(trader));
+        // currency.mint(trader, amountIn);
+
+        // // swap some currency into the backing coin
+        uint256 backingCoinReceived = _swap(zora, amountIn, backingCoin, trader, tradeReferral);
+
+        // // swap balance of backing coin into the content coin
+        uint256 contentCoinReceived = _swap(address(backingCoin), uint128(backingCoinReceived), contentCoin, trader, tradeReferral);
+
+        // swap balance of content coin into the currency
+        _swap(address(contentCoin), uint128(contentCoinReceived), contentCoin, trader, tradeReferral);
+
+        vm.stopBroadcast();
+    }
+}

package/script/TestV4Swap.s.sol

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {ProxyDeployerScript, DeterministicDeployerAndCaller} from "@zoralabs/shared-contracts/deployment/ProxyDeployerScript.sol";
+import {CoinsDeployerBase} from "./CoinsDeployerBase.sol";
+
+import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
+import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
+import {MarketConstants} from "../src/libs/MarketConstants.sol";
+import {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";
+import {CoinV4} from "../src/CoinV4.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {IUniversalRouter} from "@uniswap/universal-router/contracts/interfaces/IUniversalRouter.sol";
+import {IPermit2} from "permit2/src/interfaces/IPermit2.sol";
+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 {console} from "forge-std/console.sol";
+
+contract TestV4Swap is CoinsDeployerBase {
+    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; //
+
+    function _deployMockCurrency() internal returns (MockERC20 currency) {
+        currency = new MockERC20("Testcoin", "TEST");
+        currency.mint(getUniswapV4PoolManager(), 1000000 ether);
+    }
+
+    function _deployMockCoin(address currency, address creator, address createReferral, bytes32 salt) internal returns (ICoinV4 coin) {
+        CoinsDeployment memory deployment = readDeployment();
+        address[] memory owners = new address[](1);
+        owners[0] = creator;
+
+        bytes memory poolConfig = CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(address(currency));
+
+        (address coinAddress, ) = IZoraFactory(deployment.zoraFactory).deploy(
+            creator,
+            owners,
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            poolConfig,
+            createReferral,
+            address(0),
+            "",
+            salt
+        );
+
+        coin = ICoinV4(coinAddress);
+    }
+
+    function _swap(address currencyIn, uint128 amountIn, ICoinV4 coin, address trader, address tradeReferral) internal returns (uint256 amountOut) {
+        uint128 minAmountOut = 0;
+
+        PoolKey memory poolKey = coin.getPoolKey();
+
+        bytes memory hookData = tradeReferral != address(0) ? abi.encode(tradeReferral) : bytes("");
+
+        address currencyOut = Currency.unwrap(Currency.unwrap(poolKey.currency0) == currencyIn ? poolKey.currency1 : poolKey.currency0);
+
+        // now we need to swap some currency into the coin
+        // first let
+        (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
+            currencyIn,
+            amountIn,
+            currencyOut,
+            minAmountOut,
+            poolKey,
+            hookData
+        );
+
+        UniV4SwapHelper.approveTokenWithPermit2(
+            IPermit2(getUniswapPermit2()),
+            getUniswapUniversalRouter(),
+            currencyIn,
+            amountIn,
+            uint48(block.timestamp + 1 days)
+        );
+
+        uint256 balanceBefore = IERC20(currencyOut).balanceOf(trader);
+
+        // Execute the swap
+        uint256 deadline = block.timestamp + 1 days;
+        IUniversalRouter(getUniswapUniversalRouter()).execute(commands, inputs, deadline);
+
+        amountOut = IERC20(currencyOut).balanceOf(trader) - balanceBefore;
+    }
+
+    function run() public {
+        address trader = vm.envAddress("TRADER");
+
+        vm.startBroadcast(trader);
+
+        // address createReferral = 0xC077e4cC02fa01A5b7fAca1acE9BBe9f5ac5Af9F;
+        address tradeReferral = 0xC077e4cC02fa01A5b7fAca1acE9BBe9f5ac5Af9F;
+
+        // MockERC20 currency = _deployMockCurrency();
+
+        // ICoinV4 backingCoin = _deployMockCoin(address(currency), trader, createReferral, bytes32("backing coin"));
+        // ICoinV4 contentCoin = _deployMockCoin(address(backingCoin), trader, createReferral, bytes32("content coin"));
+
+        MockERC20 currency = MockERC20(0x21E3bde504fF56C440851ACB6A16e7E35405B278);
+        ICoinV4 backingCoin = ICoinV4(0xa8bb679A2be09eCCabdb76700170ec387C896570);
+        ICoinV4 contentCoin = ICoinV4(0x3cfE4CE87A821FB2c7eAB4359dD6eA6F9e492c61);
+
+        console.log("backingCoin", address(backingCoin));
+        console.log("contentCoin", address(contentCoin));
+        console.log("currency", address(currency));
+
+        // (MockERC20 currency, address coinAddress) = _deployMockCurrencyAndCoin(trader, createReferral);
+
+        // address coinAddress = vm.parseAddress("0x58c0d8803Ae97bEF212EdFA8ba2FE303670cca9D");
+        // console.log("currency", address(currency));
+        // console.log("coinAddress", coinAddress);
+
+        // swap in 2 ether of currency into the coin
+        uint128 amountIn = 2 ether;
+        currency.mint(trader, amountIn);
+
+        // swap some currency into the backing coin
+        uint256 backingCoinReceived = _swap(address(currency), amountIn, backingCoin, trader, tradeReferral);
+
+        // swap balance of backing coin into the content coin
+        uint256 contentCoinReceived = _swap(address(backingCoin), uint128(backingCoinReceived), contentCoin, trader, tradeReferral);
+
+        // swap balance of content coin into the currency
+        _swap(address(contentCoin), uint128(contentCoinReceived), contentCoin, trader, tradeReferral);
+
+        vm.stopBroadcast();
+    }
+}

package/script/UpgradeCoinImpl.sol

@@ -11,13 +11,13 @@ contract UpgradeCoinImpl is CoinsDeployerBase {
         vm.startBroadcast();
 
         // get deployer contract
-        DeterministicDeployerAndCaller deployer = createOrGetDeployerAndCaller();
-
         deployment = deployImpls(deployment);
 
         vm.stopBroadcast();
 
         // save the deployment json
         saveDeployment(deployment);
+
+        printUpgradeFactoryCommand(deployment);
     }
 }

package/script/UpgradeFactoryImpl.s.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {CoinsDeployerBase} from "./CoinsDeployerBase.sol";
+import {ZoraFactoryImpl} from "../src/ZoraFactoryImpl.sol";
+
+contract UpgradeFactoryImpl is CoinsDeployerBase {
+    function run() public {
+        CoinsDeployment memory deployment = readDeployment();
+
+        vm.startBroadcast();
+
+        ZoraFactoryImpl zoraFactoryImpl = deployZoraFactoryImpl(deployment.coinV3Impl, deployment.coinV4Impl);
+
+        deployment.zoraFactoryImpl = address(zoraFactoryImpl);
+
+        vm.stopBroadcast();
+
+        // save the deployment json
+        saveDeployment(deployment);
+        printUpgradeFactoryCommand(deployment);
+    }
+}