@zoralabs/protocol-deployments 0.0.3 → 0.0.5-prerelease.0

package/src/DeploymentConfig.sol

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "forge-std/Test.sol";
+import {CommonBase} from "forge-std/Base.sol";
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+import {Script} from "forge-std/Script.sol";
+
+/// @notice Chain configuration for constants set manually during deploy. Does not get written to after deploys.
+struct ChainConfig {
+    /// @notice The user that owns the factory proxy. Allows ability to upgrade for new implementations deployed.
+    address factoryOwner;
+    /// @notice Mint fee recipient user
+    address mintFeeRecipient;
+    /// @notice Protocol rewards contract address
+    address protocolRewards;
+}
+
+/// @notice Deployment addresses – set to new deployed addresses by the scripts.
+struct Deployment {
+    /// @notice Fixed price minter strategy configuration contract
+    address fixedPriceSaleStrategy;
+    /// @notice Merkle minter strategy (formerly presale) configuration
+    address merkleMintSaleStrategy;
+    /// @notice Redeem minter factory contract for redeem sales configurations
+    address redeemMinterFactory;
+    /// @notice Implementation contract for the 1155 contract
+    address contract1155Impl;
+    /// @notice Implementation contract version for the 1155 contract
+    string contract1155ImplVersion;
+    /// @notice Factory implementation contract that is the impl for the above proxy.
+    address factoryImpl;
+    /// @notice Factory proxy contract that creates zora drops style NFT contracts
+    address factoryProxy;
+    /// @notice Preminter proxy contract address
+    address preminterImpl;
+    /// @notice Preminter implementation contract address
+    address preminterProxy;
+    /// @notice Upgrade gate
+    address upgradeGate;
+}
+
+abstract contract DeploymentConfig is Script {
+    using stdJson for string;
+
+    /// @notice ChainID convenience getter
+    /// @return id chainId
+    function chainId() internal view virtual returns (uint256 id);
+
+    ///
+    // These are the JSON key constants to standardize writing and reading configuration
+    ///
+
+    string constant FACTORY_OWNER = "FACTORY_OWNER";
+    string constant MINT_FEE_RECIPIENT = "MINT_FEE_RECIPIENT";
+    string constant PROTOCOL_REWARDS = "PROTOCOL_REWARDS";
+
+    string constant FIXED_PRICE_SALE_STRATEGY = "FIXED_PRICE_SALE_STRATEGY";
+    string constant MERKLE_MINT_SALE_STRATEGY = "MERKLE_MINT_SALE_STRATEGY";
+    string constant REDEEM_MINTER_FACTORY = "REDEEM_MINTER_FACTORY";
+    string constant CONTRACT_1155_IMPL = "CONTRACT_1155_IMPL";
+    string constant CONTRACT_1155_IMPL_VERSION = "CONTRACT_1155_IMPL_VERSION";
+    string constant FACTORY_IMPL = "FACTORY_IMPL";
+    string constant FACTORY_PROXY = "FACTORY_PROXY";
+    string constant PREMINTER_PROXY = "PREMINTER_PROXY";
+    string constant PREMINTER_IMPL = "PREMINTER_IMPL";
+    string constant UPGRADE_GATE = "UPGRADE_GATE";
+
+    /// @notice Return a prefixed key for reading with a ".".
+    /// @param key key to prefix
+    /// @return prefixed key
+    function getKeyPrefix(string memory key) internal pure returns (string memory) {
+        return string.concat(".", key);
+    }
+
+    /// @notice Returns the chain configuration struct from the JSON configuration file
+    /// @return chainConfig structure
+    function getChainConfig() internal view returns (ChainConfig memory chainConfig) {
+        string memory json = vm.readFile(string.concat("chainConfigs/", Strings.toString(chainId()), ".json"));
+        chainConfig.factoryOwner = json.readAddress(getKeyPrefix(FACTORY_OWNER));
+        chainConfig.mintFeeRecipient = json.readAddress(getKeyPrefix(MINT_FEE_RECIPIENT));
+        chainConfig.protocolRewards = json.readAddress(getKeyPrefix(PROTOCOL_REWARDS));
+    }
+
+    function readAddressOrDefaultToZero(string memory json, string memory key) internal view returns (address addr) {
+        string memory keyPrefix = getKeyPrefix(key);
+
+        if (vm.keyExists(json, keyPrefix)) {
+            addr = json.readAddress(keyPrefix);
+        } else {
+            addr = address(0);
+        }
+    }
+
+    /// @notice Get the deployment configuration struct from the JSON configuration file
+    /// @return deployment deployment configuration structure
+    function getDeployment() internal view returns (Deployment memory deployment) {
+        string memory json = vm.readFile(string.concat("addresses/", Strings.toString(chainId()), ".json"));
+        deployment.fixedPriceSaleStrategy = readAddressOrDefaultToZero(json, FIXED_PRICE_SALE_STRATEGY);
+        deployment.merkleMintSaleStrategy = readAddressOrDefaultToZero(json, MERKLE_MINT_SALE_STRATEGY);
+        deployment.redeemMinterFactory = readAddressOrDefaultToZero(json, REDEEM_MINTER_FACTORY);
+        deployment.contract1155Impl = readAddressOrDefaultToZero(json, CONTRACT_1155_IMPL);
+        deployment.contract1155ImplVersion = json.readString(getKeyPrefix(CONTRACT_1155_IMPL_VERSION));
+        deployment.factoryImpl = readAddressOrDefaultToZero(json, FACTORY_IMPL);
+        deployment.factoryProxy = readAddressOrDefaultToZero(json, FACTORY_PROXY);
+        deployment.preminterImpl = readAddressOrDefaultToZero(json, PREMINTER_IMPL);
+        deployment.preminterProxy = readAddressOrDefaultToZero(json, PREMINTER_PROXY);
+        deployment.upgradeGate = readAddressOrDefaultToZero(json, UPGRADE_GATE);
+    }
+}
+
+contract ForkDeploymentConfig is DeploymentConfig {
+    function chainId() internal view override returns (uint256 id) {
+        return block.chainid;
+    }
+}
+
+contract ScriptDeploymentConfig is DeploymentConfig {
+    function chainId() internal view override returns (uint256 id) {
+        assembly {
+            id := chainid()
+        }
+    }
+}

