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

package/src/ZoraDeployerBase.sol

@@ -13,9 +13,10 @@ 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 ScriptDeploymentConfig, DeterministicDeployerScript {
+abstract contract ZoraDeployerBase is DeploymentTestingUtils, ScriptDeploymentConfig, DeterministicDeployerScript {
     using stdJson for string;
 
     /// @notice File used for demo metadata on verification test mint

package/src/ZoraDeployerUtils.sol

@@ -17,6 +17,7 @@ import {ZoraCreatorRedeemMinterFactory} from "@zoralabs/zora-1155-contracts/src/
 import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
 import {ICreatorRoyaltiesControl} from "@zoralabs/zora-1155-contracts/src/interfaces/ICreatorRoyaltiesControl.sol";
 import {UpgradeGate} from "@zoralabs/zora-1155-contracts/src/upgrades/UpgradeGate.sol";
+import {UUPSUpgradeable} from "@zoralabs/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol";
 
 struct Create2Deployment {
     address deployerAddress;
@@ -117,12 +118,13 @@ library ZoraDeployerUtils {
         // create preminter implementation
         bytes memory creationCode = abi.encodePacked(type(ZoraCreator1155PremintExecutorImpl).creationCode, abi.encode(factoryProxyAddress));
 
-        address preminterImplementation = IMMUTABLE_CREATE2_FACTORY.safeCreate2(
-            bytes32(0x0000000000000000000000000000000000000000668d7f9ec18e35000dbaba0e),
-            creationCode
-        );
+        bytes32 salt = bytes32(0x0000000000000000000000000000000000000000668d7f9ec18e35000dbaba0e);
+
+        address determinsticAddress = ZoraDeployerUtils.getImmutableCreate2Address(salt, creationCode);
+
+        ZoraDeployerUtils.getOrImmutable2Create(determinsticAddress, salt, creationCode);
 
-        return preminterImplementation;
+        return determinsticAddress;
     }
 
     function deterministicFactoryDeployerAddress() internal view returns (address) {
@@ -152,6 +154,24 @@ library ZoraDeployerUtils {
             );
     }
 
+    error MismatchedAddress(address expected, address actual);
+
+    function getImmutableCreate2Address(bytes32 salt, bytes memory creationCode) internal pure returns (address) {
+        return Create2.computeAddress(salt, keccak256(creationCode), address(IMMUTABLE_CREATE2_FACTORY));
+    }
+
+    function getOrImmutable2Create(address expectedAddress, bytes32 salt, bytes memory creationCode) internal returns (bool contractWasCreated) {
+        if (IMMUTABLE_CREATE2_FACTORY.hasBeenDeployed(expectedAddress)) {
+            return false;
+        } else {
+            address result = ZoraDeployerUtils.IMMUTABLE_CREATE2_FACTORY.safeCreate2(salt, creationCode);
+
+            if (result != expectedAddress) revert MismatchedAddress(expectedAddress, result);
+
+            return true;
+        }
+    }
+
     /// @notice Deploy a test contract for etherscan auto-verification
     /// @param factoryProxy Factory address to use
     /// @param admin Admin owner address to use
@@ -173,4 +193,20 @@ library ZoraDeployerUtils {
                 )
             );
     }
+
+    function getUpgradeCalldata(address targetImpl) internal pure returns (bytes memory upgradeCalldata) {
+        // simulate upgrade call
+        upgradeCalldata = abi.encodeWithSelector(UUPSUpgradeable.upgradeTo.selector, targetImpl);
+    }
+
+    function simulateUpgrade(address targetProxy, address targetImpl) internal returns (bytes memory upgradeCalldata) {
+        // console log update information
+
+        upgradeCalldata = getUpgradeCalldata(targetImpl);
+
+        // upgrade the factory proxy to the new implementation
+        (bool success, ) = targetProxy.call(upgradeCalldata);
+
+        require(success, "upgrade failed");
+    }
 }

package/test/UpgradesTest.t.sol

