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

package/src/ZoraDeployerBase.sol

@@ -0,0 +1,144 @@
+// 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";
+
+/// @notice Deployment drops for base where
+abstract contract ZoraDeployerBase is 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");
+    }
+}

package/src/ZoraDeployerUtils.sol

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

package/test/NewFactoryProxyDeployer.t.sol

@@ -3,14 +3,14 @@ pragma solidity 0.8.17;
 
 import "forge-std/Test.sol";
 import {Zora1155Factory} from "@zoralabs/zora-1155-contracts/src/proxies/Zora1155Factory.sol";
-import {ZoraDeployerUtils, Create2Deployment} from "@zoralabs/zora-1155-contracts/src/deployment/ZoraDeployerUtils.sol";
-import {DeterministicProxyDeployer} from "@zoralabs/zora-1155-contracts/src/deployment/DeterministicProxyDeployer.sol";
+import {ZoraDeployerUtils, Create2Deployment} from "../src/ZoraDeployerUtils.sol";
+import {DeterministicProxyDeployer} from "../src/DeterministicProxyDeployer.sol";
 import {ProxyShim} from "@zoralabs/zora-1155-contracts/src/utils/ProxyShim.sol";
 import {UpgradeGate} from "@zoralabs/zora-1155-contracts/src/upgrades/UpgradeGate.sol";
-import {Deployment, ChainConfig} from "@zoralabs/zora-1155-contracts/src/deployment/DeploymentConfig.sol";
+import {Deployment, ChainConfig} from "../src/DeploymentConfig.sol";
 import {IMinter1155} from "@zoralabs/zora-1155-contracts/src/interfaces/IMinter1155.sol";
 import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
-import {DeterministicDeployerScript, DeterministicParams} from "@zoralabs/zora-1155-contracts/src/deployment/DeterministicDeployerScript.sol";
+import {DeterministicDeployerScript, DeterministicParams} from "../src/DeterministicDeployerScript.sol";
 
 contract DeterministicProxyDeployerTest is DeterministicDeployerScript, Test {
     using stdJson for string;

package/test/ZoraCreator1155Factory_Fork.t.sol

@@ -12,7 +12,7 @@ import {IOwnable} from "@zoralabs/zora-1155-contracts/src/interfaces/IOwnable.so
 import {ICreatorRoyaltiesControl} from "@zoralabs/zora-1155-contracts/src/interfaces/ICreatorRoyaltiesControl.sol";
 import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
 import {ZoraCreatorFixedPriceSaleStrategy} from "@zoralabs/zora-1155-contracts/src/minters/fixed-price/ZoraCreatorFixedPriceSaleStrategy.sol";
-import {ForkDeploymentConfig, Deployment} from "@zoralabs/zora-1155-contracts/src/deployment/DeploymentConfig.sol";
+import {ForkDeploymentConfig, Deployment} from "../src/DeploymentConfig.sol";
 
 contract ZoraCreator1155FactoryForkTest is ForkDeploymentConfig, Test {
     uint256 constant quantityToMint = 3;
@@ -131,8 +131,6 @@ contract ZoraCreator1155FactoryForkTest is ForkDeploymentConfig, Test {
         address factoryAddress = deployment.factoryProxy;
         ZoraCreator1155FactoryImpl factory = ZoraCreator1155FactoryImpl(factoryAddress);
 
-        assertEq(factory.implementation(), deployment.factoryImpl, "factory implementation incorrect");
-
         assertEq(getChainConfig().factoryOwner, IOwnable(factoryAddress).owner(), string.concat("configured owner incorrect on: ", chainName));
 
         // make sure that the address from the factory matches the stored fixed price address

package/test/ZoraCreator1155PremintExecutorForkTest.t.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.17;
 
 import "forge-std/Test.sol";
-import {ForkDeploymentConfig} from "@zoralabs/zora-1155-contracts/src/deployment/DeploymentConfig.sol";
+import {ForkDeploymentConfig} from "../src/DeploymentConfig.sol";
 import {ZoraCreator1155Attribution, ContractCreationConfig, PremintConfig, TokenCreationConfig} from "@zoralabs/zora-1155-contracts/src/delegation/ZoraCreator1155Attribution.sol";
 import {ZoraCreator1155PremintExecutorImpl} from "@zoralabs/zora-1155-contracts/src/delegation/ZoraCreator1155PremintExecutorImpl.sol";
 import {ZoraCreator1155FactoryImpl} from "@zoralabs/zora-1155-contracts/src/factory/ZoraCreator1155FactoryImpl.sol";

package/wagmi.config.ts

@@ -85,13 +85,7 @@ const getAddresses = () => {
       chainId,
       address: jsonAddress.PREMINTER_PROXY,
       abi: abis.zoraCreator1155PremintExecutorImplABI,
-    }),
-      addAddress({
-        contractName: "IImmutableCreate2Factory",
-        chainId,
-        address: "0x0000000000FFe8B47B3e2130213B802212439497",
-        abi: abis.iImmutableCreate2FactoryABI,
-      });
+    });
   }
 
   return addresses;