package/src/DeploymentTestingUtils.sol

@@ -0,0 +1,56 @@
+// 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 {ZoraCreator1155PremintExecutorImpl} from "@zoralabs/zora-1155-contracts/src/delegation/ZoraCreator1155PremintExecutorImpl.sol";
+import {ZoraCreator1155FactoryImpl} from "@zoralabs/zora-1155-contracts/src/factory/ZoraCreator1155FactoryImpl.sol";
+import {ZoraCreator1155Attribution, ContractCreationConfig, PremintConfig, TokenCreationConfig} from "@zoralabs/zora-1155-contracts/src/delegation/ZoraCreator1155Attribution.sol";
+import {ZoraCreator1155Impl} from "@zoralabs/zora-1155-contracts/src/nft/ZoraCreator1155Impl.sol";
+
+contract DeploymentTestingUtils is Script {
+    function signAndExecutePremint(address premintExecutorProxyAddress) internal {
+        console2.log("preminter proxy", premintExecutorProxyAddress);
+
+        (address creator, uint256 creatorPrivateKey) = makeAddrAndKey("creator");
+        ZoraCreator1155PremintExecutorImpl preminterAtProxy = ZoraCreator1155PremintExecutorImpl(premintExecutorProxyAddress);
+
+        IMinter1155 fixedPriceMinter = ZoraCreator1155FactoryImpl(address(preminterAtProxy.zora1155Factory())).fixedPriceMinter();
+
+        PremintConfig memory premintConfig = PremintConfig({
+            tokenConfig: TokenCreationConfig({
+                tokenURI: "blah.token",
+                maxSupply: 10,
+                maxTokensPerAddress: 5,
+                pricePerToken: 0,
+                mintStart: 0,
+                mintDuration: 0,
+                royaltyMintSchedule: 0,
+                royaltyBPS: 100,
+                royaltyRecipient: creator,
+                fixedPriceMinter: address(fixedPriceMinter)
+            }),
+            uid: 100,
+            version: 0,
+            deleted: false
+        });
+
+        // now interface with proxy preminter - sign and execute the premint
+        ContractCreationConfig memory contractConfig = ContractCreationConfig({contractAdmin: creator, contractName: "blah", contractURI: "blah.contract"});
+        address deterministicAddress = preminterAtProxy.getContractAddress(contractConfig);
+
+        // sign the premint
+        bytes32 digest = ZoraCreator1155Attribution.premintHashedTypeDataV4(premintConfig, deterministicAddress, block.chainid);
+
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(creatorPrivateKey, digest);
+
+        uint256 quantityToMint = 1;
+
+        bytes memory signature = abi.encodePacked(r, s, v);
+
+        // execute the premint
+        uint256 tokenId = preminterAtProxy.premint{value: 0.000777 ether}(contractConfig, premintConfig, signature, quantityToMint, "");
+
+        require(ZoraCreator1155Impl(deterministicAddress).delegatedTokenId(premintConfig.uid) == tokenId, "token id not created for uid");
+    }
+}

package/src/DeterministicDeployerScript.sol

@@ -0,0 +1,253 @@
+// 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;
+
+        if (ZoraDeployerUtils.IMMUTABLE_CREATE2_FACTORY.hasBeenDeployed(proxyDeployerAddress)) {
+            factoryDeployer = DeterministicProxyDeployer(proxyDeployerAddress);
+        } else {
+            factoryDeployer = DeterministicProxyDeployer(ZoraDeployerUtils.IMMUTABLE_CREATE2_FACTORY.safeCreate2(proxyDeployerSalt, proxyDeployerCreationCode));
+        }
+
+        if (address(factoryDeployer) != params.proxyDeployerAddress) revert MismatchedAddress(params.proxyDeployerAddress, address(factoryDeployer));
+    }
+
+    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

@@ -0,0 +1,139 @@
+// 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

@@ -0,0 +1,59 @@
+// 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);
+}