@zoralabs/protocol-sdk 0.3.4 → 0.4.0

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

@@ -2,23 +2,26 @@ import {
   httpClient as defaultHttpClient,
   IHttpClient,
 } from "../apis/http-api-base";
-import { paths } from "../apis/generated/discover-api-types";
-import { ZORA_API_BASE } from "../constants";
 import { NetworkConfig, networkConfigByChain } from "src/apis/chain-constants";
+import { GenericTokenIdTypes } from "src/types";
 import { Address } from "viem";
 
-export type MintableGetToken =
-  paths["/mintables/{chain_name}/{collection_address}"];
-type MintableGetTokenPathParameters =
-  MintableGetToken["get"]["parameters"]["path"];
-type MintableGetTokenGetQueryParameters =
-  MintableGetToken["get"]["parameters"]["query"];
-export type MintableGetTokenResponse =
-  MintableGetToken["get"]["responses"][200]["content"]["application/json"];
+type FixedPriceSaleStrategyResult = {
+  address: Address;
+  pricePerToken: string;
+  saleEnd: string;
+  saleStart: string;
+  maxTokensPerAddress: string;
+};
 
-function encodeQueryParameters(params: Record<string, string>) {
-  return new URLSearchParams(params).toString();
-}
+type SaleStrategyResult = {
+  fixedPrice: FixedPriceSaleStrategyResult;
+};
+
+export type SalesConfigAndTokenInfo = {
+  fixedPrice: FixedPriceSaleStrategyResult;
+  mintFeePerQuantity: bigint;
+};
 
 export const getApiNetworkConfigForChain = (chainId: number): NetworkConfig => {
   if (!networkConfigByChain[chainId]) {
@@ -36,76 +39,77 @@ export class MintAPIClient {
     this.networkConfig = getApiNetworkConfigForChain(chainId);
   }
 
-  async getMintable(
-    path: MintableGetTokenPathParameters,
-    query: MintableGetTokenGetQueryParameters,
-  ): Promise<MintableGetTokenResponse> {
-    const httpClient = this.httpClient;
-    return httpClient.retries(() => {
-      return httpClient.get<MintableGetTokenResponse>(
-        `${ZORA_API_BASE}discover/mintables/${path.chain_name}/${
-          path.collection_address
-        }${query?.token_id ? `?${encodeQueryParameters(query)}` : ""}`,
-      );
-    });
-  }
-
-  async getSalesConfigFixedPrice({
-    contractAddress,
+  async getSalesConfigAndTokenInfo({
+    tokenAddress,
     tokenId,
   }: {
-    contractAddress: string;
-    tokenId: bigint;
-  }): Promise<undefined | { address: Address; pricePerToken: bigint }> {
+    tokenAddress: Address;
+    tokenId?: GenericTokenIdTypes;
+  }): Promise<SalesConfigAndTokenInfo> {
     const { retries, post } = this.httpClient;
     return retries(async () => {
       const response = await post<any>(this.networkConfig.subgraphUrl, {
-        query: `query ($id: ID!) {
-          zoraCreateToken(id: $id) {
-            id
-            salesStrategies(where: {type: "FIXED_PRICE"}) {
-              type
-              fixedPrice {
-                address
-                pricePerToken
-                saleEnd
-                saleStart
-                maxTokensPerAddress
+        query: `
+          fragment SaleStrategy on SalesStrategyConfig {
+            type
+            fixedPrice {
+              address
+              pricePerToken
+              saleEnd
+              saleStart
+              maxTokensPerAddress
+            }
+          }
+          
+          query ($id: ID!) {
+            zoraCreateToken(id: $id) {
+              id
+              contract {
+                mintFeePerQuantity
+                salesStrategies(where: {type: "FIXED_PRICE"}) {
+                  ...SaleStrategy
+                }
+              }
+              salesStrategies(where: {type: "FIXED_PRICE"}) {
+                ...SaleStrategy
               }
             }
           }
-        }`,
+        `,
         variables: {
-          id: `${contractAddress.toLowerCase()}-${tokenId.toString()}`,
+          id:
+            tokenId !== undefined
+              ? // Generic Token ID types all stringify down to the base numeric equivalent.
+                `${tokenAddress.toLowerCase()}-${tokenId}`
+              : `${tokenAddress.toLowerCase()}-0`,
         },
       });
 
-      const fixedPrice: {
-        address: Address;
-        pricePerToken: string;
-      } = response.data?.zoraCreateToken?.salesStrategies?.find(() => true)
-        ?.fixedPrice;
+      const token = response.data?.zoraCreateToken;
+
+      if (!token) {
+        throw new Error("Cannot find a token to mint");
+      }
+
+      const saleStrategies: SaleStrategyResult[] =
+        tokenId !== undefined
+          ? token.salesStrategies
+          : token.contract.salesStrategies;
+
+      const fixedPrice = saleStrategies
+        ?.sort((a: SaleStrategyResult, b: SaleStrategyResult) =>
+          BigInt(a.fixedPrice.saleEnd) > BigInt(b.fixedPrice.saleEnd) ? 1 : -1,
+        )
+        ?.find(() => true)?.fixedPrice;
+
+      if (!fixedPrice) {
+        throw new Error("Cannot find fixed price sale strategy");
+      }
 
       return {
-        address: fixedPrice.address as Address,
-        pricePerToken: BigInt(fixedPrice.pricePerToken),
+        fixedPrice,
+        mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity),
       };
     });
   }
-
-  async getMintableForToken({
-    tokenContract,
-    tokenId,
-  }: {
-    tokenContract: Address;
-    tokenId?: bigint | number | string;
-  }) {
-    return await this.getMintable(
-      {
-        chain_name: this.networkConfig.zoraBackendChainName,
-        collection_address: tokenContract,
-      },
-      { token_id: tokenId?.toString() },
-    );
-  }
 }

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

