@zoralabs/protocol-sdk 0.5.16 → 0.6.0

package/src/mint/mint-client.ts

@@ -1,11 +1,11 @@
 import {
   Address,
-  Chain,
   encodeAbiParameters,
   parseAbiParameters,
   zeroAddress,
   Account,
   SimulateContractParameters,
+  erc20Abi,
 } from "viem";
 import {
   erc20MinterABI,
@@ -13,20 +13,31 @@ import {
   zoraCreator1155ImplABI,
   zoraCreatorFixedPriceSaleStrategyAddress,
 } from "@zoralabs/protocol-deployments";
-import { IHttpClient } from "src/apis/http-api-base";
 import { zora721Abi } from "src/constants";
 import { GenericTokenIdTypes } from "src/types";
 import {
-  MintAPIClient,
-  SalesConfigAndTokenInfo,
-  SaleType,
-} from "./mint-api-client";
-import {
-  makeSimulateContractParamaters,
-  ClientConfig,
-  setupClient,
+  makeContractParameters,
   PublicClient,
+  mintRecipientOrAccount,
 } from "src/utils";
+import {
+  IMintGetter,
+  SalesConfigAndTokenInfo,
+  isErc20SaleStrategy,
+} from "./types";
+import {
+  MakeMintParametersArguments,
+  MakeMintParametersArgumentsBase,
+  Make1155MintArguments,
+  MakePremintMintParametersArguments,
+  Make721MintArguments,
+  GetMintCostsParameters,
+  isOnChainMint,
+  is1155Mint,
+} from "./types";
+import { collectPremint } from "src/premint/premint-client";
+import { IPremintGetter } from "src/premint/premint-api-client";
+import { getPremintMintCostsWithUnknownTokenPrice } from "src/premint/preminter";
 
 class MintError extends Error {}
 class MintInactiveError extends Error {}
@@ -36,150 +47,247 @@ export const Errors = {
   MintInactiveError,
 };
 
-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;
-};
+export class MintClient {
+  private readonly chainId: number;
+  private readonly publicClient: PublicClient;
+  private readonly mintGetter: IMintGetter;
+  private readonly premintGetter: IPremintGetter;
 
-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 {
-  readonly apiClient: MintAPIClient;
-  readonly publicClient: PublicClient;
-
-  constructor(
-    chain: Chain,
-    publicClient: PublicClient,
-    httpClient: IHttpClient,
-  ) {
-    this.apiClient = new MintAPIClient(chain.id, httpClient);
+  constructor({
+    chainId,
+    publicClient,
+    premintGetter,
+    mintGetter,
+  }: {
+    chainId: number;
+    publicClient: PublicClient;
+    premintGetter: IPremintGetter;
+    mintGetter: IMintGetter;
+  }) {
+    this.chainId = chainId;
     this.publicClient = publicClient;
+    this.mintGetter = mintGetter;
+    this.premintGetter = premintGetter;
   }
 
   /**
    * 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 MintTokenParams}
+   * @param parameters - Parameters for collecting the token {@link MakeMintParametersArguments}
    * @returns Parameters for simulating/executing the mint transaction
    */
-  async makePrepareMintTokenParams(parameters: MintTokenParams) {
-    return makePrepareMintTokenParams({
+  async mint(parameters: MakeMintParametersArguments) {
+    return mint({
+      parameters,
+      chainId: this.chainId,
+      publicClient: this.publicClient,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter,
+    });
+  }
+
+  /**
+   * Gets the costs to mint the quantity of tokens specified for a mint.
+   * @param parameters - Parameters for the mint {@link GetMintCostsParameters}
+   * @returns Costs to mint the quantity of tokens specified
+   */
+  async getMintCosts(parameters: GetMintCostsParameters): Promise<MintCosts> {
+    return getMintCosts({
       ...parameters,
-      apiClient: this.apiClient,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter,
       publicClient: this.publicClient,
     });
   }
 }
 
-/**
- * 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(clientConfig: ClientConfig) {
-  const { chain, publicClient, httpClient } = setupClient(clientConfig);
-  return new MintClient(chain, publicClient, httpClient);
+function isPremintCollect(
+  parameters: MakeMintParametersArguments,
+): parameters is MakePremintMintParametersArguments {
+  return parameters.mintType === "premint";
 }
 
-export type TMintClient = ReturnType<typeof createMintClient>;
+function is721Collect(
+  parameters: MakeMintParametersArguments,
+): parameters is Make721MintArguments {
+  return parameters.mintType === "721";
+}
 
-async function makePrepareMintTokenParams({
+async function mint({
+  parameters,
+  chainId,
   publicClient,
-  apiClient,
-  tokenId,
-  tokenAddress,
-  mintArguments,
-  ...rest
+  mintGetter,
+  premintGetter,
 }: {
+  parameters: MakeMintParametersArguments;
   publicClient: PublicClient;
-  minterAccount: Address | Account;
-  tokenId?: GenericTokenIdTypes;
+  mintGetter: IMintGetter;
+  premintGetter: IPremintGetter;
+  chainId: number;
+}) {
+  if (isPremintCollect(parameters)) {
+    return {
+      parameters: await collectPremint({
+        ...parameters,
+        premintGetter: premintGetter,
+        publicClient,
+      }),
+    };
+  }
+
+  return {
+    parameters: await collectOnchain({
+      ...parameters,
+      mintGetter: mintGetter,
+      chainId,
+    }),
+  };
+}
+
+export function requestErc20ApprovalForMint({
+  account,
+  tokenAddress,
+  quantityErc20,
+  erc20MinterAddress,
+}: {
+  account: Account | Address;
   tokenAddress: Address;
-  mintArguments: MintArguments;
-  apiClient: MintAPIClient;
+  quantityErc20: bigint;
+  erc20MinterAddress: Address;
+}) {
+  return makeContractParameters({
+    abi: erc20Abi,
+    address: tokenAddress,
+    account,
+    functionName: "approve",
+    args: [erc20MinterAddress, quantityErc20],
+  });
+}
+
+export async function getNecessaryErc20Approval({
+  chainId,
+  account,
+  tokenAddress,
+  quantityErc20,
+  publicClient,
+}: {
+  chainId: number;
+  account: Account | Address;
+  tokenAddress: Address;
+  quantityErc20: bigint;
+  publicClient: PublicClient;
+}) {
+  const destination =
+    erc20MinterAddress[chainId as keyof typeof erc20MinterAddress];
+  const allowance = await publicClient.readContract({
+    abi: erc20Abi,
+    address: tokenAddress,
+    functionName: "allowance",
+    account,
+    args: [
+      destination,
+      erc20MinterAddress[chainId as keyof typeof erc20MinterAddress],
+    ],
+  });
+
+  if (allowance < quantityErc20) {
+    return requestErc20ApprovalForMint({
+      erc20MinterAddress: destination,
+      account,
+      tokenAddress,
+      quantityErc20: quantityErc20 - allowance,
+    });
+  }
+
+  return undefined;
+}
+
+export async function collectOnchain({
+  chainId,
+  mintGetter,
+  ...parameters
+}: (Make1155MintArguments | Make721MintArguments) & {
+  mintGetter: IMintGetter;
+  chainId: number;
 }): Promise<
   SimulateContractParameters<any, any, any, any, any, Account | Address>
 > {
-  const salesConfigAndTokenInfo = await apiClient.getSalesConfigAndTokenInfo({
+  const { tokenContract: tokenContract, saleType } = parameters;
+  const tokenId = is1155Mint(parameters) ? parameters.tokenId : undefined;
+  const salesConfigAndTokenInfo = await mintGetter.getSalesConfigAndTokenInfo({
     tokenId,
-    tokenAddress,
-    saleType: mintArguments.saleType,
+    tokenAddress: tokenContract,
+    saleType,
   });
 
-  if (tokenId === undefined) {
+  if (is721Collect(parameters)) {
     return makePrepareMint721TokenParams({
       salesConfigAndTokenInfo,
-      tokenAddress,
-      mintArguments,
-      ...rest,
+      ...parameters,
     });
   }
 
   return makePrepareMint1155TokenParams({
     salesConfigAndTokenInfo,
-    tokenAddress,
-    tokenId,
-    mintArguments,
-    ...rest,
+    chainId,
+    ...parameters,
   });
 }
 
 async function makePrepareMint721TokenParams({
-  tokenAddress,
   salesConfigAndTokenInfo,
   minterAccount,
-  mintArguments,
+  tokenContract,
+  mintComment,
+  mintReferral,
+  mintRecipient,
+  quantityToMint,
 }: {
-  tokenAddress: Address;
   salesConfigAndTokenInfo: SalesConfigAndTokenInfo;
-  minterAccount: Address | Account;
-  mintArguments: MintArguments;
-}) {
-  const mintValue = getMintCosts({
+} & Pick<
+  MakeMintParametersArgumentsBase,
+  | "minterAccount"
+  | "tokenContract"
+  | "mintComment"
+  | "mintReferral"
+  | "quantityToMint"
+  | "mintRecipient"
+>) {
+  const actualQuantityToMint = BigInt(quantityToMint || 1);
+  const mintValue = parseMintCosts({
     salesConfigAndTokenInfo,
-    quantityToMint: BigInt(mintArguments.quantityToMint),
-  }).totalCost;
+    quantityToMint: actualQuantityToMint,
+  }).totalCostEth;
 
-  return makeSimulateContractParamaters({
+  return makeContractParameters({
     abi: zora721Abi,
-    address: tokenAddress,
+    address: tokenContract,
     account: minterAccount,
     functionName: "mintWithRewards",
     value: mintValue,
     args: [
-      mintArguments.mintToAddress,
-      BigInt(mintArguments.quantityToMint),
-      mintArguments.mintComment || "",
-      mintArguments.mintReferral || zeroAddress,
+      mintRecipientOrAccount({ mintRecipient, minterAccount }),
+      actualQuantityToMint,
+      mintComment || "",
+      mintReferral || zeroAddress,
     ],
   });
 }
 
 export type MintCosts = {
+  /** The total of the mint fee, in eth */
   mintFee: bigint;
-  tokenPurchaseCost: bigint;
-  totalCost: bigint;
+  /** If it is a paid or erc20 mint, the total price of the paid or erc20 mint in eth or erc20 value correspondingly. */
+  totalPurchaseCost: bigint;
+  /** If it is an erc20 mint, the erc20 address */
+  totalPurchaseCostCurrency?: Address;
+  /** The total cost in eth (mint fee + purchase cost) to mint */
+  totalCostEth: bigint;
 };
 
-export function getMintCosts({
+export function parseMintCosts({
   salesConfigAndTokenInfo,
   quantityToMint,
 }: {
@@ -188,83 +296,139 @@ export function getMintCosts({
 }): MintCosts {
   const mintFeeForTokens =
     salesConfigAndTokenInfo.mintFeePerQuantity * quantityToMint;
+
   const tokenPurchaseCost =
     BigInt(salesConfigAndTokenInfo.salesConfig.pricePerToken) * quantityToMint;
 
+  const totalPurchaseCostCurrency = isErc20SaleStrategy(
+    salesConfigAndTokenInfo.salesConfig,
+  )
+    ? salesConfigAndTokenInfo.salesConfig.currency
+    : undefined;
+
+  const totalPurchaseCostEth = totalPurchaseCostCurrency
+    ? 0n
+    : tokenPurchaseCost;
+
   return {
     mintFee: mintFeeForTokens,
-    tokenPurchaseCost,
-    totalCost: mintFeeForTokens + tokenPurchaseCost,
+    totalPurchaseCost: tokenPurchaseCost,
+    totalPurchaseCostCurrency,
+    totalCostEth: mintFeeForTokens + totalPurchaseCostEth,
   };
 }
 
-async function makePrepareMint1155TokenParams({
+export async function getMintCosts(
+  params: GetMintCostsParameters & {
+    mintGetter: IMintGetter;
+    premintGetter: IPremintGetter;
+    publicClient: PublicClient;
+  },
+) {
+  const { quantityMinted: quantityToMint, collection, publicClient } = params;
+  if (isOnChainMint(params)) {
+    const tokenId = is1155Mint(params) ? params.tokenId : undefined;
+    const salesConfigAndTokenInfo =
+      await params.mintGetter.getSalesConfigAndTokenInfo({
+        tokenId,
+        tokenAddress: collection,
+      });
+
+    return parseMintCosts({
+      salesConfigAndTokenInfo,
+      quantityToMint: BigInt(quantityToMint),
+    });
+  }
+
+  return getPremintMintCostsWithUnknownTokenPrice({
+    premintGetter: params.premintGetter,
+    publicClient: publicClient,
+    quantityToMint: BigInt(quantityToMint),
+    uid: params.uid,
+    tokenContract: collection,
+  });
+}
+
+export function makePrepareMint1155TokenParams({
+  tokenContract: tokenContract,
   tokenId,
   salesConfigAndTokenInfo,
   minterAccount,
-  tokenAddress,
-  mintArguments,
+  mintComment,
+  mintReferral,
+  mintRecipient,
+  quantityToMint,
+  chainId,
 }: {
   salesConfigAndTokenInfo: SalesConfigAndTokenInfo;
+  chainId: number;
   tokenId: GenericTokenIdTypes;
-  minterAccount: Address | Account;
-  tokenAddress: Address;
-  mintArguments: MintArguments;
-}) {
-  const mintQuantity = BigInt(mintArguments.quantityToMint);
+} & Pick<
+  MakeMintParametersArgumentsBase,
+  | "minterAccount"
+  | "tokenContract"
+  | "mintComment"
+  | "mintReferral"
+  | "quantityToMint"
+  | "mintRecipient"
+>) {
+  const mintQuantity = BigInt(quantityToMint || 1);
 
-  const mintValue = getMintCosts({
-    salesConfigAndTokenInfo,
-    quantityToMint: mintQuantity,
-  }).totalCost;
-
-  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,
-        ],
-      });
+  const mintTo = mintRecipientOrAccount({ mintRecipient, minterAccount });
 
-    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 || "",
-        ],
-      });
+  const saleType = salesConfigAndTokenInfo.salesConfig.saleType;
+
+  if (saleType === "fixedPrice") {
+    const mintValue = parseMintCosts({
+      salesConfigAndTokenInfo,
+      quantityToMint: mintQuantity,
+    }).totalCostEth;
 
-    default:
-      throw new MintError("Unsupported sale type");
+    return makeContractParameters({
+      abi: zoraCreator1155ImplABI,
+      functionName: "mintWithRewards",
+      account: minterAccount,
+      value: mintValue,
+      address: tokenContract,
+      /* args: minter, tokenId, quantity, minterArguments, mintReferral */
+      args: [
+        (salesConfigAndTokenInfo.salesConfig.address ||
+          zoraCreatorFixedPriceSaleStrategyAddress[
+            chainId as keyof typeof zoraCreatorFixedPriceSaleStrategyAddress
+          ]) as Address,
+        BigInt(tokenId),
+        mintQuantity,
+        encodeAbiParameters(parseAbiParameters("address, string"), [
+          mintTo,
+          mintComment || "",
+        ]),
+        mintReferral || zeroAddress,
+      ],
+    });
   }
+
+  if (saleType === "erc20") {
+    return makeContractParameters({
+      abi: erc20MinterABI,
+      functionName: "mint",
+      account: minterAccount,
+      address: (salesConfigAndTokenInfo?.salesConfig.address ||
+        erc20MinterAddress[
+          chainId as keyof typeof erc20MinterAddress
+        ]) as Address,
+      /* args: mintTo, quantity, tokenAddress, tokenId, totalValue, currency, mintReferral, comment */
+      args: [
+        mintTo,
+        mintQuantity,
+        tokenContract,
+        BigInt(tokenId),
+        salesConfigAndTokenInfo.salesConfig.pricePerToken * mintQuantity,
+        salesConfigAndTokenInfo.salesConfig.currency,
+        mintReferral || zeroAddress,
+        mintComment || "",
+      ],
+    });
+  }
+
+  throw new MintError("Unsupported sale type");
 }

package/src/mint/{mint-api-client.ts → subgraph-mint-getter.ts}

@@ -5,10 +5,9 @@ import {
 } from "../apis/http-api-base";
 import { NetworkConfig, networkConfigByChain } from "src/apis/chain-constants";
 import { GenericTokenIdTypes } from "src/types";
+import { IMintGetter, SalesConfigAndTokenInfo, SaleType } from "./types";
 import { NFT_SALE_QUERY } from "src/constants";
 
-export type SaleType = "fixedPrice" | "erc20";
-
 type FixedPriceSaleStrategyResult = {
   address: Address;
   pricePerToken: string;
@@ -40,28 +39,6 @@ type TokenQueryResult = {
   };
 };
 
-type SaleStrategy<T extends SaleType> = {
-  saleType: T;
-  address: Address;
-  pricePerToken: bigint;
-  saleEnd: string;
-  saleStart: string;
-  maxTokensPerAddress: bigint;
-};
-
-type FixedPriceSaleStrategy = SaleStrategy<"fixedPrice">;
-
-type ERC20SaleStrategy = SaleStrategy<"erc20"> & {
-  currency: Address;
-};
-
-type SaleStrategies = FixedPriceSaleStrategy | ERC20SaleStrategy;
-
-export type SalesConfigAndTokenInfo = {
-  salesConfig: SaleStrategies;
-  mintFeePerQuantity: bigint;
-};
-
 export const getApiNetworkConfigForChain = (chainId: number): NetworkConfig => {
   if (!networkConfigByChain[chainId]) {
     throw new Error(`chain id ${chainId} network not configured `);
@@ -69,7 +46,7 @@ export const getApiNetworkConfigForChain = (chainId: number): NetworkConfig => {
   return networkConfigByChain[chainId]!;
 };
 
-export class MintAPIClient {
+export class SubgraphMintGetter implements IMintGetter {
   httpClient: IHttpClient;
   networkConfig: NetworkConfig;