@zoralabs/protocol-sdk 0.5.7-MINT.1 → 0.5.7-MINT.3

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @zoralabs/protocol-sdk
 
+## 0.5.7-MINT.3
+
+### Patch Changes
+
+- Updated dependencies [e3d346c7]
+  - @zoralabs/protocol-deployments@0.1.3-MINT.2
+
+## 0.5.7-MINT.2
+
+### Patch Changes
+
+- 70c593bc: Added sdk method to get total MINT balance
+
 ## 0.5.7-MINT.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoralabs/protocol-sdk",
-  "version": "0.5.7-MINT.1",
+  "version": "0.5.7-MINT.3",
   "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.3-MINT.1",
+    "@zoralabs/protocol-deployments": "0.1.3-MINT.2",
     "abitype": "^0.10.3"
   },
   "peerDependencies": {

package/.turbo/turbo-build.log

@@ -1,15 +0,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
-ESM dist/index.js     48.81 KB
-ESM dist/index.js.map 103.22 KB
-ESM ⚡️ Build success in 110ms
-CJS dist/index.cjs     53.11 KB
-CJS dist/index.cjs.map 103.21 KB
-CJS ⚡️ Build success in 113ms

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

@@ -1,104 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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/mints/mints-queries.test.ts

@@ -1,105 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  MintAccountBalance,
-  selectMintsToCollectWithFromQueryResult,
-  sumBalances,
-} from "./mints-queries";
-
-describe("MINTs queries", () => {
-  describe("selectMintsToCollectWithFromQueryResult", () => {
-    it("should return the optimum tokenIds and quantities to collect", async () => {
-      // account has 3 of token 1, 4 of token 2, 10 of token 3
-      // token 1 price is 2, token 2 price is 1, token 3 price is 3
-      // we want to collect 10 tokens
-      // we should return token 2 with 4 tokens, token 1 with 3 tokens, and token 3 with 3 tokens
-      const mintTokenBalances: MintAccountBalance[] = [
-        {
-          mintToken: {
-            id: "1",
-            pricePerToken: "2",
-          },
-          balance: "3",
-        },
-        {
-          mintToken: {
-            id: "2",
-            pricePerToken: "1",
-          },
-          balance: "4",
-        },
-        {
-          mintToken: {
-            id: "3",
-            pricePerToken: "3",
-          },
-          balance: "10",
-        },
-      ];
-
-      const result = selectMintsToCollectWithFromQueryResult(
-        mintTokenBalances,
-        10n,
-      );
-
-      const expectedResult = {
-        tokenIds: [2n, 1n, 3n],
-        quantities: [4n, 3n, 3n],
-      };
-
-      expect(result).toEqual(expectedResult);
-    });
-
-    it("should throw an error if not enough tokens to collect with", () => {
-      const mintTokenBalances: MintAccountBalance[] = [
-        {
-          mintToken: {
-            id: "1",
-            pricePerToken: "2",
-          },
-          balance: "3",
-        },
-        {
-          mintToken: {
-            id: "2",
-            pricePerToken: "1",
-          },
-          balance: "4",
-        },
-      ];
-      const quantityToCollect = 8n;
-
-      expect(() => {
-        selectMintsToCollectWithFromQueryResult(
-          mintTokenBalances,
-          quantityToCollect,
-        );
-      }).toThrowError("Not enough MINTs to collect with");
-    });
-  });
-
-  describe("sumBalances", () => {
-    it("should return the sum of the balances", async () => {
-      // account has 3 of token 1, 4 of token 2, 10 of token 3
-      // token 1 price is 2, token 2 price is 1, token 3 price is 3
-      // we want to collect 10 tokens
-      // we should return token 2 with 4 tokens, token 1 with 3 tokens, and token 3 with 3 tokens
-      const mintTokenBalances: Pick<MintAccountBalance, "balance">[] = [
-        {
-          balance: "3",
-        },
-        {
-          balance: "4",
-        },
-        {
-          balance: "10",
-        },
-      ];
-
-      const result = sumBalances(mintTokenBalances);
-
-      const expectedResult = 3n + 4n + 10n;
-
-      expect(result).toEqual(expectedResult);
-    });
-  });
-});

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

@@ -1,239 +0,0 @@
-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

@@ -1,615 +0,0 @@
-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

@@ -1,146 +0,0 @@
-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

@@ -1,10 +0,0 @@
-{
-  "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

@@ -1,12 +0,0 @@
-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",
-});