@zoralabs/protocol-deployments 0.0.2

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@zoralabs/protocol-deployments",
+  "version": "0.0.2",
+  "repository": "https://github.com/ourzora/zora-protocol",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/package/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "dev": "FOUNDRY_PROFILE=dev forge test --watch -vvv",
+    "test:fork": "FORK_TEST_CHAINS=mainnet,goerli,optimism,optimism_goerli,zora,zora_goerli,base_goerli,base,zora_sepolia forge test -vvv",
+    "test": "forge test -vvv",
+    "build": "yarn wagmi && yarn bundle-configs && tsup",
+    "bundle-configs": "node script/bundle-chainConfigs.mjs && yarn prettier",
+    "prettier": "prettier --write 'package/**/*.ts' 'script/**/*.ts' 'wagmi.config.ts'",
+    "update-new-deployment-addresses": "node script/copy-deployed-contracts.mjs deploy",
+    "wagmi": "wagmi generate",
+    "unlink-protocol-rewards": "rm -rf ./node_modules/@zoralabs/protocol-rewards && cp -r ../protocol-rewards ./node_modules/@zoralabs/protocol-rewards",
+    "unlink-1155": "rm -rf ./node_modules/@zoralabs/zora-1155-contracts && cp -r ../1155-contracts ./node_modules/@zoralabs/zora-1155-contracts",
+    "unlink-contracts": "yarn unlink-protocol-rewards && yarn unlink-1155",
+    "link-contracts": "rm -rf ./node_modules && cd .. && yarn"
+  },
+  "dependencies": {
+    "@zoralabs/zora-1155-contracts": "*",
+    "ds-test": "https://github.com/dapphub/ds-test#cd98eff28324bfac652e63a239a60632a761790b",
+    "forge-std": "https://github.com/foundry-rs/forge-std#705263c95892a906d7af65f0f73ce8a4a0c80b80",
+    "solmate": "^6.1.0"
+  },
+  "devDependencies": {
+    "@turnkey/api-key-stamper": "^0.1.1",
+    "@turnkey/http": "^1.2.0",
+    "@turnkey/viem": "^0.2.4",
+    "@types/node": "^20.1.2",
+    "@wagmi/cli": "^1.0.1",
+    "es-main": "^1.2.0",
+    "glob": "^10.2.2",
+    "prettier": "^2.8.8",
+    "prettier-plugin-solidity": "^1.1.3",
+    "solady": "^0.0.132",
+    "tsup": "^7.2.0",
+    "tsx": "^3.13.0",
+    "typescript": "^5.2.2"
+  }
+}

package/remappings.txt

@@ -0,0 +1,9 @@
+ds-test/=node_modules/ds-test/src/
+forge-std/=node_modules/forge-std/src/
+@zoralabs/openzeppelin-contracts-upgradeable/=node_modules/@zoralabs/openzeppelin-contracts-upgradeable/
+@zoralabs/protocol-rewards/src/=node_modules/@zoralabs/protocol-rewards/src/
+@zoralabs/zora-1155-contracts/src/=node_modules/@zoralabs/zora-1155-contracts/src/
+@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/
+_imagine=node_modules/@zoralabs/zora-1155-contracts/_imagine
+solemate/=/node_modules/solemate/src/
+solady/=node_modules/solady/src/

package/script/CalculateDeterministicParams.s.sol

