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

package/src/DeploymentTestingUtils.sol

@@ -1,166 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.13;
-
-import "forge-std/Script.sol";
-import {IMinter1155} from "@zoralabs/zora-1155-contracts/src/interfaces/IMinter1155.sol";
-import {IZoraCreator1155PremintExecutor} from "@zoralabs/zora-1155-contracts/src/interfaces/IZoraCreator1155PremintExecutor.sol";
-import {ZoraCreator1155PremintExecutorImpl} from "@zoralabs/zora-1155-contracts/src/delegation/ZoraCreator1155PremintExecutorImpl.sol";
-import {ZoraCreator1155FactoryImpl} from "@zoralabs/zora-1155-contracts/src/factory/ZoraCreator1155FactoryImpl.sol";
-import {ZoraCreator1155Attribution, ContractCreationConfig, PremintConfigV2, TokenCreationConfigV2, PremintConfig, TokenCreationConfig} from "@zoralabs/zora-1155-contracts/src/delegation/ZoraCreator1155Attribution.sol";
-import {ScriptDeploymentConfig} from "./DeploymentConfig.sol";
-import {ZoraCreator1155Impl} from "@zoralabs/zora-1155-contracts/src/nft/ZoraCreator1155Impl.sol";
-
-contract DeploymentTestingUtils is Script {
-    function createAndSignPremintV1(
-        address premintExecutorProxyAddress,
-        address payoutRecipient
-    )
-        internal
-        returns (
-            ContractCreationConfig memory contractConfig,
-            IZoraCreator1155PremintExecutor preminterAtProxy,
-            PremintConfig memory premintConfig,
-            bytes memory signature
-        )
-    {
-        (address creator, uint256 creatorPrivateKey) = makeAddrAndKey("creator");
-        preminterAtProxy = IZoraCreator1155PremintExecutor(premintExecutorProxyAddress);
-
-        premintConfig = PremintConfig({
-            tokenConfig: TokenCreationConfig({
-                tokenURI: "blah.token",
-                maxSupply: 10,
-                maxTokensPerAddress: 5,
-                pricePerToken: 0,
-                mintStart: 0,
-                mintDuration: 0,
-                royaltyMintSchedule: 0,
-                royaltyBPS: 100,
-                royaltyRecipient: payoutRecipient,
-                fixedPriceMinter: address(ZoraCreator1155FactoryImpl(address(preminterAtProxy.zora1155Factory())).fixedPriceMinter())
-            }),
-            uid: 101,
-            version: 0,
-            deleted: false
-        });
-
-        // now interface with proxy preminter - sign and execute the premint
-        contractConfig = ContractCreationConfig({contractAdmin: creator, contractName: "blahb", contractURI: "blah.contract"});
-        address deterministicAddress = preminterAtProxy.getContractAddress(contractConfig);
-
-        signature = signPremint(premintConfig, deterministicAddress, creatorPrivateKey);
-    }
-
-    function signAndExecutePremintV1(
-        address premintExecutorProxyAddress,
-        address payoutRecipient,
-        IZoraCreator1155PremintExecutor.MintArguments memory mintArguments
-    ) internal {
-        (
-            ContractCreationConfig memory contractConfig,
-            IZoraCreator1155PremintExecutor preminterAtProxy,
-            PremintConfig memory premintConfig,
-            bytes memory signature
-        ) = createAndSignPremintV1(premintExecutorProxyAddress, payoutRecipient);
-
-        uint256 quantityToMint = 1;
-
-        // execute the premint
-        IZoraCreator1155PremintExecutor.PremintResult memory premintResult = preminterAtProxy.premintV1{value: mintFee(quantityToMint)}(
-            contractConfig,
-            premintConfig,
-            signature,
-            quantityToMint,
-            mintArguments
-        );
-
-        require(ZoraCreator1155Impl(payable(premintResult.contractAddress)).delegatedTokenId(premintConfig.uid) == premintResult.tokenId, "token id mismatch");
-    }
-
-    function createAndSignPremintV2(
-        address premintExecutorProxyAddress,
-        address payoutRecipient
-    )
-        internal
-        returns (
-            ContractCreationConfig memory contractConfig,
-            IZoraCreator1155PremintExecutor preminterAtProxy,
-            PremintConfigV2 memory premintConfig,
-            bytes memory signature
-        )
-    {
-        (address creator, uint256 creatorPrivateKey) = makeAddrAndKey("creator");
-        preminterAtProxy = IZoraCreator1155PremintExecutor(premintExecutorProxyAddress);
-
-        premintConfig = PremintConfigV2({
-            tokenConfig: TokenCreationConfigV2({
-                tokenURI: "blah.token",
-                maxSupply: 100,
-                maxTokensPerAddress: 50,
-                pricePerToken: 0,
-                mintStart: 0,
-                mintDuration: 0,
-                royaltyBPS: 100,
-                payoutRecipient: payoutRecipient,
-                fixedPriceMinter: address(ZoraCreator1155FactoryImpl(address(preminterAtProxy.zora1155Factory())).fixedPriceMinter()),
-                createReferral: creator
-            }),
-            uid: 100,
-            version: 0,
-            deleted: false
-        });
-
-        // now interface with proxy preminter - sign and execute the premint
-        contractConfig = ContractCreationConfig({contractAdmin: creator, contractName: "blahb", contractURI: "blah.contract"});
-        address deterministicAddress = preminterAtProxy.getContractAddress(contractConfig);
-
-        signature = signPremint(premintConfig, deterministicAddress, creatorPrivateKey);
-    }
-
-    function signAndExecutePremintV2(
-        address premintExecutorProxyAddress,
-        address payoutRecipient,
-        IZoraCreator1155PremintExecutor.MintArguments memory mintArguments
-    ) internal {
-        (
-            ContractCreationConfig memory contractConfig,
-            IZoraCreator1155PremintExecutor preminterAtProxy,
-            PremintConfigV2 memory premintConfig,
-            bytes memory signature
-        ) = createAndSignPremintV2(premintExecutorProxyAddress, payoutRecipient);
-
-        uint256 quantityToMint = 1;
-        // execute the premint
-        uint256 tokenId = preminterAtProxy
-        .premintV2{value: mintFee(quantityToMint)}(contractConfig, premintConfig, signature, quantityToMint, mintArguments).tokenId;
-
-        require(
-            ZoraCreator1155Impl(payable(preminterAtProxy.getContractAddress(contractConfig))).delegatedTokenId(premintConfig.uid) == tokenId,
-            "token id not created for uid"
-        );
-    }
-
-    function signPremint(PremintConfigV2 memory premintConfig, address deterministicAddress, uint256 privateKey) private view returns (bytes memory signature) {
-        bytes32 signatureVersion = ZoraCreator1155Attribution.HASHED_VERSION_2;
-        bytes32 structHash = ZoraCreator1155Attribution.hashPremint(premintConfig);
-        // sign the premint
-        bytes32 digest = ZoraCreator1155Attribution.premintHashedTypeDataV4(structHash, deterministicAddress, signatureVersion, block.chainid);
-
-        (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, digest);
-        return abi.encodePacked(r, s, v);
-    }
-
-    function mintFee(uint256 quantityToMint) internal pure returns (uint256) {
-        return quantityToMint * 0.000777 ether;
-    }
-
-    function signPremint(PremintConfig memory premintConfig, address deterministicAddress, uint256 privateKey) private view returns (bytes memory signature) {
-        bytes32 signatureVersion = ZoraCreator1155Attribution.HASHED_VERSION_1;
-        bytes32 structHash = ZoraCreator1155Attribution.hashPremint(premintConfig);
-        // sign the premint
-        bytes32 digest = ZoraCreator1155Attribution.premintHashedTypeDataV4(structHash, deterministicAddress, signatureVersion, block.chainid);
-
-        (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, digest);
-        return abi.encodePacked(r, s, v);
-    }
-}

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