@zoralabs/protocol-deployments 0.0.12 → 0.0.13

package/src/ZoraDeployerUtils.sol

@@ -1,212 +0,0 @@
-// spdx-license-identifier: mit
-pragma solidity ^0.8.17;
-
-import {Zora1155Factory} from "@zoralabs/zora-1155-contracts/src/proxies/Zora1155Factory.sol";
-import {ZoraCreator1155Impl} from "@zoralabs/zora-1155-contracts/src/nft/ZoraCreator1155Impl.sol";
-import {IZoraCreator1155Factory} from "@zoralabs/zora-1155-contracts/src/interfaces/IZoraCreator1155Factory.sol";
-import {ZoraCreator1155FactoryImpl} from "@zoralabs/zora-1155-contracts/src/factory/ZoraCreator1155FactoryImpl.sol";
-import {IMinter1155} from "@zoralabs/zora-1155-contracts/src/interfaces/IMinter1155.sol";
-import {Deployment, ChainConfig} from "./DeploymentConfig.sol";
-import {ProxyShim} from "@zoralabs/zora-1155-contracts/src/utils/ProxyShim.sol";
-import {ZoraCreator1155PremintExecutorImpl} from "@zoralabs/zora-1155-contracts/src/delegation/ZoraCreator1155PremintExecutorImpl.sol";
-import {IImmutableCreate2Factory} from "./IImmutableCreate2Factory.sol";
-import {DeterministicProxyDeployer} from "./DeterministicProxyDeployer.sol";
-import {ZoraCreatorFixedPriceSaleStrategy} from "@zoralabs/zora-1155-contracts/src/minters/fixed-price/ZoraCreatorFixedPriceSaleStrategy.sol";
-import {ZoraCreatorMerkleMinterStrategy} from "@zoralabs/zora-1155-contracts/src/minters/merkle/ZoraCreatorMerkleMinterStrategy.sol";
-import {ZoraCreatorRedeemMinterFactory} from "@zoralabs/zora-1155-contracts/src/minters/redeem/ZoraCreatorRedeemMinterFactory.sol";
-import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
-import {ICreatorRoyaltiesControl} from "@zoralabs/zora-1155-contracts/src/interfaces/ICreatorRoyaltiesControl.sol";
-import {UpgradeGate} from "@zoralabs/zora-1155-contracts/src/upgrades/UpgradeGate.sol";
-import {UUPSUpgradeable} from "@zoralabs/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol";
-
-struct Create2Deployment {
-    address deployerAddress;
-    bytes32 salt;
-    bytes constructorArguments;
-    address deployedAddress;
-}
-
-library ZoraDeployerUtils {
-    IImmutableCreate2Factory constant IMMUTABLE_CREATE2_FACTORY = IImmutableCreate2Factory(0x0000000000FFe8B47B3e2130213B802212439497);
-
-    bytes32 constant IMMUTABLE_CREATE_2_FRIENDLY_SALT = bytes32(0x0000000000000000000000000000000000000000000000000000000000000001);
-
-    function deployWithImmutableCreate2(
-        bytes32 salt,
-        bytes memory creationCode,
-        bytes memory constructorArguments
-    ) internal returns (Create2Deployment memory) {
-        address deployedAddress = IMMUTABLE_CREATE2_FACTORY.safeCreate2(salt, abi.encodePacked(creationCode, constructorArguments));
-
-        return
-            Create2Deployment({
-                deployerAddress: address(IMMUTABLE_CREATE2_FACTORY),
-                salt: salt,
-                constructorArguments: constructorArguments,
-                deployedAddress: deployedAddress
-            });
-    }
-
-    function ensureValidUpgradeGate(address upgradeGateAddress) internal pure {
-        require(
-            keccak256(abi.encodePacked(UpgradeGate(upgradeGateAddress).contractName())) == keccak256(abi.encodePacked("ZORA 1155 Upgrade Gate")),
-            "INVALID_UPGRADE_GATE"
-        );
-    }
-
-    function deployNew1155AndFactoryImpl(
-        address upgradeGateAddress,
-        address mintFeeRecipient,
-        address protocolRewards,
-        IMinter1155 merkleMinter,
-        IMinter1155 redeemMinterFactory,
-        IMinter1155 fixedPriceMinter
-    ) internal returns (address factoryImplAddress, address contract1155ImplAddress, string memory contract1155ImplVersion) {
-        ensureValidUpgradeGate(upgradeGateAddress);
-
-        ZoraCreator1155Impl zoraCreator1155Impl = new ZoraCreator1155Impl(mintFeeRecipient, upgradeGateAddress, protocolRewards);
-
-        contract1155ImplVersion = zoraCreator1155Impl.contractVersion();
-
-        contract1155ImplAddress = address(zoraCreator1155Impl);
-        factoryImplAddress = address(
-            new ZoraCreator1155FactoryImpl({
-                _zora1155Impl: zoraCreator1155Impl,
-                _merkleMinter: merkleMinter,
-                _redeemMinterFactory: redeemMinterFactory,
-                _fixedPriceMinter: fixedPriceMinter
-            })
-        );
-    }
-
-    function deployImmutableOrGetAddress(bytes32 salt, bytes memory creationCode) internal returns (address) {
-        address deployedAddress = Create2.computeAddress(salt, keccak256(creationCode), address(IMMUTABLE_CREATE2_FACTORY));
-        if (IMMUTABLE_CREATE2_FACTORY.hasBeenDeployed(deployedAddress)) {
-            return deployedAddress;
-        }
-
-        return IMMUTABLE_CREATE2_FACTORY.safeCreate2(salt, creationCode);
-    }
-
-    function deployMinters() internal returns (address fixedPriceMinter, address merkleMinter, address redeemMinterFactory) {
-        fixedPriceMinter = deployImmutableOrGetAddress(
-            bytes32(0x0000000000000000000000000000000000000000000000000000000000000001),
-            type(ZoraCreatorFixedPriceSaleStrategy).creationCode
-        );
-
-        merkleMinter = deployImmutableOrGetAddress(
-            bytes32(0x0000000000000000000000000000000000000000000000000000000000000001),
-            type(ZoraCreatorMerkleMinterStrategy).creationCode
-        );
-
-        redeemMinterFactory = deployImmutableOrGetAddress(
-            bytes32(0x0000000000000000000000000000000000000000000000000000000000000001),
-            type(ZoraCreatorRedeemMinterFactory).creationCode
-        );
-    }
-
-    // we dont care what this salt is, as long as it's the same for all deployments and it has first 20 bytes of 0
-    // so that anyone can deploy it
-    bytes32 constant FACTORY_DEPLOYER_DEPLOYMENT_SALT = bytes32(0x0000000000000000000000000000000000000000668d7f9ed18e35000dbaba0f);
-
-    function createDeterministicFactoryProxyDeployer() internal returns (DeterministicProxyDeployer) {
-        return
-            DeterministicProxyDeployer(IMMUTABLE_CREATE2_FACTORY.safeCreate2(FACTORY_DEPLOYER_DEPLOYMENT_SALT, type(DeterministicProxyDeployer).creationCode));
-    }
-
-    function deployNewPreminterImplementationDeterminstic(address factoryProxyAddress) internal returns (address) {
-        // create preminter implementation
-        bytes memory creationCode = abi.encodePacked(type(ZoraCreator1155PremintExecutorImpl).creationCode, abi.encode(factoryProxyAddress));
-
-        bytes32 salt = bytes32(0x0000000000000000000000000000000000000000668d7f9ec18e35000dbaba0e);
-
-        address determinsticAddress = ZoraDeployerUtils.getImmutableCreate2Address(salt, creationCode);
-
-        ZoraDeployerUtils.getOrImmutable2Create(determinsticAddress, salt, creationCode);
-
-        return determinsticAddress;
-    }
-
-    function deterministicFactoryDeployerAddress() internal view returns (address) {
-        // we can know deterministically what the address of the new factory proxy deployer will be, given it's deployed from with the salt and init code,
-        // from the ImmutableCreate2Factory
-        return IMMUTABLE_CREATE2_FACTORY.findCreate2Address(FACTORY_DEPLOYER_DEPLOYMENT_SALT, type(DeterministicProxyDeployer).creationCode);
-    }
-
-    function factoryProxyConstructorArguments(bytes32 proxyShimSalt, address proxyDeployerAddress) internal pure returns (bytes memory) {
-        address proxyShimAddress = Create2.computeAddress(
-            proxyShimSalt,
-            keccak256(abi.encodePacked(type(ProxyShim).creationCode, abi.encode(proxyDeployerAddress))),
-            proxyDeployerAddress
-        );
-
-        return abi.encode(proxyShimAddress, "");
-    }
-
-    function deterministicFactoryProxyAddress(bytes32 proxyShimSalt, bytes32 factoryProxySalt, address proxyDeployerAddress) internal pure returns (address) {
-        bytes memory constructorArguments = factoryProxyConstructorArguments(proxyShimSalt, proxyDeployerAddress);
-
-        return
-            Create2.computeAddress(
-                factoryProxySalt,
-                keccak256(abi.encodePacked(type(Zora1155Factory).creationCode, constructorArguments)),
-                proxyDeployerAddress
-            );
-    }
-
-    error MismatchedAddress(address expected, address actual);
-
-    function getImmutableCreate2Address(bytes32 salt, bytes memory creationCode) internal pure returns (address) {
-        return Create2.computeAddress(salt, keccak256(creationCode), address(IMMUTABLE_CREATE2_FACTORY));
-    }
-
-    function getOrImmutable2Create(address expectedAddress, bytes32 salt, bytes memory creationCode) internal returns (bool contractWasCreated) {
-        if (IMMUTABLE_CREATE2_FACTORY.hasBeenDeployed(expectedAddress)) {
-            return false;
-        } else {
-            address result = ZoraDeployerUtils.IMMUTABLE_CREATE2_FACTORY.safeCreate2(salt, creationCode);
-
-            if (result != expectedAddress) revert MismatchedAddress(expectedAddress, result);
-
-            return true;
-        }
-    }
-
-    /// @notice Deploy a test contract for etherscan auto-verification
-    /// @param factoryProxy Factory address to use
-    /// @param admin Admin owner address to use
-    function deployTestContractForVerification(address factoryProxy, address admin) internal returns (address) {
-        bytes[] memory initUpdate = new bytes[](1);
-        initUpdate[0] = abi.encodeWithSelector(
-            ZoraCreator1155Impl.setupNewToken.selector,
-            "ipfs://bafkreigu544g6wjvqcysurpzy5pcskbt45a5f33m6wgythpgb3rfqi3lzi",
-            100
-        );
-        return
-            address(
-                IZoraCreator1155Factory(factoryProxy).createContract(
-                    "ipfs://bafybeicgolwqpozsc7iwgytavete56a2nnytzix2nb2rxefdvbtwwtnnoe/metadata",
-                    unicode"🪄",
-                    ICreatorRoyaltiesControl.RoyaltyConfiguration({royaltyBPS: 0, royaltyRecipient: address(0), royaltyMintSchedule: 0}),
-                    payable(admin),
-                    initUpdate
-                )
-            );
-    }
-
-    function getUpgradeCalldata(address targetImpl) internal pure returns (bytes memory upgradeCalldata) {
-        // simulate upgrade call
-        upgradeCalldata = abi.encodeWithSelector(UUPSUpgradeable.upgradeTo.selector, targetImpl);
-    }
-
-    function simulateUpgrade(address targetProxy, address targetImpl) internal returns (bytes memory upgradeCalldata) {
-        // console log update information
-
-        upgradeCalldata = getUpgradeCalldata(targetImpl);
-
-        // upgrade the factory proxy to the new implementation
-        (bool success, ) = targetProxy.call(upgradeCalldata);
-
-        require(success, "upgrade failed");
-    }
-}