@@ -0,0 +1,84 @@
+// spdx-license-identifier: mit
+pragma solidity ^0.8.17;
+
+import "forge-std/Script.sol";
+import "forge-std/console2.sol";
+
+import {ZoraDeployerBase} from "@zoralabs/zora-1155-contracts/src/deployment/ZoraDeployerBase.sol";
+import {Zora1155Factory} from "@zoralabs/zora-1155-contracts/src/proxies/Zora1155Factory.sol";
+import {ProxyShim} from "@zoralabs/zora-1155-contracts/src/utils/ProxyShim.sol";
+import {UpgradeGate} from "@zoralabs/zora-1155-contracts/src/upgrades/UpgradeGate.sol";
+import {LibString} from "solady/utils/LibString.sol";
+import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
+import {ZoraDeployerUtils} from "@zoralabs/zora-1155-contracts/src/deployment/ZoraDeployerUtils.sol";
+import {Zora1155PremintExecutor} from "@zoralabs/zora-1155-contracts/src/proxies/Zora1155PremintExecutor.sol";
+import {DeterministicDeployerScript, DeterministicParams} from "@zoralabs/zora-1155-contracts/src/deployment/DeterministicDeployerScript.sol";
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+
+/// @title Gets parameters for deterministically deploying a new 1155 factory proxy at an address starting with 0x777777, regardless of the chain.
+/// @dev Example usage: DEPLOYER=0xf69fEc6d858c77e969509843852178bd24CAd2B6 forge script script/GetDeterminsticParam.s.sol --rpc-url https://testnet.rpc.zora.energy --ffi
+/// @author doved
+/// @notice Ensure to set env variable for DEPLOYER
+contract FactoryProxyDeterministicParams is ZoraDeployerBase {
+    address deployerAddress;
+    // Set in step 2
+    address proxyDeployerAddress;
+
+    function run() public {
+        vm.createSelectFork("zora_goerli", 1252119);
+
+        deployerAddress = vm.envAddress("TURNKEY_TARGET_ADDRESS");
+
+        calculateForFactoryProxy();
+        calculateForPremintExecutorProxy();
+
+        // Note: relies on proxyDeployerAddress
+        calculateUpgradeGateAddress();
+    }
+
+    function calculateForFactoryProxy() internal {
+        bytes memory proxyCreationCode = type(Zora1155Factory).creationCode;
+
+        DeterministicParams memory deterministicParams = getDeterministicDeploymentParams(deployerAddress, proxyCreationCode, 100);
+
+        proxyDeployerAddress = deterministicParams.proxyDeployerAddress;
+
+        mkdir("deterministicConfig/factoryProxy");
+        serializeAndSaveOutput(deterministicParams, "factoryProxy");
+    }
+
+    function calculateForPremintExecutorProxy() internal {
+        bytes memory proxyCreationCode = type(Zora1155PremintExecutor).creationCode;
+
+        DeterministicParams memory deterministicParams = getDeterministicDeploymentParams(deployerAddress, proxyCreationCode, 200);
+
+        mkdir("deterministicConfig/premintExecutorProxy");
+        serializeAndSaveOutput(deterministicParams, "premintExecutorProxy");
+    }
+
+    // @notice Since this doesn't
+    function calculateUpgradeGateAddress() internal {
+        bytes memory creationCodeUpgradeGate = type(UpgradeGate).creationCode;
+        bytes32 salt = saltWithAddressInFirst20Bytes(deployerAddress, 20);
+        address resultAddress = Create2.computeAddress(salt, keccak256(creationCodeUpgradeGate), proxyDeployerAddress);
+
+        vm.serializeAddress("UPGRADE_GATE_JSON", "deployerAddress", deployerAddress);
+        vm.serializeAddress("UPGRADE_GATE_JSON", "upgradeGateAddress", resultAddress);
+        vm.serializeAddress("UPGRADE_GATE_JSON", "proxyDeployerAddress", proxyDeployerAddress);
+        vm.serializeBytes32("UPGRADE_GATE_JSON", "salt", salt);
+        string memory output = vm.serializeBytes("UPGRADE_GATE_JSON", "creationCode", creationCodeUpgradeGate);
+
+        console2.log(output);
+
+        mkdir("deterministicConfig/upgradeGate");
+        vm.writeJson(output, paramsFilePath("upgradeGate"));
+    }
+
+    function mkdir(string memory path) internal {
+        string[] memory commands = new string[](3);
+        commands[0] = "mkdir";
+        commands[1] = "-p";
+        commands[2] = path;
+        vm.ffi(commands);
+    }
+}

