@zoralabs/protocol-sdk 0.8.0 → 0.9.1

package/src/mint/mint-transactions.ts

@@ -5,28 +5,35 @@ import {
   zeroAddress,
   Account,
   SimulateContractParameters,
+  Hex,
 } from "viem";
 import {
   erc20MinterABI,
   zoraCreator1155ImplABI,
+  zoraTimedSaleStrategyABI,
 } from "@zoralabs/protocol-deployments";
 import { zora721Abi, zora1155LegacyAbi } from "src/constants";
 import {
   GenericTokenIdTypes,
   SimulateContractParametersWithAccount,
 } from "src/types";
-import { makeContractParameters, mintRecipientOrAccount } from "src/utils";
+import {
+  Concrete,
+  makeContractParameters,
+  mintRecipientOrAccount,
+} from "src/utils";
 import { MintCosts, SaleStrategies, isErc20SaleStrategy } from "./types";
 import { MakeMintParametersArgumentsBase } from "./types";
 
 import { contractSupportsNewMintFunction } from "./utils";
 import { OnchainSalesConfigAndTokenInfo } from "./types";
+import { AllowListEntry } from "src/allow-list/types";
 
 export function makeOnchainMintCall({
   token,
   mintParams,
 }: {
-  token: OnchainSalesConfigAndTokenInfo;
+  token: Concrete<OnchainSalesConfigAndTokenInfo>;
   mintParams: Omit<MakeMintParametersArgumentsBase, "tokenContract">;
 }): SimulateContractParametersWithAccount {
   if (token.mintType === "721") {
@@ -47,7 +54,7 @@ export function makeOnchainMintCall({
 
 export type MintableParameters = Pick<
   OnchainSalesConfigAndTokenInfo,
-  "contractVersion" | "mintFeePerQuantity" | "salesConfig"
+  "contractVersion" | "salesConfig"
 >;
 
 export function makePrepareMint1155TokenParams({
@@ -59,8 +66,9 @@ export function makePrepareMint1155TokenParams({
   mintReferral,
   mintRecipient,
   quantityToMint,
+  allowListEntry,
 }: {
-  salesConfigAndTokenInfo: MintableParameters;
+  salesConfigAndTokenInfo: Concrete<MintableParameters>;
   tokenId: GenericTokenIdTypes;
 } & Pick<
   MakeMintParametersArgumentsBase,
@@ -70,6 +78,7 @@ export function makePrepareMint1155TokenParams({
   | "mintReferral"
   | "quantityToMint"
   | "mintRecipient"
+  | "allowListEntry"
 >): SimulateContractParameters<any, any, any, any, any, Address | Account> {
   const mintQuantity = BigInt(quantityToMint || 1);
 
@@ -77,7 +86,7 @@ export function makePrepareMint1155TokenParams({
 
   const saleType = salesConfigAndTokenInfo.salesConfig.saleType;
 
-  if (saleType === "fixedPrice") {
+  if (saleType === "fixedPrice" || saleType === "allowlist") {
     return makeEthMintCall({
       mintComment,
       minterAccount,
@@ -87,6 +96,27 @@ export function makePrepareMint1155TokenParams({
       salesConfigAndTokenInfo,
       tokenContract,
       tokenId,
+      allowListEntry,
+    });
+  }
+
+  if (saleType === "timed") {
+    return makeContractParameters({
+      abi: zoraTimedSaleStrategyABI,
+      functionName: "mint",
+      account: minterAccount,
+      address: salesConfigAndTokenInfo.salesConfig.address,
+      value:
+        salesConfigAndTokenInfo.salesConfig.mintFeePerQuantity * mintQuantity,
+      /* args: mintTo, quantity, collection, tokenId, mintReferral, comment */
+      args: [
+        mintTo,
+        mintQuantity,
+        tokenContract,
+        BigInt(tokenId),
+        mintReferral || zeroAddress,
+        mintComment || "",
+      ],
     });
   }
 
@@ -122,7 +152,7 @@ function makePrepareMint721TokenParams({
   mintRecipient,
   quantityToMint,
 }: {
-  salesConfigAndTokenInfo: MintableParameters;
+  salesConfigAndTokenInfo: Concrete<MintableParameters>;
 } & Pick<
   MakeMintParametersArgumentsBase,
   | "minterAccount"
@@ -134,9 +164,9 @@ function makePrepareMint721TokenParams({
 >): SimulateContractParametersWithAccount {
   const actualQuantityToMint = BigInt(quantityToMint || 1);
   const mintValue = parseMintCosts({
-    mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
     salesConfig: salesConfigAndTokenInfo.salesConfig,
     quantityToMint: actualQuantityToMint,
+    allowListEntry: undefined,
   }).totalCostEth;
 
   return makeContractParameters({
@@ -154,6 +184,37 @@ function makePrepareMint721TokenParams({
   });
 }
 
+function makeFixedPriceMinterArguments({
+  mintTo,
+  mintComment,
+}: {
+  mintTo: Address;
+  mintComment?: string;
+}) {
+  return encodeAbiParameters(parseAbiParameters("address, string"), [
+    mintTo,
+    mintComment || "",
+  ]);
+}
+
+function makeAllowListMinterArguments({
+  mintTo,
+  allowListEntry,
+}: {
+  mintTo: Address;
+  allowListEntry: AllowListEntry;
+}) {
+  return encodeAbiParameters(
+    parseAbiParameters("address, uint256, uint256, bytes32[]"),
+    [
+      mintTo,
+      BigInt(allowListEntry.maxCanMint),
+      allowListEntry.price,
+      allowListEntry.proof,
+    ],
+  );
+}
+
 function makeEthMintCall({
   tokenContract,
   tokenId,
@@ -163,26 +224,35 @@ function makeEthMintCall({
   mintReferral,
   mintQuantity,
   mintTo,
+  allowListEntry,
 }: {
   minterAccount: Account | Address;
   tokenContract: Address;
   mintTo: Address;
-  salesConfigAndTokenInfo: MintableParameters;
+  salesConfigAndTokenInfo: Concrete<MintableParameters>;
   tokenId: GenericTokenIdTypes;
   mintQuantity: bigint;
   mintComment?: string;
   mintReferral?: Address;
+  allowListEntry?: AllowListEntry;
 }): SimulateContractParametersWithAccount {
   const mintValue = parseMintCosts({
-    mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
     salesConfig: salesConfigAndTokenInfo.salesConfig,
     quantityToMint: mintQuantity,
+    allowListEntry,
   }).totalCostEth;
 
-  const minterArguments = encodeAbiParameters(
-    parseAbiParameters("address, string"),
-    [mintTo, mintComment || ""],
-  );
+  const saleType = salesConfigAndTokenInfo.salesConfig.saleType;
+  let minterArguments: Hex;
+
+  if (saleType === "fixedPrice") {
+    minterArguments = makeFixedPriceMinterArguments({ mintTo, mintComment });
+  } else if (saleType === "allowlist") {
+    if (!allowListEntry) throw new Error("Missing allowListEntry");
+    minterArguments = makeAllowListMinterArguments({ mintTo, allowListEntry });
+  } else {
+    throw new Error("Unsupported sale type");
+  }
 
   // if based on contract version it has the new mint function,
   // call the new mint function.
@@ -223,18 +293,35 @@ function makeEthMintCall({
   });
 }
 
+function paidMintCost(
+  salesConfig: SaleStrategies,
+  allowListEntry?: Pick<AllowListEntry, "price">,
+) {
+  if (
+    salesConfig.saleType === "erc20" ||
+    salesConfig.saleType === "fixedPrice"
+  ) {
+    return salesConfig.pricePerToken;
+  }
+
+  if (allowListEntry) return allowListEntry.price;
+
+  return 0n;
+}
+
 export function parseMintCosts({
   salesConfig,
-  mintFeePerQuantity,
   quantityToMint,
+  allowListEntry,
 }: {
   salesConfig: SaleStrategies;
-  mintFeePerQuantity: bigint;
   quantityToMint: bigint;
+  allowListEntry: Pick<AllowListEntry, "price"> | undefined;
 }): MintCosts {
-  const mintFeeForTokens = mintFeePerQuantity * quantityToMint;
+  const mintFeeForTokens = salesConfig.mintFeePerQuantity * quantityToMint;
 
-  const tokenPurchaseCost = BigInt(salesConfig.pricePerToken) * quantityToMint;
+  const tokenPurchaseCost =
+    paidMintCost(salesConfig, allowListEntry) * quantityToMint;
 
   const totalPurchaseCostCurrency = isErc20SaleStrategy(salesConfig)
     ? salesConfig.currency

package/src/mint/subgraph-mint-getter.ts

@@ -1,8 +1,6 @@
 import { Address } from "viem";
-import {
-  httpClient as defaultHttpClient,
-  IHttpClient,
-} from "../apis/http-api-base";
+import { httpClient as defaultHttpClient } from "../apis/http-api-base";
+import { ISubgraphQuerier, SubgraphQuerier } from "../apis/subgraph-querier";
 import { NetworkConfig, networkConfigByChain } from "src/apis/chain-constants";
 import { GenericTokenIdTypes } from "src/types";
 import {
@@ -11,19 +9,15 @@ import {
   OnchainMintable,
   OnchainSalesConfigAndTokenInfo,
   OnchainSalesStrategies,
-  isErc20SaleStrategy,
 } from "./types";
-import { querySubgraphWithRetries } from "src/utils";
 import {
   buildContractTokensQuery,
-  buildGetDefaultMintPriceQuery,
   buildNftTokenSalesQuery,
   buildPremintsOfContractQuery,
   ISubgraphQuery,
   SalesStrategyResult,
   TokenQueryResult,
 } from "./subgraph-queries";
-import * as semver from "semver";
 
 export const getApiNetworkConfigForChain = (chainId: number): NetworkConfig => {
   if (!networkConfigByChain[chainId]) {
@@ -34,6 +28,7 @@ export const getApiNetworkConfigForChain = (chainId: number): NetworkConfig => {
 
 function parseSalesConfig(
   targetStrategy: SalesStrategyResult,
+  contractMintFee: bigint,
 ): OnchainSalesStrategies {
   if (targetStrategy.type === "FIXED_PRICE")
     return {
@@ -43,6 +38,7 @@ function parseSalesConfig(
         targetStrategy.fixedPrice.maxTokensPerAddress,
       ),
       pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken),
+      mintFeePerQuantity: contractMintFee,
     };
 
   if (targetStrategy.type === "ERC_20_MINTER") {
@@ -53,6 +49,30 @@ function parseSalesConfig(
         targetStrategy.erc20Minter.maxTokensPerAddress,
       ),
       pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken),
+      mintFeePerQuantity: 0n,
+    };
+  }
+  if (targetStrategy.type === "PRESALE") {
+    return {
+      saleType: "allowlist",
+      address: targetStrategy.presale.address,
+      merkleRoot: targetStrategy.presale.merkleRoot,
+      saleStart: targetStrategy.presale.presaleStart,
+      saleEnd: targetStrategy.presale.presaleEnd,
+      mintFeePerQuantity: contractMintFee,
+    };
+  }
+  if (targetStrategy.type === "ZORA_TIMED") {
+    return {
+      saleType: "timed",
+      address: targetStrategy.zoraTimedMinter.address,
+      mintFee: BigInt(targetStrategy.zoraTimedMinter.mintFee),
+      saleStart: targetStrategy.zoraTimedMinter.saleStart,
+      saleEnd: targetStrategy.zoraTimedMinter.saleEnd,
+      erc20Z: targetStrategy.zoraTimedMinter.erc20Z.id,
+      pool: targetStrategy.zoraTimedMinter.erc20Z.pool,
+      secondaryActivated: targetStrategy.zoraTimedMinter.secondaryActivated,
+      mintFeePerQuantity: BigInt(targetStrategy.zoraTimedMinter.mintFee),
     };
   }
 
@@ -60,36 +80,56 @@ function parseSalesConfig(
 }
 
 function getSaleEnd(a: SalesStrategyResult) {
-  return BigInt(
-    a.type === "ERC_20_MINTER" ? a.erc20Minter.saleEnd : a.fixedPrice.saleEnd,
-  );
+  if (a.type === "FIXED_PRICE") return BigInt(a.fixedPrice.saleEnd);
+  if (a.type === "ERC_20_MINTER") return BigInt(a.erc20Minter.saleEnd);
+  if (a.type === "ZORA_TIMED") return BigInt(a.zoraTimedMinter.saleEnd);
+  return BigInt(a.presale.presaleEnd);
+}
+
+function strategyIsStillValid(
+  strategy: SalesStrategyResult,
+  blockTime: bigint,
+): boolean {
+  if (strategy.type === "FIXED_PRICE") {
+    return BigInt(strategy.fixedPrice.saleEnd) > blockTime;
+  }
+  if (strategy.type === "ERC_20_MINTER") {
+    return BigInt(strategy.erc20Minter.saleEnd) > blockTime;
+  }
+  if (strategy.type === "ZORA_TIMED") {
+    return BigInt(strategy.zoraTimedMinter.saleEnd) > blockTime;
+  }
+  return BigInt(strategy.presale.presaleEnd) > blockTime;
 }
 
 function getTargetStrategy({
   tokenId,
   preferredSaleType,
   token,
+  blockTime,
 }: {
   tokenId?: GenericTokenIdTypes;
   preferredSaleType?: SaleType;
   token: TokenQueryResult;
-}) {
+  blockTime: bigint;
+}): SalesStrategyResult | undefined {
   const allStrategies =
     (typeof tokenId !== "undefined"
       ? token.salesStrategies
       : token.contract.salesStrategies) || [];
 
-  const saleStrategies = allStrategies.sort((a, b) =>
+  const stillValidSalesStrategies = allStrategies.filter((strategy) =>
+    strategyIsStillValid(strategy, blockTime),
+  );
+
+  const saleStrategies = stillValidSalesStrategies.sort((a, b) =>
     getSaleEnd(a) > getSaleEnd(b) ? 1 : -1,
   );
 
   let targetStrategy: SalesStrategyResult | undefined;
 
   if (!preferredSaleType) {
-    targetStrategy = saleStrategies[0];
-    if (!targetStrategy) {
-      throw new Error("Cannot find sale strategy");
-    }
+    return saleStrategies[0];
   } else {
     const mappedSaleType =
       preferredSaleType === "erc20" ? "ERC_20_MINTER" : "FIXED_PRICE";
@@ -110,24 +150,17 @@ function getTargetStrategy({
 }
 
 export class SubgraphMintGetter implements IOnchainMintGetter {
-  httpClient: IHttpClient;
+  public readonly subgraphQuerier: ISubgraphQuerier;
   networkConfig: NetworkConfig;
 
-  constructor(chainId: number, httpClient?: IHttpClient) {
-    this.httpClient = httpClient || defaultHttpClient;
+  constructor(chainId: number, subgraphQuerier?: ISubgraphQuerier) {
+    this.subgraphQuerier =
+      subgraphQuerier || new SubgraphQuerier(defaultHttpClient);
     this.networkConfig = getApiNetworkConfigForChain(chainId);
   }
 
   async getContractMintFee(contract: TokenQueryResult["contract"]) {
-    const storedMintFee = BigInt(contract.mintFeePerQuantity);
-    if (!contractUsesMintCardsForMintFee(contract.contractVersion)) {
-      return storedMintFee;
-    }
-    const defaultMintFee = await this.querySubgraphWithRetries(
-      buildGetDefaultMintPriceQuery({}),
-    );
-
-    return defaultMintFee || storedMintFee;
+    return BigInt(contract.mintFeePerQuantity);
   }
 
   async querySubgraphWithRetries<T>({
@@ -135,8 +168,7 @@ export class SubgraphMintGetter implements IOnchainMintGetter {
     variables,
     parseResponseData,
   }: ISubgraphQuery<T>) {
-    const responseData = await querySubgraphWithRetries({
-      httpClient: this.httpClient,
+    const responseData = await this.subgraphQuerier.query({
       subgraphUrl: this.networkConfig.subgraphUrl,
       query,
       variables,
@@ -149,6 +181,7 @@ export class SubgraphMintGetter implements IOnchainMintGetter {
     tokenAddress,
     tokenId,
     preferredSaleType: saleType,
+    blockTime,
   }) => {
     const token = await this.querySubgraphWithRetries(
       buildNftTokenSalesQuery({
@@ -168,15 +201,18 @@ export class SubgraphMintGetter implements IOnchainMintGetter {
       defaultMintFee,
       tokenId,
       preferredSaleType: saleType,
+      blockTime,
     });
   };
 
   async getContractMintable({
     tokenAddress,
     preferredSaleType,
+    blockTime,
   }: {
     tokenAddress: Address;
     preferredSaleType?: SaleType;
+    blockTime: bigint;
   }) {
     const tokens = await this.querySubgraphWithRetries(
       buildContractTokensQuery({
@@ -196,6 +232,7 @@ export class SubgraphMintGetter implements IOnchainMintGetter {
           tokenId: token.tokenId,
           preferredSaleType,
           defaultMintFee,
+          blockTime,
         }),
       );
   }
@@ -220,30 +257,57 @@ export class SubgraphMintGetter implements IOnchainMintGetter {
   }
 }
 
-function parseTokenQueryResult({
+function getTargetStrategyAndMintFee({
   token,
   tokenId,
   preferredSaleType,
   defaultMintFee,
+  blockTime,
 }: {
   token: TokenQueryResult;
   tokenId?: GenericTokenIdTypes;
   preferredSaleType?: SaleType;
   defaultMintFee: bigint;
-}): OnchainSalesConfigAndTokenInfo {
+  blockTime: bigint;
+}) {
   const targetStrategy = getTargetStrategy({
     tokenId,
     preferredSaleType: preferredSaleType,
     token,
+    blockTime,
   });
 
-  const tokenInfo = parseTokenInfo(token, defaultMintFee);
+  if (!targetStrategy) return undefined;
 
-  const salesConfig = parseSalesConfig(targetStrategy);
+  const salesConfig = parseSalesConfig(targetStrategy, defaultMintFee);
 
-  if (isErc20SaleStrategy(salesConfig)) {
-    tokenInfo.mintFeePerQuantity = 0n;
-  }
+  return salesConfig;
+}
+
+function parseTokenQueryResult({
+  token,
+  tokenId,
+  preferredSaleType,
+  defaultMintFee,
+  blockTime,
+}: {
+  token: TokenQueryResult;
+  tokenId?: GenericTokenIdTypes;
+  preferredSaleType?: SaleType;
+  defaultMintFee: bigint;
+  blockTime: bigint;
+}): OnchainSalesConfigAndTokenInfo {
+  const salesConfig = getTargetStrategyAndMintFee({
+    token,
+    tokenId,
+    preferredSaleType,
+    defaultMintFee,
+    blockTime,
+  });
+
+  const tokenInfo = parseTokenInfo({
+    token,
+  });
 
   return {
     ...tokenInfo,
@@ -251,17 +315,11 @@ function parseTokenQueryResult({
   };
 }
 
-const contractUsesMintCardsForMintFee = (contractVersion: string) => {
-  const semVerContractVersion = semver.coerce(contractVersion)?.raw;
-  if (!semVerContractVersion) return false;
-
-  return semver.gte(semVerContractVersion, "2.9.0");
-};
-
-function parseTokenInfo(
-  token: TokenQueryResult,
-  defaultMintFee: bigint,
-): OnchainMintable {
+function parseTokenInfo({
+  token,
+}: {
+  token: TokenQueryResult;
+}): OnchainMintable {
   return {
     contract: {
       address: token.contract.address,
@@ -274,7 +332,6 @@ function parseTokenInfo(
     creator: token.creator,
     totalMinted: BigInt(token.totalMinted),
     maxSupply: BigInt(token.maxSupply),
-    mintFeePerQuantity: defaultMintFee,
     contractVersion: token.contract.contractVersion,
   };
 }

package/src/mint/subgraph-queries.ts

@@ -2,26 +2,58 @@ import { GenericTokenIdTypes } from "src/types";
 import { Address } from "viem";
 
 export type FixedPriceSaleStrategyResult = {
-  address: Address;
-  pricePerToken: string;
-  saleEnd: string;
-  saleStart: string;
-  maxTokensPerAddress: string;
+  type: "FIXED_PRICE";
+  fixedPrice: {
+    address: Address;
+    pricePerToken: string;
+    saleEnd: string;
+    saleStart: string;
+    maxTokensPerAddress: string;
+  };
 };
 
-export type ERC20SaleStrategyResult = FixedPriceSaleStrategyResult & {
-  currency: Address;
+export type ERC20SaleStrategyResult = {
+  type: "ERC_20_MINTER";
+  erc20Minter: {
+    address: Address;
+    pricePerToken: string;
+    saleEnd: string;
+    saleStart: string;
+    maxTokensPerAddress: string;
+    currency: Address;
+  };
 };
 
-export type SalesStrategyResult =
-  | {
-      type: "FIXED_PRICE";
-      fixedPrice: FixedPriceSaleStrategyResult;
-    }
-  | {
-      type: "ERC_20_MINTER";
-      erc20Minter: ERC20SaleStrategyResult;
+export type PresaleSalesStrategyResult = {
+  type: "PRESALE";
+  presale: {
+    address: Address;
+    presaleStart: string;
+    presaleEnd: string;
+    merkleRoot: string;
+  };
+};
+
+export type ZoraTimedMinterSaleStrategyResult = {
+  type: "ZORA_TIMED";
+  zoraTimedMinter: {
+    address: Address;
+    mintFee: string;
+    saleStart: string;
+    saleEnd: string;
+    erc20Z: {
+      id: Address;
+      pool: Address;
     };
+    secondaryActivated: boolean;
+  };
+};
+
+export type SalesStrategyResult =
+  | FixedPriceSaleStrategyResult
+  | ERC20SaleStrategyResult
+  | PresaleSalesStrategyResult
+  | ZoraTimedMinterSaleStrategyResult;
 
 export type TokenQueryResult = {
   tokenId?: string;
@@ -32,7 +64,7 @@ export type TokenQueryResult = {
   salesStrategies?: SalesStrategyResult[];
   tokenStandard: "ERC1155" | "ERC721";
   contract: {
-    mintFeePerQuantity: "string";
+    mintFeePerQuantity: string;
     salesStrategies: SalesStrategyResult[];
     address: Address;
     contractVersion: string;
@@ -59,6 +91,23 @@ fragment SaleStrategy on SalesStrategyConfig {
     saleStart
     maxTokensPerAddress
   }
+  presale {
+    address
+    presaleStart
+    presaleEnd
+    merkleRoot
+  }
+  zoraTimedMinter {
+    address
+    mintFee
+    saleStart
+    saleEnd
+    erc20Z {
+      id 
+      pool
+    }
+    secondaryActivated
+  }
 }`;
 
 const TOKEN_FRAGMENT = `
@@ -69,7 +118,7 @@ fragment Token on ZoraCreateToken {
     totalMinted
     maxSupply
     tokenStandard
-    salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
+    salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER", "PRESALE", "ZORA_TIMED"]}) {
       ...SaleStrategy
     }
     contract {
@@ -78,7 +127,7 @@ fragment Token on ZoraCreateToken {
       contractVersion
       contractURI
       name
-      salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
+      salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER", "PRESALE", "ZORA_TIMED"]}) {
         ...SaleStrategy
       }
     }
@@ -117,25 +166,6 @@ query ($id: ID!) {
   };
 }
 
-export function buildGetDefaultMintPriceQuery({}): ISubgraphQuery<
-  bigint | undefined
-> {
-  return {
-    query: `
-{
-  defaultMintPrice(id: "0x0000000000000000000000000000000000000000") {
-    pricePerToken
-  }
-}
-`,
-    variables: {},
-    parseResponseData: (responseData: any | undefined) =>
-      responseData?.defaultMintPrice?.pricePerToken
-        ? BigInt(responseData?.defaultMintPrice?.pricePerToken)
-        : undefined,
-  };
-}
-
 export function buildContractTokensQuery({
   tokenAddress,
 }: {