@zoralabs/protocol-sdk 0.7.3-SPARKS.0 → 0.7.3

package/dist/mints/mints-relay-example.d.ts

@@ -1,6 +1,6 @@
 import { Address, Hex, PublicClient, WalletClient } from "viem";
 import { PermitSafeTransferBatch } from "./mints-contracts";
-import { sparksEthUnwrapperAndCallerAddress } from "@zoralabs/protocol-deployments";
+import { mintsEthUnwrapperAndCallerAddress } from "@zoralabs/protocol-deployments";
 export declare const getRelayCall: ({ tx, depositingAccount, originChainId, toChainId, }: {
     tx: {
         to: Address;
@@ -23,7 +23,7 @@ export declare const getRelayCall: ({ tx, depositingAccount, originChainId, toCh
     relayFee: bigint;
 }>;
 export declare const makeAndSignSponsoredRelayCall: ({ originChainId, toChainId, tx, executingAccount, walletClient, }: {
-    originChainId: keyof typeof sparksEthUnwrapperAndCallerAddress;
+    originChainId: keyof typeof mintsEthUnwrapperAndCallerAddress;
     toChainId: number;
     tx: {
         to: Address;
@@ -43,7 +43,7 @@ export declare const validateSponsoredRelayCall: ({ safeTransferData, additional
     additionalValueToSend: bigint;
     deadline: bigint;
     executingAccount: Address;
-    chainId: keyof typeof sparksEthUnwrapperAndCallerAddress;
+    chainId: keyof typeof mintsEthUnwrapperAndCallerAddress;
     signature: Hex;
 }) => Promise<void>;
 export declare const validateAndExecuteSponsoredRelayCall: ({ permit, permitSignature, additionalValueToSend, deadline, chainId, executingAccount, sponsoredCallSignature, walletClient, publicClient, }: {
@@ -52,7 +52,7 @@ export declare const validateAndExecuteSponsoredRelayCall: ({ permit, permitSign
     additionalValueToSend: bigint;
     deadline: bigint;
     executingAccount: Address;
-    chainId: keyof typeof sparksEthUnwrapperAndCallerAddress;
+    chainId: keyof typeof mintsEthUnwrapperAndCallerAddress;
     sponsoredCallSignature: Hex;
     publicClient: PublicClient;
     walletClient: WalletClient;

package/dist/mints/mints-relay-example.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mints-relay-example.d.ts","sourceRoot":"","sources":["../../src/mints/mints-relay-example.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,GAAG,EACH,YAAY,EAGZ,YAAY,EAEb,MAAM,MAAM,CAAC;AAGd,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAEL,kCAAkC,EACnC,MAAM,gCAAgC,CAAC;AAuBxC,eAAO,MAAM,YAAY;QAMnB;QACF,EAAE,EAAE,OAAO,CAAC;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,GAAG,CAAC;KACX;uBACkB,OAAO;mBACX,MAAM;eACV,MAAM;;;;;;;;;;;;EAyClB,CAAC;AAKF,eAAO,MAAM,6BAA6B;mBAQzB,MAAM,yCAAyC;eAEnD,MAAM;QAEb;QACF,EAAE,EAAE,OAAO,CAAC;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,GAAG,CAAC;KACX;sBACiB,OAAO;kBACX,YAAY;;;;;;EA2C3B,CAAC;AAIF,eAAO,MAAM,0BAA0B;sBASnB,GAAG;2BACE,MAAM;cACnB,MAAM;sBACE,OAAO;aAChB,MAAM,yCAAyC;eAC7C,GAAG;mBAiBf,CAAC;AAIF,eAAO,MAAM,oCAAoC;YAYvC,uBAAuB;qBACd,GAAG;2BAEG,MAAM;cAEnB,MAAM;sBAEE,OAAO;aAChB,MAAM,yCAAyC;4BAEhC,GAAG;kBACb,YAAY;kBACZ,YAAY;mBAyC3B,CAAC"}
+{"version":3,"file":"mints-relay-example.d.ts","sourceRoot":"","sources":["../../src/mints/mints-relay-example.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,GAAG,EACH,YAAY,EAGZ,YAAY,EAEb,MAAM,MAAM,CAAC;AAEd,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAEL,iCAAiC,EAClC,MAAM,gCAAgC,CAAC;AAiCxC,eAAO,MAAM,YAAY;QAMnB;QACF,EAAE,EAAE,OAAO,CAAC;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,GAAG,CAAC;KACX;uBACkB,OAAO;mBACX,MAAM;eACV,MAAM;;;;;;;;;;;;EAyClB,CAAC;AAKF,eAAO,MAAM,6BAA6B;mBAQzB,MAAM,wCAAwC;eAElD,MAAM;QAEb;QACF,EAAE,EAAE,OAAO,CAAC;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,GAAG,CAAC;KACX;sBACiB,OAAO;kBACX,YAAY;;;;;;EA2C3B,CAAC;AAIF,eAAO,MAAM,0BAA0B;sBASnB,GAAG;2BACE,MAAM;cACnB,MAAM;sBACE,OAAO;aAChB,MAAM,wCAAwC;eAC5C,GAAG;mBAiBf,CAAC;AAIF,eAAO,MAAM,oCAAoC;YAYvC,uBAAuB;qBACd,GAAG;2BAEG,MAAM;cAEnB,MAAM;sBAEE,OAAO;aAChB,MAAM,wCAAwC;4BAE/B,GAAG;kBACb,YAAY;kBACZ,YAAY;mBAyC3B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoralabs/protocol-sdk",
-  "version": "0.7.3-SPARKS.0",
+  "version": "0.7.3",
   "repository": "https://github.com/ourzora/zora-protocol",
   "license": "MIT",
   "type": "module",
@@ -16,28 +16,32 @@
     }
   },
   "scripts": {
-    "build": "tsup",
+    "build": "yarn run tsup",
     "prepack": "yarn build",
     "test:js": "vitest src",
     "test:integration": "vitest test-integration",
     "generate-types": "echo 'npx is used here because this is a rare operation' && npx openapi-typescript https://api.zora.co/premint/openapi.json -o src/apis/generated/premint-api-types.ts",
-    "prettier": "prettier --write 'src/**/*.ts' 'test-integration/**/*.ts'",
+    "prettier:write": "prettier --write 'src/**/*.ts' 'test-integration/**/*.ts'",
     "lint": "prettier --check 'src/**/*.ts' 'test-integration/**/*.ts'"
   },
   "dependencies": {
-    "@zoralabs/protocol-deployments": "0.2.0-SPARKS.0",
+    "@zoralabs/protocol-deployments": "*",
+    "abitype": "^1.0.2",
     "semver": "^7.6.2"
   },
   "peerDependencies": {
-    "viem": "^2.11.1"
+    "viem": "^2.13.2"
   },
   "devDependencies": {
+    "@types/node": "^20.13.0",
     "@fleekhq/fleek-storage-js": "^1.0.24",
     "@lavamoat/preinstall-always-fail": "2.0.0",
     "@reservoir0x/relay-sdk": "^0.3.8",
     "@reservoir0x/reservoir-sdk": "^2.0.11",
-    "abitype": "^1.0.2",
     "graphql-prettier": "^1.0.6",
+    "tsup": "^7.2.0",
+    "prettier": "^3.0.3",
+    "prettier-plugin-solidity": "^1.1.3",
     "typescript": "^5.2.2",
     "vite": "^4.5.0",
     "vitest": "^0.34.6",

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

@@ -0,0 +1,325 @@
+import { describe, expect } from "vitest";
+import { getTokenIdFromCreateReceipt } from "./1155-create-helper";
+import { anvilTest } from "src/anvil";
+import { createCreatorClient } from "src/sdk";
+import { zoraCreator1155ImplABI } from "@zoralabs/protocol-deployments";
+import { waitForSuccess } from "src/test-utils";
+import { parseEther } from "viem";
+import {
+  MintableParameters,
+  makePrepareMint1155TokenParams,
+} from "src/mint/mint-transactions";
+
+const demoTokenMetadataURI = "ipfs://DUMMY/token.json";
+const demoContractMetadataURI = "ipfs://DUMMY/contract.json";
+
+describe("create-helper", () => {
+  anvilTest(
+    "creates a new 1155 contract and token",
+    async ({ viemClients: { publicClient, walletClient, chain } }) => {
+      const addresses = await walletClient.getAddresses();
+      const creatorAddress = addresses[0]!;
+
+      const creatorClient = createCreatorClient({
+        chainId: chain.id,
+        publicClient: publicClient,
+      });
+      const { parameters: request } = await creatorClient.create1155({
+        contract: {
+          name: "testContract",
+          uri: demoContractMetadataURI,
+        },
+        token: {
+          tokenMetadataURI: demoTokenMetadataURI,
+          mintToCreatorCount: 1,
+        },
+        account: creatorAddress,
+      });
+      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, then can create a new token on this existing contract",
+    async ({ viemClients: { publicClient, walletClient, chain } }) => {
+      const addresses = await walletClient.getAddresses();
+      const creatorAccount = addresses[0]!;
+
+      const creatorClient = createCreatorClient({
+        chainId: chain.id,
+        publicClient: publicClient,
+      });
+
+      const {
+        parameters: request,
+        collectionAddress: contractAddress,
+        contractExists,
+      } = await creatorClient.create1155({
+        contract: {
+          name: "testContract2",
+          uri: demoContractMetadataURI,
+        },
+        token: {
+          tokenMetadataURI: demoTokenMetadataURI,
+          mintToCreatorCount: 3,
+        },
+        account: creatorAccount,
+      });
+      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();
+
+      // creator should have mint to creator count balance
+      expect(
+        await publicClient.readContract({
+          address: contractAddress,
+          abi: zoraCreator1155ImplABI,
+          functionName: "balanceOf",
+          args: [creatorAccount, firstTokenId!],
+        }),
+      ).toBe(3n);
+
+      const newTokenOnExistingContract = await creatorClient.create1155({
+        contract: {
+          name: "testContract2",
+          uri: demoContractMetadataURI,
+        },
+        token: {
+          tokenMetadataURI: demoTokenMetadataURI,
+          mintToCreatorCount: 2,
+        },
+        account: creatorAccount,
+      });
+      expect(newTokenOnExistingContract.collectionAddress).to.be.equal(
+        "0xb1A8928dF830C21eD682949Aa8A83C1C215194d3",
+      );
+      expect(newTokenOnExistingContract.contractExists).to.be.true;
+      const { request: simulateRequest } = await publicClient.simulateContract(
+        newTokenOnExistingContract.parameters,
+      );
+      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,
+  );
+  anvilTest(
+    "creates a new token with a create referral address",
+    async ({ viemClients: { publicClient, walletClient, chain } }) => {
+      const addresses = await walletClient.getAddresses();
+      const creatorAddress = addresses[0]!;
+      const createReferral = addresses[1]!;
+
+      const creatorClient = createCreatorClient({
+        chainId: chain.id,
+        publicClient: publicClient,
+      });
+      const { parameters: request } = await creatorClient.create1155({
+        contract: {
+          name: "testContract",
+          uri: demoContractMetadataURI,
+        },
+        token: {
+          tokenMetadataURI: demoTokenMetadataURI,
+          createReferral,
+        },
+        account: creatorAddress,
+      });
+      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("0xa72724cc3dcef210141a1b84c61824074151dc99");
+      expect(getTokenIdFromCreateReceipt(receipt)).to.be.equal(2n);
+
+      expect(
+        await publicClient.readContract({
+          abi: zoraCreator1155ImplABI,
+          address: "0xa72724cc3dcef210141a1b84c61824074151dc99",
+          functionName: "createReferrals",
+          args: [2n],
+        }),
+      ).to.be.equal(createReferral);
+    },
+    20 * 1000,
+  );
+
+  anvilTest(
+    "creates a new 1155 free mint that can be minted",
+    async ({
+      viemClients: { testClient, publicClient, walletClient, chain },
+    }) => {
+      const addresses = await walletClient.getAddresses();
+      const creatorAddress = addresses[0]!;
+
+      const creatorClient = createCreatorClient({
+        chainId: chain.id,
+        publicClient: publicClient,
+      });
+      const {
+        parameters: request,
+        collectionAddress,
+        newTokenId,
+        newToken,
+        minter,
+      } = await creatorClient.create1155({
+        contract: {
+          name: "testContract",
+          uri: demoContractMetadataURI,
+        },
+        token: {
+          tokenMetadataURI: demoTokenMetadataURI,
+        },
+        account: creatorAddress,
+      });
+      const { request: createSimulation } =
+        await publicClient.simulateContract(request);
+      await waitForSuccess(
+        await walletClient.writeContract(createSimulation),
+        publicClient,
+      );
+
+      const salesConfigAndTokenInfo: MintableParameters = {
+        mintFeePerQuantity: parseEther("0.000777"),
+        contractVersion: "2.8.0",
+        salesConfig: {
+          saleType: "fixedPrice",
+          address: minter,
+          pricePerToken: newToken.salesConfig.pricePerToken,
+          // these dont matter
+          maxTokensPerAddress: 0n,
+          saleEnd: "",
+          saleStart: "",
+        },
+      };
+
+      const quantityToMint = 5n;
+
+      // now try to mint a free mint
+      const minterAddress = addresses[1]!;
+
+      await testClient.setBalance({
+        address: minterAddress,
+        value: parseEther("10"),
+      });
+
+      const mintParams = makePrepareMint1155TokenParams({
+        tokenContract: collectionAddress,
+        minterAccount: minterAddress,
+        tokenId: newTokenId,
+        salesConfigAndTokenInfo,
+        quantityToMint,
+      });
+
+      const { request: collectSimulation } =
+        await publicClient.simulateContract(mintParams);
+      await waitForSuccess(
+        await walletClient.writeContract(collectSimulation),
+        publicClient,
+      );
+    },
+    20 * 1000,
+  );
+
+  anvilTest(
+    "creates a new 1155 paid mint that can be minted",
+    async ({
+      viemClients: { testClient, publicClient, walletClient, chain },
+    }) => {
+      const addresses = await walletClient.getAddresses();
+      const creatorAddress = addresses[0]!;
+
+      const creatorClient = createCreatorClient({
+        chainId: chain.id,
+        publicClient: publicClient,
+      });
+
+      const pricePerToken = parseEther("0.01");
+
+      const {
+        parameters: request,
+        collectionAddress,
+        newTokenId,
+        newToken,
+        minter,
+      } = await creatorClient.create1155({
+        contract: {
+          name: "testContract",
+          uri: demoContractMetadataURI,
+        },
+        token: {
+          tokenMetadataURI: demoTokenMetadataURI,
+          salesConfig: {
+            pricePerToken,
+          },
+        },
+        account: creatorAddress,
+      });
+      const { request: createSimulation } =
+        await publicClient.simulateContract(request);
+      await waitForSuccess(
+        await walletClient.writeContract(createSimulation),
+        publicClient,
+      );
+
+      const salesConfigAndTokenInfo: MintableParameters = {
+        mintFeePerQuantity: parseEther("0.000777"),
+        contractVersion: "2.8.0",
+        salesConfig: {
+          saleType: "fixedPrice",
+          address: minter,
+          pricePerToken: newToken.salesConfig.pricePerToken,
+          // these dont matter
+          maxTokensPerAddress: 0n,
+          saleEnd: "",
+          saleStart: "",
+        },
+      };
+
+      const quantityToMint = 5n;
+
+      // now try to mint a free mint
+      const minterAddress = addresses[1]!;
+
+      await testClient.setBalance({
+        address: minterAddress,
+        value: parseEther("10"),
+      });
+
+      const mintParams = makePrepareMint1155TokenParams({
+        tokenContract: collectionAddress,
+        minterAccount: minterAddress,
+        tokenId: newTokenId,
+        salesConfigAndTokenInfo,
+        quantityToMint,
+      });
+
+      const { request: collectSimulation } =
+        await publicClient.simulateContract(mintParams);
+      await waitForSuccess(
+        await walletClient.writeContract(collectSimulation),
+        publicClient,
+      );
+    },
+    20 * 1000,
+  );
+});

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

@@ -0,0 +1,263 @@
+import { describe, expect } from "vitest";
+import { Address, erc20Abi, parseAbi, parseEther } from "viem";
+import { zora, zoraSepolia } from "viem/chains";
+import { zoraCreator1155ImplABI } from "@zoralabs/protocol-deployments";
+import { forkUrls, makeAnvilTest } from "src/anvil";
+import { createCollectorClient } from "src/sdk";
+
+const erc721ABI = parseAbi([
+  "function balanceOf(address owner) public view returns (uint256)",
+] as const);
+
+describe("mint-helper", () => {
+  makeAnvilTest({
+    forkBlockNumber: 16028671,
+    forkUrl: forkUrls.zoraMainnet,
+    anvilChainId: zora.id,
+  })(
+    "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 collectorClient = createCollectorClient({
+        chainId: zora.id,
+        publicClient,
+      });
+
+      const { token: mintable, prepareMint } = await collectorClient.getToken({
+        tokenContract: targetContract,
+        mintType: "1155",
+        tokenId: targetTokenId,
+      });
+
+      mintable.maxSupply;
+      mintable.totalMinted;
+      mintable.tokenURI;
+      mintable;
+
+      const { parameters, costs } = prepareMint({
+        minterAccount: creatorAccount,
+        quantityToMint: 1,
+      });
+
+      expect(costs.totalCostEth).toBe(1n * parseEther("0.000777"));
+
+      const oldBalance = await publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [creatorAccount, targetTokenId],
+      });
+
+      const simulationResult = await publicClient.simulateContract(parameters);
+
+      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,
+    anvilChainId: zora.id,
+  })(
+    "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 collectorClient = createCollectorClient({
+        chainId: zora.id,
+        publicClient,
+      });
+
+      const { prepareMint } = await collectorClient.getToken({
+        tokenContract: targetContract,
+        mintType: "721",
+      });
+
+      const quantityToMint = 3n;
+
+      const { parameters, costs } = prepareMint({
+        minterAccount: creatorAccount,
+        mintRecipient: creatorAccount,
+        quantityToMint,
+      });
+
+      expect(costs.totalPurchaseCost).toBe(quantityToMint * parseEther(".08"));
+      expect(costs.totalCostEth).toBe(
+        quantityToMint * (parseEther("0.08") + parseEther("0.000777")),
+      );
+
+      const oldBalance = await publicClient.readContract({
+        abi: erc721ABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [creatorAccount],
+      });
+
+      const simulated = await publicClient.simulateContract(parameters);
+
+      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(quantityToMint);
+    },
+    12 * 1000,
+  );
+
+  makeAnvilTest({
+    forkUrl: forkUrls.zoraMainnet,
+    forkBlockNumber: 14484183,
+    anvilChainId: zora.id,
+  })(
+    "mints an 1155 token with an ERC20 token",
+    async ({ viemClients }) => {
+      const { testClient, walletClient, publicClient, chain } = viemClients;
+
+      const targetContract: Address =
+        "0x689bc305456c38656856d12469aed282fbd89fe0";
+      const targetTokenId = 16n;
+
+      const minter = createCollectorClient({ chainId: chain.id, publicClient });
+
+      const mockCollector = "0xb6b701878a1f80197dF2c209D0BDd292EA73164D";
+      await testClient.impersonateAccount({
+        address: mockCollector,
+      });
+
+      const { prepareMint } = await minter.getToken({
+        mintType: "1155",
+        tokenContract: targetContract,
+        tokenId: targetTokenId,
+      });
+
+      const quantityToMint = 1n;
+
+      const { parameters, erc20Approval, costs } = prepareMint({
+        minterAccount: mockCollector,
+        quantityToMint,
+      });
+
+      expect(erc20Approval).toBeDefined();
+      expect(costs.totalCostEth).toBe(0n);
+      expect(costs.totalPurchaseCost).toBe(
+        quantityToMint * 1000000000000000000n,
+      );
+      expect(costs.totalPurchaseCostCurrency).toBe(
+        "0xa6b280b42cb0b7c4a4f789ec6ccc3a7609a1bc39",
+      );
+
+      const beforeERC20Balance = await publicClient.readContract({
+        abi: erc20Abi,
+        address: erc20Approval!.erc20,
+        functionName: "balanceOf",
+        args: [mockCollector],
+      });
+
+      // execute the erc20 approval
+      const { request: erc20Request } = await publicClient.simulateContract({
+        abi: erc20Abi,
+        address: erc20Approval!.erc20,
+        functionName: "approve",
+        args: [erc20Approval!.approveTo, erc20Approval!.quantity],
+        account: mockCollector,
+      });
+
+      const approveHash = await walletClient.writeContract(erc20Request);
+      await publicClient.waitForTransactionReceipt({
+        hash: approveHash,
+      });
+
+      const beforeCollector1155Balance = await publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [mockCollector, targetTokenId],
+      });
+      expect(beforeCollector1155Balance).to.be.equal(0n);
+
+      // execute the mint
+      const simulationResult = await publicClient.simulateContract(parameters);
+      const hash = await walletClient.writeContract(simulationResult.request);
+      await publicClient.waitForTransactionReceipt({ hash });
+
+      const afterERC20Balance = await publicClient.readContract({
+        abi: erc20Abi,
+        address: erc20Approval!.erc20,
+        functionName: "balanceOf",
+        args: [mockCollector],
+      });
+
+      expect(beforeERC20Balance - afterERC20Balance).to.be.equal(
+        erc20Approval!.quantity,
+      );
+
+      const afterCollector1155Balance = await publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [mockCollector, targetTokenId],
+      });
+      expect(afterCollector1155Balance).to.be.equal(quantityToMint);
+    },
+    12 * 1000,
+  );
+
+  makeAnvilTest({
+    forkUrl: forkUrls.zoraSepolia,
+    forkBlockNumber: 10294670,
+    anvilChainId: zoraSepolia.id,
+  })(
+    "gets onchain and premint mintables",
+    async ({ viemClients }) => {
+      const { publicClient, chain } = viemClients;
+
+      const targetContract: Address =
+        "0xa33e4228843092bb0f2fcbb2eb237bcefc1046b3";
+
+      const minter = createCollectorClient({ chainId: chain.id, publicClient });
+
+      const { tokens: mintables, contract } = await minter.getTokensOfContract({
+        tokenContract: targetContract,
+      });
+
+      expect(mintables.length).toBe(4);
+      expect(contract).toBeDefined();
+    },
+    12 * 1000,
+  );
+});