@@ -1,4 +1,4 @@
-import { parseAbi, parseEther } from "viem";
+import { Address, parseAbi, parseEther } from "viem";
 import { zora } from "viem/chains";
 import { describe, expect } from "vitest";
 import { createMintClient } from "./mint-client";
@@ -19,16 +19,15 @@ describe("mint-helper", () => {
         address: creatorAccount,
         value: parseEther("2000"),
       });
-      const targetContract = "0xa2fea3537915dc6c7c7a97a82d1236041e6feb2e";
+      const targetContract: Address =
+        "0xa2fea3537915dc6c7c7a97a82d1236041e6feb2e";
       const targetTokenId = 1n;
       const minter = createMintClient({ chain: zora });
 
       const params = await minter.makePrepareMintTokenParams({
         minterAccount: creatorAccount,
-        mintable: await minter.getMintable({
-          tokenId: targetTokenId,
-          tokenContract: targetContract,
-        }),
+        tokenId: targetTokenId,
+        tokenAddress: targetContract,
         mintArguments: {
           mintToAddress: creatorAccount,
           quantityToMint: 1,
@@ -69,15 +68,14 @@ describe("mint-helper", () => {
         value: parseEther("2000"),
       });
 
-      const targetContract = "0x7aae7e67515A2CbB8585C707Ca6db37BDd3EA839";
+      const targetContract: Address =
+        "0x7aae7e67515A2CbB8585C707Ca6db37BDd3EA839";
       const targetTokenId = undefined;
       const minter = createMintClient({ chain: zora });
 
       const params = await minter.makePrepareMintTokenParams({
-        mintable: await minter.getMintable({
-          tokenContract: targetContract,
-          tokenId: targetTokenId,
-        }),
+        tokenId: targetTokenId,
+        tokenAddress: targetContract,
         minterAccount: creatorAccount,
         mintArguments: {
           mintToAddress: creatorAccount,

package/src/mint/mint-client.ts

@@ -4,18 +4,19 @@ import {
   PublicClient,
   createPublicClient,
   encodeAbiParameters,
-  parseAbi,
   parseAbiParameters,
   zeroAddress,
   http,
 } from "viem";
 import { IHttpClient } from "../apis/http-api-base";
-import { MintAPIClient, MintableGetTokenResponse } from "./mint-api-client";
+import { MintAPIClient, SalesConfigAndTokenInfo } from "./mint-api-client";
 import { SimulateContractParameters } from "viem";
 import {
   zoraCreator1155ImplABI,
   zoraCreatorFixedPriceSaleStrategyAddress,
 } from "@zoralabs/protocol-deployments";
+import { GenericTokenIdTypes } from "src/types";
+import { zora721Abi } from "src/constants";
 
 class MintError extends Error {}
 class MintInactiveError extends Error {}
@@ -32,11 +33,6 @@ type MintArguments = {
   mintToAddress: Address;
 };
 
-const zora721Abi = parseAbi([
-  "function mintWithRewards(address recipient, uint256 quantity, string calldata comment, address mintReferral) external payable",
-  "function zoraFeeForAmount(uint256 amount) public view returns (address, uint256)",
-] as const);
-
 class MintClient {
   readonly apiClient: MintAPIClient;
   readonly publicClient: PublicClient;
@@ -51,25 +47,6 @@ class MintClient {
       publicClient || createPublicClient({ chain, transport: http() });
   }
 
-  /**
-   * Gets mintable information for a given token
-   * @param param0.tokenContract The contract address of the token to mint.
-   * @param param0.tokenId The token id to mint.
-   * @returns
-   */
-  async getMintable({
-    tokenContract,
-    tokenId,
-  }: {
-    tokenContract: Address;
-    tokenId?: bigint | number | string;
-  }) {
-    return await this.apiClient.getMintableForToken({
-      tokenContract,
-      tokenId: tokenId?.toString(),
-    });
-  }
-
   /**
    * Returns the parameters needed to prepare a transaction mint a token.
    * @param param0.minterAccount The account that will mint the token.
@@ -81,7 +58,8 @@ class MintClient {
     ...rest
   }: {
     minterAccount: Address;
-    mintable: MintableGetTokenResponse;
+    tokenAddress: Address;
+    tokenId?: GenericTokenIdTypes;
     mintArguments: MintArguments;
   }): Promise<SimulateContractParameters> {
     return makePrepareMintTokenParams({
@@ -90,42 +68,6 @@ class MintClient {
       publicClient: this.publicClient,
     });
   }
-
-  /**
-   * Returns the mintFee, sale fee, and total cost of minting x quantities of a token.
-   * @param param0.mintable The mintable token to mint.
-   * @param param0.quantityToMint The quantity of tokens to mint.
-   * @returns
-   */
-  async getMintCosts({
-    mintable,
-    quantityToMint,
-  }: {
-    mintable: Mintable;
-    quantityToMint: number | bigint;
-  }): Promise<MintCosts> {
-    const mintContextType = validateMintableAndGetContextType(mintable);
-
-    if (mintContextType === "zora_create_1155") {
-      return await get1155MintCosts({
-        mintable,
-        price: BigInt(mintable.cost.native_price.raw),
-        publicClient: this.publicClient,
-        quantityToMint: BigInt(quantityToMint),
-      });
-    }
-    if (mintContextType === "zora_create") {
-      return await get721MintCosts({
-        mintable,
-        publicClient: this.publicClient,
-        quantityToMint: BigInt(quantityToMint),
-      });
-    }
-
-    throw new MintError(
-      `Mintable type ${mintContextType} is currently unsupported.`,
-    );
-  }
 }
 
 /**
@@ -149,128 +91,60 @@ export function createMintClient({
 
 export type TMintClient = ReturnType<typeof createMintClient>;
 
-function validateMintableAndGetContextType(
-  mintable: MintableGetTokenResponse | undefined,
-) {
-  if (!mintable) {
-    throw new MintError("No mintable found");
-  }
-
-  if (!mintable.is_active) {
-    throw new MintInactiveError("Minting token is inactive");
-  }
-
-  if (!mintable.mint_context) {
-    throw new MintError("No minting context data from zora API");
-  }
-
-  if (
-    !["zora_create", "zora_create_1155"].includes(
-      mintable.mint_context?.mint_context_type!,
-    )
-  ) {
-    throw new MintError(
-      `Mintable type ${mintable.mint_context.mint_context_type} is currently unsupported.`,
-    );
-  }
-
-  return mintable.mint_context.mint_context_type;
-}
-
 async function makePrepareMintTokenParams({
   publicClient,
-  mintable,
   apiClient,
+  tokenId,
+  tokenAddress,
   ...rest
 }: {
   publicClient: PublicClient;
   minterAccount: Address;
-  mintable: MintableGetTokenResponse;
+  tokenId?: GenericTokenIdTypes;
+  tokenAddress: Address;
   mintArguments: MintArguments;
   apiClient: MintAPIClient;
 }): Promise<SimulateContractParameters> {
-  const mintContextType = validateMintableAndGetContextType(mintable);
-
-  const thisPublicClient = publicClient;
+  const salesConfigAndTokenInfo = await apiClient.getSalesConfigAndTokenInfo({
+    tokenId,
+    tokenAddress,
+  });
 
-  if (mintContextType === "zora_create_1155") {
-    return makePrepareMint1155TokenParams({
-      apiClient,
-      publicClient: thisPublicClient,
-      mintable,
-      mintContextType,
-      ...rest,
-    });
-  }
-  if (mintContextType === "zora_create") {
+  if (tokenId === undefined) {
     return makePrepareMint721TokenParams({
-      publicClient: thisPublicClient,
-      mintable,
-      mintContextType,
+      salesConfigAndTokenInfo,
+      tokenAddress,
       ...rest,
     });
   }
 
-  throw new MintError(
-    `Mintable type ${mintContextType} is currently unsupported.`,
-  );
-}
-
-async function get721MintCosts({
-  mintable,
-  publicClient,
-  quantityToMint,
-}: {
-  mintable: MintableGetTokenResponse;
-  publicClient: PublicClient;
-  quantityToMint: bigint;
-}): Promise<MintCosts> {
-  const address = mintable.collection.address as Address;
-
-  const [_, mintFee] = await publicClient.readContract({
-    abi: zora721Abi,
-    address,
-    functionName: "zoraFeeForAmount",
-    args: [BigInt(quantityToMint)],
+  return makePrepareMint1155TokenParams({
+    salesConfigAndTokenInfo,
+    tokenAddress,
+    tokenId,
+    ...rest,
   });
-
-  const tokenPurchaseCost =
-    BigInt(mintable.cost.native_price.raw) * quantityToMint;
-  return {
-    mintFee,
-    tokenPurchaseCost,
-    totalCost: mintFee + tokenPurchaseCost,
-  };
 }
 
 async function makePrepareMint721TokenParams({
-  publicClient,
+  tokenAddress,
+  salesConfigAndTokenInfo,
   minterAccount,
-  mintable,
-  mintContextType,
   mintArguments,
 }: {
-  publicClient: PublicClient;
-  mintable: MintableGetTokenResponse;
-  mintContextType: ReturnType<typeof validateMintableAndGetContextType>;
+  tokenAddress: Address;
+  salesConfigAndTokenInfo: SalesConfigAndTokenInfo;
   minterAccount: Address;
   mintArguments: MintArguments;
 }): Promise<SimulateContractParameters<typeof zora721Abi, "mintWithRewards">> {
-  if (mintContextType !== "zora_create") {
-    throw new Error("Minted token type must be for 1155");
-  }
-
-  const mintValue = (
-    await get721MintCosts({
-      mintable,
-      publicClient,
-      quantityToMint: BigInt(mintArguments.quantityToMint),
-    })
-  ).totalCost;
+  const mintValue = getMintCosts({
+    salesConfigAndTokenInfo,
+    quantityToMint: BigInt(mintArguments.quantityToMint),
+  }).totalCost;
 
   const result = {
     abi: zora721Abi,
-    address: mintable.contract_address as Address,
+    address: tokenAddress,
     account: minterAccount,
     functionName: "mintWithRewards",
     value: mintValue,
@@ -285,46 +159,23 @@ async function makePrepareMint721TokenParams({
   return result;
 }
 
-async function get1155MintFee({
-  collectionAddress,
-  publicClient,
-}: {
-  collectionAddress: Address;
-  publicClient: PublicClient;
-}) {
-  return await publicClient.readContract({
-    abi: zoraCreator1155ImplABI,
-    functionName: "mintFee",
-    address: collectionAddress,
-  });
-}
-
 export type MintCosts = {
   mintFee: bigint;
   tokenPurchaseCost: bigint;
   totalCost: bigint;
 };
 
-export async function get1155MintCosts({
-  mintable,
-  price,
-  publicClient,
+export function getMintCosts({
+  salesConfigAndTokenInfo,
   quantityToMint,
 }: {
-  mintable: MintableGetTokenResponse;
-  price: bigint;
-  publicClient: PublicClient;
+  salesConfigAndTokenInfo: SalesConfigAndTokenInfo;
   quantityToMint: bigint;
-}): Promise<MintCosts> {
-  const address = mintable.collection.address as Address;
-
-  const mintFee = await get1155MintFee({
-    collectionAddress: address,
-    publicClient,
-  });
-
-  const mintFeeForTokens = mintFee * quantityToMint;
-  const tokenPurchaseCost = price * quantityToMint;
+}): MintCosts {
+  const mintFeeForTokens =
+    salesConfigAndTokenInfo.mintFeePerQuantity * quantityToMint;
+  const tokenPurchaseCost =
+    BigInt(salesConfigAndTokenInfo.fixedPrice.pricePerToken) * quantityToMint;
 
   return {
     mintFee: mintFeeForTokens,
@@ -334,55 +185,36 @@ export async function get1155MintCosts({
 }
 
 async function makePrepareMint1155TokenParams({
-  apiClient,
-  publicClient,
+  tokenId,
+  salesConfigAndTokenInfo,
   minterAccount,
-  mintable,
-  mintContextType,
+  tokenAddress,
   mintArguments,
 }: {
-  apiClient: Pick<MintAPIClient, "getSalesConfigFixedPrice">;
-  publicClient: PublicClient;
-  mintable: Mintable;
-  mintContextType: ReturnType<typeof validateMintableAndGetContextType>;
+  salesConfigAndTokenInfo: SalesConfigAndTokenInfo;
+  tokenId: GenericTokenIdTypes;
   minterAccount: Address;
+  tokenAddress: Address;
   mintArguments: MintArguments;
 }) {
-  if (mintContextType !== "zora_create_1155") {
-    throw new Error("Minted token type must be for 1155");
-  }
-
   const mintQuantity = BigInt(mintArguments.quantityToMint);
 
-  const address = mintable.collection.address as Address;
-
-  const tokenFixedPriceMinter = await apiClient.getSalesConfigFixedPrice({
-    contractAddress: address,
-    tokenId: BigInt(mintable.token_id!),
-  });
-
-  const mintValue = (
-    await get1155MintCosts({
-      mintable,
-      price:
-        tokenFixedPriceMinter?.pricePerToken ||
-        BigInt(mintable.cost.native_price.raw),
-      publicClient,
-      quantityToMint: mintQuantity,
-    })
-  ).totalCost;
+  const mintValue = getMintCosts({
+    salesConfigAndTokenInfo,
+    quantityToMint: mintQuantity,
+  }).totalCost;
 
   const result = {
     abi: zoraCreator1155ImplABI,
     functionName: "mintWithRewards",
     account: minterAccount,
     value: mintValue,
-    address,
+    address: tokenAddress,
     /* args: minter, tokenId, quantity, minterArguments, mintReferral */
     args: [
-      (tokenFixedPriceMinter?.address ||
+      (salesConfigAndTokenInfo?.fixedPrice.address ||
         zoraCreatorFixedPriceSaleStrategyAddress[999]) as Address,
-      BigInt(mintable.token_id!),
+      BigInt(tokenId),
       mintQuantity,
       encodeAbiParameters(parseAbiParameters("address, string"), [
         mintArguments.mintToAddress,
@@ -397,5 +229,3 @@ async function makePrepareMint1155TokenParams({
 
   return result;
 }
-
-export type Mintable = MintableGetTokenResponse;