@zoralabs/protocol-sdk 0.3.3 → 0.3.5

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,41 +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,
-        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.`,
-    );
-  }
 }
 
 /**
@@ -148,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,
@@ -284,45 +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,
-  publicClient,
+export function getMintCosts({
+  salesConfigAndTokenInfo,
   quantityToMint,
 }: {
-  mintable: MintableGetTokenResponse;
-  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;
+}): MintCosts {
+  const mintFeeForTokens =
+    salesConfigAndTokenInfo.mintFeePerQuantity * quantityToMint;
   const tokenPurchaseCost =
-    BigInt(mintable.cost.native_price.raw) * quantityToMint;
+    BigInt(salesConfigAndTokenInfo.fixedPrice.pricePerToken) * quantityToMint;
 
   return {
     mintFee: mintFeeForTokens,
@@ -332,52 +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 mintValue = (
-    await get1155MintCosts({
-      mintable,
-      publicClient,
-      quantityToMint: mintQuantity,
-    })
-  ).totalCost;
-
-  const tokenFixedPriceMinter = await apiClient.getSalesConfigFixedPrice({
-    contractAddress: address,
-    tokenId: BigInt(mintable.token_id!),
-  });
+  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 ||
+      (salesConfigAndTokenInfo?.fixedPrice.address ||
         zoraCreatorFixedPriceSaleStrategyAddress[999]) as Address,
-      BigInt(mintable.token_id!),
+      BigInt(tokenId),
       mintQuantity,
       encodeAbiParameters(parseAbiParameters("address, string"), [
         mintArguments.mintToAddress,
@@ -392,5 +229,3 @@ async function makePrepareMint1155TokenParams({
 
   return result;
 }
-
-export type Mintable = MintableGetTokenResponse;

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

@@ -1,10 +1,14 @@
 import { foundry } from "viem/chains";
 import { describe, expect, vi } from "vitest";
 import { createPremintClient } from "./premint-client";
-import { anvilTest } from "src/anvil";
+import { anvilTest, forkUrls, makeAnvilTest } from "src/anvil";
+import { PremintSignatureResponse } from "./premint-api-client";
 
 describe("ZoraCreator1155Premint", () => {
-  anvilTest(
+  makeAnvilTest({
+    forkUrl: forkUrls.zoraGoerli,
+    forkBlockNumber: 1763437,
+  })(
     "can sign on the forked premint contract",
     async ({ viemClients: { walletClient, publicClient } }) => {
       const [deployerAccount] = await walletClient.getAddresses();
@@ -76,7 +80,7 @@ describe("ZoraCreator1155Premint", () => {
         publicClient,
       });
 
-      const premintData = {
+      const premintData: PremintSignatureResponse = {
         collection: {
           contractAdmin: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
           contractName: "Testing Contract",
@@ -101,15 +105,12 @@ describe("ZoraCreator1155Premint", () => {
               "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
           },
         },
-        chain_name: "ZORA-TESTNET",
+        chain_name: "ZORA-GOERLI",
         signature:
           "0x588d19641de9ba1dade4d2bb5387c8dc96f4a990fef69787534b60caead759e6334975a6be10a796da948cd7d1d4f5580b3f84d49d9fa4e0b41c97759507975a1c",
       } as const;
 
-      const signatureValid = await premintClient.isValidSignature({
-        // @ts-ignore: Fix enum type
-        data: premintData,
-      });
+      const signatureValid = await premintClient.isValidSignature(premintData);
       expect(signatureValid.isValid).toBe(true);
     },
   );