package/script/DeployMintersAndImplementations.s.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "forge-std/Script.sol";
+import "forge-std/console2.sol";
+
+import {ZoraDeployerBase} from "@zoralabs/zora-1155-contracts/src/deployment/ZoraDeployerBase.sol";
+import {ZoraDeployerUtils} from "@zoralabs/zora-1155-contracts/src/deployment/ZoraDeployerUtils.sol";
+import {Deployment} from "@zoralabs/zora-1155-contracts/src/deployment/DeploymentConfig.sol";
+
+contract DeployMintersAndImplementations is ZoraDeployerBase {
+    function run() public returns (string memory) {
+        Deployment memory deployment = getDeployment();
+
+        address deployer = vm.envAddress("DEPLOYER");
+
+        vm.startBroadcast(deployer);
+
+        deployUpgradeGateDeterminstic(deployment);
+
+        deployMinters(deployment);
+
+        deployNew1155AndFactoryImpl(deployment);
+
+        deployNewPreminterImplementationDeterminstic(deployment);
+
+        vm.stopBroadcast();
+
+        return getDeploymentJSON(deployment);
+    }
+}

package/script/DeployNewImplementation.s.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "forge-std/Script.sol";
+import "forge-std/console2.sol";
+
+import {ZoraDeployerBase} from "@zoralabs/zora-1155-contracts/src/deployment/ZoraDeployerBase.sol";
+import {Deployment} from "@zoralabs/zora-1155-contracts/src/deployment/DeploymentConfig.sol";
+import {DeterministicDeployerScript} from "@zoralabs/zora-1155-contracts/src/deployment/DeterministicDeployerScript.sol";
+
+/// @dev Deploys implementation contracts for 1155 contracts.
+/// @notice Run after deploying the minters
+/// @notice This
+contract DeployNewImplementations is ZoraDeployerBase {
+    function run() public returns (string memory) {
+        Deployment memory deployment = getDeployment();
+
+        vm.startBroadcast();
+
+        deployNew1155AndFactoryImpl(deployment);
+
+        deployNewPreminterImplementationDeterminstic(deployment);
+
+        return getDeploymentJSON(deployment);
+    }
+}

package/script/DeployPreminterImpl.s.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "forge-std/Script.sol";
+import "forge-std/console2.sol";
+
+import {ZoraDeployerBase} from "@zoralabs/zora-1155-contracts/src/deployment/ZoraDeployerBase.sol";
+import {Deployment} from "@zoralabs/zora-1155-contracts/src/deployment/DeploymentConfig.sol";
+import {DeterministicDeployerScript} from "@zoralabs/zora-1155-contracts/src/deployment/DeterministicDeployerScript.sol";
+
+/// @dev Deploys preminter implementation contract.
+/// @notice Run after deploying the minters
+contract DeployPreminterImpl is ZoraDeployerBase {
+    function run() public returns (string memory) {
+        Deployment memory deployment = getDeployment();
+
+        vm.startBroadcast();
+
+        deployNewPreminterImplementationDeterminstic(deployment);
+
+        return getDeploymentJSON(deployment);
+    }
+}

