@zoralabs/protocol-sdk 0.5.6-exports.0 → 0.5.6

package/.turbo/turbo-build.log

@@ -0,0 +1,16 @@
+warning package.json: "dependencies" has dependency "vite" with range "4.5.0" that collides with a dependency in "devDependencies" of the same name with version "^4.5.0"
+$ tsup
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.build.json
+CLI tsup v7.3.0
+CLI Using tsup config: /home/runner/work/zora-protocol-private/zora-protocol-private/packages/protocol-sdk/tsup.config.ts
+CLI Target: es2021
+CLI Cleaning output folder
+CJS Build start
+ESM Build start
+CJS dist/index.cjs     50.17 KB
+CJS dist/index.cjs.map 97.10 KB
+CJS ⚡️ Build success in 72ms
+ESM dist/index.js     46.25 KB
+ESM dist/index.js.map 97.16 KB
+ESM ⚡️ Build success in 72ms

package/CHANGELOG.md

@@ -1,12 +1,12 @@
 # @zoralabs/protocol-sdk
 
-## 0.5.6-exports.0
+## 0.5.6
 
 ### Patch Changes
 
-- b10b8d05: Publishing package in format that supports commonjs imports by specifying exports
-- Updated dependencies [b10b8d05]
-  - @zoralabs/protocol-deployments@0.1.2-exports.0
+- 52b16aa: Publishing package in format that supports commonjs imports by specifying exports
+- Updated dependencies [52b16aa]
+  - @zoralabs/protocol-deployments@0.1.2
 
 ## 0.5.5
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoralabs/protocol-sdk",
-  "version": "0.5.6-exports.0",
+  "version": "0.5.6",
   "repository": "https://github.com/ourzora/zora-protocol",
   "license": "MIT",
   "type": "module",
@@ -25,7 +25,7 @@
     "lint": "prettier --check 'src/**/*.ts' 'test-integration/**/*.ts'"
   },
   "dependencies": {
-    "@zoralabs/protocol-deployments": "0.1.2-exports.0",
+    "@zoralabs/protocol-deployments": "*",
     "abitype": "^0.10.3",
     "vite": "4.5.0"
   },

package/src/create/1155-create-helper.test.ts

@@ -0,0 +1,104 @@
+import { parseEther } from "viem";
+import { describe, expect } from "vitest";
+import {
+  create1155CreatorClient,
+  getTokenIdFromCreateReceipt,
+} from "./1155-create-helper";
+import { anvilTest } from "src/anvil";
+
+const demoTokenMetadataURI = "ipfs://DUMMY/token.json";
+const demoContractMetadataURI = "ipfs://DUMMY/contract.json";
+
+describe("create-helper", () => {
+  anvilTest(
+    "creates a new contract given arguments",
+    async ({ viemClients: { testClient, publicClient, walletClient } }) => {
+      const addresses = await walletClient.getAddresses();
+      const creatorAddress = addresses[0]!;
+      await testClient.setBalance({
+        address: creatorAddress,
+        value: parseEther("1"),
+      });
+      const creatorClient = create1155CreatorClient({
+        publicClient: publicClient,
+      });
+      const { request } = await creatorClient.createNew1155Token({
+        contract: {
+          name: "testContract",
+          uri: demoContractMetadataURI,
+        },
+        tokenMetadataURI: demoTokenMetadataURI,
+        account: creatorAddress,
+        mintToCreatorCount: 1,
+      });
+      const { request: simulationResponse } =
+        await publicClient.simulateContract(request);
+      const hash = await walletClient.writeContract(simulationResponse);
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      expect(receipt).not.toBeNull();
+      expect(receipt.to).to.equal("0x777777c338d93e2c7adf08d102d45ca7cc4ed021");
+      expect(getTokenIdFromCreateReceipt(receipt)).to.be.equal(1n);
+    },
+    20 * 1000,
+  );
+  anvilTest(
+    "creates a new contract, than creates a new token on this existing contract",
+    async ({ viemClients: { publicClient, walletClient } }) => {
+      const addresses = await walletClient.getAddresses();
+      const creatorAccount = addresses[0]!;
+
+      const creatorClient = create1155CreatorClient({
+        publicClient: publicClient,
+      });
+
+      const { request, contractAddress, contractExists } =
+        await creatorClient.createNew1155Token({
+          contract: {
+            name: "testContract2",
+            uri: demoContractMetadataURI,
+          },
+          tokenMetadataURI: demoTokenMetadataURI,
+          account: creatorAccount,
+          mintToCreatorCount: 1,
+        });
+      expect(contractAddress).to.be.equal(
+        "0xb1A8928dF830C21eD682949Aa8A83C1C215194d3",
+      );
+      expect(contractExists).to.be.false;
+      const { request: simulateResponse } =
+        await publicClient.simulateContract(request);
+      const hash = await walletClient.writeContract(simulateResponse);
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      const firstTokenId = getTokenIdFromCreateReceipt(receipt);
+      expect(firstTokenId).to.be.equal(1n);
+      expect(receipt).not.toBeNull();
+
+      const newTokenOnExistingContract = await creatorClient.createNew1155Token(
+        {
+          contract: {
+            name: "testContract2",
+            uri: demoContractMetadataURI,
+          },
+          tokenMetadataURI: demoTokenMetadataURI,
+          account: creatorAccount,
+          mintToCreatorCount: 1,
+        },
+      );
+      expect(newTokenOnExistingContract.contractAddress).to.be.equal(
+        "0xb1A8928dF830C21eD682949Aa8A83C1C215194d3",
+      );
+      expect(newTokenOnExistingContract.contractExists).to.be.true;
+      const { request: simulateRequest } = await publicClient.simulateContract(
+        newTokenOnExistingContract.request,
+      );
+      const newHash = await walletClient.writeContract(simulateRequest);
+      const newReceipt = await publicClient.waitForTransactionReceipt({
+        hash: newHash,
+      });
+      const tokenId = getTokenIdFromCreateReceipt(newReceipt);
+      expect(tokenId).to.be.equal(2n);
+      expect(newReceipt).not.toBeNull();
+    },
+    20 * 1000,
+  );
+});

