@zoralabs/protocol-sdk 0.5.14 → 0.5.16

package/src/mint/mint-client.ts

@@ -1,24 +1,32 @@
 import {
   Address,
   Chain,
-  PublicClient,
-  createPublicClient,
   encodeAbiParameters,
   parseAbiParameters,
   zeroAddress,
-  http,
   Account,
   SimulateContractParameters,
 } from "viem";
-import { IHttpClient } from "../apis/http-api-base";
-import { MintAPIClient, SalesConfigAndTokenInfo } from "./mint-api-client";
 import {
+  erc20MinterABI,
+  erc20MinterAddress,
   zoraCreator1155ImplABI,
   zoraCreatorFixedPriceSaleStrategyAddress,
 } from "@zoralabs/protocol-deployments";
-import { GenericTokenIdTypes } from "src/types";
+import { IHttpClient } from "src/apis/http-api-base";
 import { zora721Abi } from "src/constants";
-import { makeSimulateContractParamaters } from "src/utils";
+import { GenericTokenIdTypes } from "src/types";
+import {
+  MintAPIClient,
+  SalesConfigAndTokenInfo,
+  SaleType,
+} from "./mint-api-client";
+import {
+  makeSimulateContractParamaters,
+  ClientConfig,
+  setupClient,
+  PublicClient,
+} from "src/utils";
 
 class MintError extends Error {}
 class MintInactiveError extends Error {}
