@zoralabs/protocol-deployments 0.0.2

package/script/signDeploymentTransactions.ts

@@ -0,0 +1,277 @@
+import { createAccount } from "@turnkey/viem";
+import { TurnkeyClient } from "@turnkey/http";
+import { Address, encodeFunctionData, parseAbi, LocalAccount, Hex } from "viem";
+import { ApiKeyStamper } from "@turnkey/api-key-stamper";
+import { glob } from "glob";
+import * as path from "path";
+import * as dotenv from "dotenv";
+import { writeFile, readFile } from "fs/promises";
+import {
+  ConfiguredSalt,
+  DeterministicDeploymentConfig,
+  GenericDeploymentConfiguration,
+  signDeployFactory,
+  signGenericDeploy,
+} from "../package/deployment";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Load environment variables from `.env.local`
+dotenv.config({ path: path.resolve(__dirname, "../.env") });
+
+type ChainConfig = {
+  chainId: number;
+  implementationAddress: Address;
+  owner: Address;
+};
+
+async function signAndSaveSignatures({
+  turnkeyAccount,
+  chainConfigs,
+  proxyName,
+}: {
+  turnkeyAccount: LocalAccount;
+  chainConfigs: ChainConfig[];
+  proxyName: "factoryProxy" | "premintExecutorProxy";
+}) {
+  const configFolder = path.resolve(
+    __dirname,
+    `../deterministicConfig/${proxyName}/`
+  );
+  const configFile = path.join(configFolder, "params.json");
+  const deterministicDeployConfig = JSON.parse(
+    await readFile(configFile, "utf-8")
+  );
+
+  const deploymentConfig: DeterministicDeploymentConfig = {
+    proxyDeployerAddress:
+      deterministicDeployConfig.proxyDeployerAddress as Address,
+    proxySalt: deterministicDeployConfig.proxySalt as ConfiguredSalt,
+    proxyShimSalt: deterministicDeployConfig.proxyShimSalt as ConfiguredSalt,
+    proxyCreationCode: deterministicDeployConfig.proxyCreationCode as Address,
+  };
+
+  const signedConfigs = await Promise.all(
+    chainConfigs.map(async (chainConfig) => {
+      return {
+        chainId: chainConfig.chainId,
+        signature: await signDeployFactory({
+          account: turnkeyAccount,
+          implementationAddress: chainConfig.implementationAddress,
+          owner: chainConfig.owner,
+          chainId: chainConfig.chainId,
+          deterministicDeploymentConfig: deploymentConfig,
+        }),
+      };
+    })
+  );
+
+  // aggregate above to object of key value pair indexed by chain id as number:
+  const byChainId = signedConfigs.reduce((acc, { chainId, signature }) => {
+    acc[chainId] = signature;
+    return acc;
+  }, {} as { [key: number]: string });
+
+  // write as json to ../deterministicConfig/factoryDeploySignatures.json:
+  await writeFile(
+    path.join(configFolder, "signatures.json"),
+    JSON.stringify(byChainId, null, 2)
+  );
+}
+
+async function signAndSaveUpgradeGate({
+  turnkeyAccount,
+  chainConfigs,
+  proxyName,
+}: {
+  turnkeyAccount: LocalAccount;
+  chainConfigs: {
+    chainId: number;
+    owner: Address;
+  }[];
+  proxyName: "upgradeGate";
+}) {
+  const configFolder = path.resolve(
+    __dirname,
+    `../deterministicConfig/${proxyName}/`
+  );
+  const configFile = path.join(configFolder, "params.json");
+  const deterministicDeployConfig = JSON.parse(
+    await readFile(configFile, "utf-8")
+  );
+
+  const deploymentConfig: GenericDeploymentConfiguration = {
+    creationCode: deterministicDeployConfig.creationCode! as Hex,
+    salt: deterministicDeployConfig.salt! as Hex,
+    deployerAddress: deterministicDeployConfig.deployerAddress! as Address,
+    upgradeGateAddress:
+      deterministicDeployConfig.upgradeGateAddress! as Address,
+    proxyDeployerAddress:
+      deterministicDeployConfig.proxyDeployerAddress! as Address,
+  };
+
+  const upgradeGateAbi = parseAbi([
+    //  ^? const abi: readonly [{ name: "balanceOf"; type: "function"; stateMutability:...
+    "function initialize(address owner)",
+  ]);
+
+  const signedConfigs = await Promise.all(
+    chainConfigs.map(async (chainConfig) => {
+      const initCall = encodeFunctionData({
+        abi: upgradeGateAbi,
+        functionName: "initialize",
+        args: [chainConfig.owner],
+      });
+
+      return {
+        chainId: chainConfig.chainId,
+        signature: await signGenericDeploy({
+          account: turnkeyAccount,
+          chainId: chainConfig.chainId,
+          config: deploymentConfig,
+          initCall,
+        }),
+      };
+    })
+  );
+
+  // aggregate above to object of key value pair indexed by chain id as number:
+  const byChainId = signedConfigs.reduce((acc, { chainId, signature }) => {
+    acc[chainId] = signature;
+    return acc;
+  }, {} as { [key: number]: string });
+
+  // write as json to ../deterministicConfig/factoryDeploySignatures.json:
+  await writeFile(
+    path.join(configFolder, "signatures.json"),
+    JSON.stringify(byChainId, null, 2)
+  );
+}
+
+const getChainConfigs = async () => {
+  const chainConfigsFiles = await glob(
+    path.resolve(__dirname, "../chainConfigs/*.json")
+  );
+
+  const chainConfigs = await Promise.all(
+    chainConfigsFiles.map(async (chainConfigFile) => {
+      const chainId = parseInt(path.basename(chainConfigFile).split(".")[0]!);
+
+      // read file and process JSON contents:
+      const fileContents = await import(chainConfigFile);
+
+      return {
+        chainId,
+        owner: fileContents["FACTORY_OWNER"]! as Address,
+      };
+    })
+  );
+
+  return chainConfigs;
+};
+
+const getFactoryImplConfigs = async () => {
+  const addresseFiles = await glob(
+    path.resolve(__dirname, "../addresses/*.json")
+  );
+
+  const chainConfigs = await Promise.all(
+    addresseFiles.map(async (addressConfigFile) => {
+      const chainId = parseInt(path.basename(addressConfigFile).split(".")[0]!);
+
+      // read file and process JSON contents:
+      const fileContents = await import(addressConfigFile);
+
+      // read chain config file as json, which is located at: ../chainConfigs/${chainId}.json:
+      const chainConfig = await import(
+        path.resolve(__dirname, `../chainConfigs/${chainId}.json`)
+      );
+
+      return {
+        chainId,
+        implementationAddress: fileContents["FACTORY_IMPL"] as Address,
+        owner: chainConfig["FACTORY_OWNER"] as Address,
+      };
+    })
+  );
+
+  return chainConfigs;
+};
+
+const getPreminterImplConfigs = async () => {
+  const addresseFiles = await glob(
+    path.resolve(__dirname, "../addresses/*.json")
+  );
+
+  const chainConfigs = await Promise.all(
+    addresseFiles.map(async (addressConfigFile) => {
+      const chainId = parseInt(path.basename(addressConfigFile).split(".")[0]!);
+
+      // read file and process JSON contents:
+      const fileContents = await import(addressConfigFile);
+
+      // read chain config file as json, which is located at: ../chainConfigs/${chainId}.json:
+      const chainConfig = await import(
+        path.resolve(__dirname, `../chainConfigs/${chainId}.json`)
+      );
+
+      return {
+        chainId,
+        implementationAddress: fileContents["PREMINTER_IMPL"] as Address,
+        owner: chainConfig["FACTORY_OWNER"] as Address,
+      };
+    })
+  );
+
+  return chainConfigs.filter((x) => x.implementationAddress !== undefined);
+};
+
+async function main() {
+  // Create a Turnkey HTTP client with API key credentials
+  const httpClient = new TurnkeyClient(
+    {
+      baseUrl: "https://api.turnkey.com",
+    },
+    // This uses API key credentials.
+    // If you're using passkeys, use `@turnkey/webauthn-stamper` to collect webauthn signatures:
+    new ApiKeyStamper({
+      apiPublicKey: process.env.TURNKEY_API_PUBLIC_KEY!,
+      apiPrivateKey: process.env.TURNKEY_API_PRIVATE_KEY!,
+    })
+  );
+
+  // Create the Viem custom account
+  const turnkeyAccount = await createAccount({
+    client: httpClient,
+    organizationId: process.env.TURNKEY_ORGANIZATION_ID!,
+    privateKeyId: process.env.TURNKEY_PRIVATE_KEY_ID!,
+    // optional; will be fetched from Turnkey if not provided
+    ethereumAddress: process.env.TURNKEY_TARGET_ADDRESS!,
+  });
+
+  await signAndSaveSignatures({
+    turnkeyAccount,
+    chainConfigs: await getFactoryImplConfigs(),
+    proxyName: "factoryProxy",
+  });
+
+  await signAndSaveSignatures({
+    turnkeyAccount,
+    chainConfigs: await getPreminterImplConfigs(),
+    proxyName: "premintExecutorProxy",
+  });
+
+  await signAndSaveUpgradeGate({
+    turnkeyAccount,
+    chainConfigs: await getChainConfigs(),
+    proxyName: "upgradeGate",
+  });
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/test/NewFactoryProxyDeployer.t.sol

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: MIT
+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 {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 {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";
+
+contract DeterministicProxyDeployerTest is DeterministicDeployerScript, Test {
+    using stdJson for string;
+
+    // the values in this test can be determined by running the script GetDeterministicParam.s.sol,
+    // and copying the output values here.
+    function _deployKnownZoraFactoryProxy(bytes32 salt) internal returns (DeterministicProxyDeployer) {
+        // create new factory deployer using ImmutableCreate2Factory
+        return DeterministicProxyDeployer(ZoraDeployerUtils.IMMUTABLE_CREATE2_FACTORY.safeCreate2(salt, type(DeterministicProxyDeployer).creationCode));
+    }
+
+    function create1155FactoryImpl() internal returns (address) {
+        address mintFeeRecipient = makeAddr("mintFeeRecipient");
+        address protocolRewards = makeAddr("protocolRewards");
+
+        (address factoryImplDeployment, , ) = ZoraDeployerUtils.deployNew1155AndFactoryImpl({
+            upgradeGateAddress: address(new UpgradeGate()),
+            mintFeeRecipient: mintFeeRecipient,
+            protocolRewards: protocolRewards,
+            merkleMinter: IMinter1155(address(0)),
+            redeemMinterFactory: IMinter1155(address(0)),
+            fixedPriceMinter: IMinter1155(address(0))
+        });
+
+        return factoryImplDeployment;
+    }
+
+    function test_proxyCanByDeployedAtDesiredAddress(bytes32 proxySalt) external {
+        vm.createSelectFork("zora_goerli", 1252119);
+        // ensure nonce is greater than current account's nonce
+
+        (address deployerAddress, uint256 deployerPrivateKey) = makeAddrAndKey("deployer");
+        bytes32 proxyDeployerSalt = ZoraDeployerUtils.FACTORY_DEPLOYER_DEPLOYMENT_SALT;
+
+        // now we can create the implementation, pointing it to the expected deterministic address:
+        bytes32 proxyShimSalt = saltWithAddressInFirst20Bytes(deployerAddress, 10);
+
+        // 1. Create implementation contracts based on deterministic factory proxy address
+
+        // create 1155 and factory impl, we can know the deterministic factor proxy address ahead of time:
+        address factoryImplAddress = create1155FactoryImpl();
+
+        // 2. Create factory deployer at deterministic address
+        DeterministicProxyDeployer factoryProxyDeployer = _deployKnownZoraFactoryProxy(proxyDeployerSalt);
+
+        bytes memory factoryProxyCreationCode = type(Zora1155Factory).creationCode;
+        address mintFeeRecipient = makeAddr("mintFeeRecipient ");
+
+        bytes32 digest = factoryProxyDeployer.hashedDigestFactoryProxy(
+            proxyShimSalt,
+            proxySalt,
+            factoryProxyCreationCode,
+            factoryImplAddress,
+            mintFeeRecipient
+        );
+
+        // sign the message
+        bytes memory signature = signAndMakeBytes(digest, deployerPrivateKey);
+
+        address expectedFactoryProxyAddress = ZoraDeployerUtils.deterministicFactoryProxyAddress(proxyShimSalt, proxySalt, address(factoryProxyDeployer));
+
+        // now do it as original deployer, it should succeed:
+        address factoryProxyAddress = factoryProxyDeployer.createFactoryProxyDeterministic(
+            proxyShimSalt,
+            proxySalt,
+            factoryProxyCreationCode,
+            expectedFactoryProxyAddress,
+            factoryImplAddress,
+            mintFeeRecipient,
+            signature
+        );
+
+        // we know this salt from a script we ran that will generated
+        // create factory proxy, using deterministic address and known salt to get proper expected address:
+        assertEq(factoryProxyAddress, expectedFactoryProxyAddress, "factory proxy address wrong");
+    }
+
+    function signAndMakeBytes(bytes32 digest, uint256 privateKey) internal pure returns (bytes memory) {
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, digest);
+
+        // combine into a single bytes array
+        return abi.encodePacked(r, s, v);
+    }
+
+    function test_genericContractCanByDeployedAtDesiredAddress(uint32 nonce) external {
+        vm.createSelectFork("zora_goerli", 1252119);
+
+        (address deployerAddress, uint256 deployerPrivateKey) = makeAddrAndKey("deployer");
+
+        vm.assume(nonce > vm.getNonce(deployerAddress));
+        // we set the nonce to a random value, to prove this doesn't affect the deterministic addrss
+        vm.setNonce(deployerAddress, nonce);
+
+        DeterministicProxyDeployer factoryProxyDeployer = _deployKnownZoraFactoryProxy(bytes32(0));
+
+        address gateAdmin = makeAddr("gateAdmin");
+
+        bytes memory upgradeGateDeployCode = type(UpgradeGate).creationCode;
+
+        bytes memory initCall = abi.encodeWithSignature("initialize(address)", gateAdmin);
+
+        bytes32 genericTestDeploySalt = saltWithAddressInFirst20Bytes(deployerAddress, 20);
+
+        bytes32 digest = factoryProxyDeployer.hashedDigestGenericCreation(genericTestDeploySalt, upgradeGateDeployCode, initCall);
+
+        // sign the message
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(deployerPrivateKey, digest);
+
+        // combine into a single bytes array
+        bytes memory signature = abi.encodePacked(r, s, v);
+
+        factoryProxyDeployer.createAndInitGenericContractDeterministic(genericTestDeploySalt, upgradeGateDeployCode, initCall, signature);
+    }
+}

package/test/ZoraCreator1155Factory_Fork.t.sol

@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "forge-std/Test.sol";
+import {IZoraCreator1155Factory} from "@zoralabs/zora-1155-contracts/src/interfaces/IZoraCreator1155Factory.sol";
+import {ZoraCreator1155FactoryImpl} from "@zoralabs/zora-1155-contracts/src/factory/ZoraCreator1155FactoryImpl.sol";
+import {IZoraCreator1155Errors} from "@zoralabs/zora-1155-contracts/src/interfaces/IZoraCreator1155Errors.sol";
+import {IZoraCreator1155} from "@zoralabs/zora-1155-contracts/src/interfaces/IZoraCreator1155.sol";
+import {ZoraCreator1155Impl} from "@zoralabs/zora-1155-contracts/src/nft/ZoraCreator1155Impl.sol";
+import {IMinter1155} from "@zoralabs/zora-1155-contracts/src/interfaces/IMinter1155.sol";
+import {IOwnable} from "@zoralabs/zora-1155-contracts/src/interfaces/IOwnable.sol";
+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";
+
+contract ZoraCreator1155FactoryForkTest is ForkDeploymentConfig, Test {
+    uint256 constant quantityToMint = 3;
+    uint256 constant tokenMaxSupply = 100;
+    uint32 constant royaltyMintSchedule = 10;
+    uint32 constant royaltyBPS = 100;
+    uint256 constant mintFee = 0.000777 ether;
+
+    address collector;
+    address creator;
+
+    uint256 public constant PERMISSION_BIT_MINTER = 2 ** 2;
+
+    function setUp() external {
+        creator = vm.addr(1);
+        collector = vm.addr(2);
+    }
+
+    /// @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 _setupToken(IZoraCreator1155 target, IMinter1155 fixedPrice, uint96 tokenPrice) private returns (uint256 tokenId) {
+        string memory tokenURI = "ipfs://token";
+
+        tokenId = target.setupNewToken(tokenURI, tokenMaxSupply);
+
+        target.addPermission(tokenId, address(fixedPrice), PERMISSION_BIT_MINTER);
+
+        target.callSale(
+            tokenId,
+            fixedPrice,
+            abi.encodeWithSelector(
+                ZoraCreatorFixedPriceSaleStrategy.setSale.selector,
+                tokenId,
+                ZoraCreatorFixedPriceSaleStrategy.SalesConfig({
+                    pricePerToken: tokenPrice,
+                    saleStart: 0,
+                    saleEnd: type(uint64).max,
+                    maxTokensPerAddress: 0,
+                    fundsRecipient: address(0)
+                })
+            )
+        );
+    }
+
+    function _createErc1155Contract(IZoraCreator1155Factory factory) private returns (IZoraCreator1155 target) {
+        // create the contract, with no toekns
+        bytes[] memory initSetup = new bytes[](0);
+
+        address admin = creator;
+        string memory contractURI = "ipfs://asdfasdf";
+        string memory name = "Test";
+        address royaltyRecipient = creator;
+
+        address deployedAddress = factory.createContract(
+            contractURI,
+            name,
+            ICreatorRoyaltiesControl.RoyaltyConfiguration({
+                royaltyBPS: royaltyBPS,
+                royaltyRecipient: royaltyRecipient,
+                royaltyMintSchedule: royaltyMintSchedule
+            }),
+            payable(admin),
+            initSetup
+        );
+
+        target = IZoraCreator1155(deployedAddress);
+
+        // ** 2. Setup a new token with the fixed price sales strategy **
+    }
+
+    function mintTokenAtFork(IZoraCreator1155Factory factory) internal {
+        uint96 tokenPrice = 1 ether;
+        IMinter1155 fixedPrice = factory.defaultMinters()[0];
+        // now create a contract with the factory
+        vm.startPrank(creator);
+
+        // ** 1. Create the erc1155 contract **
+        IZoraCreator1155 target = _createErc1155Contract(factory);
+
+        // ** 2. Setup a new token with the fixed price sales strategy and the token price **
+        uint256 tokenId = _setupToken(target, fixedPrice, tokenPrice);
+
+        // ** 3. Mint on that contract **
+
+        // mint 3 tokens
+        uint256 valueToSend = quantityToMint * (tokenPrice + mintFee);
+
+        // mint the token
+        vm.deal(collector, valueToSend);
+        vm.startPrank(collector);
+        ZoraCreator1155Impl(address(target)).mintWithRewards{value: valueToSend}(fixedPrice, tokenId, quantityToMint, abi.encode(collector), address(0));
+
+        uint256 balance = ZoraCreator1155Impl(address(target)).balanceOf(collector, tokenId);
+
+        assertEq(balance, quantityToMint, "balance mismatch");
+    }
+
+    function testTheFork(string memory chainName) private {
+        console.log("testing on fork: ", chainName);
+
+        // create and select the fork, which will be used for all subsequent calls
+        // it will also affect the current block chain id based on the rpc url returned
+        vm.createSelectFork(vm.rpcUrl(chainName));
+
+        Deployment memory deployment = getDeployment();
+
+        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
+        // sanity check - check minters match config
+        assertEq(address(factory.merkleMinter()), deployment.merkleMintSaleStrategy, "merkle minter incorrect");
+        assertEq(address(factory.fixedPriceMinter()), deployment.fixedPriceSaleStrategy, "fixed priced minter incorrect");
+        assertEq(address(factory.redeemMinterFactory()), deployment.redeemMinterFactory, "redeem minter not correct");
+    }
+
+    function test_fork_canCreateContractAndMint() external {
+        string[] memory forkTestChains = getForkTestChains();
+        for (uint256 i = 0; i < forkTestChains.length; i++) {
+            testTheFork(forkTestChains[i]);
+        }
+    }
+}

package/test/ZoraCreator1155PremintExecutorForkTest.t.sol

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "forge-std/Test.sol";
+import {ForkDeploymentConfig} from "@zoralabs/zora-1155-contracts/src/deployment/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";
+
+contract ZoraCreator1155PreminterForkTest is ForkDeploymentConfig, Test {
+    ZoraCreator1155FactoryImpl factory;
+    ZoraCreator1155PremintExecutorImpl preminter;
+    uint256 mintFeeAmount = 0.000777 ether;
+
+    /// @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 testTheForkPremint(string memory chainName) private {
+        console.log("testing on fork: ", chainName);
+
+        // create and select the fork, which will be used for all subsequent calls
+        // it will also affect the current block chain id based on the rpc url returned
+        vm.createSelectFork(vm.rpcUrl(chainName));
+
+        // get contract hash, which is unique per contract creation config, and can be used
+        // retreive the address created for a contract
+        address preminterAddress = getDeployment().preminterProxy;
+
+        if (preminterAddress == address(0)) {
+            console.log("preminter not configured for chain...skipping");
+            return;
+        }
+
+        // override local preminter to use the addresses from the chain
+        factory = ZoraCreator1155FactoryImpl(getDeployment().factoryProxy);
+        preminter = ZoraCreator1155PremintExecutorImpl(preminterAddress);
+    }
+
+    function test_fork_successfullyMintsTokens() external {
+        string[] memory forkTestChains = getForkTestChains();
+        for (uint256 i = 0; i < forkTestChains.length; i++) {
+            testTheForkPremint(forkTestChains[i]);
+        }
+    }
+
+    function _signAndExecutePremint(
+        ContractCreationConfig memory contractConfig,
+        PremintConfig memory premintConfig,
+        uint256 privateKey,
+        uint256 chainId,
+        address executor,
+        uint256 quantityToMint,
+        string memory comment
+    ) private returns (uint256 newTokenId) {
+        bytes memory signature = _signPremint(preminter.getContractAddress(contractConfig), premintConfig, privateKey, chainId);
+
+        uint256 mintCost = mintFeeAmount * quantityToMint;
+        vm.deal(executor, mintCost);
+
+        // now call the premint function, using the same config that was used to generate the digest, and the signature
+        vm.prank(executor);
+        newTokenId = preminter.premint{value: mintCost}(contractConfig, premintConfig, signature, quantityToMint, comment);
+    }
+
+    function _signPremint(
+        address contractAddress,
+        PremintConfig memory premintConfig,
+        uint256 privateKey,
+        uint256 chainId
+    ) private pure returns (bytes memory) {
+        bytes32 digest = ZoraCreator1155Attribution.premintHashedTypeDataV4(premintConfig, contractAddress, chainId);
+
+        // 3. Sign the digest
+        // create a signature with the digest for the params
+        return _sign(privateKey, digest);
+    }
+
+    function _sign(uint256 privateKey, bytes32 digest) private pure returns (bytes memory) {
+        // sign the message
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, digest);
+
+        // combine into a single bytes array
+        return abi.encodePacked(r, s, v);
+    }
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "baseUrl": ".",
+    "downlevelIteration": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "lib": ["es2021"],
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noImplicitAny": true,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "target": "es2021",
+    "types": ["node"],
+    "outDir": "dist"
+  },
+  "exclude": ["node_modules/**", "dist/**"],
+  "include": ["package/**/*.ts", "script/*.ts"]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: ['package/index.ts'],
+  sourcemap: true,
+  clean: true,
+  dts: false,
+  format: ['cjs', 'esm'],
+  onSuccess: 'tsc --emitDeclarationOnly --declaration --declarationMap'
+})