@zoralabs/protocol-sdk 0.5.17 → 0.7.0

package/src/mint/mint-client.ts

@@ -1,32 +1,23 @@
+import { Address, Account, SimulateContractParameters } from "viem";
+import { IPublicClient } from "src/types";
 import {
-  Address,
-  Chain,
-  encodeAbiParameters,
-  parseAbiParameters,
-  zeroAddress,
-  Account,
-  SimulateContractParameters,
-} from "viem";
-import {
-  erc20MinterABI,
-  erc20MinterAddress,
-  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,
+  GetMintParameters,
+  IOnchainMintGetter,
+  MintCosts,
+  PrepareMintReturn,
   SaleType,
-} from "./mint-api-client";
+} from "./types";
 import {
-  makeSimulateContractParamaters,
-  ClientConfig,
-  setupClient,
-  PublicClient,
-} from "src/utils";
+  MakeMintParametersArguments,
+  Make1155MintArguments,
+  Make721MintArguments,
+  GetMintCostsParameters,
+  is1155Mint,
+} from "./types";
+import { IPremintGetter } from "src/premint/premint-api-client";
+
+import { makeOnchainMintCall } from "./mint-transactions";
+import { getMint, getMintCosts, getMintsOfContract } from "./mint-queries";
 
 class MintError extends Error {}
 class MintInactiveError extends Error {}