@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "forge-std/Test.sol";
+import {ZoraCreator1155FactoryImpl} from "@zoralabs/zora-1155-contracts/src/factory/ZoraCreator1155FactoryImpl.sol";
+import {ZoraCreator1155PremintExecutorImpl} from "@zoralabs/zora-1155-contracts/src/delegation/ZoraCreator1155PremintExecutorImpl.sol";
+import {ForkDeploymentConfig, Deployment, ChainConfig} from "../src/DeploymentConfig.sol";
+import {ZoraDeployerUtils} from "../src/ZoraDeployerUtils.sol";
+import {DeploymentTestingUtils} from "../src/DeploymentTestingUtils.sol";
+import {IZoraCreator1155PremintExecutor} from "@zoralabs/zora-1155-contracts/src/interfaces/IZoraCreator1155PremintExecutor.sol";
+
+contract UpgradesTest is ForkDeploymentConfig, DeploymentTestingUtils, Test {
+    /// @notice gets the chains to do fork tests on, by reading environment var FORK_TEST_CHAINS.
+    /// Chains are by name, and must match whats under `rpc_endpoints` in the foundry.toml
+    function getForkTestChains() private view returns (string[] memory result) {
+        try vm.envString("FORK_TEST_CHAINS", ",") returns (string[] memory forkTestChains) {
+            result = forkTestChains;
+        } catch {
+            console.log("could not get fork test chains - make sure the environment variable FORK_TEST_CHAINS is set");
+            result = new string[](0);
+        }
+    }
+
+    function determine1155Upgrade(Deployment memory deployment) private view returns (bool upgradeNeeded, address targetProxy, address targetImpl) {
+        targetProxy = deployment.factoryProxy;
+        targetImpl = deployment.factoryImpl;
+        address currentImplementation = ZoraCreator1155FactoryImpl(targetProxy).implementation();
+
+        upgradeNeeded = targetImpl != currentImplementation;
+    }
+
+    function determinePreminterUpgrade(Deployment memory deployment) private returns (bool upgradeNeeded, address targetProxy, address targetImpl) {
+        targetProxy = deployment.preminterProxy;
+        targetImpl = deployment.preminterImpl;
+
+        // right now we cannot call "implementation" on contract since it doesn't exist yet, so we check if deployed impl meets the v1 impl we know
+        address preminterV1ImplAddress = 0x6E2AbBcd82935bFC68A1d5d2c96372b13b65eD9C;
+
+        // if the target impl is still the v1 impl, it didnt have a method to check impl so we can't call it, also we know its still v1 impl so we don't need to upgrade
+        if (targetImpl == preminterV1ImplAddress) {
+            upgradeNeeded = false;
+        } else {
+            // if doesnt have implementation method, then we know upgrade is needed
+            (bool success, bytes memory data) = deployment.preminterProxy.call(abi.encodePacked(ZoraCreator1155PremintExecutorImpl.implementation.selector));
+
+            if (!success) {
+                upgradeNeeded = true;
+            } else {
+                address currentImplementation = abi.decode(data, (address));
+                upgradeNeeded = currentImplementation != targetImpl;
+            }
+
+            console2.log(upgradeNeeded);
+        }
+    }
+
+    /// @notice checks which chains need an upgrade, simulated the upgrade, and gets the upgrade calldata
+    function simulateUpgradeOnFork(string memory chainName) private {
+        // create and select the fork, which will be used for all subsequent calls
+        vm.createSelectFork(vm.rpcUrl(chainName));
+
+        Deployment memory deployment = getDeployment();
+
+        ChainConfig memory chainConfig = getChainConfig();
+
+        address creator = makeAddr("creator");
+
+        (bool is1155UpgradeNeeded, address targetProxy1155, address targetImpl1155) = determine1155Upgrade(deployment);
+        (bool preminterUpgradeNeeded, address targetPreminterProxy, address targetPremintImpl) = determinePreminterUpgrade(deployment);
+
+        if (!is1155UpgradeNeeded && !preminterUpgradeNeeded) {
+            return;
+        }
+
+        console2.log("====== upgrade needed ======");
+        console2.log("chain:", chainName);
+        console2.log("upgrade owner:", chainConfig.factoryOwner);
+
+        if (is1155UpgradeNeeded) {
+            console2.log("-- 1155 upgrade needed --");
+            vm.prank(chainConfig.factoryOwner);
+            bytes memory factory1155UpgradeCalldata = ZoraDeployerUtils.simulateUpgrade(targetProxy1155, targetImpl1155);
+            vm.prank(creator);
+            ZoraDeployerUtils.deployTestContractForVerification(targetProxy1155, creator);
+
+            console2.log("1155 upgrade target:", targetProxy1155);
+            console2.log("upgrade calldata:");
+            console.logBytes(factory1155UpgradeCalldata);
+            console2.log("upgrade to address:", targetImpl1155);
+            console2.log("upgrade to version:", ZoraCreator1155FactoryImpl(targetImpl1155).contractVersion());
+            console2.log("------------------------");
+        }
+
+        // hack - for now, only check on zora sepolia or goerli
+        if (preminterUpgradeNeeded) {
+            console2.log("-- preminter upgrade needed --");
+            console2.log("preminter upgrade target:", targetPreminterProxy);
+            vm.prank(chainConfig.factoryOwner);
+            bytes memory preminterUpgradeCalldata = ZoraDeployerUtils.simulateUpgrade(deployment.preminterProxy, deployment.preminterImpl);
+
+            address collector = makeAddr("collector");
+            address mintReferral = makeAddr("referral");
+            vm.deal(collector, 10 ether);
+
+            IZoraCreator1155PremintExecutor.MintArguments memory mintArguments = IZoraCreator1155PremintExecutor.MintArguments({
+                mintRecipient: collector,
+                mintComment: "",
+                mintReferral: mintReferral
+            });
+
+            vm.startPrank(collector);
+            signAndExecutePremintV1(targetPreminterProxy, makeAddr("payoutRecipientA"), mintArguments);
+            signAndExecutePremintV2(targetPreminterProxy, makeAddr("payoutRecipientB"), mintArguments);
+
+            vm.stopPrank();
+
+            console2.log("upgrade calldata:");
+            console.logBytes(preminterUpgradeCalldata);
+            console2.log("upgrade to address:", targetPremintImpl);
+            console2.log("------------------------");
+        }
+
+        console2.log("=================\n");
+    }
+
+    function test_fork_simulateUpgrades() external {
+        string[] memory forkTestChains = getForkTestChains();
+        for (uint256 i = 0; i < forkTestChains.length; i++) {
+            simulateUpgradeOnFork(forkTestChains[i]);
+        }
+    }
+}

package/test/ZoraCreator1155PremintExecutorForkTest.t.sol

@@ -76,7 +76,12 @@ contract ZoraCreator1155PreminterForkTest is ForkDeploymentConfig, Test {
         uint256 privateKey,
         uint256 chainId
     ) private pure returns (bytes memory) {
-        bytes32 digest = ZoraCreator1155Attribution.premintHashedTypeDataV4(premintConfig, contractAddress, chainId);
+        bytes32 digest = ZoraCreator1155Attribution.premintHashedTypeDataV4(
+            ZoraCreator1155Attribution.hashPremint(premintConfig),
+            contractAddress,
+            ZoraCreator1155Attribution.HASHED_VERSION_1,
+            chainId
+        );
 
         // 3. Sign the digest
         // create a signature with the digest for the params