@zoralabs/protocol-deployments 0.0.11 → 0.0.13

package/src/DeterministicDeployerScript.sol

@@ -1,249 +0,0 @@
-// spdx-license-identifier: mit
-pragma solidity ^0.8.17;
-
-import "forge-std/Script.sol";
-import {Deployment, ChainConfig} from "./DeploymentConfig.sol";
-import {ProxyShim} from "@zoralabs/zora-1155-contracts/src/utils/ProxyShim.sol";
-import {DeterministicProxyDeployer} from "./DeterministicProxyDeployer.sol";
-import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
-import {UpgradeGate} from "@zoralabs/zora-1155-contracts/src/upgrades/UpgradeGate.sol";
-import {LibString} from "solady/utils/LibString.sol";
-import {ZoraDeployerUtils} from "./ZoraDeployerUtils.sol";
-
-struct DeterministicParams {
-    bytes proxyDeployerCreationCode;
-    bytes proxyCreationCode;
-    address deployerAddress;
-    address proxyDeployerAddress;
-    bytes32 proxyDeployerSalt;
-    bytes32 proxyShimSalt;
-    bytes32 proxySalt;
-    address deterministicProxyAddress;
-}
-
-contract DeterministicDeployerScript is Script {
-    using stdJson for string;
-
-    // copied from: https://github.com/karmacoma-eth/foundry-playground/blob/main/script/MineSaltScript.sol#L17C1-L36C9
-    function mineSalt(address deployer, bytes32 initCodeHash, string memory startsWith) internal returns (bytes32 salt, address expectedAddress) {
-        string[] memory args = new string[](8);
-        args[0] = "cast";
-        args[1] = "create2";
-        args[2] = "--starts-with";
-        args[3] = startsWith;
-        args[4] = "--deployer";
-        args[5] = LibString.toHexString(deployer);
-        args[6] = "--init-code-hash";
-        args[7] = LibString.toHexStringNoPrefix(uint256(initCodeHash), 32);
-        string memory result = string(vm.ffi(args));
-
-        uint256 addressIndex = LibString.indexOf(result, "Address: ");
-        string memory addressStr = LibString.slice(result, addressIndex + 9, addressIndex + 9 + 42);
-        expectedAddress = vm.parseAddress(addressStr);
-
-        uint256 saltIndex = LibString.indexOf(result, "Salt: ");
-        string memory saltStr = LibString.slice(result, saltIndex + 6, bytes(result).length);
-
-        salt = bytes32(vm.parseUint(saltStr));
-    }
-
-    function saltWithAddressInFirst20Bytes(address addressToMakeSaltWith, uint256 suffix) internal pure returns (bytes32) {
-        uint256 shifted = uint256(uint160(address(addressToMakeSaltWith))) << 96;
-
-        // shifted on the left, suffix on the right:
-
-        return bytes32(shifted | suffix);
-    }
-
-    function paramsFilePath(string memory proxyName) internal pure returns (string memory) {
-        return string.concat("deterministicConfig/", proxyName, "/params.json");
-    }
-
-    function signaturesFilePath(string memory proxyName) internal pure returns (string memory) {
-        return string.concat("deterministicConfig/", proxyName, "/signatures.json");
-    }
-
-    function serializeAndSaveOutput(DeterministicParams memory params, string memory proxyName) internal {
-        string memory result = "deterministicKey";
-
-        vm.serializeBytes(result, "proxyDeployerCreationCode", params.proxyDeployerCreationCode);
-        vm.serializeBytes(result, "proxyCreationCode", params.proxyCreationCode);
-        vm.serializeAddress(result, "deployerAddress", params.deployerAddress);
-        vm.serializeAddress(result, "proxyDeployerAddress", params.proxyDeployerAddress);
-        vm.serializeBytes32(result, "proxyDeployerSalt", params.proxyDeployerSalt);
-        vm.serializeBytes32(result, "proxyShimSalt", params.proxyShimSalt);
-        vm.serializeBytes32(result, "proxySalt", params.proxySalt);
-
-        string memory finalOutput = vm.serializeAddress(result, "deterministicProxyAddress", params.deterministicProxyAddress);
-
-        console2.log(finalOutput);
-
-        vm.writeJson(finalOutput, paramsFilePath(proxyName));
-    }
-
-    function readDeterministicParams(string memory proxyName) internal view returns (DeterministicParams memory params) {
-        string memory deployConfig = vm.readFile(paramsFilePath(proxyName));
-
-        return
-            DeterministicParams({
-                proxyDeployerCreationCode: deployConfig.readBytes(".proxyDeployerCreationCode"),
-                proxyCreationCode: deployConfig.readBytes(".proxyCreationCode"),
-                deployerAddress: deployConfig.readAddress(".deployerAddress"),
-                proxyDeployerAddress: deployConfig.readAddress(".proxyDeployerAddress"),
-                proxyDeployerSalt: deployConfig.readBytes32(".proxyDeployerSalt"),
-                proxyShimSalt: deployConfig.readBytes32(".proxyShimSalt"),
-                proxySalt: deployConfig.readBytes32(".proxySalt"),
-                deterministicProxyAddress: deployConfig.readAddress(".deterministicProxyAddress")
-            });
-    }
-
-    function readDeterministicParamsAndSig(
-        string memory proxyName,
-        uint256 chain
-    ) internal view returns (DeterministicParams memory params, bytes memory signature) {
-        string memory signatures = vm.readFile(signaturesFilePath(proxyName));
-
-        params = readDeterministicParams(proxyName);
-
-        signature = signatures.readBytes(string.concat(".", string.concat(vm.toString(chain))));
-    }
-
-    function getProxyDeployerParams() internal view returns (bytes32 proxyDeployerSalt, bytes memory proxyDeployerCreationCode, address proxyDeployerAddress) {
-        proxyDeployerSalt = ZoraDeployerUtils.FACTORY_DEPLOYER_DEPLOYMENT_SALT;
-
-        proxyDeployerCreationCode = type(DeterministicProxyDeployer).creationCode;
-
-        // 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
-        proxyDeployerAddress = ZoraDeployerUtils.IMMUTABLE_CREATE2_FACTORY.findCreate2Address(proxyDeployerSalt, proxyDeployerCreationCode);
-    }
-
-    function getProxyShimParams(
-        address proxyDeployerAddress,
-        address deployerAddress,
-        uint256 proxyShimSaltSuffix
-    ) internal pure returns (bytes memory proxyShimInitCode, bytes32 proxyShimSalt, address proxyShimAddress) {
-        proxyShimInitCode = abi.encodePacked(type(ProxyShim).creationCode, abi.encode(proxyDeployerAddress));
-
-        // create any arbitrary salt for proxy shim (this can be anything, we just care about the resulting address)
-        proxyShimSalt = saltWithAddressInFirst20Bytes(deployerAddress, proxyShimSaltSuffix);
-
-        // now get deterministic proxy shim address based on salt, deployer address, which will be DeterministicProxyDeployer address and init code
-        proxyShimAddress = Create2.computeAddress(proxyShimSalt, keccak256(proxyShimInitCode), proxyDeployerAddress);
-    }
-
-    function getProxyParams(
-        bytes memory proxyCreationCode,
-        address proxyShimAddress,
-        address proxyDeployerAddress
-    ) internal returns (bytes32 proxySalt, address deterministicProxyAddress) {
-        bytes memory factoryProxyInitCode = abi.encodePacked(proxyCreationCode, abi.encode(proxyShimAddress, ""));
-        bytes32 creationCodeHash = keccak256(factoryProxyInitCode);
-
-        (proxySalt, deterministicProxyAddress) = mineSalt(proxyDeployerAddress, creationCodeHash, "777777");
-    }
-
-    function getDeterministicDeploymentParams(
-        address deployerAddress,
-        bytes memory proxyCreationCode,
-        uint256 proxyShimSaltSuffix
-    ) internal returns (DeterministicParams memory) {
-        // 1. Get salt with first bytes that match address, and resulting determinisitic factory proxy deployer address
-        (bytes32 proxyDeployerSalt, bytes memory proxyDeployerCreationCode, address proxyDeployerAddress) = getProxyDeployerParams();
-        // replace first 20 characters of salt with deployer address, so that the salt can be used with
-        // ImmutableCreate2Factory.safeCreate2 when called by this deployer's account:
-
-        // 2. Get random proxy shim salt, and resulting deterministic address
-        // Proxy shim will be initialized with the factory deployer address as the owner, allowing only the factory deployer to upgrade the proxy,
-        // to the eventual factory implementation
-        (, bytes32 proxyShimSalt, address proxyShimAddress) = getProxyShimParams({
-            proxyDeployerAddress: proxyDeployerAddress,
-            deployerAddress: deployerAddress,
-            proxyShimSaltSuffix: proxyShimSaltSuffix
-        });
-
-        // 3. Mine for a salt that can be used to deterministically create the factory proxy, given the proxy shim address, which is passed as the
-        // constructor argument, and the deployer, which is the new factory proxy deployer, which we know the address of deterministically
-        (bytes32 proxySalt, address deterministicProxyAddress) = getProxyParams({
-            proxyCreationCode: proxyCreationCode,
-            proxyShimAddress: proxyShimAddress,
-            proxyDeployerAddress: proxyDeployerAddress
-        });
-
-        return
-            DeterministicParams({
-                proxyDeployerCreationCode: proxyDeployerCreationCode,
-                proxyCreationCode: proxyCreationCode,
-                deployerAddress: deployerAddress,
-                proxyDeployerAddress: proxyDeployerAddress,
-                proxyDeployerSalt: proxyDeployerSalt,
-                proxyShimSalt: proxyShimSalt,
-                proxySalt: proxySalt,
-                deterministicProxyAddress: deterministicProxyAddress
-            });
-    }
-
-    error MismatchedAddress(address expected, address actual);
-
-    function readFactoryProxyDeterminsticParams() internal view returns (DeterministicParams memory) {
-        return readDeterministicParams("factoryProxy");
-    }
-
-    function readPreminterProxyDeterminsticParams() internal view returns (DeterministicParams memory) {
-        return readDeterministicParams("premintExecutorProxy");
-    }
-
-    function getOrCreateProxyDeployer() internal returns (DeterministicProxyDeployer factoryDeployer) {
-        DeterministicParams memory params = readFactoryProxyDeterminsticParams();
-        address proxyDeployerAddress = params.proxyDeployerAddress;
-        bytes32 proxyDeployerSalt = params.proxyDeployerSalt;
-        bytes memory proxyDeployerCreationCode = params.proxyDeployerCreationCode;
-
-        ZoraDeployerUtils.getOrImmutable2Create(proxyDeployerAddress, proxyDeployerSalt, proxyDeployerCreationCode);
-
-        factoryDeployer = DeterministicProxyDeployer(proxyDeployerAddress);
-    }
-
-    function deployDeterministicProxy(string memory proxyName, address implementation, address owner, uint256 chain) internal returns (address) {
-        (DeterministicParams memory params, bytes memory signature) = readDeterministicParamsAndSig(proxyName, chain);
-
-        DeterministicProxyDeployer factoryDeployer = getOrCreateProxyDeployer();
-
-        address resultAddress = factoryDeployer.createFactoryProxyDeterministic(
-            params.proxyShimSalt,
-            params.proxySalt,
-            params.proxyCreationCode,
-            params.deterministicProxyAddress,
-            implementation,
-            owner,
-            signature
-        );
-
-        require(resultAddress == params.deterministicProxyAddress, "DeterministicDeployerScript: proxy address mismatch");
-
-        return resultAddress;
-    }
-
-    function deployUpgradeGate(uint256 chain, address upgradeGateOwner) internal returns (address) {
-        string memory signatures = vm.readFile(signaturesFilePath("upgradeGate"));
-        bytes memory signature = signatures.readBytes(string.concat(".", string.concat(vm.toString(chain))));
-
-        string memory upgradeGateParams = vm.readFile("./deterministicConfig/upgradeGate/params.json");
-
-        bytes32 genericCreationSalt = vm.parseJsonBytes32(upgradeGateParams, ".salt");
-        bytes memory creationCode = vm.parseJsonBytes(upgradeGateParams, ".creationCode");
-
-        DeterministicProxyDeployer factoryDeployer = getOrCreateProxyDeployer();
-
-        address resultAddress = factoryDeployer.createAndInitGenericContractDeterministic({
-            genericCreationSalt: genericCreationSalt,
-            creationCode: creationCode,
-            initCall: abi.encodeWithSelector(UpgradeGate.initialize.selector, upgradeGateOwner),
-            signature: signature
-        });
-
-        require(resultAddress == vm.parseJsonAddress(upgradeGateParams, ".upgradeGateAddress"), "DeterministicDeployerScript: upgrade gate address mismatch");
-
-        return resultAddress;
-    }
-}

