@zoralabs/protocol-sdk 0.11.12 → 0.12.0

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

@@ -16,7 +16,6 @@ import {
 } from "@zoralabs/protocol-deployments";
 import { forkUrls, makeAnvilTest } from "src/anvil";
 import { writeContractWithRetries } from "src/test-utils";
-import { createCollectorClient, createCreatorClient } from "src/sdk";
 import { getAllowListEntry } from "src/allow-list/allow-list-client";
 import { SubgraphMintGetter } from "./subgraph-mint-getter";
 import { new1155ContractVersion } from "src/create/contract-setup";
@@ -26,6 +25,8 @@ import {
 } from "src/fixtures/contract-setup";
 import { ISubgraphQuerier } from "src/apis/subgraph-querier";
 import { mockTimedSaleStrategyTokenQueryResult } from "src/fixtures/mint-query-results";
+import { getToken, getTokensOfContract } from "./mint-queries";
+import { create1155 } from "src/create/create-client";
 
 const erc721ABI = parseAbi([
   "function balanceOf(address owner) public view returns (uint256)",
@@ -47,7 +48,7 @@ const getCommentIdentifierFromReceipt = (
   return logs[0]!.args.commentIdentifier;
 };
 
-describe("mint-helper", () => {
+describe("mint-client", () => {
   makeAnvilTest({
     forkBlockNumber: 16028124,
     forkUrl: forkUrls.zoraSepolia,
@@ -55,7 +56,7 @@ describe("mint-helper", () => {
   })(
     "mints a new 1155 token with a comment",
     async ({ viemClients }) => {
-      const { testClient, walletClient, publicClient, chain } = viemClients;
+      const { testClient, walletClient, publicClient } = viemClients;
       const creatorAccount = (await walletClient.getAddresses())[0]!;
       await testClient.setBalance({
         address: creatorAccount,
@@ -64,19 +65,14 @@ describe("mint-helper", () => {
       const targetContract: Address =
         "0xD42557F24034b53e7340A40bb5813eF9Ba88F2b4";
       const targetTokenId = 3n;
-      const collectorClient = createCollectorClient({
-        chainId: chain.id,
+
+      const { prepareMint, primaryMintActive } = await getToken({
+        tokenContract: targetContract,
+        mintType: "1155",
+        tokenId: targetTokenId,
         publicClient,
       });
 
-      const { prepareMint, primaryMintActive } = await collectorClient.getToken(
-        {
-          tokenContract: targetContract,
-          mintType: "1155",
-          tokenId: targetTokenId,
-        },
-      );
-
       expect(primaryMintActive).toBe(true);
       expect(prepareMint).toBeDefined();
 
@@ -143,18 +139,14 @@ describe("mint-helper", () => {
 
       const targetContract: Address =
         "0x7aae7e67515A2CbB8585C707Ca6db37BDd3EA839";
-      const collectorClient = createCollectorClient({
-        chainId: zora.id,
+
+      const { prepareMint, primaryMintActive } = await getToken({
+        tokenContract: targetContract,
+        mintType: "721",
         publicClient,
+        preferredSaleType: "fixedPrice",
       });
 
-      const { prepareMint, primaryMintActive } = await collectorClient.getToken(
-        {
-          tokenContract: targetContract,
-          mintType: "721",
-        },
-      );
-
       const quantityToMint = 3n;
 
       expect(primaryMintActive).toBe(true);
@@ -165,7 +157,7 @@ describe("mint-helper", () => {
         quantityToMint,
       });
 
-      expect(costs.totalPurchaseCost).toBe(quantityToMint * parseEther(".08"));
+      expect(costs.totalPurchaseCost).toBe(quantityToMint * parseEther("0.08"));
       expect(costs.totalCostEth).toBe(
         quantityToMint * (parseEther("0.08") + parseEther("0.000777")),
       );
@@ -204,23 +196,22 @@ describe("mint-helper", () => {
   })(
     "mints an 1155 token with an ERC20 token",
     async ({ viemClients }) => {
-      const { testClient, walletClient, publicClient, chain } = viemClients;
+      const { testClient, walletClient, publicClient } = 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, primaryMintActive } = await minter.getToken({
+      const { prepareMint, primaryMintActive } = await getToken({
         mintType: "1155",
         tokenContract: targetContract,
         tokenId: targetTokenId,
+        publicClient,
       });
 
       const quantityToMint = 1n;
@@ -303,12 +294,7 @@ describe("mint-helper", () => {
     forkBlockNumber: 10970943,
     anvilChainId: zoraSepolia.id,
   })("can mint allowlist tokens", async ({ viemClients }) => {
-    const { publicClient, chain, testClient, walletClient } = viemClients;
-
-    const collectorClient = createCollectorClient({
-      chainId: chain.id,
-      publicClient,
-    });
+    const { publicClient, testClient, walletClient } = viemClients;
 
     const targetContract = "0x440cF6a9f12b2f05Ec4Cee8eE0F317B0eC0c2eCD";
 
@@ -323,10 +309,11 @@ describe("mint-helper", () => {
       merkleRoot,
     });
 
-    const { prepareMint, primaryMintActive } = await collectorClient.getToken({
+    const { prepareMint, primaryMintActive } = await getToken({
       mintType: "1155",
       tokenContract: targetContract,
       tokenId,
+      publicClient,
     });
 
     const minter = (await walletClient.getAddresses())[0]!;
@@ -368,21 +355,16 @@ describe("mint-helper", () => {
     })(
       "gets onchain and premint mintables",
       async ({ viemClients }) => {
-        const { publicClient, chain } = viemClients;
+        const { publicClient } = viemClients;
 
         const targetContract: Address =
           "0xa33e4228843092bb0f2fcbb2eb237bcefc1046b3";
 
-        const minter = createCollectorClient({
-          chainId: chain.id,
+        const { tokens: mintables, contract } = await getTokensOfContract({
+          tokenContract: targetContract,
           publicClient,
         });
 
-        const { tokens: mintables, contract } =
-          await minter.getTokensOfContract({
-            tokenContract: targetContract,
-          });
-
         expect(mintables.length).toBe(4);
         expect(contract).toBeDefined();
       },
@@ -400,24 +382,19 @@ describe("mint-helper", () => {
 
       const creator = (await walletClient.getAddresses())[0]!;
 
-      const creatorClient = createCreatorClient({
-        chainId: chain.id,
+      const { parameters, contractAddress, newTokenId } = await create1155({
+        account: creator,
+        contract: {
+          name: "Test Timed Sale",
+          uri: demoContractMetadataURI,
+          defaultAdmin: creator,
+        },
+        token: {
+          tokenMetadataURI: demoTokenMetadataURI,
+        },
         publicClient,
       });
 
-      const { parameters, contractAddress, newTokenId } =
-        await creatorClient.create1155({
-          account: creator,
-          contract: {
-            name: "Test Timed Sale",
-            uri: demoContractMetadataURI,
-            defaultAdmin: creator,
-          },
-          token: {
-            tokenMetadataURI: demoTokenMetadataURI,
-          },
-        });
-
       const { request: createRequest } =
         await publicClient.simulateContract(parameters);
       await writeContractWithRetries({
@@ -446,12 +423,6 @@ describe("mint-helper", () => {
       const mintGetter = new SubgraphMintGetter(chain.id);
       mintGetter.subgraphQuerier.query = mockQuery;
 
-      const collectorClient = createCollectorClient({
-        chainId: chain.id,
-        publicClient,
-        mintGetter,
-      });
-
       const collector = (await walletClient.getAddresses())[1]!;
 
       const {
@@ -459,10 +430,12 @@ describe("mint-helper", () => {
         primaryMintActive,
         primaryMintEnd,
         secondaryMarketActive,
-      } = await collectorClient.getToken({
+      } = await getToken({
         mintType: "1155",
         tokenContract: contractAddress,
         tokenId: newTokenId,
+        publicClient,
+        mintGetter,
       });
 
       expect(primaryMintActive).toBe(true);

package/src/mint/mint-client.ts

@@ -1,16 +1,20 @@
 import { Address } from "viem";
 import { IPublicClient } from "src/types";
 import {
-  GetMintParameters,
+  GetMintParametersArguments,
   IOnchainMintGetter,
+  MakeMintParameters,
   MintCosts,
   PrepareMintReturn,
   SaleType,
 } from "./types";
-import { MakeMintParametersArguments, GetMintCostsParameters } from "./types";
+import {
+  MakeMintParametersArguments,
+  GetMintCostsParameterArguments,
+} from "./types";
 import { IPremintGetter } from "src/premint/premint-api-client";
 
-import { getMint, getMintCosts, getMintsOfContract } from "./mint-queries";
+import { getToken, getMintCosts, getTokensOfContract } from "./mint-queries";
 
 class MintError extends Error {}
 class MintInactiveError extends Error {}
@@ -20,26 +24,28 @@ export const Errors = {
   MintInactiveError,
 };
 
+/**
+ * @deprecated Please use functions directly without creating a client.
+ * Example: Instead of `new MintClient().mint()`, use `mint()`
+ * Import the functions you need directly from their respective modules:
+ * import { mint, getToken, getTokensOfContract, getMintCosts } from '@zoralabs/protocol-sdk'
+ */
 export class MintClient {
   private readonly publicClient: IPublicClient;
   private readonly mintGetter: IOnchainMintGetter;
   private readonly premintGetter: IPremintGetter;
-  private readonly chainId: number;
   constructor({
     publicClient,
     premintGetter,
     mintGetter,
-    chainId,
   }: {
     publicClient: IPublicClient;
     premintGetter: IPremintGetter;
     mintGetter: IOnchainMintGetter;
-    chainId: number;
   }) {
     this.publicClient = publicClient;
     this.mintGetter = mintGetter;
     this.premintGetter = premintGetter;
-    this.chainId = chainId;
   }
 
   /**
@@ -53,27 +59,25 @@ export class MintClient {
     parameters: MakeMintParametersArguments,
   ): Promise<PrepareMintReturn> {
     return mint({
-      parameters,
+      ...parameters,
       publicClient: this.publicClient,
       mintGetter: this.mintGetter,
       premintGetter: this.premintGetter,
-      chainId: this.chainId,
     });
   }
 
   /**
    * Gets an 1155, 721, or premint, and returns both information about it, and a function
    * that can be used to build a mint transaction for a quantity of items to mint.
-   * @param parameters - Token to get {@link GetMintParameters}
+   * @param parameters - Token to get {@link GetMintParametersArguments}
    * @Returns Information about the mint and a function to build a mint transaction {@link MintableReturn}
    */
-  async get(parameters: GetMintParameters) {
-    return getMint({
-      params: parameters,
+  async get(parameters: GetMintParametersArguments) {
+    return getToken({
+      ...parameters,
       mintGetter: this.mintGetter,
       premintGetter: this.premintGetter,
       publicClient: this.publicClient,
-      chainId: this.chainId,
     });
   }
 
@@ -87,21 +91,22 @@ export class MintClient {
     tokenContract: Address;
     preferredSaleType?: SaleType;
   }) {
-    return getMintsOfContract({
-      params,
+    return getTokensOfContract({
+      ...params,
       mintGetter: this.mintGetter,
       premintGetter: this.premintGetter,
       publicClient: this.publicClient,
-      chainId: this.chainId,
     });
   }
 
   /**
    * Gets the costs to mint the quantity of tokens specified for a mint.
-   * @param parameters - Parameters for the mint {@link GetMintCostsParameters}
+   * @param parameters - Parameters for the mint {@link GetMintCostsParameterArguments}
    * @returns Costs to mint the quantity of tokens specified
    */
-  async getMintCosts(parameters: GetMintCostsParameters): Promise<MintCosts> {
+  async getMintCosts(
+    parameters: GetMintCostsParameterArguments,
+  ): Promise<MintCosts> {
     return getMintCosts({
       params: parameters,
       mintGetter: this.mintGetter,
@@ -111,25 +116,24 @@ export class MintClient {
   }
 }
 
-async function mint({
-  parameters,
+/**
+ * Returns the parameters needed to prepare a transaction mint a token.
+ * Works with premint, onchain 1155, and onchain 721.
+ *
+ * @param parameters - Parameters for collecting the token {@link MakeMintParameters}
+ * @returns Parameters for simulating/executing the mint transaction, any necessary erc20 approval, and costs to mint
+ */
+export async function mint({
   publicClient,
   mintGetter,
   premintGetter,
-  chainId,
-}: {
-  parameters: MakeMintParametersArguments;
-  publicClient: IPublicClient;
-  mintGetter: IOnchainMintGetter;
-  premintGetter: IPremintGetter;
-  chainId: number;
-}): Promise<PrepareMintReturn> {
-  const { prepareMint, primaryMintActive } = await getMint({
-    params: parameters,
+  ...parameters
+}: MakeMintParameters): Promise<PrepareMintReturn> {
+  const { prepareMint, primaryMintActive } = await getToken({
+    ...parameters,
     mintGetter,
     premintGetter,
     publicClient,
-    chainId,
   });
 
   if (!primaryMintActive) {

package/src/mint/mint-queries.ts

@@ -1,10 +1,12 @@
-import { IPremintGetter } from "src/premint/premint-api-client";
+import {
+  IPremintGetter,
+  PremintAPIClient,
+} from "src/premint/premint-api-client";
 import {
   ContractInfo,
   Erc20Approval,
-  GetMintCostsParameters,
+  GetMintCostsParameterArguments,
   GetMintParameters,
-  GetMintsOfContractParameters,
   IOnchainMintGetter,
   MintParametersBase,
   MintableReturn,
@@ -14,6 +16,8 @@ import {
   is1155Mint,
   isOnChainMint,
   GetMintableReturn,
+  GetMintsOfContractParameters,
+  WithPublicClientAndRequiredGetters,
 } from "./types";
 import { Address, zeroAddress } from "viem";
 import {
@@ -27,45 +31,51 @@ import {
 } from "src/premint/conversions";
 import { makeOnchainMintCall, parseMintCosts } from "./mint-transactions";
 import { buildPremintMintCall } from "src/premint/premint-client";
-import { IPublicClient } from "src/types";
 import { AllowListEntry } from "src/allow-list/types";
 import { Concrete } from "src/utils";
-
-export async function getMint({
-  params,
-  mintGetter,
-  premintGetter,
-  publicClient,
-  chainId,
-}: {
-  params: GetMintParameters;
-  mintGetter: IOnchainMintGetter;
-  premintGetter: IPremintGetter;
-  publicClient: IPublicClient;
-  chainId: number;
-}): Promise<MintableReturn> {
-  const { tokenContract } = params;
+import { parseAndFilterTokenQueryResult } from "./strategies-parsing";
+import { SubgraphMintGetter } from "./subgraph-mint-getter";
+
+/**
+ * Gets an 1155, 721, or premint, and returns both information about it, and a function
+ * that can be used to build a mint transaction for a quantity of items to mint.
+ * @param parameters - Token to get {@link GetMintParameters}
+ * @returns Information about the mint and a function to build a mint transaction {@link MintableReturn}
+ */
+export async function getToken(
+  params: GetMintParameters,
+): Promise<MintableReturn> {
+  const { premintGetter, publicClient } = params;
+  const chainId = publicClient.chain.id;
   if (isOnChainMint(params)) {
     const tokenId = is1155Mint(params) ? params.tokenId : undefined;
     const blockTime = (await publicClient.getBlock()).timestamp;
-    const result = await mintGetter.getMintable({
+    const mintGetterOrDefault =
+      params.mintGetter ?? new SubgraphMintGetter(chainId);
+    const result = await mintGetterOrDefault.getMintable({
+      tokenId,
+      tokenAddress: params.tokenContract,
+    });
+
+    const token = parseAndFilterTokenQueryResult({
+      token: result,
       tokenId,
-      tokenAddress: tokenContract,
       preferredSaleType: params.preferredSaleType,
-      blockTime: blockTime,
+      blockTime,
     });
 
-    return toMintableReturn(result, chainId);
+    return toMintableReturn(token, chainId);
   }
 
-  const premint = await premintGetter.get({
-    collectionAddress: tokenContract,
+  const premintGetterOrDefault = premintGetter ?? new PremintAPIClient(chainId);
+  const premint = await premintGetterOrDefault.get({
+    collectionAddress: params.tokenContract,
     uid: params.uid,
   });
 
   const mintFee = await getPremintMintFee({
     publicClient,
-    tokenContract: tokenContract,
+    tokenContract: params.tokenContract,
   });
 
   return toPremintMintReturn({ premint, mintFee });
@@ -100,28 +110,33 @@ export async function getPremintsOfCollectionWithTokenIds({
   };
 }
 
-export async function getMintsOfContract({
-  params,
+/**
+ * Gets onchain and premint tokens of an 1155 contract. For each token returns both information about it, and a function
+ * that can be used to build a mint transaction for a quantity of items to mint.
+ * @param parameters - Contract address to get tokens for {@link GetMintsOfContractParameters}
+ * @returns Array of tokens, each containing information about the token and a function to build a mint transaction.
+ */
+export async function getTokensOfContract({
   mintGetter,
   premintGetter,
   publicClient,
-  chainId,
-}: {
-  params: GetMintsOfContractParameters;
-  mintGetter: IOnchainMintGetter;
-  premintGetter: IPremintGetter;
-  publicClient: IPublicClient;
-  chainId: number;
-}): Promise<{ contract?: ContractInfo; tokens: MintableReturn[] }> {
+  ...params
+}: GetMintsOfContractParameters): Promise<{
+  contract?: ContractInfo;
+  tokens: MintableReturn[];
+}> {
+  const chainId = publicClient.chain.id;
+  const mintGetterOrDefault: IOnchainMintGetter =
+    mintGetter ?? new SubgraphMintGetter(chainId);
   const onchainMints = (
-    await mintGetter.getContractMintable({
+    await mintGetterOrDefault.getContractMintable({
       tokenAddress: params.tokenContract,
     })
   ).map((result) => toMintableReturn(result, chainId));
 
   const offchainMints = await getPremintsOfContractMintable({
-    mintGetter,
-    premintGetter,
+    mintGetter: mintGetterOrDefault,
+    premintGetter: premintGetter ?? new PremintAPIClient(chainId),
     publicClient,
     params: {
       tokenContract: params.tokenContract,
@@ -136,35 +151,42 @@ export async function getMintsOfContract({
   };
 }
 
+/**
+ * Gets the costs to mint the quantity of tokens specified for a mint.
+ * @param parameters - Parameters for the mint {@link GetMintCostsParameterArguments}
+ * @returns Costs to mint the quantity of tokens specified
+ */
 export async function getMintCosts({
   params,
   allowListEntry,
   mintGetter,
   premintGetter,
   publicClient,
-}: {
-  params: GetMintCostsParameters;
+}: WithPublicClientAndRequiredGetters<{
+  params: GetMintCostsParameterArguments;
   allowListEntry?: Pick<AllowListEntry, "price">;
-  mintGetter: IOnchainMintGetter;
-  premintGetter: IPremintGetter;
-  publicClient: IPublicClient;
-}) {
+}>) {
   const { quantityMinted: quantityToMint, collection } = params;
   if (isOnChainMint(params)) {
     const tokenId = is1155Mint(params) ? params.tokenId : undefined;
     const blockTime = (await publicClient.getBlock()).timestamp;
-    const { salesConfigAndTokenInfo } = await mintGetter.getMintable({
+    const result = await mintGetter.getMintable({
       tokenId,
       tokenAddress: collection,
+    });
+
+    const token = parseAndFilterTokenQueryResult({
+      token: result,
+      tokenId,
       blockTime,
     });
 
-    if (!salesConfigAndTokenInfo.salesConfig) {
+    if (!token.salesConfigAndTokenInfo.salesConfig) {
       throw new Error("No valid sales config found for token");
     }
 
     return parseMintCosts({
-      salesConfig: salesConfigAndTokenInfo.salesConfig,
+      salesConfig: token.salesConfigAndTokenInfo.salesConfig,
       quantityToMint: BigInt(quantityToMint),
       allowListEntry,
     });
@@ -184,12 +206,9 @@ async function getPremintsOfContractMintable({
   premintGetter,
   publicClient,
   params,
-}: {
-  mintGetter: IOnchainMintGetter;
-  premintGetter: IPremintGetter;
-  publicClient: IPublicClient;
+}: WithPublicClientAndRequiredGetters<{
   params: { tokenContract: Address };
-}): Promise<MintableReturn[]> {
+}>): Promise<MintableReturn[]> {
   const { premints, collection } = await getPremintsOfCollectionWithTokenIds({
     mintGetter,
     premintGetter,
@@ -295,7 +314,7 @@ export const makeOnchainPrepareMint =
     };
   };
 
-function toMintableReturn(
+export function toMintableReturn(
   result: GetMintableReturn,
   chainId: number,
 ): MintableReturn {