package/script/DeployProxiesToNewChain.s.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "forge-std/Script.sol";
+import "forge-std/console2.sol";
+
+import {ZoraDeployerBase} from "@zoralabs/zora-1155-contracts/src/deployment/ZoraDeployerBase.sol";
+import {Deployment} from "@zoralabs/zora-1155-contracts/src/deployment/DeploymentConfig.sol";
+import {ZoraDeployerUtils} from "@zoralabs/zora-1155-contracts/src/deployment/ZoraDeployerUtils.sol";
+import {DeploymentTestingUtils} from "@zoralabs/zora-1155-contracts/src/deployment/DeploymentTestingUtils.sol";
+
+contract DeployProxiesToNewChain is ZoraDeployerBase, DeploymentTestingUtils {
+    function run() public returns (string memory) {
+        Deployment memory deployment = getDeployment();
+
+        vm.startBroadcast();
+
+        console.log("deploy factory proxy");
+
+        deployFactoryProxyDeterminstic(deployment);
+
+        console2.log("factory proxy address:", deployment.factoryProxy);
+
+        console2.log("create test contract for verification");
+
+        ZoraDeployerUtils.deployTestContractForVerification(deployment.factoryProxy, makeAddr("admin"));
+
+        deployPreminterProxyDeterminstic(deployment);
+
+        console2.log("preminter proxy", deployment.preminterProxy);
+
+        console2.log("testing premint");
+
+        signAndExecutePremint(deployment.preminterProxy);
+
+        vm.stopBroadcast();
+
+        // now test signing and executing premint
+
+        return getDeploymentJSON(deployment);
+    }
+}

package/script/DeployUpgradeGate.s.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "forge-std/Script.sol";
+import "forge-std/console2.sol";
+
+import {ZoraDeployerBase} from "@zoralabs/zora-1155-contracts/src/deployment/ZoraDeployerBase.sol";
+import {Deployment} from "@zoralabs/zora-1155-contracts/src/deployment/DeploymentConfig.sol";
+import {ZoraDeployerUtils} from "@zoralabs/zora-1155-contracts/src/deployment/ZoraDeployerUtils.sol";
+import {DeploymentTestingUtils} from "@zoralabs/zora-1155-contracts/src/deployment/DeploymentTestingUtils.sol";
+import {DeterministicDeployerScript} from "@zoralabs/zora-1155-contracts/src/deployment/DeterministicDeployerScript.sol";
+
+contract DeployUpgradeGate is ZoraDeployerBase {
+    function run() public returns (string memory) {
+        Deployment memory deployment = getDeployment();
+
+        vm.startBroadcast();
+
+        deployUpgradeGateDeterminstic(deployment);
+
+        vm.stopBroadcast();
+
+        // now test signing and executing premint
+
+        return getDeploymentJSON(deployment);
+    }
+}