package/src/DeterministicProxyDeployer.sol

@@ -1,139 +0,0 @@
-// spdx-license-identifier: mit
-pragma solidity ^0.8.17;
-
-import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
-import {ProxyShim} from "@zoralabs/zora-1155-contracts/src/utils/ProxyShim.sol";
-import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
-import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
-
-interface IUpgradeableProxy {
-    function upgradeTo(address newImplementation) external;
-
-    function initialize(address newOwner) external;
-}
-
-/// @notice Deterministic proxy deployer for deploying zora 1155 contract suite
-/// @dev Supports both generic contracts and the UUPS shim proxy pattern used for ZORA 1155
-/// @dev Requires approved signatures depending on the salt hashes (pattern from IMMUTABLE_CREATE2_FACTORY)
-contract DeterministicProxyDeployer is EIP712 {
-    error FactoryProxyAddressMismatch(address expected, address actual);
-    error FailedToInitGenericDeployedContract();
-
-    constructor() EIP712("DeterministicProxyDeployer", "1") {}
-
-    /// Creates a new factory proxy at a Deterministic address, with this address as the owner
-    /// Upgrades the proxy to the factory implementation, and sets the new owner as the owner.
-    /// @param proxyShimSalt Salt for deterministic proxy shim address
-    /// @param factoryProxySalt Salt for deterministic factory proxy address
-    function _createAndInitializeNewFactoryProxyDeterministic(
-        bytes32 proxyShimSalt,
-        bytes32 factoryProxySalt,
-        bytes calldata proxyCreationCode,
-        address expectedFactoryProxyAddress,
-        address implementationAddress,
-        address newOwner
-    ) internal returns (address factoryProxyAddress) {
-        // create proxy shim and factory proxy deterministically
-        ProxyShim proxyShim = new ProxyShim{salt: proxyShimSalt}({_canUpgrade: address(this)});
-
-        bytes memory creationCode = abi.encodePacked(proxyCreationCode, abi.encode(address(proxyShim), ""));
-
-        address factoryProxy = Create2.deploy(0, factoryProxySalt, creationCode);
-
-        if (factoryProxy != expectedFactoryProxyAddress) {
-            revert FactoryProxyAddressMismatch(expectedFactoryProxyAddress, address(factoryProxy));
-        }
-
-        factoryProxyAddress = address(factoryProxy);
-        IUpgradeableProxy proxy = IUpgradeableProxy(address(factoryProxy));
-        proxy.upgradeTo(implementationAddress);
-        proxy.initialize(newOwner);
-
-        return factoryProxyAddress;
-    }
-
-    function _createAndInitGenericContractDeterministic(
-        bytes32 genericCreationSalt,
-        bytes calldata creationCode,
-        bytes calldata initCall
-    ) internal returns (address resultAddress) {
-        resultAddress = Create2.deploy(0, genericCreationSalt, creationCode);
-
-        (bool success, ) = resultAddress.call(initCall);
-        if (!success) {
-            revert FailedToInitGenericDeployedContract();
-        }
-    }
-
-    bytes32 constant DOMAIN_UPGRADEABLE_PROXY =
-        keccak256("createProxy(bytes32 proxyShimSalt,bytes32 proxySalt,bytes proxyCreationCode,address implementationAddress,address owner)");
-    bytes32 constant DOMAIN_GENERIC_CREATION = keccak256("createGenericContract(bytes32 salt,bytes creationCode,bytes initCall)");
-
-    function recoverSignature(bytes32 digest, bytes calldata signature) public pure returns (address) {
-        return ECDSA.recover(digest, signature);
-    }
-
-    function hashedDigestFactoryProxy(
-        bytes32 proxyShimSalt,
-        bytes32 proxySalt,
-        bytes calldata proxyCreationCode,
-        address implementationAddress,
-        address newOwner
-    ) public view returns (bytes32) {
-        return
-            _hashTypedDataV4(
-                keccak256(abi.encode(DOMAIN_UPGRADEABLE_PROXY, proxyShimSalt, proxySalt, keccak256(proxyCreationCode), implementationAddress, newOwner))
-            );
-    }
-
-    function hashedDigestGenericCreation(bytes32 salt, bytes calldata creationCode, bytes calldata initCall) public view returns (bytes32) {
-        return _hashTypedDataV4(keccak256(abi.encode(DOMAIN_GENERIC_CREATION, salt, keccak256(creationCode), keccak256(initCall))));
-    }
-
-    function requireContainsCaller(address caller, bytes32 salt) private pure {
-        // prevent contract submissions from being stolen from tx.pool by requiring
-        // that the first 20 bytes of the submitted salt match msg.sender.
-        require((address(bytes20(salt)) == caller) || (bytes20(salt) == bytes20(0)), "Invalid salt - first 20 bytes of the salt must match calling address.");
-    }
-
-    /// Creates a new factory proxy at a Deterministic address, with this address as the owner
-    /// Upgrades the proxy to the factory implementation, and sets the new owner as the owner.
-    /// @param proxyShimSalt Salt for deterministic proxy shim address
-    /// @param proxySalt Salt for deterministic factory proxy address
-    function createFactoryProxyDeterministic(
-        bytes32 proxyShimSalt,
-        bytes32 proxySalt,
-        bytes calldata proxyCreationCode,
-        address expectedFactoryProxyAddress,
-        address implementationAddress,
-        address owner,
-        bytes calldata signature
-    ) external returns (address factoryProxyAddress) {
-        address signer = recoverSignature(hashedDigestFactoryProxy(proxyShimSalt, proxySalt, proxyCreationCode, implementationAddress, owner), signature);
-
-        requireContainsCaller(signer, proxyShimSalt);
-
-        return
-            _createAndInitializeNewFactoryProxyDeterministic(
-                proxyShimSalt,
-                proxySalt,
-                proxyCreationCode,
-                expectedFactoryProxyAddress,
-                implementationAddress,
-                owner
-            );
-    }
-
-    function createAndInitGenericContractDeterministic(
-        bytes32 genericCreationSalt,
-        bytes calldata creationCode,
-        bytes calldata initCall,
-        bytes calldata signature
-    ) external returns (address resultAddress) {
-        address signer = recoverSignature(hashedDigestGenericCreation(genericCreationSalt, creationCode, initCall), signature);
-
-        requireContainsCaller(signer, genericCreationSalt);
-
-        return _createAndInitGenericContractDeterministic(genericCreationSalt, creationCode, initCall);
-    }
-}

