@zoralabs/protocol-sdk 0.3.2 → 0.3.3

package/src/mint/mint-client.ts

@@ -2,12 +2,14 @@ import {
   Address,
   Chain,
   PublicClient,
+  createPublicClient,
   encodeAbiParameters,
   parseAbi,
   parseAbiParameters,
   zeroAddress,
+  http,
 } from "viem";
-import { ClientBase } from "../apis/client-base";
+import { IHttpClient } from "../apis/http-api-base";
 import { MintAPIClient, MintableGetTokenResponse } from "./mint-api-client";
 import { SimulateContractParameters } from "viem";
 import {
@@ -30,30 +32,31 @@ type MintArguments = {
   mintToAddress: Address;
 };
 
-type MintParameters = {
-  mintArguments: MintArguments;
-  publicClient: PublicClient;
-  mintable: MintableGetTokenResponse;
-  sender: 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 extends ClientBase {
-  apiClient: typeof MintAPIClient;
-
-  constructor(chain: Chain, apiClient?: typeof MintAPIClient) {
-    super(chain);
+class MintClient {
+  readonly apiClient: MintAPIClient;
+  readonly publicClient: PublicClient;
 
-    if (!apiClient) {
-      apiClient = MintAPIClient;
-    }
-    this.apiClient = apiClient;
+  constructor(
+    chain: Chain,
+    publicClient?: PublicClient,
+    httpClient?: IHttpClient,
+  ) {
+    this.apiClient = new MintAPIClient(chain.id, httpClient);
+    this.publicClient =
+      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,
@@ -61,168 +64,333 @@ class MintClient extends ClientBase {
     tokenContract: Address;
     tokenId?: bigint | number | string;
   }) {
-    return this.apiClient.getMintable(
-      {
-        chain_name: this.network.zoraBackendChainName,
-        collection_address: tokenContract,
-      },
-      { token_id: tokenId?.toString() },
-    );
+    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.
+   * @param param0.mintable The mintable token to mint.
+   * @param param0.mintArguments The arguments for the mint (mint recipient, comment, mint referral, quantity to mint)
+   * @returns
+   */
   async makePrepareMintTokenParams({
-    publicClient,
-    minterAccount,
-    mintable,
-    mintArguments,
+    ...rest
   }: {
-    publicClient: PublicClient;
-    mintable: MintableGetTokenResponse;
     minterAccount: Address;
+    mintable: MintableGetTokenResponse;
     mintArguments: MintArguments;
-  }): Promise<{ simulateContractParameters: SimulateContractParameters }> {
-    if (!mintable) {
-      throw new MintError("No mintable found");
-    }
+  }): Promise<SimulateContractParameters> {
+    return makePrepareMintTokenParams({
+      ...rest,
+      apiClient: this.apiClient,
+      publicClient: this.publicClient,
+    });
+  }
 
-    if (!mintable.is_active) {
-      throw new MintInactiveError("Minting token is inactive");
-    }
+  /**
+   * 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 (!mintable.mint_context) {
-      throw new MintError("No minting context data from zora API");
+    if (mintContextType === "zora_create_1155") {
+      return await get1155MintCosts({
+        mintable,
+        publicClient: this.publicClient,
+        quantityToMint: BigInt(quantityToMint),
+      });
     }
-
-    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.`,
-      );
+    if (mintContextType === "zora_create") {
+      return await get721MintCosts({
+        mintable,
+        publicClient: this.publicClient,
+        quantityToMint: BigInt(quantityToMint),
+      });
     }
 
-    const thisPublicClient = this.getPublicClient(publicClient);
-
-    if (mintable.mint_context.mint_context_type === "zora_create_1155") {
-      return {
-        simulateContractParameters: await this.prepareMintZora1155({
-          publicClient: thisPublicClient,
-          mintArguments,
-          sender: minterAccount,
-          mintable,
-        }),
-      };
-    }
-    if (mintable.mint_context.mint_context_type === "zora_create") {
-      return {
-        simulateContractParameters: await this.prepareMintZora721({
-          publicClient: thisPublicClient,
-          mintArguments,
-          sender: minterAccount,
-          mintable,
-        }),
-      };
-    }
+    throw new MintError(
+      `Mintable type ${mintContextType} is currently unsupported.`,
+    );
+  }
+}
 
-    throw new Error("Mintable type not found or recognized.");
+/**
+ * Creates a new MintClient.
+ * @param param0.chain The chain to use for the mint client.
+ * @param param0.publicClient Optional viem public client
+ * @param param0.httpClient Optional http client to override post, get, and retry methods
+ * @returns
+ */
+export function createMintClient({
+  chain,
+  publicClient,
+  httpClient,
+}: {
+  chain: Chain;
+  publicClient?: PublicClient;
+  httpClient?: IHttpClient;
+}) {
+  return new MintClient(chain, publicClient, httpClient);
+}
+
+export type TMintClient = ReturnType<typeof createMintClient>;
+
+function validateMintableAndGetContextType(
+  mintable: MintableGetTokenResponse | undefined,
+) {
+  if (!mintable) {
+    throw new MintError("No mintable found");
   }
 
-  private async prepareMintZora1155({
-    mintable,
-    sender,
-    publicClient,
-    mintArguments,
-  }: MintParameters) {
-    const mintQuantity = BigInt(mintArguments.quantityToMint);
+  if (!mintable.is_active) {
+    throw new MintInactiveError("Minting token is inactive");
+  }
 
-    const address = mintable.collection.address as Address;
+  if (!mintable.mint_context) {
+    throw new MintError("No minting context data from zora API");
+  }
 
-    const mintFee = await publicClient.readContract({
-      abi: zoraCreator1155ImplABI,
-      functionName: "mintFee",
-      address,
+  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,
+  ...rest
+}: {
+  publicClient: PublicClient;
+  minterAccount: Address;
+  mintable: MintableGetTokenResponse;
+  mintArguments: MintArguments;
+  apiClient: MintAPIClient;
+}): Promise<SimulateContractParameters> {
+  const mintContextType = validateMintableAndGetContextType(mintable);
+
+  const thisPublicClient = publicClient;
+
+  if (mintContextType === "zora_create_1155") {
+    return makePrepareMint1155TokenParams({
+      apiClient,
+      publicClient: thisPublicClient,
+      mintable,
+      mintContextType,
+      ...rest,
+    });
+  }
+  if (mintContextType === "zora_create") {
+    return makePrepareMint721TokenParams({
+      publicClient: thisPublicClient,
+      mintable,
+      mintContextType,
+      ...rest,
     });
+  }
 
-    const tokenFixedPriceMinter = await this.apiClient.getSalesConfigFixedPrice(
-      {
-        contractAddress: mintable.contract_address,
-        tokenId: mintable.token_id!,
-        subgraphUrl: this.network.subgraphUrl,
-      },
-    );
+  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 result: SimulateContractParameters<
-      typeof zoraCreator1155ImplABI,
-      "mintWithRewards"
-    > = {
-      abi: zoraCreator1155ImplABI,
-      functionName: "mintWithRewards",
-      account: sender,
-      value: (mintFee + BigInt(mintable.cost.native_price.raw)) * mintQuantity,
-      address,
-      /* args: minter, tokenId, quantity, minterArguments, mintReferral */
-      args: [
-        (tokenFixedPriceMinter ||
-          zoraCreatorFixedPriceSaleStrategyAddress[999]) as Address,
-        BigInt(mintable.token_id!),
-        mintQuantity,
-        encodeAbiParameters(parseAbiParameters("address, string"), [
-          mintArguments.mintToAddress,
-          mintArguments.mintComment || "",
-        ]),
-        mintArguments.mintReferral || zeroAddress,
-      ],
-    };
-
-    return result;
+  const [_, mintFee] = await publicClient.readContract({
+    abi: zora721Abi,
+    address,
+    functionName: "zoraFeeForAmount",
+    args: [BigInt(quantityToMint)],
+  });
+
+  const tokenPurchaseCost =
+    BigInt(mintable.cost.native_price.raw) * quantityToMint;
+  return {
+    mintFee,
+    tokenPurchaseCost,
+    totalCost: mintFee + tokenPurchaseCost,
+  };
+}
+
+async function makePrepareMint721TokenParams({
+  publicClient,
+  minterAccount,
+  mintable,
+  mintContextType,
+  mintArguments,
+}: {
+  publicClient: PublicClient;
+  mintable: MintableGetTokenResponse;
+  mintContextType: ReturnType<typeof validateMintableAndGetContextType>;
+  minterAccount: Address;
+  mintArguments: MintArguments;
+}): Promise<SimulateContractParameters<typeof zora721Abi, "mintWithRewards">> {
+  if (mintContextType !== "zora_create") {
+    throw new Error("Minted token type must be for 1155");
   }
 
-  private async prepareMintZora721({
-    mintable,
+  const mintValue = (
+    await get721MintCosts({
+      mintable,
+      publicClient,
+      quantityToMint: BigInt(mintArguments.quantityToMint),
+    })
+  ).totalCost;
+
+  const result = {
+    abi: zora721Abi,
+    address: mintable.contract_address as Address,
+    account: minterAccount,
+    functionName: "mintWithRewards",
+    value: mintValue,
+    args: [
+      mintArguments.mintToAddress,
+      BigInt(mintArguments.quantityToMint),
+      mintArguments.mintComment || "",
+      mintArguments.mintReferral || zeroAddress,
+    ],
+  } satisfies SimulateContractParameters<typeof zora721Abi, "mintWithRewards">;
+
+  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,
+  publicClient,
+  quantityToMint,
+}: {
+  mintable: MintableGetTokenResponse;
+  publicClient: PublicClient;
+  quantityToMint: bigint;
+}): Promise<MintCosts> {
+  const address = mintable.collection.address as Address;
+
+  const mintFee = await get1155MintFee({
+    collectionAddress: address,
     publicClient,
-    sender,
-    mintArguments,
-  }: MintParameters) {
-    const [_, mintFee] = await publicClient.readContract({
-      abi: zora721Abi,
-      address: mintable.contract_address as Address,
-      functionName: "zoraFeeForAmount",
-      args: [BigInt(mintArguments.quantityToMint)],
-    });
+  });
 
-    const result: SimulateContractParameters<
-      typeof zora721Abi,
-      "mintWithRewards"
-    > = {
-      abi: zora721Abi,
-      address: mintable.contract_address as Address,
-      account: sender,
-      functionName: "mintWithRewards",
-      value:
-        mintFee +
-        BigInt(mintable.cost.native_price.raw) *
-          BigInt(mintArguments.quantityToMint),
-      /* args: mint recipient, quantity to mint, mint comment, mintReferral */
-      args: [
-        mintArguments.mintToAddress,
-        BigInt(mintArguments.quantityToMint),
-        mintArguments.mintComment || "",
-        mintArguments.mintReferral || zeroAddress,
-      ],
-    };
+  const mintFeeForTokens = mintFee * quantityToMint;
+  const tokenPurchaseCost =
+    BigInt(mintable.cost.native_price.raw) * quantityToMint;
 
-    return result;
-  }
+  return {
+    mintFee: mintFeeForTokens,
+    tokenPurchaseCost,
+    totalCost: mintFeeForTokens + tokenPurchaseCost,
+  };
 }
 
-export function createMintClient({
-  chain,
-  mintAPIClient,
+async function makePrepareMint1155TokenParams({
+  apiClient,
+  publicClient,
+  minterAccount,
+  mintable,
+  mintContextType,
+  mintArguments,
 }: {
-  chain: Chain;
-  mintAPIClient?: typeof MintAPIClient;
+  apiClient: Pick<MintAPIClient, "getSalesConfigFixedPrice">;
+  publicClient: PublicClient;
+  mintable: Mintable;
+  mintContextType: ReturnType<typeof validateMintableAndGetContextType>;
+  minterAccount: Address;
+  mintArguments: MintArguments;
 }) {
-  return new MintClient(chain, mintAPIClient);
+  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 mintValue = (
+    await get1155MintCosts({
+      mintable,
+      publicClient,
+      quantityToMint: mintQuantity,
+    })
+  ).totalCost;
+
+  const tokenFixedPriceMinter = await apiClient.getSalesConfigFixedPrice({
+    contractAddress: address,
+    tokenId: BigInt(mintable.token_id!),
+  });
+
+  const result = {
+    abi: zoraCreator1155ImplABI,
+    functionName: "mintWithRewards",
+    account: minterAccount,
+    value: mintValue,
+    address,
+    /* args: minter, tokenId, quantity, minterArguments, mintReferral */
+    args: [
+      (tokenFixedPriceMinter ||
+        zoraCreatorFixedPriceSaleStrategyAddress[999]) as Address,
+      BigInt(mintable.token_id!),
+      mintQuantity,
+      encodeAbiParameters(parseAbiParameters("address, string"), [
+        mintArguments.mintToAddress,
+        mintArguments.mintComment || "",
+      ]),
+      mintArguments.mintReferral || zeroAddress,
+    ],
+  } satisfies SimulateContractParameters<
+    typeof zoraCreator1155ImplABI,
+    "mintWithRewards"
+  >;
+
+  return result;
 }
+
+export type Mintable = MintableGetTokenResponse;

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

@@ -1,6 +1,11 @@
-import { post, retries, get } from "../apis/http-api-base";
+import {
+  IHttpClient,
+  httpClient as defaultHttpClient,
+} from "../apis/http-api-base";
 import { components, paths } from "../apis/generated/premint-api-types";
 import { ZORA_API_BASE } from "../constants";
+import { NetworkConfig } from "src/apis/chain-constants";
+import { getApiNetworkConfigForChain } from "src/mint/mint-api-client";
 
 type SignaturePostType = paths["/signature"]["post"];
 type PremintSignatureRequestBody =
@@ -22,36 +27,85 @@ type PremintSignatureGetPathParameters =
 export type PremintSignatureGetResponse =
   SignaturePremintGetType["responses"][200]["content"]["application/json"];
 
+export type PremintCollection = PremintSignatureGetResponse["collection"];
+
 export type BackendChainNames = components["schemas"]["ChainName"];
 
-const postSignature = async (
-  data: PremintSignatureRequestBody,
-): Promise<PremintSignatureResponse> =>
+const postSignature = async ({
+  httpClient: { post, retries } = defaultHttpClient,
+  ...data
+}: PremintSignatureRequestBody & {
+  httpClient?: Pick<IHttpClient, "retries" | "post">;
+}): Promise<PremintSignatureResponse> =>
   retries(() =>
     post<PremintSignatureResponse>(`${ZORA_API_BASE}premint/signature`, data),
   );
 
-const getNextUID = async (
-  path: PremintNextUIDGetPathParameters,
-): Promise<PremintNextUIDGetResponse> =>
+const getNextUID = async ({
+  chain_name,
+  collection_address,
+  httpClient: { retries, get } = defaultHttpClient,
+}: PremintNextUIDGetPathParameters & {
+  httpClient?: Pick<IHttpClient, "retries" | "get">;
+}): Promise<PremintNextUIDGetResponse> =>
   retries(() =>
     get<PremintNextUIDGetResponse>(
-      `${ZORA_API_BASE}premint/signature/${path.chain_name}/${path.collection_address}/next_uid`,
+      `${ZORA_API_BASE}premint/signature/${chain_name}/${collection_address}/next_uid`,
     ),
   );
 
-const getSignature = async (
-  path: PremintSignatureGetPathParameters,
-): Promise<PremintSignatureGetResponse> =>
+const getSignature = async ({
+  collection_address,
+  uid,
+  chain_name,
+  httpClient: { retries, get } = defaultHttpClient,
+}: PremintSignatureGetPathParameters & {
+  httpClient?: Pick<IHttpClient, "retries" | "get">;
+}): Promise<PremintSignatureGetResponse> =>
   retries(() =>
     get<PremintSignatureGetResponse>(
-      `${ZORA_API_BASE}premint/signature/${path.chain_name}/${path.collection_address}/${path.uid}`,
+      `${ZORA_API_BASE}premint/signature/${chain_name}/${collection_address}/${uid}`,
     ),
   );
 
-export const PremintAPIClient = {
-  postSignature,
-  getSignature,
-  getNextUID,
-};
-export { ZORA_API_BASE };
+type OmitChainName<T> = Omit<T, "chain_name">;
+
+class PremintAPIClient {
+  httpClient: IHttpClient;
+  networkConfig: NetworkConfig;
+
+  constructor(chainId: number, httpClient?: IHttpClient) {
+    this.httpClient = httpClient || defaultHttpClient;
+    this.networkConfig = getApiNetworkConfigForChain(chainId);
+  }
+  postSignature = async (
+    data: OmitChainName<PremintSignatureRequestBody>,
+  ): Promise<PremintSignatureResponse> =>
+    postSignature({
+      ...data,
+      chain_name: this.networkConfig.zoraBackendChainName,
+      httpClient: this.httpClient,
+    });
+
+  getNextUID = async (
+    path: OmitChainName<PremintNextUIDGetPathParameters>,
+  ): Promise<PremintNextUIDGetResponse> =>
+    getNextUID({
+      ...path,
+      chain_name: this.networkConfig.zoraBackendChainName,
+      httpClient: this.httpClient,
+    });
+
+  getSignature = async ({
+    collection_address,
+    uid,
+  }: OmitChainName<PremintSignatureGetPathParameters>): Promise<PremintSignatureGetResponse> =>
+    getSignature({
+      collection_address,
+      uid,
+      chain_name: this.networkConfig.zoraBackendChainName,
+      httpClient: this.httpClient,
+    });
+}
+
+export { ZORA_API_BASE, PremintAPIClient };