package/script/Upgrade.s.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "forge-std/Script.sol";
+
+import {ZoraDeployerBase} from "@zoralabs/zora-1155-contracts/src/deployment/ZoraDeployerBase.sol";
+import {ChainConfig, Deployment} from "@zoralabs/zora-1155-contracts/src/deployment/DeploymentConfig.sol";
+
+import {ZoraCreator1155FactoryImpl} from "@zoralabs/zora-1155-contracts/src/factory/ZoraCreator1155FactoryImpl.sol";
+import {Zora1155Factory} from "@zoralabs/zora-1155-contracts/src/proxies/Zora1155Factory.sol";
+import {ZoraCreator1155Impl} from "@zoralabs/zora-1155-contracts/src/nft/ZoraCreator1155Impl.sol";
+import {ICreatorRoyaltiesControl} from "@zoralabs/zora-1155-contracts/src/interfaces/ICreatorRoyaltiesControl.sol";
+import {IZoraCreator1155Factory} from "@zoralabs/zora-1155-contracts/src/interfaces/IZoraCreator1155Factory.sol";
+import {IMinter1155} from "@zoralabs/zora-1155-contracts/src/interfaces/IMinter1155.sol";
+import {IZoraCreator1155} from "@zoralabs/zora-1155-contracts/src/interfaces/IZoraCreator1155.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 {ZoraDeployerUtils} from "@zoralabs/zora-1155-contracts/src/deployment/ZoraDeployerUtils.sol";
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+
+contract UpgradeScript is ZoraDeployerBase {
+    using Strings for uint256;
+    using stdJson for string;
+
+    string configFile;
+
+    function run() public returns (string memory) {
+        Deployment memory deployment = getDeployment();
+        ChainConfig memory chainConfig = getChainConfig();
+
+        vm.startBroadcast();
+
+        if (deployment.fixedPriceSaleStrategy == address(0)) {
+            deployment.fixedPriceSaleStrategy = address(new ZoraCreatorFixedPriceSaleStrategy());
+            console2.log("New FixedPriceMinter", deployment.fixedPriceSaleStrategy);
+        } else {
+            console2.log("Existing FIXED_PRICE_STRATEGY", deployment.fixedPriceSaleStrategy);
+        }
+
+        if (deployment.merkleMintSaleStrategy == address(0)) {
+            deployment.merkleMintSaleStrategy = address(new ZoraCreatorMerkleMinterStrategy());
+            console2.log("New MerkleMintStrategy", deployment.merkleMintSaleStrategy);
+        } else {
+            console2.log("Existing MERKLE_MINT_STRATEGY", deployment.merkleMintSaleStrategy);
+        }
+
+        if (deployment.redeemMinterFactory == address(0)) {
+            deployment.redeemMinterFactory = address(new ZoraCreatorRedeemMinterFactory());
+            console2.log("New REDEEM_MINTER_FACTORY", address(deployment.redeemMinterFactory));
+        } else {
+            console2.log("Existing REDEEM_MINTER_FACTORY", deployment.redeemMinterFactory);
+        }
+
+        bool isNewNFTImpl = deployment.contract1155Impl == address(0);
+        if (isNewNFTImpl) {
+            console2.log("mintFeeRecipient", chainConfig.mintFeeRecipient);
+            console2.log("protocolRewards", chainConfig.protocolRewards);
+            deployment.contract1155Impl = address(new ZoraCreator1155Impl(chainConfig.mintFeeRecipient, deployment.factoryProxy, chainConfig.protocolRewards));
+            console2.log("New NFT_IMPL", deployment.contract1155Impl);
+        } else {
+            console2.log("Existing NFT_IMPL", deployment.contract1155Impl);
+        }
+
+        deployment.factoryProxy = address(
+            new ZoraCreator1155FactoryImpl({
+                _zora1155Impl: IZoraCreator1155(deployment.contract1155Impl),
+                _merkleMinter: ZoraCreatorMerkleMinterStrategy(deployment.merkleMintSaleStrategy),
+                _redeemMinterFactory: ZoraCreatorRedeemMinterFactory(deployment.redeemMinterFactory),
+                _fixedPriceMinter: ZoraCreatorFixedPriceSaleStrategy(deployment.fixedPriceSaleStrategy)
+            })
+        );
+
+        console2.log("New Factory Impl", deployment.factoryImpl);
+        console2.log("Upgrade to this new factory impl on the proxy:", deployment.factoryProxy);
+
+        if (isNewNFTImpl) {
+            ZoraDeployerUtils.deployTestContractForVerification(deployment.factoryProxy, makeAddr("admin"));
+        }
+
+        return getDeploymentJSON(deployment);
+    }
+}

package/script/UpgradePreminter.s.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "forge-std/Script.sol";
+import "forge-std/console2.sol";
+
+import {ZoraDeployerBase} from "@zoralabs/zora-1155-contracts/src/deployment/ZoraDeployerBase.sol";
+import {ChainConfig, Deployment} from "@zoralabs/zora-1155-contracts/src/deployment/DeploymentConfig.sol";
+import {UUPSUpgradeable} from "@zoralabs/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol";
+import {ZoraDeployerUtils} from "@zoralabs/zora-1155-contracts/src/deployment/ZoraDeployerUtils.sol";
+
+contract UpgradePreminter is ZoraDeployerBase {
+    function run() public returns (string memory, bytes memory upgradeCalldata, address upgradeTarget) {
+        Deployment memory deployment = getDeployment();
+
+        uint256 deployerPrivateKey = vm.envUint("DEPLOYER_PRIVATE_KEY");
+
+        vm.startBroadcast(deployerPrivateKey);
+
+        address preminterImplementation = ZoraDeployerUtils.deployNewPreminterImplementationDeterminstic(deployment.factoryProxy);
+
+        vm.stopBroadcast();
+
+        upgradeCalldata = abi.encodeWithSelector(UUPSUpgradeable.upgradeTo.selector, preminterImplementation);
+
+        upgradeTarget = deployment.preminterImpl;
+
+        console2.log("Upgrade PremintExecutor target and implementatin:", upgradeTarget, preminterImplementation);
+        console2.log("To upgrade, use this calldata:");
+        console2.logBytes(upgradeCalldata);
+
+        return (getDeploymentJSON(deployment), upgradeCalldata, upgradeTarget);
+    }
+}

