@zoralabs/protocol-sdk 0.7.0 → 0.7.2-ALLOWLIST.0

package/src/mint/mint-transactions.ts

@@ -5,6 +5,7 @@ import {
   zeroAddress,
   Account,
   SimulateContractParameters,
+  Hex,
 } from "viem";
 import {
   erc20MinterABI,
@@ -21,6 +22,7 @@ import { MakeMintParametersArgumentsBase } from "./types";
 
 import { contractSupportsNewMintFunction } from "./utils";
 import { OnchainSalesConfigAndTokenInfo } from "./types";
+import { AllowListEntry } from "src/allow-list/types";
 
 export function makeOnchainMintCall({
   token,
@@ -59,6 +61,7 @@ export function makePrepareMint1155TokenParams({
   mintReferral,
   mintRecipient,
   quantityToMint,
+  allowListEntry,
 }: {
   salesConfigAndTokenInfo: MintableParameters;
   tokenId: GenericTokenIdTypes;
@@ -70,6 +73,7 @@ export function makePrepareMint1155TokenParams({
   | "mintReferral"
   | "quantityToMint"
   | "mintRecipient"
+  | "allowListEntry"
 >): SimulateContractParameters<any, any, any, any, any, Address | Account> {
   const mintQuantity = BigInt(quantityToMint || 1);
 
@@ -77,7 +81,7 @@ export function makePrepareMint1155TokenParams({
 
   const saleType = salesConfigAndTokenInfo.salesConfig.saleType;
 
-  if (saleType === "fixedPrice") {
+  if (saleType === "fixedPrice" || saleType === "allowlist") {
     return makeEthMintCall({
       mintComment,
       minterAccount,
@@ -87,6 +91,7 @@ export function makePrepareMint1155TokenParams({
       salesConfigAndTokenInfo,
       tokenContract,
       tokenId,
+      allowListEntry,
     });
   }
 
@@ -137,6 +142,7 @@ function makePrepareMint721TokenParams({
     mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
     salesConfig: salesConfigAndTokenInfo.salesConfig,
     quantityToMint: actualQuantityToMint,
+    allowListEntry: undefined,
   }).totalCostEth;
 
   return makeContractParameters({
@@ -154,6 +160,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,6 +200,7 @@ function makeEthMintCall({
   mintReferral,
   mintQuantity,
   mintTo,
+  allowListEntry,
 }: {
   minterAccount: Account | Address;
   tokenContract: Address;
@@ -172,17 +210,26 @@ function makeEthMintCall({
   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 +270,37 @@ 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 tokenPurchaseCost = BigInt(salesConfig.pricePerToken) * quantityToMint;
+  const tokenPurchaseCost =
+    paidMintCost(salesConfig, allowListEntry) * quantityToMint;
 
   const totalPurchaseCostCurrency = isErc20SaleStrategy(salesConfig)
     ? salesConfig.currency

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

@@ -53,14 +53,23 @@ function parseSalesConfig(
       pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken),
     };
   }
+  if (targetStrategy.type === "PRESALE") {
+    return {
+      saleType: "allowlist",
+      address: targetStrategy.presale.address,
+      merkleRoot: targetStrategy.presale.merkleRoot,
+      saleStart: targetStrategy.presale.presaleStart,
+      saleEnd: targetStrategy.presale.presaleEnd,
+    };
+  }
 
   throw new Error("Unknown saleType");
 }
 
 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);
+  return BigInt(a.presale.presaleEnd);
 }
 
 function getTargetStrategy({

package/src/mint/subgraph-queries.ts

@@ -2,26 +2,42 @@ 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 PresaleSalesStrategyResult = {
+  type: "PRESALE";
+  presale: {
+    address: Address;
+    presaleStart: string;
+    presaleEnd: string;
+    merkleRoot: string;
+  };
 };
 
 export type SalesStrategyResult =
-  | {
-      type: "FIXED_PRICE";
-      fixedPrice: FixedPriceSaleStrategyResult;
-    }
-  | {
-      type: "ERC_20_MINTER";
-      erc20Minter: ERC20SaleStrategyResult;
-    };
+  | FixedPriceSaleStrategyResult
+  | ERC20SaleStrategyResult
+  | PresaleSalesStrategyResult;
 
 export type TokenQueryResult = {
   tokenId?: string;
@@ -59,6 +75,12 @@ fragment SaleStrategy on SalesStrategyConfig {
     saleStart
     maxTokensPerAddress
   }
+  presale {
+    address
+    presaleStart
+    presaleEnd
+    merkleRoot
+  }
 }`;
 
 const TOKEN_FRAGMENT = `
@@ -69,7 +91,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"]}) {
       ...SaleStrategy
     }
     contract {
@@ -78,7 +100,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"]}) {
         ...SaleStrategy
       }
     }

package/src/mint/types.ts

@@ -3,6 +3,7 @@ import {
   GenericTokenIdTypes,
   SimulateContractParametersWithAccount,
 } from "src/types";
+import { AllowListEntry } from "src/allow-list/types";
 
 export type MintParameters<MintType> = {
   /** Type of the collection to be minted. */
@@ -25,7 +26,7 @@ export type PremintMintParameters = MintParameters<"premint"> & {
   uid: number;
 };
 
-export type MintType = "1155" | "721" | "premint";
+export type MintType = "1155" | "721" | "allowlist" | "premint";
 
 export type MintTypes =
   | Erc1155MintParameters
@@ -63,6 +64,8 @@ export type MintParametersBase = {
   mintRecipient?: Address;
   /** If this is a premint, the address to get the first minter reward */
   firstMinter?: Address;
+  /** If this is an allow list mint, the info for the allow list entry */
+  allowListEntry?: AllowListEntry;
 };
 
 export type MakeMintParametersArgumentsBase = MintParametersBase & {
@@ -99,40 +102,60 @@ export type GetMintCostsParameters = {
   quantityMinted: number | bigint;
 } & MintTypes;
 
-export type SaleType = "fixedPrice" | "erc20" | "premint";
+export type SaleType = "fixedPrice" | "erc20" | "allowlist" | "premint";
 
 type SaleStrategy<T extends SaleType> = {
   saleType: T;
+};
+
+type PricedSaleStrategy = {
   pricePerToken: bigint;
   maxTokensPerAddress: bigint;
 };
 
-type FixedPriceSaleStrategy = SaleStrategy<"fixedPrice"> & {
-  address: Address;
+export type StartAndEnd = {
   saleStart: string;
   saleEnd: string;
 };
 
-type ERC20SaleStrategy = SaleStrategy<"erc20"> & {
+type FixedPriceSaleStrategy = SaleStrategy<"fixedPrice"> &
+  PricedSaleStrategy &
+  StartAndEnd & {
+    address: Address;
+  };
+
+type ERC20SaleStrategy = SaleStrategy<"erc20"> &
+  PricedSaleStrategy &
+  StartAndEnd & {
+    address: Address;
+    currency: Address;
+  };
+
+type AllowListSaleStrategy = SaleStrategy<"allowlist"> & {
   address: Address;
   saleStart: string;
   saleEnd: string;
-  currency: Address;
+  merkleRoot: string;
 };
 
-type PremintSaleStrategy = SaleStrategy<"premint"> & {
-  duration: bigint;
-};
+type PremintSaleStrategy = SaleStrategy<"premint"> &
+  PricedSaleStrategy & {
+    duration: bigint;
+  };
 
 export type SaleStrategies =
   | FixedPriceSaleStrategy
   | ERC20SaleStrategy
+  | AllowListSaleStrategy
   | PremintSaleStrategy;
 
-export type OnchainSalesStrategies = FixedPriceSaleStrategy | ERC20SaleStrategy;
+export type OnchainSalesStrategies =
+  | FixedPriceSaleStrategy
+  | ERC20SaleStrategy
+  | AllowListSaleStrategy;
 
 export function isErc20SaleStrategy(
-  salesConfig: FixedPriceSaleStrategy | ERC20SaleStrategy | PremintSaleStrategy,
+  salesConfig: SaleStrategies,
 ): salesConfig is ERC20SaleStrategy {
   return salesConfig.saleType === "erc20";
 }
@@ -173,7 +196,10 @@ export type PremintMintable = MintableBase & {
 };
 
 export type OnchainSalesConfigAndTokenInfo = {
-  salesConfig: FixedPriceSaleStrategy | ERC20SaleStrategy;
+  salesConfig:
+    | FixedPriceSaleStrategy
+    | ERC20SaleStrategy
+    | AllowListSaleStrategy;
 } & OnchainMintable;
 
 export type PremintSalesConfigAndTokenInfo = {

package/src/premint/premint-client.ts

@@ -65,7 +65,7 @@ type PremintedV2LogType = DecodeEventLogReturnType<
   "PremintedV2"
 >["args"];
 
-type URLSReturnType = {
+export type URLSReturnType = {
   explorer: null | string;
   zoraCollect: null | string;
   zoraManage: null | string;
@@ -433,6 +433,7 @@ type PremintReturn<T extends PremintConfigVersion> = {
   signAndSubmit: (params: SignAndSubmitParams) => Promise<SignAndSubmitReturn>;
   /** For the case where the premint is signed externally, takes the signature for the Premint, and submits it and the Premint to the Zora Premint API */
   submit: (params: SubmitParams) => Promise<void>;
+  urls: URLSReturnType;
 } & PremintConfigWithVersion<T>;
 
 function makePremintReturn<T extends PremintConfigVersion>({
@@ -503,6 +504,12 @@ function makePremintReturn<T extends PremintConfigVersion>({
     });
   };
 
+  const urls = makeUrls({
+    chainId,
+    address: collectionAddress,
+    uid: premintConfig.uid,
+  });
+
   return {
     premintConfig,
     premintConfigVersion,
@@ -510,6 +517,7 @@ function makePremintReturn<T extends PremintConfigVersion>({
     collectionAddress,
     signAndSubmit,
     submit,
+    urls,
   };
 }