package/src/mint/mint-client.test.ts

@@ -0,0 +1,114 @@
+import { Address, parseAbi, parseEther } from "viem";
+import { zora } from "viem/chains";
+import { describe, expect } from "vitest";
+import { createMintClient } from "./mint-client";
+import { zoraCreator1155ImplABI } from "@zoralabs/protocol-deployments";
+import { anvilTest, forkUrls, makeAnvilTest } from "src/anvil";
+
+const erc721ABI = parseAbi([
+  "function balanceOf(address owner) public view returns (uint256)",
+] as const);
+
+describe("mint-helper", () => {
+  anvilTest(
+    "mints a new 1155 token",
+    async ({ viemClients }) => {
+      const { testClient, walletClient, publicClient } = viemClients;
+      const creatorAccount = (await walletClient.getAddresses())[0]!;
+      await testClient.setBalance({
+        address: creatorAccount,
+        value: parseEther("2000"),
+      });
+      const targetContract: Address =
+        "0xa2fea3537915dc6c7c7a97a82d1236041e6feb2e";
+      const targetTokenId = 1n;
+      const minter = createMintClient({ chain: zora });
+
+      const params = await minter.makePrepareMintTokenParams({
+        minterAccount: creatorAccount,
+        tokenId: targetTokenId,
+        tokenAddress: targetContract,
+        mintArguments: {
+          mintToAddress: creatorAccount,
+          quantityToMint: 1,
+        },
+      });
+
+      const oldBalance = await publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [creatorAccount, targetTokenId],
+      });
+
+      const simulationResult = await publicClient.simulateContract(params);
+
+      const hash = await walletClient.writeContract(simulationResult.request);
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      const newBalance = await publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [creatorAccount, targetTokenId],
+      });
+      expect(receipt).to.not.be.null;
+      expect(oldBalance).to.be.equal(0n);
+      expect(newBalance).to.be.equal(1n);
+    },
+    12 * 1000,
+  );
+
+  makeAnvilTest({
+    forkUrl: forkUrls.zoraMainnet,
+    forkBlockNumber: 6133407,
+  })(
+    "mints a new 721 token",
+    async ({ viemClients }) => {
+      const { testClient, walletClient, publicClient } = viemClients;
+      const creatorAccount = (await walletClient.getAddresses())[0]!;
+      await testClient.setBalance({
+        address: creatorAccount,
+        value: parseEther("2000"),
+      });
+
+      const targetContract: Address =
+        "0x7aae7e67515A2CbB8585C707Ca6db37BDd3EA839";
+      const targetTokenId = undefined;
+      const minter = createMintClient({ chain: zora });
+
+      const params = await minter.makePrepareMintTokenParams({
+        tokenId: targetTokenId,
+        tokenAddress: targetContract,
+        minterAccount: creatorAccount,
+        mintArguments: {
+          mintToAddress: creatorAccount,
+          quantityToMint: 1,
+        },
+      });
+      const oldBalance = await publicClient.readContract({
+        abi: erc721ABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [creatorAccount],
+      });
+
+      const simulated = await publicClient.simulateContract(params);
+
+      const hash = await walletClient.writeContract(simulated.request);
+
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      expect(receipt).not.to.be.null;
+
+      const newBalance = await publicClient.readContract({
+        abi: erc721ABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [creatorAccount],
+      });
+
+      expect(oldBalance).to.be.equal(0n);
+      expect(newBalance).to.be.equal(1n);
+    },
+    12 * 1000,
+  );
+});

package/src/premint/premint-client.test.ts