package/test/NewFactoryProxyDeployer.t.sol

@@ -1,127 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.17;
-
-import "forge-std/Test.sol";
-import {Zora1155Factory} from "@zoralabs/zora-1155-contracts/src/proxies/Zora1155Factory.sol";
-import {ZoraDeployerUtils, Create2Deployment} from "../src/ZoraDeployerUtils.sol";
-import {DeterministicProxyDeployer} from "../src/DeterministicProxyDeployer.sol";
-import {ProxyShim} from "@zoralabs/zora-1155-contracts/src/utils/ProxyShim.sol";
-import {UpgradeGate} from "@zoralabs/zora-1155-contracts/src/upgrades/UpgradeGate.sol";
-import {Deployment, ChainConfig} from "../src/DeploymentConfig.sol";
-import {IMinter1155} from "@zoralabs/zora-1155-contracts/src/interfaces/IMinter1155.sol";
-import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
-import {DeterministicDeployerScript, DeterministicParams} from "../src/DeterministicDeployerScript.sol";
-
-contract DeterministicProxyDeployerTest is DeterministicDeployerScript, Test {
-    using stdJson for string;
-
-    // the values in this test can be determined by running the script GetDeterministicParam.s.sol,
-    // and copying the output values here.
-    function _deployKnownZoraFactoryProxy(bytes32 salt) internal returns (DeterministicProxyDeployer) {
-        // create new factory deployer using ImmutableCreate2Factory
-        return DeterministicProxyDeployer(ZoraDeployerUtils.IMMUTABLE_CREATE2_FACTORY.safeCreate2(salt, type(DeterministicProxyDeployer).creationCode));
-    }
-
-    function create1155FactoryImpl() internal returns (address) {
-        address mintFeeRecipient = makeAddr("mintFeeRecipient");
-        address protocolRewards = makeAddr("protocolRewards");
-
-        (address factoryImplDeployment, , ) = ZoraDeployerUtils.deployNew1155AndFactoryImpl({
-            upgradeGateAddress: address(new UpgradeGate()),
-            mintFeeRecipient: mintFeeRecipient,
-            protocolRewards: protocolRewards,
-            merkleMinter: IMinter1155(address(0)),
-            redeemMinterFactory: IMinter1155(address(0)),
-            fixedPriceMinter: IMinter1155(address(0))
-        });
-
-        return factoryImplDeployment;
-    }
-
-    function test_proxyCanByDeployedAtDesiredAddress(bytes32 proxySalt) external {
-        vm.createSelectFork("zora_goerli", 1252119);
-        // ensure nonce is greater than current account's nonce
-
-        (address deployerAddress, uint256 deployerPrivateKey) = makeAddrAndKey("deployer");
-        bytes32 proxyDeployerSalt = ZoraDeployerUtils.FACTORY_DEPLOYER_DEPLOYMENT_SALT;
-
-        // now we can create the implementation, pointing it to the expected deterministic address:
-        bytes32 proxyShimSalt = saltWithAddressInFirst20Bytes(deployerAddress, 10);
-
-        // 1. Create implementation contracts based on deterministic factory proxy address
-
-        // create 1155 and factory impl, we can know the deterministic factor proxy address ahead of time:
-        address factoryImplAddress = create1155FactoryImpl();
-
-        // 2. Create factory deployer at deterministic address
-        DeterministicProxyDeployer factoryProxyDeployer = _deployKnownZoraFactoryProxy(proxyDeployerSalt);
-
-        bytes memory factoryProxyCreationCode = type(Zora1155Factory).creationCode;
-        address mintFeeRecipient = makeAddr("mintFeeRecipient ");
-
-        bytes32 digest = factoryProxyDeployer.hashedDigestFactoryProxy(
-            proxyShimSalt,
-            proxySalt,
-            factoryProxyCreationCode,
-            factoryImplAddress,
-            mintFeeRecipient
-        );
-
-        // sign the message
-        bytes memory signature = signAndMakeBytes(digest, deployerPrivateKey);
-
-        address expectedFactoryProxyAddress = ZoraDeployerUtils.deterministicFactoryProxyAddress(proxyShimSalt, proxySalt, address(factoryProxyDeployer));
-
-        // now do it as original deployer, it should succeed:
-        address factoryProxyAddress = factoryProxyDeployer.createFactoryProxyDeterministic(
-            proxyShimSalt,
-            proxySalt,
-            factoryProxyCreationCode,
-            expectedFactoryProxyAddress,
-            factoryImplAddress,
-            mintFeeRecipient,
-            signature
-        );
-
-        // we know this salt from a script we ran that will generated
-        // create factory proxy, using deterministic address and known salt to get proper expected address:
-        assertEq(factoryProxyAddress, expectedFactoryProxyAddress, "factory proxy address wrong");
-    }
-
-    function signAndMakeBytes(bytes32 digest, uint256 privateKey) internal pure returns (bytes memory) {
-        (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, digest);
-
-        // combine into a single bytes array
-        return abi.encodePacked(r, s, v);
-    }
-
-    function test_genericContractCanByDeployedAtDesiredAddress(uint32 nonce) external {
-        vm.createSelectFork("zora_goerli", 1252119);
-
-        (address deployerAddress, uint256 deployerPrivateKey) = makeAddrAndKey("deployer");
-
-        vm.assume(nonce > vm.getNonce(deployerAddress));
-        // we set the nonce to a random value, to prove this doesn't affect the deterministic addrss
-        vm.setNonce(deployerAddress, nonce);
-
-        DeterministicProxyDeployer factoryProxyDeployer = _deployKnownZoraFactoryProxy(bytes32(0));
-
-        address gateAdmin = makeAddr("gateAdmin");
-
-        bytes memory upgradeGateDeployCode = type(UpgradeGate).creationCode;
-
-        bytes memory initCall = abi.encodeWithSignature("initialize(address)", gateAdmin);
-
-        bytes32 genericTestDeploySalt = saltWithAddressInFirst20Bytes(deployerAddress, 20);
-
-        bytes32 digest = factoryProxyDeployer.hashedDigestGenericCreation(genericTestDeploySalt, upgradeGateDeployCode, initCall);
-
-        // sign the message
-        (uint8 v, bytes32 r, bytes32 s) = vm.sign(deployerPrivateKey, digest);
-
-        // combine into a single bytes array
-        bytes memory signature = abi.encodePacked(r, s, v);
-
-        factoryProxyDeployer.createAndInitGenericContractDeterministic(genericTestDeploySalt, upgradeGateDeployCode, initCall, signature);
-    }
-}

