@zoralabs/protocol-deployments 0.0.12 → 0.0.14-MINT.0

package/src/Zora1155PremintFixtures.sol

@@ -1,75 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.17;
-
-import {ZoraCreator1155Impl} from "@zoralabs/zora-1155-contracts/src/nft/ZoraCreator1155Impl.sol";
-import {ZoraCreatorFixedPriceSaleStrategy} from "@zoralabs/zora-1155-contracts/src/minters/fixed-price/ZoraCreatorFixedPriceSaleStrategy.sol";
-import {IZoraCreator1155Errors} from "@zoralabs/zora-1155-contracts/src/interfaces/IZoraCreator1155Errors.sol";
-import {IMinter1155} from "@zoralabs/zora-1155-contracts/src/interfaces/IMinter1155.sol";
-import {Zora1155Factory} from "@zoralabs/zora-1155-contracts/src/proxies/Zora1155Factory.sol";
-import {ZoraCreator1155FactoryImpl} from "@zoralabs/zora-1155-contracts/src/factory/ZoraCreator1155FactoryImpl.sol";
-import {ProtocolRewards} from "@zoralabs/protocol-rewards/src/ProtocolRewards.sol";
-import {ProxyShim} from "@zoralabs/zora-1155-contracts/src/utils/ProxyShim.sol";
-import {PremintConfig, PremintConfigV2, ContractCreationConfig, TokenCreationConfigV2, TokenCreationConfig} from "@zoralabs/zora-1155-contracts/src/delegation/ZoraCreator1155Attribution.sol";
-
-library Zora1155PremintFixtures {
-    function makeDefaultContractCreationConfig(address contractAdmin) internal pure returns (ContractCreationConfig memory) {
-        return ContractCreationConfig({contractAdmin: contractAdmin, contractName: "blah_______blah", contractURI: "blah.contract"});
-    }
-
-    function makeTokenCreationConfigV2WithCreateReferral(
-        IMinter1155 fixedPriceMinter,
-        address payoutRecipient,
-        address createReferral
-    ) internal pure returns (TokenCreationConfigV2 memory) {
-        return
-            TokenCreationConfigV2({
-                tokenURI: "blah.token",
-                maxSupply: 10,
-                maxTokensPerAddress: 5,
-                pricePerToken: 0,
-                mintStart: 0,
-                mintDuration: 0,
-                fixedPriceMinter: address(fixedPriceMinter),
-                payoutRecipient: payoutRecipient,
-                royaltyBPS: 10,
-                createReferral: createReferral
-            });
-    }
-
-    function makeDefaultV2PremintConfig(
-        IMinter1155 fixedPriceMinter,
-        address payoutRecipient,
-        address createReferral
-    ) internal pure returns (PremintConfigV2 memory) {
-        // make a v2 premint config
-        return
-            PremintConfigV2({
-                tokenConfig: makeTokenCreationConfigV2WithCreateReferral(fixedPriceMinter, payoutRecipient, createReferral),
-                uid: 100,
-                version: 0,
-                deleted: false
-            });
-    }
-
-    function makeDefaultV1PremintConfig(IMinter1155 fixedPriceMinter, address royaltyRecipient) internal pure returns (PremintConfig memory) {
-        // make a v1 premint config
-        return
-            PremintConfig({
-                tokenConfig: TokenCreationConfig({
-                    tokenURI: "blah.token",
-                    maxSupply: 10,
-                    maxTokensPerAddress: 5,
-                    pricePerToken: 0,
-                    mintStart: 0,
-                    mintDuration: 0,
-                    fixedPriceMinter: address(fixedPriceMinter),
-                    royaltyRecipient: royaltyRecipient,
-                    royaltyBPS: 10,
-                    royaltyMintSchedule: 0
-                }),
-                uid: 100,
-                version: 0,
-                deleted: false
-            });
-    }
-}

package/src/ZoraDeployerBase.sol