package/src/IImmutableCreate2Factory.sol

@@ -1,59 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.17;
-
-// Extracted interface of ImmutableCreate2Factory.sol, located at https://raw.githubusercontent.com/0age/metamorphic/master/contracts/ImmutableCreate2Factory.sol
-
-interface IImmutableCreate2Factory {
-    /**
-     * @dev Create a contract using CREATE2 by submitting a given salt or nonce
-     * along with the initialization code for the contract. Note that the first 20
-     * bytes of the salt must match those of the calling address, which prevents
-     * contract creation events from being submitted by unintended parties.
-     * @param salt bytes32 The nonce that will be passed into the CREATE2 call.
-     * @param initializationCode bytes The initialization code that will be passed
-     * into the CREATE2 call.
-     * @return deploymentAddress Address of the contract that will be created, or the null address
-     * if a contract already exists at that address.
-     */
-    function safeCreate2(bytes32 salt, bytes calldata initializationCode) external payable returns (address deploymentAddress);
-
-    /**
-     * @dev Compute the address of the contract that will be created when
-     * submitting a given salt or nonce to the contract along with the contract's
-     * initialization code. The CREATE2 address is computed in accordance with
-     * EIP-1014, and adheres to the formula therein of
-     * `keccak256( 0xff ++ address ++ salt ++ keccak256(init_code)))[12:]` when
-     * performing the computation. The computed address is then checked for any
-     * existing contract code - if so, the null address will be returned instead.
-     * @param salt bytes32 The nonce passed into the CREATE2 address calculation.
-     * @param initCode bytes The contract initialization code to be used.
-     * that will be passed into the CREATE2 address calculation.
-     * @return deploymentAddress Address of the contract that will be created, or the null address
-     * if a contract has already been deployed to that address.
-     */
-    function findCreate2Address(bytes32 salt, bytes calldata initCode) external view returns (address deploymentAddress);
-
-    /**
-     * @dev Compute the address of the contract that will be created when
-     * submitting a given salt or nonce to the contract along with the keccak256
-     * hash of the contract's initialization code. The CREATE2 address is computed
-     * in accordance with EIP-1014, and adheres to the formula therein of
-     * `keccak256( 0xff ++ address ++ salt ++ keccak256(init_code)))[12:]` when
-     * performing the computation. The computed address is then checked for any
-     * existing contract code - if so, the null address will be returned instead.
-     * @param salt bytes32 The nonce passed into the CREATE2 address calculation.
-     * @param initCodeHash bytes32 The keccak256 hash of the initialization code
-     * that will be passed into the CREATE2 address calculation.
-     * @return deploymentAddress Address of the contract that will be created, or the null address
-     * if a contract has already been deployed to that address.
-     */
-    function findCreate2AddressViaHash(bytes32 salt, bytes32 initCodeHash) external view returns (address deploymentAddress);
-
-    /**
-     * @dev Determine if a contract has already been deployed by the factory to a
-     * given address.
-     * @param deploymentAddress address The contract address to check.
-     * @return True if the contract has been deployed, false otherwise.
-     */
-    function hasBeenDeployed(address deploymentAddress) external view returns (bool);
-}

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,145 +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);
-        console2.log(deploymentJson);
-    }
-
-    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");
-    }
-}