@@ -29,10 +37,26 @@ export const Errors = {
 };
 
 type MintArguments = {
+  /** Quantity of tokens to mint */
   quantityToMint: number;
+  /** Comment to add to the mint */
   mintComment?: string;
+  /** Optional address to receive the mint referral reward */
   mintReferral?: Address;
+  /** Address to receive the minted tokens */
   mintToAddress: Address;
+  saleType?: SaleType;
+};
+
+type MintTokenParams = {
+  /** Account to execute the mint */
+  minterAccount: Address | Account;
+  /** Contract address of token to mint */
+  tokenAddress: Address;
+  /** Id of token to mint */
+  tokenId?: GenericTokenIdTypes;
+  /** Mint settings */
+  mintArguments: MintArguments;
 };
 
 class MintClient {
@@ -41,31 +65,22 @@ class MintClient {
 
   constructor(
     chain: Chain,
-    publicClient?: PublicClient,
-    httpClient?: IHttpClient,
+    publicClient: PublicClient,
+    httpClient: IHttpClient,
   ) {
     this.apiClient = new MintAPIClient(chain.id, httpClient);
-    this.publicClient =
-      publicClient || createPublicClient({ chain, transport: http() });
+    this.publicClient = publicClient;
   }
 
   /**
    * 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
+   *
+   * @param parameters - Parameters for collecting the token {@link MintTokenParams}
+   * @returns Parameters for simulating/executing the mint transaction
    */
-  async makePrepareMintTokenParams({
-    ...rest
-  }: {
-    minterAccount: Address | Account;
-    tokenAddress: Address;
-    tokenId?: GenericTokenIdTypes;
-    mintArguments: MintArguments;
-  }) {
+  async makePrepareMintTokenParams(parameters: MintTokenParams) {
     return makePrepareMintTokenParams({
-      ...rest,
+      ...parameters,
       apiClient: this.apiClient,
       publicClient: this.publicClient,
     });
@@ -79,15 +94,8 @@ class MintClient {
  * @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;
-}) {
+export function createMintClient(clientConfig: ClientConfig) {
+  const { chain, publicClient, httpClient } = setupClient(clientConfig);
   return new MintClient(chain, publicClient, httpClient);
 }
 
@@ -98,6 +106,7 @@ async function makePrepareMintTokenParams({
   apiClient,
   tokenId,
   tokenAddress,
+  mintArguments,
   ...rest
 }: {
   publicClient: PublicClient;
@@ -112,12 +121,14 @@ async function makePrepareMintTokenParams({
   const salesConfigAndTokenInfo = await apiClient.getSalesConfigAndTokenInfo({
     tokenId,
     tokenAddress,
+    saleType: mintArguments.saleType,
   });
 
   if (tokenId === undefined) {
     return makePrepareMint721TokenParams({
       salesConfigAndTokenInfo,
       tokenAddress,
+      mintArguments,
       ...rest,
     });
   }
@@ -126,6 +137,7 @@ async function makePrepareMintTokenParams({
     salesConfigAndTokenInfo,
     tokenAddress,
     tokenId,
+    mintArguments,
     ...rest,
   });
 }
@@ -177,7 +189,7 @@ export function getMintCosts({
   const mintFeeForTokens =
     salesConfigAndTokenInfo.mintFeePerQuantity * quantityToMint;
   const tokenPurchaseCost =
-    BigInt(salesConfigAndTokenInfo.fixedPrice.pricePerToken) * quantityToMint;
+    BigInt(salesConfigAndTokenInfo.salesConfig.pricePerToken) * quantityToMint;
 
   return {
     mintFee: mintFeeForTokens,
@@ -206,23 +218,53 @@ async function makePrepareMint1155TokenParams({
     quantityToMint: mintQuantity,
   }).totalCost;
 
-  return makeSimulateContractParamaters({
-    abi: zoraCreator1155ImplABI,
-    functionName: "mintWithRewards",
-    account: minterAccount,
-    value: mintValue,
-    address: tokenAddress,
-    /* args: minter, tokenId, quantity, minterArguments, mintReferral */
-    args: [
-      (salesConfigAndTokenInfo?.fixedPrice.address ||
-        zoraCreatorFixedPriceSaleStrategyAddress[999]) as Address,
-      BigInt(tokenId),
-      mintQuantity,
-      encodeAbiParameters(parseAbiParameters("address, string"), [
-        mintArguments.mintToAddress,
-        mintArguments.mintComment || "",
-      ]),
-      mintArguments.mintReferral || zeroAddress,
-    ],
-  });
+  switch (salesConfigAndTokenInfo.salesConfig.saleType) {
+    case "fixedPrice":
+      const fixedPriceArgs = mintArguments;
+
+      return makeSimulateContractParamaters({
+        abi: zoraCreator1155ImplABI,
+        functionName: "mintWithRewards",
+        account: minterAccount,
+        value: mintValue,
+        address: tokenAddress,
+        /* args: minter, tokenId, quantity, minterArguments, mintReferral */
+        args: [
+          (salesConfigAndTokenInfo.salesConfig.address ||
+            zoraCreatorFixedPriceSaleStrategyAddress[999999999]) as Address,
+          BigInt(tokenId),
+          mintQuantity,
+          encodeAbiParameters(parseAbiParameters("address, string"), [
+            fixedPriceArgs.mintToAddress,
+            fixedPriceArgs.mintComment || "",
+          ]),
+          fixedPriceArgs.mintReferral || zeroAddress,
+        ],
+      });
+
+    case "erc20":
+      const erc20Args = mintArguments;
+
+      return makeSimulateContractParamaters({
+        abi: erc20MinterABI,
+        functionName: "mint",
+        account: minterAccount,
+        address: (salesConfigAndTokenInfo?.salesConfig.address ||
+          erc20MinterAddress[999999999]) as Address,
+        /* args: mintTo, quantity, tokenAddress, tokenId, totalValue, currency, mintReferral, comment */
+        args: [
+          mintArguments.mintToAddress,
+          mintQuantity,
+          tokenAddress,
+          BigInt(tokenId),
+          salesConfigAndTokenInfo.salesConfig.pricePerToken,
+          salesConfigAndTokenInfo.salesConfig.currency,
+          erc20Args.mintReferral || zeroAddress,
+          erc20Args.mintComment || "",
+        ],
+      });
+
+    default:
+      throw new MintError("Unsupported sale type");
+  }
 }

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

@@ -29,16 +29,13 @@ describe("ZoraCreator1155Premint - v1 signatures", () => {
         .fn<Parameters<typeof premintClient.apiClient.postSignature>>()
         .mockResolvedValue({ ok: true });
 
-      await premintClient.createPremint({
-        walletClient,
-        creatorAccount: deployerAccount!,
-        checkSignature: true,
+      const { signAndSubmit } = await premintClient.createPremint({
+        payoutRecipient: deployerAccount!,
         collection: {
           contractAdmin: deployerAccount!,
           contractName: "Testing Contract",
           contractURI:
             "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
-          additionalAdmins: [],
         },
         tokenCreationConfig: {
           tokenURI:
@@ -46,6 +43,12 @@ describe("ZoraCreator1155Premint - v1 signatures", () => {
         },
       });
 
+      await signAndSubmit({
+        walletClient,
+        checkSignature: true,
+        account: deployerAccount!,
+      });
+
       const expectedPostSignatureArgs: Parameters<
         typeof premintClient.apiClient.postSignature
       >[0] = {
@@ -189,16 +192,13 @@ describe("ZoraCreator1155Premint - v2 signatures", () => {
         .fn<Parameters<typeof premintClient.apiClient.postSignature>>()
         .mockResolvedValue({ ok: true });
 
-      await premintClient.createPremint({
-        walletClient,
-        creatorAccount: creatorAccount!,
-        checkSignature: true,
+      const { signAndSubmit } = await premintClient.createPremint({
+        payoutRecipient: creatorAccount!,
         collection: {
           contractAdmin: creatorAccount!,
           contractName: "Testing Contract Premint V2",
           contractURI:
             "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
-          additionalAdmins: [],
         },
         premintConfigVersion: PremintConfigVersion.V2,
         tokenCreationConfig: {
@@ -208,6 +208,12 @@ describe("ZoraCreator1155Premint - v2 signatures", () => {
         },
       });
 
+      await signAndSubmit({
+        account: creatorAccount!,
+        walletClient,
+        checkSignature: true,
+      });
+
       const expectedPostSignatureArgs: Parameters<
         typeof premintClient.apiClient.postSignature
       >[0] = {