package/script/bundle-chainConfigs.mjs

@@ -0,0 +1,36 @@
+import { readdirSync, readFileSync, writeFileSync } from 'fs';
+
+// Reads all the chain configs in ./chainConfigs folder, and bundles them into a typescript 
+// definition that looks like:
+// export const chainConfigs = {
+//  [chainId]: {
+//    ...chainConfig
+//  }
+//}
+function makeConfig() {
+  // read all files in the chainConfigs folder
+  const files = readdirSync('chainConfigs');
+
+  // combine them into a single mapping
+  const chainConfigsInner = files
+    .map((fileName) => {
+      const chainId = fileName.split('.')[0];
+
+      const fileContents = JSON.parse(readFileSync(`chainConfigs/${fileName}`));
+
+      return `[${chainId}]: ${JSON.stringify(fileContents, null, 2)}`;
+    })
+    .join(', ');
+
+  return `export const chainConfigs = {
+    ${chainConfigsInner}
+  };`;
+}
+
+async function bundleChainConfigs() {
+  const configString = makeConfig();
+
+  writeFileSync('./package/chainConfigs.ts', configString);
+}
+
+await bundleChainConfigs();

package/script/copy-deployed-contracts.ts

@@ -0,0 +1,66 @@
+import { writeFile, readFile } from "fs/promises";
+import esMain from "es-main";
+import { glob } from "glob";
+
+type Deploy = {
+  timestamp: number;
+  commit: string;
+  returns: { value: string }[];
+  chain: number;
+};
+async function copyEnvironmentRunFiles() {
+  const latestFiles = await glob(`broadcast/**/*run-latest.json`);
+
+  const allFileContents = await Promise.all(
+    latestFiles.map(async (file) => {
+      const fileParts = file.split("/");
+      const chainId = fileParts[fileParts.length - 2];
+      return {
+        chainId,
+        contents: JSON.parse(await readFile(file, "utf-8")) as Deploy,
+      };
+    })
+  );
+
+  const groupedByChainId = allFileContents.reduce((acc, file) => {
+    const chainId = file.chainId!;
+    if (isNaN(Number(chainId))) return acc;
+
+    if (!acc[chainId]) {
+      acc[chainId] = [];
+    }
+    acc[chainId]!.push(file.contents);
+    return acc;
+  }, {} as Record<string, Deploy[]>);
+
+  const withLatest = Object.entries(groupedByChainId).map(
+    ([chainId, files]) => {
+      const latest = files.sort((a, b) => b.timestamp! - a.timestamp!)[0];
+      return {
+        chainId,
+        latest,
+      };
+    }
+  );
+
+  withLatest.forEach(async ({ chainId, latest }) => {
+    const filePath = `addresses/${chainId}.json`;
+
+    await writeFile(
+      filePath,
+      JSON.stringify(
+        {
+          ...JSON.parse(latest!.returns["0"]!.value),
+          timestamp: latest!.timestamp,
+          commit: latest!.commit,
+        },
+        null,
+        2
+      )
+    );
+  });
+}
+
+if (esMain(import.meta)) {
+  await copyEnvironmentRunFiles();
+}