@@ -36,235 +27,140 @@ 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;
-};
-
-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);
+export class MintClient {
+  private readonly publicClient: IPublicClient;
+  private readonly mintGetter: IOnchainMintGetter;
+  private readonly premintGetter: IPremintGetter;
+
+  constructor({
+    publicClient,
+    premintGetter,
+    mintGetter,
+  }: {
+    publicClient: IPublicClient;
+    premintGetter: IPremintGetter;
+    mintGetter: IOnchainMintGetter;
+  }) {
     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}
-   * @returns Parameters for simulating/executing the mint transaction
+   * @param parameters - Parameters for collecting the token {@link MakeMintParametersArguments}
+   * @returns Parameters for simulating/executing the mint transaction, any necessary erc20 approval, and costs to mint
    */
-  async makePrepareMintTokenParams(parameters: MintTokenParams) {
-    return makePrepareMintTokenParams({
-      ...parameters,
-      apiClient: this.apiClient,
+  async mint(
+    parameters: MakeMintParametersArguments,
+  ): Promise<PrepareMintReturn> {
+    return mint({
+      parameters,
       publicClient: this.publicClient,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter,
     });
   }
-}
-
-/**
- * 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);
-}
 
-export type TMintClient = ReturnType<typeof createMintClient>;
-
-async function makePrepareMintTokenParams({
-  publicClient,
-  apiClient,
-  tokenId,
-  tokenAddress,
-  mintArguments,
-  ...rest
-}: {
-  publicClient: PublicClient;
-  minterAccount: Address | Account;
-  tokenId?: GenericTokenIdTypes;
-  tokenAddress: Address;
-  mintArguments: MintArguments;
-  apiClient: MintAPIClient;
-}): Promise<
-  SimulateContractParameters<any, any, any, any, any, Account | Address>
-> {
-  const salesConfigAndTokenInfo = await apiClient.getSalesConfigAndTokenInfo({
-    tokenId,
-    tokenAddress,
-    saleType: mintArguments.saleType,
-  });
+  /**
+   * Gets an 1155, 721, or premint, and returns both information about it, and a function
+   * that can be used to build a mint transaction for a quantity of items to mint.
+   * @param parameters - Token to get {@link GetMintParameters}
+   * @Returns Information about the mint and a function to build a mint transaction {@link MintableReturn}
+   */
+  async get(parameters: GetMintParameters) {
+    return getMint({
+      params: parameters,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter,
+      publicClient: this.publicClient,
+    });
+  }
 
-  if (tokenId === undefined) {
-    return makePrepareMint721TokenParams({
-      salesConfigAndTokenInfo,
-      tokenAddress,
-      mintArguments,
-      ...rest,
+  /**
+   * Gets onchain and premint tokens of an 1155 contract.  For each token returns both information about it, and a function
+   * that can be used to build a mint transaction for a quantity of items to mint.
+   * @param parameters - Contract address to get tokens for {@link GetMintsOfContractParameters}
+   * @Returns Array of tokens, each containing information about the token and a function to build a mint transaction.
+   */
+  async getOfContract(params: {
+    tokenContract: Address;
+    preferredSaleType?: SaleType;
+  }) {
+    return getMintsOfContract({
+      params,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter,
+      publicClient: this.publicClient,
     });
   }
 
-  return makePrepareMint1155TokenParams({
-    salesConfigAndTokenInfo,
-    tokenAddress,
-    tokenId,
-    mintArguments,
-    ...rest,
-  });
+  /**
+   * 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({
+      params: parameters,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter,
+      publicClient: this.publicClient,
+    });
+  }
 }
 
-async function makePrepareMint721TokenParams({
-  tokenAddress,
-  salesConfigAndTokenInfo,
-  minterAccount,
-  mintArguments,
+async function mint({
+  parameters,
+  publicClient,
+  mintGetter,
+  premintGetter,
 }: {
-  tokenAddress: Address;
-  salesConfigAndTokenInfo: SalesConfigAndTokenInfo;
-  minterAccount: Address | Account;
-  mintArguments: MintArguments;
-}) {
-  const mintValue = getMintCosts({
-    salesConfigAndTokenInfo,
-    quantityToMint: BigInt(mintArguments.quantityToMint),
-  }).totalCost;
-
-  return makeSimulateContractParamaters({
-    abi: zora721Abi,
-    address: tokenAddress,
-    account: minterAccount,
-    functionName: "mintWithRewards",
-    value: mintValue,
-    args: [
-      mintArguments.mintToAddress,
-      BigInt(mintArguments.quantityToMint),
-      mintArguments.mintComment || "",
-      mintArguments.mintReferral || zeroAddress,
-    ],
+  parameters: MakeMintParametersArguments;
+  publicClient: IPublicClient;
+  mintGetter: IOnchainMintGetter;
+  premintGetter: IPremintGetter;
+}): Promise<PrepareMintReturn> {
+  const { prepareMint } = await getMint({
+    params: parameters,
+    mintGetter,
+    premintGetter,
+    publicClient,
   });
-}
-
-export type MintCosts = {
-  mintFee: bigint;
-  tokenPurchaseCost: bigint;
-  totalCost: bigint;
-};
 
-export function getMintCosts({
-  salesConfigAndTokenInfo,
-  quantityToMint,
-}: {
-  salesConfigAndTokenInfo: SalesConfigAndTokenInfo;
-  quantityToMint: bigint;
-}): MintCosts {
-  const mintFeeForTokens =
-    salesConfigAndTokenInfo.mintFeePerQuantity * quantityToMint;
-  const tokenPurchaseCost =
-    BigInt(salesConfigAndTokenInfo.salesConfig.pricePerToken) * quantityToMint;
-
-  return {
-    mintFee: mintFeeForTokens,
-    tokenPurchaseCost,
-    totalCost: mintFeeForTokens + tokenPurchaseCost,
-  };
+  return prepareMint({
+    minterAccount: parameters.minterAccount,
+    quantityToMint: parameters.quantityToMint,
+    firstMinter: parameters.firstMinter,
+    mintComment: parameters.mintComment,
+    mintRecipient: parameters.mintRecipient,
+    mintReferral: parameters.mintReferral,
+  });
 }
 
-async function makePrepareMint1155TokenParams({
-  tokenId,
-  salesConfigAndTokenInfo,
-  minterAccount,
-  tokenAddress,
-  mintArguments,
-}: {
-  salesConfigAndTokenInfo: SalesConfigAndTokenInfo;
-  tokenId: GenericTokenIdTypes;
-  minterAccount: Address | Account;
-  tokenAddress: Address;
-  mintArguments: MintArguments;
-}) {
-  const mintQuantity = BigInt(mintArguments.quantityToMint);
-
-  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,
-        ],
-      });
-
-    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 || "",
-        ],
-      });
+export async function collectOnchain({
+  chainId,
+  mintGetter,
+  ...parameters
+}: (Make1155MintArguments | Make721MintArguments) & {
+  mintGetter: IOnchainMintGetter;
+  chainId: number;
+}): Promise<
+  SimulateContractParameters<any, any, any, any, any, Account | Address>
+> {
+  const { tokenContract: tokenContract, preferredSaleType: saleType } =
+    parameters;
+  const tokenId = is1155Mint(parameters) ? parameters.tokenId : undefined;
+  const salesConfigAndTokenInfo = await mintGetter.getMintable({
+    tokenId,
+    tokenAddress: tokenContract,
+    preferredSaleType: saleType,
+  });
 
-    default:
-      throw new MintError("Unsupported sale type");
-  }
+  return makeOnchainMintCall({
+    mintParams: parameters,
+    token: salesConfigAndTokenInfo,
+  });
 }