@@ -1,144 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.13;
-
-import "forge-std/Script.sol";
-import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
-
-import {IZoraCreator1155Factory} from "@zoralabs/zora-1155-contracts/src/interfaces/IZoraCreator1155Factory.sol";
-import {ZoraCreator1155Impl} from "@zoralabs/zora-1155-contracts/src/nft/ZoraCreator1155Impl.sol";
-import {Zora1155Factory} from "@zoralabs/zora-1155-contracts/src/proxies/Zora1155Factory.sol";
-import {ICreatorRoyaltiesControl} from "@zoralabs/zora-1155-contracts/src/interfaces/ICreatorRoyaltiesControl.sol";
-import {ScriptDeploymentConfig, Deployment, ChainConfig} from "./DeploymentConfig.sol";
-import {ZoraDeployerUtils} from "./ZoraDeployerUtils.sol";
-import {IMinter1155} from "@zoralabs/zora-1155-contracts/src/interfaces/IMinter1155.sol";
-import {DeterministicDeployerScript} from "./DeterministicDeployerScript.sol";
-import {ZoraCreator1155FactoryImpl} from "@zoralabs/zora-1155-contracts/src/factory/ZoraCreator1155FactoryImpl.sol";
-import {DeploymentTestingUtils} from "./DeploymentTestingUtils.sol";
-
-/// @notice Deployment drops for base where
-abstract contract ZoraDeployerBase is DeploymentTestingUtils, ScriptDeploymentConfig, DeterministicDeployerScript {
-    using stdJson for string;
-
-    /// @notice File used for demo metadata on verification test mint
-    string constant DEMO_IPFS_METADATA_FILE = "ipfs://bafkreigu544g6wjvqcysurpzy5pcskbt45a5f33m6wgythpgb3rfqi3lzi";
-
-    /// @notice Get deployment configuration struct as JSON
-    /// @param deployment deployment struct
-    /// @return deploymentJson string JSON of the deployment info
-    function getDeploymentJSON(Deployment memory deployment) internal returns (string memory deploymentJson) {
-        string memory deploymentJsonKey = "deployment_json_file_key";
-        vm.serializeAddress(deploymentJsonKey, FIXED_PRICE_SALE_STRATEGY, deployment.fixedPriceSaleStrategy);
-        vm.serializeAddress(deploymentJsonKey, MERKLE_MINT_SALE_STRATEGY, deployment.merkleMintSaleStrategy);
-        vm.serializeAddress(deploymentJsonKey, REDEEM_MINTER_FACTORY, deployment.redeemMinterFactory);
-        vm.serializeString(deploymentJsonKey, CONTRACT_1155_IMPL_VERSION, deployment.contract1155ImplVersion);
-        vm.serializeAddress(deploymentJsonKey, CONTRACT_1155_IMPL, deployment.contract1155Impl);
-        vm.serializeAddress(deploymentJsonKey, FACTORY_IMPL, deployment.factoryImpl);
-        vm.serializeAddress(deploymentJsonKey, PREMINTER_PROXY, deployment.preminterProxy);
-        vm.serializeAddress(deploymentJsonKey, PREMINTER_IMPL, deployment.preminterImpl);
-        vm.serializeAddress(deploymentJsonKey, UPGRADE_GATE, deployment.upgradeGate);
-        deploymentJson = vm.serializeAddress(deploymentJsonKey, FACTORY_PROXY, deployment.factoryProxy);
-    }
-
-    function deployMinters(Deployment memory deployment) internal {
-        (address fixedPriceMinter, address merkleMinter, address redeemMinterFactory) = ZoraDeployerUtils.deployMinters();
-        deployment.fixedPriceSaleStrategy = address(fixedPriceMinter);
-        deployment.merkleMintSaleStrategy = address(merkleMinter);
-        deployment.redeemMinterFactory = address(redeemMinterFactory);
-    }
-
-    function deployNew1155AndFactoryImpl(Deployment memory deployment) internal {
-        ChainConfig memory chainConfig = getChainConfig();
-
-        ensureCanOwn(chainConfig.factoryOwner);
-
-        (address factoryImplDeployment, address contract1155ImplDeployment, string memory contract1155ImplVersion) = ZoraDeployerUtils
-            .deployNew1155AndFactoryImpl({
-                upgradeGateAddress: determinsticUpgradeGateAddress(),
-                mintFeeRecipient: chainConfig.mintFeeRecipient,
-                protocolRewards: chainConfig.protocolRewards,
-                merkleMinter: IMinter1155(deployment.merkleMintSaleStrategy),
-                redeemMinterFactory: IMinter1155(deployment.redeemMinterFactory),
-                fixedPriceMinter: IMinter1155(deployment.fixedPriceSaleStrategy)
-            });
-
-        deployment.factoryImpl = factoryImplDeployment;
-        deployment.contract1155Impl = contract1155ImplDeployment;
-        deployment.contract1155ImplVersion = contract1155ImplVersion;
-    }
-
-    function deployNewPreminterImplementationDeterminstic(Deployment memory deployment) internal {
-        address factoryProxyAddress = determinticFactoryProxyAddress();
-        deployment.preminterImpl = ZoraDeployerUtils.deployNewPreminterImplementationDeterminstic(factoryProxyAddress);
-    }
-
-    function determinticFactoryProxyAddress() internal view returns (address) {
-        return readFactoryProxyDeterminsticParams().deterministicProxyAddress;
-    }
-
-    function determinsticPreminterProxyAddress() internal view returns (address) {
-        return readPreminterProxyDeterminsticParams().deterministicProxyAddress;
-    }
-
-    function deployFactoryProxyDeterminstic(Deployment memory deployment) internal {
-        ChainConfig memory chainConfig = getChainConfig();
-
-        ensureCanOwn(chainConfig.factoryOwner);
-
-        address factoryProxyAddress = deployDeterministicProxy({
-            proxyName: "factoryProxy",
-            implementation: deployment.factoryImpl,
-            owner: chainConfig.factoryOwner,
-            chain: chainId()
-        });
-
-        require(factoryProxyAddress == determinticFactoryProxyAddress(), "address not expected deterministic address");
-
-        require(
-            keccak256(abi.encodePacked(ZoraCreator1155FactoryImpl(factoryProxyAddress).contractName())) ==
-                keccak256(abi.encodePacked("ZORA 1155 Contract Factory"))
-        );
-
-        deployment.factoryProxy = factoryProxyAddress;
-    }
-
-    function deployPreminterProxyDeterminstic(Deployment memory deployment) internal {
-        ChainConfig memory chainConfig = getChainConfig();
-
-        ensureCanOwn(chainConfig.factoryOwner);
-
-        address preminterProxyAddress = deployDeterministicProxy({
-            proxyName: "premintExecutorProxy",
-            implementation: deployment.preminterImpl,
-            owner: chainConfig.factoryOwner,
-            chain: chainId()
-        });
-
-        require(preminterProxyAddress == determinsticPreminterProxyAddress(), "address not expected deterministic address");
-
-        deployment.preminterProxy = preminterProxyAddress;
-    }
-
-    function deployUpgradeGateDeterminstic(Deployment memory deployment) internal {
-        ChainConfig memory chainConfig = getChainConfig();
-
-        ensureCanOwn(chainConfig.factoryOwner);
-
-        address upgradeGateAddress = deployUpgradeGate({chain: chainId(), upgradeGateOwner: chainConfig.factoryOwner});
-
-        require(upgradeGateAddress == determinsticUpgradeGateAddress(), "address not expected deterministic address");
-
-        deployment.upgradeGate = upgradeGateAddress;
-    }
-
-    function ensureCanOwn(address account) internal view {
-        // Sanity check to make sure that the factory owner is a smart contract.
-        // This may catch cross-chain data copy mistakes where there is no safe at the desired admin address.
-        if (account.code.length == 0) {
-            revert("FactoryOwner should be a contract. See DeployNewProxies:31.");
-        }
-    }
-
-    function determinsticUpgradeGateAddress() internal view returns (address) {
-        return vm.parseJsonAddress(vm.readFile("./deterministicConfig/upgradeGate/params.json"), ".upgradeGateAddress");
-    }
-}

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);
-    }
-}