@@ -0,0 +1,239 @@
+import { foundry } from "viem/chains";
+import { describe, expect, vi } from "vitest";
+
+import { createPremintClient } from "./premint-client";
+import { anvilTest } from "src/anvil";
+import { PremintConfigVersion } from "./contract-types";
+import { getDefaultFixedPriceMinterAddress } from "./preminter";
+
+describe("ZoraCreator1155Premint - v1 signatures", () => {
+  anvilTest(
+    "can sign by default v1 on the forked premint contract",
+    async ({ viemClients: { walletClient, publicClient, chain } }) => {
+      const [deployerAccount] = await walletClient.getAddresses();
+      const premintClient = createPremintClient({
+        chain,
+        publicClient,
+      });
+
+      premintClient.apiClient.getNextUID = vi
+        .fn<any, ReturnType<typeof premintClient.apiClient.getNextUID>>()
+        .mockResolvedValue(3);
+      premintClient.apiClient.postSignature = vi
+        .fn<Parameters<typeof premintClient.apiClient.postSignature>>()
+        .mockResolvedValue({ ok: true });
+
+      await premintClient.createPremint({
+        walletClient,
+        creatorAccount: deployerAccount!,
+        checkSignature: true,
+        collection: {
+          contractAdmin: deployerAccount!,
+          contractName: "Testing Contract",
+          contractURI:
+            "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+        },
+        tokenCreationConfig: {
+          tokenURI:
+            "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+        },
+      });
+
+      const expectedPostSignatureArgs: Parameters<
+        typeof premintClient.apiClient.postSignature
+      >[0] = {
+        collection: {
+          contractAdmin: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+          contractName: "Testing Contract",
+          contractURI:
+            "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+        },
+        premintConfig: {
+          deleted: false,
+          tokenConfig: {
+            fixedPriceMinter: getDefaultFixedPriceMinterAddress(chain.id),
+            maxSupply: 18446744073709551615n,
+            maxTokensPerAddress: 0n,
+            mintDuration: 604800n,
+            mintStart: 0n,
+            pricePerToken: 0n,
+            royaltyBPS: 1000,
+            royaltyMintSchedule: 0,
+            royaltyRecipient: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+            tokenURI:
+              "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+          },
+          uid: 3,
+          version: 0,
+        },
+        premintConfigVersion: PremintConfigVersion.V1,
+        signature:
+          "0x70fc1d6e862c42f2b0e4a062f4eb973cc8692df58a24b71b4fe91ae7baa5a26d2c99b1b8ab61f64ff431bf30b0897877b11b7405542c90b89b041808f1561a6c1c",
+      };
+
+      expect(premintClient.apiClient.postSignature).toHaveBeenCalledWith(
+        expectedPostSignatureArgs,
+      );
+    },
+    20 * 1000,
+  );
+
+  anvilTest(
+    "can execute premint on network",
+    async ({ viemClients: { walletClient, publicClient, chain } }) => {
+      const [deployerAccount] = await walletClient.getAddresses();
+      const premintClient = createPremintClient({
+        chain: foundry,
+        publicClient,
+      });
+
+      premintClient.apiClient.getSignature = vi
+        .fn<any, ReturnType<typeof premintClient.apiClient.getSignature>>()
+        .mockResolvedValue({
+          collection: {
+            contractAdmin: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+            contractName: "Testing Contract",
+            contractURI:
+              "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+          },
+          premintConfig: {
+            deleted: false,
+            tokenConfig: {
+              fixedPriceMinter: getDefaultFixedPriceMinterAddress(chain.id),
+              maxSupply: 18446744073709551615n,
+              maxTokensPerAddress: 0n,
+              mintDuration: 604800n,
+              mintStart: 0n,
+              pricePerToken: 0n,
+              royaltyBPS: 1000,
+              royaltyMintSchedule: 0,
+              royaltyRecipient: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+              tokenURI:
+                "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+            },
+            uid: 3,
+            version: 0,
+          },
+          premintConfigVersion: PremintConfigVersion.V1,
+          signature:
+            "0x70fc1d6e862c42f2b0e4a062f4eb973cc8692df58a24b71b4fe91ae7baa5a26d2c99b1b8ab61f64ff431bf30b0897877b11b7405542c90b89b041808f1561a6c1c",
+        });
+
+      premintClient.apiClient.postSignature = vi.fn();
+
+      const simulateContractParameters = await premintClient.makeMintParameters(
+        {
+          minterAccount: deployerAccount!,
+          tokenContract: "0xf8dA7f53c283d898818af7FB9d98103F559bDac2",
+          uid: 3,
+          mintArguments: {
+            quantityToMint: 1,
+            mintComment: "",
+          },
+        },
+      );
+      const { request: simulateRequest } = await publicClient.simulateContract(
+        simulateContractParameters,
+      );
+      const hash = await walletClient.writeContract(simulateRequest);
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      const { premintedLog, urls } =
+        premintClient.getDataFromPremintReceipt(receipt);
+
+      expect(urls).toEqual({
+        explorer:
+          "https://undefined/token/0xf8dA7f53c283d898818af7FB9d98103F559bDac2/instance/1",
+        zoraCollect:
+          "https://testnet.zora.co/collect/zgor:0xf8dA7f53c283d898818af7FB9d98103F559bDac2/1",
+        zoraManage:
+          "https://testnet.zora.co/collect/zgor:0xf8dA7f53c283d898818af7FB9d98103F559bDac2/1",
+      });
+
+      expect(premintedLog).toEqual({
+        contractAddress: "0xf8dA7f53c283d898818af7FB9d98103F559bDac2",
+        createdNewContract: expect.any(Boolean),
+        minter: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        quantityMinted: 1n,
+        tokenId: 1n,
+        uid: 3,
+      });
+    },
+    20 * 1000,
+  );
+});
+
+describe("ZoraCreator1155Premint - v2 signatures", () => {
+  anvilTest(
+    "can sign on the forked premint contract",
+    async ({ viemClients: { walletClient, publicClient, chain } }) => {
+      const [creatorAccount, createReferralAccount] =
+        await walletClient.getAddresses();
+      const premintClient = createPremintClient({
+        chain,
+        publicClient,
+      });
+
+      premintClient.apiClient.getNextUID = vi
+        .fn<any, ReturnType<typeof premintClient.apiClient.getNextUID>>()
+        .mockResolvedValue(3);
+      premintClient.apiClient.postSignature = vi
+        .fn<Parameters<typeof premintClient.apiClient.postSignature>>()
+        .mockResolvedValue({ ok: true });
+
+      await premintClient.createPremint({
+        walletClient,
+        creatorAccount: creatorAccount!,
+        checkSignature: true,
+        collection: {
+          contractAdmin: creatorAccount!,
+          contractName: "Testing Contract Premint V2",
+          contractURI:
+            "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+        },
+        premintConfigVersion: PremintConfigVersion.V2,
+        tokenCreationConfig: {
+          tokenURI:
+            "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+          createReferral: createReferralAccount,
+        },
+      });
+
+      const expectedPostSignatureArgs: Parameters<
+        typeof premintClient.apiClient.postSignature
+      >[0] = {
+        collection: {
+          contractAdmin: creatorAccount!,
+          contractName: "Testing Contract Premint V2",
+          contractURI:
+            "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+        },
+        premintConfig: {
+          deleted: false,
+          tokenConfig: {
+            fixedPriceMinter: "0x04E2516A2c207E84a1839755675dfd8eF6302F0a",
+            maxSupply: 18446744073709551615n,
+            maxTokensPerAddress: 0n,
+            mintDuration: 604800n,
+            mintStart: 0n,
+            pricePerToken: 0n,
+            royaltyBPS: 1000,
+            payoutRecipient: creatorAccount!,
+            createReferral: createReferralAccount!,
+            tokenURI:
+              "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+          },
+          uid: 3,
+          version: 0,
+        },
+        premintConfigVersion: PremintConfigVersion.V2,
+        signature:
+          "0x8be7932b0b31bdb7fc9269b756e0d0c9514519f083d86576e23b73c033d8ed8440ea363bc8bba0ec5c30eb6bbdf796163a324201bc7520965037102518fb5e991c",
+      };
+
+      expect(premintClient.apiClient.postSignature).toHaveBeenCalledWith(
+        expectedPostSignatureArgs,
+      );
+    },
+    20 * 1000,
+  );
+});

package/src/premint/preminter.test.ts

@@ -0,0 +1,615 @@
+import { Address, zeroAddress } from "viem";
+import { foundry } from "viem/chains";
+import { describe, expect } from "vitest";
+import { parseEther } from "viem";
+import {
+  zoraCreator1155PremintExecutorImplABI as preminterAbi,
+  zoraCreator1155ImplABI,
+  zoraCreator1155FactoryImplAddress,
+  zoraCreator1155FactoryImplConfig,
+} from "@zoralabs/protocol-deployments";
+
+import {
+  premintTypedDataDefinition,
+  isValidSignature,
+  recoverCreatorFromCreatorAttribution,
+  getPremintExecutorAddress,
+  getPremintMintCosts,
+} from "./preminter";
+import {
+  ContractCreationConfig,
+  PremintConfigV1,
+  TokenCreationConfigV1,
+  PremintConfigVersion,
+  TokenCreationConfigV2,
+  PremintConfigV2,
+  MintArguments,
+} from "./contract-types";
+import { AnvilViemClientsTest, forkUrls, makeAnvilTest } from "src/anvil";
+
+// create token and contract creation config:
+const defaultContractConfig = ({
+  contractAdmin,
+}: {
+  contractAdmin: Address;
+}): ContractCreationConfig => ({
+  contractAdmin,
+  contractURI: "ipfs://asdfasdfasdf",
+  contractName: "My fun NFT",
+});
+
+const defaultTokenConfigV1 = (
+  fixedPriceMinterAddress: Address,
+  creatorAccount: Address,
+): TokenCreationConfigV1 => ({
+  tokenURI: "ipfs://tokenIpfsId0",
+  maxSupply: 100n,
+  maxTokensPerAddress: 10n,
+  pricePerToken: 0n,
+  mintStart: 0n,
+  mintDuration: 100n,
+  royaltyMintSchedule: 30,
+  royaltyBPS: 200,
+  royaltyRecipient: creatorAccount,
+  fixedPriceMinter: fixedPriceMinterAddress,
+});
+
+const defaultTokenConfigV2 = (
+  fixedPriceMinterAddress: Address,
+  creatorAccount: Address,
+  createReferral: Address,
+): TokenCreationConfigV2 => ({
+  tokenURI: "ipfs://tokenIpfsId0",
+  maxSupply: 100n,
+  maxTokensPerAddress: 10n,
+  pricePerToken: 0n,
+  mintStart: 0n,
+  mintDuration: 100n,
+  royaltyBPS: 200,
+  payoutRecipient: creatorAccount,
+  fixedPriceMinter: fixedPriceMinterAddress,
+  createReferral,
+});
+
+const defaultPremintConfigV1 = ({
+  fixedPriceMinter,
+  creatorAccount,
+}: {
+  fixedPriceMinter: Address;
+  creatorAccount: Address;
+}): PremintConfigV1 => ({
+  tokenConfig: defaultTokenConfigV1(fixedPriceMinter, creatorAccount),
+  deleted: false,
+  uid: 105,
+  version: 0,
+});
+
+const defaultPremintConfigV2 = ({
+  fixedPriceMinter,
+  creatorAccount,
+  createReferral = zeroAddress,
+}: {
+  fixedPriceMinter: Address;
+  creatorAccount: Address;
+  createReferral?: Address;
+}): PremintConfigV2 => ({
+  tokenConfig: defaultTokenConfigV2(
+    fixedPriceMinter,
+    creatorAccount,
+    createReferral,
+  ),
+  deleted: false,
+  uid: 106,
+  version: 0,
+});
+
+const PREMINTER_ADDRESS = getPremintExecutorAddress();
+
+const anvilTest = makeAnvilTest({
+  forkUrl: forkUrls.zoraSepolia,
+  forkBlockNumber: 1265490,
+});
+
+async function setupContracts({
+  viemClients: { walletClient, testClient, publicClient },
+}: AnvilViemClientsTest) {
+  // JSON-RPC Account
+  const [deployerAccount, creatorAccount, collectorAccount] =
+    (await walletClient.getAddresses()) as [Address, Address, Address, Address];
+
+  // deploy signature minter contract
+  await testClient.setBalance({
+    address: deployerAccount,
+    value: parseEther("10"),
+  });
+
+  const fixedPriceMinterAddress = await publicClient.readContract({
+    abi: zoraCreator1155FactoryImplConfig.abi,
+    address: zoraCreator1155FactoryImplAddress[999],
+    functionName: "fixedPriceMinter",
+  });
+
+  return {
+    accounts: {
+      deployerAccount,
+      creatorAccount,
+      collectorAccount,
+    },
+    fixedPriceMinterAddress,
+  };
+}
+
+const zoraSepoliaAnvilTest = makeAnvilTest({
+  forkUrl: forkUrls.zoraSepolia,
+  forkBlockNumber: 3118200,
+});
+
+describe("ZoraCreator1155Preminter", () => {
+  // skip for now - we need to make this work on zora testnet chain too
+  anvilTest(
+    "can sign on the forked premint contract",
+    async ({ viemClients }) => {
+      const {
+        fixedPriceMinterAddress,
+        accounts: { creatorAccount },
+      } = await setupContracts({ viemClients });
+      const premintConfig = defaultPremintConfigV1({
+        fixedPriceMinter: fixedPriceMinterAddress,
+        creatorAccount,
+      });
+      const contractConfig = defaultContractConfig({
+        contractAdmin: creatorAccount,
+      });
+
+      const preminterAddress = getPremintExecutorAddress();
+
+      const contractAddress = await viemClients.publicClient.readContract({
+        abi: preminterAbi,
+        address: preminterAddress,
+        functionName: "getContractAddress",
+        args: [contractConfig],
+      });
+
+      const signedMessage = await viemClients.walletClient.signTypedData({
+        ...premintTypedDataDefinition({
+          verifyingContract: contractAddress,
+          chainId: 999,
+          premintConfig,
+          premintConfigVersion: PremintConfigVersion.V1,
+        }),
+        account: creatorAccount,
+      });
+
+      console.log({
+        creatorAccount,
+        signedMessage,
+        contractConfig,
+        premintConfig,
+        contractAddress,
+      });
+    },
+    20 * 1000,
+  );
+  zoraSepoliaAnvilTest(
+    "can sign and recover a v1 premint config signature",
+    async ({ viemClients }) => {
+      const {
+        fixedPriceMinterAddress,
+        accounts: { creatorAccount },
+      } = await setupContracts({ viemClients });
+
+      const premintConfig = defaultPremintConfigV1({
+        fixedPriceMinter: fixedPriceMinterAddress,
+        creatorAccount,
+      });
+      const contractConfig = defaultContractConfig({
+        contractAdmin: creatorAccount,
+      });
+
+      const tokenContract = await viemClients.publicClient.readContract({
+        abi: preminterAbi,
+        address: PREMINTER_ADDRESS,
+        functionName: "getContractAddress",
+        args: [contractConfig],
+      });
+
+      // sign message containing contract and token creation config and uid
+      const signedMessage = await viemClients.walletClient.signTypedData({
+        ...premintTypedDataDefinition({
+          verifyingContract: tokenContract,
+          // we need to sign here for the anvil chain, cause thats where it is run on
+          chainId: foundry.id,
+          premintConfig,
+          premintConfigVersion: PremintConfigVersion.V1,
+        }),
+        account: creatorAccount,
+      });
+
+      // recover and verify address is correct
+      const { recoveredAddress, isAuthorized } = await isValidSignature({
+        collection: contractConfig,
+        chainId: viemClients.publicClient.chain!.id,
+        premintConfig,
+        premintConfigVersion: PremintConfigVersion.V1,
+        publicClient: viemClients.publicClient,
+        signature: signedMessage,
+      });
+
+      expect(recoveredAddress).to.equal(creatorAccount);
+      expect(isAuthorized).toBe(true);
+
+      expect(recoveredAddress).to.equal(creatorAccount);
+    },
+
+    20 * 1000,
+  );
+  zoraSepoliaAnvilTest(
+    "can sign and recover a v2 premint config signature",
+    async ({ viemClients }) => {
+      const {
+        fixedPriceMinterAddress,
+        accounts: { creatorAccount },
+      } = await setupContracts({ viemClients });
+
+      const premintConfig = defaultPremintConfigV2({
+        creatorAccount,
+        fixedPriceMinter: fixedPriceMinterAddress,
+        createReferral: creatorAccount,
+      });
+      const contractConfig = defaultContractConfig({
+        contractAdmin: creatorAccount,
+      });
+
+      const tokenContract = await viemClients.publicClient.readContract({
+        abi: preminterAbi,
+        address: PREMINTER_ADDRESS,
+        functionName: "getContractAddress",
+        args: [contractConfig],
+      });
+
+      // sign message containing contract and token creation config and uid
+      const signedMessage = await viemClients.walletClient.signTypedData({
+        ...premintTypedDataDefinition({
+          verifyingContract: tokenContract,
+          // we need to sign here for the anvil chain, cause thats where it is run on
+          chainId: foundry.id,
+          premintConfig,
+          premintConfigVersion: PremintConfigVersion.V2,
+        }),
+        account: creatorAccount,
+      });
+
+      // recover and verify address is correct
+      const { recoveredAddress, isAuthorized } = await isValidSignature({
+        collection: contractConfig,
+        chainId: viemClients.publicClient.chain!.id,
+        premintConfig,
+        premintConfigVersion: PremintConfigVersion.V2,
+        publicClient: viemClients.publicClient,
+        signature: signedMessage,
+      });
+
+      expect(recoveredAddress).to.equal(creatorAccount);
+      expect(isAuthorized).toBe(true);
+
+      expect(recoveredAddress).to.equal(creatorAccount);
+    },
+
+    20 * 1000,
+  );
+  zoraSepoliaAnvilTest(
+    "can sign and mint multiple tokens",
+    async ({ viemClients }) => {
+      const {
+        fixedPriceMinterAddress,
+        accounts: { creatorAccount, collectorAccount },
+      } = await setupContracts({ viemClients });
+      // setup contract and token creation parameters
+      const premintConfig1 = defaultPremintConfigV1({
+        fixedPriceMinter: fixedPriceMinterAddress,
+        creatorAccount,
+      });
+      const contractConfig = defaultContractConfig({
+        contractAdmin: creatorAccount,
+      });
+
+      // lets make it a random number to not break the existing tests that expect fresh data
+      premintConfig1.uid = Math.round(Math.random() * 1000000);
+
+      let contractAddress = await viemClients.publicClient.readContract({
+        abi: preminterAbi,
+        address: PREMINTER_ADDRESS,
+        functionName: "getContractAddress",
+        args: [contractConfig],
+      });
+
+      // have creator sign the message to create the contract
+      // and the token
+      const signedMessage = await viemClients.walletClient.signTypedData({
+        ...premintTypedDataDefinition({
+          verifyingContract: contractAddress,
+          // we need to sign here for the anvil chain, cause thats where it is run on
+          chainId: foundry.id,
+          premintConfig: premintConfig1,
+          premintConfigVersion: PremintConfigVersion.V1,
+        }),
+        account: creatorAccount,
+      });
+
+      const quantityToMint = 2n;
+
+      const valueToSend = (
+        await getPremintMintCosts({
+          publicClient: viemClients.publicClient,
+          quantityToMint,
+          tokenContract: contractAddress,
+          tokenPrice: premintConfig1.tokenConfig.pricePerToken,
+        })
+      ).totalCost;
+
+      await viemClients.testClient.setBalance({
+        address: collectorAccount,
+        value: parseEther("10"),
+      });
+
+      // get the premint status - it should not be minted
+      let [contractCreated, tokenId] =
+        await viemClients.publicClient.readContract({
+          abi: preminterAbi,
+          address: PREMINTER_ADDRESS,
+          functionName: "premintStatus",
+          args: [contractAddress, premintConfig1.uid],
+        });
+
+      expect(contractCreated).toBe(false);
+      expect(tokenId).toBe(0n);
+
+      const mintArguments: MintArguments = {
+        mintComment: "",
+        mintRecipient: collectorAccount,
+        mintRewardsRecipients: [],
+      };
+
+      // now have the collector execute the first signed message;
+      // it should create the contract, the token,
+      // and min the quantity to mint tokens to the collector
+      // the signature along with contract + token creation
+      // parameters are required to call this function
+      const mintHash = await viemClients.walletClient.writeContract({
+        abi: preminterAbi,
+        functionName: "premintV1",
+        account: collectorAccount,
+        chain: foundry,
+        address: PREMINTER_ADDRESS,
+        args: [
+          contractConfig,
+          premintConfig1,
+          signedMessage,
+          quantityToMint,
+          mintArguments,
+        ],
+        value: valueToSend,
+      });
+
+      // ensure it succeeded
+      const receipt = await viemClients.publicClient.waitForTransactionReceipt({
+        hash: mintHash,
+      });
+
+      expect(receipt.status).toBe("success");
+
+      // fetch the premint token id
+      [contractCreated, tokenId] = await viemClients.publicClient.readContract({
+        abi: preminterAbi,
+        address: PREMINTER_ADDRESS,
+        functionName: "premintStatus",
+        args: [contractAddress, premintConfig1.uid],
+      });
+
+      expect(contractCreated).toBe(true);
+      expect(tokenId).not.toBe(0n);
+
+      // now use what was created, to get the balance from the created contract
+      const tokenBalance = await viemClients.publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: contractAddress,
+        functionName: "balanceOf",
+        args: [collectorAccount, tokenId],
+      });
+
+      // get token balance - should be amount that was created
+      expect(tokenBalance).toBe(quantityToMint);
+
+      const premintConfig2 = defaultPremintConfigV2({
+        creatorAccount,
+        fixedPriceMinter: fixedPriceMinterAddress,
+        createReferral: creatorAccount,
+      });
+
+      // sign the message to create the second token
+      const signedMessage2 = await viemClients.walletClient.signTypedData({
+        ...premintTypedDataDefinition({
+          verifyingContract: contractAddress,
+          chainId: foundry.id,
+          premintConfig: premintConfig2,
+          premintConfigVersion: PremintConfigVersion.V2,
+        }),
+        account: creatorAccount,
+      });
+
+      const quantityToMint2 = 4n;
+
+      const valueToSend2 = (
+        await getPremintMintCosts({
+          publicClient: viemClients.publicClient,
+          quantityToMint: quantityToMint2,
+          tokenContract: contractAddress,
+          tokenPrice: premintConfig2.tokenConfig.pricePerToken,
+        })
+      ).totalCost;
+
+      const simulationResult = await viemClients.publicClient.simulateContract({
+        abi: preminterAbi,
+        functionName: "premintV2",
+        account: collectorAccount,
+        chain: foundry,
+        address: PREMINTER_ADDRESS,
+        args: [
+          contractConfig,
+          premintConfig2,
+          signedMessage2,
+          quantityToMint2,
+          mintArguments,
+        ],
+        value: valueToSend2,
+      });
+
+      // now have the collector execute the second signed message.
+      // it should create a new token against the existing contract
+      const mintHash2 = await viemClients.walletClient.writeContract(
+        simulationResult.request,
+      );
+
+      const premintV2Receipt =
+        await viemClients.publicClient.waitForTransactionReceipt({
+          hash: mintHash2,
+        });
+
+      expect(premintV2Receipt.status).toBe("success");
+
+      // now premint status for the second mint, it should be minted
+      [, tokenId] = await viemClients.publicClient.readContract({
+        abi: preminterAbi,
+        address: PREMINTER_ADDRESS,
+        functionName: "premintStatus",
+        args: [contractAddress, premintConfig2.uid],
+      });
+
+      expect(tokenId).not.toBe(0n);
+
+      // get balance of second token
+      const tokenBalance2 = await viemClients.publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: contractAddress,
+        functionName: "balanceOf",
+        args: [collectorAccount, tokenId],
+      });
+
+      expect(tokenBalance2).toBe(quantityToMint2);
+    },
+    // 10 second timeout
+    40 * 1000,
+  );
+
+  zoraSepoliaAnvilTest(
+    "can decode the CreatorAttribution event",
+    async ({ viemClients }) => {
+      const {
+        fixedPriceMinterAddress,
+        accounts: { creatorAccount, collectorAccount },
+      } = await setupContracts({ viemClients });
+      const premintConfig = defaultPremintConfigV2({
+        fixedPriceMinter: fixedPriceMinterAddress,
+        creatorAccount,
+      });
+      const contractConfig = defaultContractConfig({
+        contractAdmin: creatorAccount,
+      });
+
+      // lets make it a random number to not break the existing tests that expect fresh data
+      premintConfig.uid = Math.round(Math.random() * 1000000);
+
+      let contractAddress = await viemClients.publicClient.readContract({
+        abi: preminterAbi,
+        address: PREMINTER_ADDRESS,
+        functionName: "getContractAddress",
+        args: [contractConfig],
+      });
+
+      const signingChainId = foundry.id;
+
+      // have creator sign the message to create the contract
+      // and the token
+      const signedMessage = await viemClients.walletClient.signTypedData({
+        ...premintTypedDataDefinition({
+          verifyingContract: contractAddress,
+          // we need to sign here for the anvil chain, cause thats where it is run on
+          chainId: signingChainId,
+          premintConfig,
+          premintConfigVersion: PremintConfigVersion.V2,
+        }),
+        account: creatorAccount,
+      });
+
+      const quantityToMint = 2n;
+
+      const valueToSend = (
+        await getPremintMintCosts({
+          publicClient: viemClients.publicClient,
+          quantityToMint,
+          tokenContract: contractAddress,
+          tokenPrice: premintConfig.tokenConfig.pricePerToken,
+        })
+      ).totalCost;
+
+      await viemClients.testClient.setBalance({
+        address: collectorAccount,
+        value: parseEther("10"),
+      });
+
+      // now have the collector execute the first signed message;
+      // it should create the contract, the token,
+      // and min the quantity to mint tokens to the collector
+      // the signature along with contract + token creation
+      // parameters are required to call this function
+      const mintHash = await viemClients.walletClient.writeContract({
+        abi: preminterAbi,
+        functionName: "premintV2",
+        account: collectorAccount,
+        chain: foundry,
+        address: PREMINTER_ADDRESS,
+        args: [
+          contractConfig,
+          premintConfig,
+          signedMessage,
+          quantityToMint,
+          {
+            mintComment: "",
+            mintRecipient: collectorAccount,
+            mintRewardsRecipients: [],
+          },
+        ],
+        value: valueToSend,
+      });
+
+      // ensure it succeeded
+      const receipt = await viemClients.publicClient.waitForTransactionReceipt({
+        hash: mintHash,
+      });
+
+      expect(receipt.status).toBe("success");
+
+      // get the CreatorAttribution event from the erc1155 contract:
+      const topics = await viemClients.publicClient.getContractEvents({
+        abi: zoraCreator1155ImplABI,
+        address: contractAddress,
+        eventName: "CreatorAttribution",
+      });
+
+      expect(topics.length).toBe(1);
+
+      const creatorAttributionEvent = topics[0]!;
+
+      const { creator: creatorFromEvent } = creatorAttributionEvent.args;
+
+      const recoveredSigner = await recoverCreatorFromCreatorAttribution({
+        creatorAttribution: creatorAttributionEvent.args,
+        chainId: signingChainId,
+        tokenContract: contractAddress,
+      });
+
+      expect(creatorFromEvent).toBe(creatorAccount);
+      expect(recoveredSigner).toBe(creatorFromEvent);
+    },
+  );
+});

package/test-integration/premint-client.test.ts

@@ -0,0 +1,146 @@
+import { zoraSepolia, zoraTestnet } from "viem/chains";
+import { describe } from "vitest";
+
+import { createPremintClient } from "src/premint/premint-client";
+import { forkUrls, makeAnvilTest } from "src/anvil";
+import { PremintConfigVersion } from "src/premint/contract-types";
+
+const zoraGoerliTest = makeAnvilTest({
+  forkBlockNumber: 2107926,
+  forkUrl: forkUrls.zoraGoerli,
+  anvilChainId: zoraTestnet.id,
+});
+
+const zoraSepoliaTest = makeAnvilTest({
+  forkBlockNumber: 3118200,
+  forkUrl: forkUrls.zoraSepolia,
+  anvilChainId: zoraSepolia.id,
+});
+
+const tests = [
+  {
+    anvilTest: zoraGoerliTest,
+    chain: zoraTestnet,
+  },
+  {
+    anvilTest: zoraSepoliaTest,
+    chain: zoraSepolia,
+  },
+];
+
+tests.forEach(({ anvilTest, chain }) => {
+  describe(chain.name, () => {
+    describe("ZoraCreator1155Premint", () => {
+      describe("v2 signatures", () => {
+        anvilTest(
+          "can sign and execute on the forked premint contract",
+          async ({
+            viemClients: { walletClient, publicClient, testClient },
+          }) => {
+            const [creatorAccount, createReferralAccount, minterAccount] =
+              await walletClient.getAddresses();
+            const premintClient = createPremintClient({
+              chain,
+              publicClient,
+            });
+
+            const { uid, verifyingContract } =
+              await premintClient.createPremint({
+                walletClient,
+                creatorAccount: creatorAccount!,
+                checkSignature: true,
+                collection: {
+                  contractAdmin: creatorAccount!,
+                  contractName: "Testing Contract Premint V2",
+                  contractURI:
+                    "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3f",
+                },
+                premintConfigVersion: PremintConfigVersion.V2,
+                tokenCreationConfig: {
+                  tokenURI:
+                    "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2f",
+                  createReferral: createReferralAccount!,
+                },
+              });
+
+            const mintParameters = await premintClient.makeMintParameters({
+              minterAccount: minterAccount!,
+              tokenContract: verifyingContract,
+              uid,
+            });
+
+            const mintCosts = await premintClient.getMintCosts({
+              tokenContract: verifyingContract,
+              quantityToMint: 1n,
+              pricePerToken: 0n,
+            });
+
+            await testClient.setBalance({
+              address: minterAccount!,
+              value: mintCosts.totalCost,
+            });
+
+            // if simulation succeeds, mint will succeed
+            await publicClient.simulateContract(mintParameters);
+          },
+          20 * 1000,
+        );
+      });
+
+      describe("v1 signatures", () => {
+        anvilTest(
+          "can sign and execute on the forked premint contract",
+          async ({
+            viemClients: { walletClient, publicClient, testClient },
+          }) => {
+            const [creatorAccount, minterAccount] =
+              await walletClient.getAddresses();
+            const premintClient = createPremintClient({
+              chain,
+              publicClient,
+            });
+
+            const { uid, verifyingContract } =
+              await premintClient.createPremint({
+                walletClient,
+                creatorAccount: creatorAccount!,
+                checkSignature: true,
+                collection: {
+                  contractAdmin: creatorAccount!,
+                  contractName: `Testing Contract Premint V1 ${publicClient.chain?.name}`,
+                  contractURI:
+                    "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3fg",
+                },
+                premintConfigVersion: PremintConfigVersion.V1,
+                tokenCreationConfig: {
+                  tokenURI:
+                    "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+                },
+              });
+
+            const mintParameters = await premintClient.makeMintParameters({
+              minterAccount: minterAccount!,
+              tokenContract: verifyingContract,
+              uid,
+            });
+
+            const mintCosts = await premintClient.getMintCosts({
+              tokenContract: verifyingContract,
+              quantityToMint: 1n,
+              pricePerToken: 0n,
+            });
+
+            await testClient.setBalance({
+              address: minterAccount!,
+              value: mintCosts.totalCost,
+            });
+
+            // if simulation succeeds, mint will succeed
+            await publicClient.simulateContract(mintParameters);
+          },
+          20 * 1000,
+        );
+      });
+    });
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,10 @@
+{
+  "extends": "zoralabs-tsconfig/tsconfig.json",
+  "compilerOptions": {
+    "lib": ["es2021", "DOM"],
+    "baseUrl": ".",
+    "outDir": "dist"
+  },
+  "exclude": ["node_modules/**", "dist/**", "**/*test.ts"],
+  "include": ["src/**/*.ts"],
+}

package/tsup.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  sourcemap: true,
+  clean: true,
+  tsconfig: "tsconfig.build.json",
+  dts: false,
+  format: ["cjs", "esm"],
+  onSuccess:
+    "tsc --project tsconfig.build.json --emitDeclarationOnly --declaration --declarationMap",
+});