package/test/UpgradesTest.t.sol

@@ -1,222 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.17;
-
-import "forge-std/Test.sol";
-import {ZoraCreator1155FactoryImpl} from "@zoralabs/zora-1155-contracts/src/factory/ZoraCreator1155FactoryImpl.sol";
-import {ZoraCreator1155PremintExecutorImpl} from "@zoralabs/zora-1155-contracts/src/delegation/ZoraCreator1155PremintExecutorImpl.sol";
-import {ForkDeploymentConfig, Deployment, ChainConfig} from "../src/DeploymentConfig.sol";
-import {ZoraDeployerUtils} from "../src/ZoraDeployerUtils.sol";
-import {DeploymentTestingUtils} from "../src/DeploymentTestingUtils.sol";
-import {IZoraCreator1155PremintExecutor} from "@zoralabs/zora-1155-contracts/src/interfaces/IZoraCreator1155PremintExecutor.sol";
-
-contract UpgradesTest is ForkDeploymentConfig, DeploymentTestingUtils, Test {
-    /// @notice gets the chains to do fork tests on, by reading environment var FORK_TEST_CHAINS.
-    /// Chains are by name, and must match whats under `rpc_endpoints` in the foundry.toml
-    function getForkTestChains() private view returns (string[] memory result) {
-        try vm.envString("FORK_TEST_CHAINS", ",") returns (string[] memory forkTestChains) {
-            result = forkTestChains;
-        } catch {
-            console.log("could not get fork test chains - make sure the environment variable FORK_TEST_CHAINS is set");
-            result = new string[](0);
-        }
-    }
-
-    function determine1155Upgrade(Deployment memory deployment) private view returns (bool upgradeNeeded, address targetProxy, address targetImpl) {
-        targetProxy = deployment.factoryProxy;
-        targetImpl = deployment.factoryImpl;
-        address currentImplementation = ZoraCreator1155FactoryImpl(targetProxy).implementation();
-
-        upgradeNeeded = targetImpl != currentImplementation;
-    }
-
-    function determinePreminterUpgrade(Deployment memory deployment) private returns (bool upgradeNeeded, address targetProxy, address targetImpl) {
-        targetProxy = deployment.preminterProxy;
-        targetImpl = deployment.preminterImpl;
-
-        // right now we cannot call "implementation" on contract since it doesn't exist yet, so we check if deployed impl meets the v1 impl we know
-        address preminterV1ImplAddress = 0x6E2AbBcd82935bFC68A1d5d2c96372b13b65eD9C;
-
-        // if the target impl is still the v1 impl, it didnt have a method to check impl so we can't call it, also we know its still v1 impl so we don't need to upgrade
-        if (targetImpl == preminterV1ImplAddress) {
-            upgradeNeeded = false;
-        } else {
-            // if doesnt have implementation method, then we know upgrade is needed
-            (bool success, bytes memory data) = deployment.preminterProxy.call(abi.encodePacked(ZoraCreator1155PremintExecutorImpl.implementation.selector));
-
-            if (!success) {
-                upgradeNeeded = true;
-            } else {
-                address currentImplementation = abi.decode(data, (address));
-                upgradeNeeded = currentImplementation != targetImpl;
-            }
-        }
-    }
-
-    function _buildSafeUrl(address safe, address target, bytes memory cd) internal view returns (string memory) {
-        address[] memory targets = new address[](1);
-        targets[0] = target;
-
-        bytes[] memory calldatas = new bytes[](1);
-        calldatas[0] = cd;
-
-        return _buildBatchSafeUrl(safe, targets, calldatas);
-    }
-
-    // pipe delimiter is url encoded | which is %7C
-    string constant PIPE_DELIMITER = "%7C";
-
-    function _buildBatchSafeUrl(address safe, address[] memory targets, bytes[] memory cd) internal view returns (string memory) {
-        string memory targetsString = "";
-
-        for (uint256 i = 0; i < targets.length; i++) {
-            targetsString = string.concat(targetsString, vm.toString(targets[i]));
-
-            if (i < targets.length - 1) {
-                targetsString = string.concat(targetsString, PIPE_DELIMITER);
-            }
-        }
-
-        string memory calldataString = "";
-
-        for (uint256 i = 0; i < cd.length; i++) {
-            calldataString = string.concat(calldataString, vm.toString(cd[i]));
-
-            if (i < cd.length - 1) {
-                calldataString = string.concat(calldataString, PIPE_DELIMITER);
-            }
-        }
-
-        string memory valuesString = "";
-
-        for (uint256 i = 0; i < cd.length; i++) {
-            valuesString = string.concat(valuesString, "0");
-
-            if (i < cd.length - 1) {
-                valuesString = string.concat(valuesString, PIPE_DELIMITER);
-            }
-        }
-
-        // sample url: https://ourzora.github.io/smol-safe/${chainId}/${safeAddress}&target={pipeDelimitedTargets}&calldata={pipeDelimitedCalldata}&value={pipeDelimitedValues}
-        string memory targetUrl = "https://ourzora.github.io/smol-safe/#safe/";
-        targetUrl = string.concat(targetUrl, vm.toString(block.chainid));
-        targetUrl = string.concat(targetUrl, "/");
-        targetUrl = string.concat(targetUrl, vm.toString(safe));
-        targetUrl = string.concat(targetUrl, "/new");
-        targetUrl = string.concat(targetUrl, "?");
-        targetUrl = string.concat(targetUrl, "targets=");
-        targetUrl = string.concat(targetUrl, targetsString);
-        targetUrl = string.concat(targetUrl, "&calldatas=");
-        targetUrl = string.concat(targetUrl, calldataString);
-        targetUrl = string.concat(targetUrl, "&values=");
-        targetUrl = string.concat(targetUrl, valuesString);
-
-        return targetUrl;
-    }
-
-    /// @notice checks which chains need an upgrade, simulated the upgrade, and gets the upgrade calldata
-    function simulateUpgradeOnFork(string memory chainName) private {
-        // create and select the fork, which will be used for all subsequent calls
-        vm.createSelectFork(vm.rpcUrl(chainName));
-
-        Deployment memory deployment = getDeployment();
-
-        ChainConfig memory chainConfig = getChainConfig();
-
-        address creator = makeAddr("creator");
-
-        (bool is1155UpgradeNeeded, address targetProxy1155, address targetImpl1155) = determine1155Upgrade(deployment);
-        (bool preminterUpgradeNeeded, address targetPreminterProxy, address targetPremintImpl) = determinePreminterUpgrade(deployment);
-
-        if (!is1155UpgradeNeeded && !preminterUpgradeNeeded) {
-            return;
-        }
-
-        console2.log("====== upgrade needed ======");
-        console2.log("chain:", chainName);
-        console2.log("upgrade owner:", chainConfig.factoryOwner);
-
-        bytes memory factory1155UpgradeCalldata;
-
-        if (is1155UpgradeNeeded) {
-            console2.log("-- 1155 upgrade needed --");
-            vm.prank(chainConfig.factoryOwner);
-            factory1155UpgradeCalldata = ZoraDeployerUtils.simulateUpgrade(targetProxy1155, targetImpl1155);
-            vm.prank(creator);
-            ZoraDeployerUtils.deployTestContractForVerification(targetProxy1155, creator);
-
-            console2.log("1155 upgrade target:", targetProxy1155);
-            console2.log("upgrade calldata:");
-            console.logBytes(factory1155UpgradeCalldata);
-            {
-                console2.log("upgrade to address:", targetImpl1155);
-                console2.log("upgrade to version:", ZoraCreator1155FactoryImpl(targetImpl1155).contractVersion());
-                if (!preminterUpgradeNeeded) {
-                    console2.log("smol safe upgrade url: ", _buildSafeUrl(chainConfig.factoryOwner, targetProxy1155, factory1155UpgradeCalldata));
-                }
-                console2.log("------------------------");
-            }
-        }
-
-        address factoryOwner = chainConfig.factoryOwner;
-        bytes memory preminterUpgradeCalldata;
-
-        // hack - for now, only check on zora sepolia or goerli
-        if (preminterUpgradeNeeded) {
-            console2.log("-- preminter upgrade needed --");
-            console2.log("preminter upgrade target:", targetPreminterProxy);
-            vm.prank(factoryOwner);
-            preminterUpgradeCalldata = ZoraDeployerUtils.simulateUpgrade(deployment.preminterProxy, deployment.preminterImpl);
-
-            address collector = makeAddr("collector");
-            address mintReferral = makeAddr("referral");
-            vm.deal(collector, 10 ether);
-
-            address[] memory mintRewardsRecipients = new address[](1);
-            mintRewardsRecipients[0] = mintReferral;
-
-            IZoraCreator1155PremintExecutor.MintArguments memory mintArguments = IZoraCreator1155PremintExecutor.MintArguments({
-                mintRecipient: collector,
-                mintComment: "",
-                mintRewardsRecipients: mintRewardsRecipients
-            });
-
-            vm.startPrank(collector);
-            signAndExecutePremintV1(targetPreminterProxy, makeAddr("payoutRecipientA"), mintArguments);
-            signAndExecutePremintV2(targetPreminterProxy, makeAddr("payoutRecipientB"), mintArguments);
-
-            vm.stopPrank();
-
-            {
-                console2.log("upgrade calldata:");
-                console.logBytes(preminterUpgradeCalldata);
-                console2.log("upgrade to address:", targetPremintImpl);
-                if (!is1155UpgradeNeeded) {
-                    console2.log("smol safe upgrade url: ", _buildSafeUrl(factoryOwner, targetPreminterProxy, preminterUpgradeCalldata));
-                }
-                console2.log("------------------------");
-            }
-        }
-
-        // if both needed:
-        if (is1155UpgradeNeeded && preminterUpgradeNeeded) {
-            address[] memory targets = new address[](2);
-            targets[0] = targetProxy1155;
-            targets[1] = targetPreminterProxy;
-
-            bytes[] memory calldatas = new bytes[](2);
-            calldatas[0] = factory1155UpgradeCalldata;
-            calldatas[1] = preminterUpgradeCalldata;
-
-            console2.log("multi-upgrade smol safe upgrade url: ", _buildBatchSafeUrl(factoryOwner, targets, calldatas));
-        }
-
-        console2.log("=================\n");
-    }
-
-    function test_fork_simulateUpgrades() external {
-        string[] memory forkTestChains = getForkTestChains();
-        for (uint256 i = 0; i < forkTestChains.length; i++) {
-            simulateUpgradeOnFork(forkTestChains[i]);
-        }
-    }
-}