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

package/src/apis/http-api-base.ts

@@ -49,6 +49,15 @@ export const get = async <T>(url: string) => {
  * @throws Error when HTTP response fails
  */
 export const post = async <T>(url: string, data: any) => {
+  const controller = new AbortController();
+  const { signal } = controller;
+
+  // 30 minute timeout:
+  const timeout = 30 * 60 * 1000;
+
+  // Set a timeout to automatically abort the request
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+
   const response = await fetch(url, {
     method: "POST",
     headers: {
@@ -56,7 +65,10 @@ export const post = async <T>(url: string, data: any) => {
       accept: "application/json",
     },
     body: JSON.stringify(data),
+    signal,
   });
+
+  clearTimeout(timeoutId);
   if (response.status !== 200) {
     let json;
     try {

package/src/create/1155-create-helper.ts

@@ -37,6 +37,23 @@ export const getTokenIdFromCreateReceipt = (
   }
 };
 
+export const getContractAddressFromCreateReceipt = (
+  receipt: TransactionReceipt,
+): Address | undefined => {
+  for (const data of receipt.logs) {
+    try {
+      const decodedLog = decodeEventLog({
+        abi: zoraCreator1155FactoryImplABI,
+        eventName: "SetupNewContract",
+        ...data,
+      });
+      if (decodedLog && decodedLog.eventName === "SetupNewContract") {
+        return decodedLog.args.newContract;
+      }
+    } catch (err: any) {}
+  }
+};
+
 type CreateNew1155TokenReturn = {
   parameters: SimulateContractParameters<
     any,

package/src/create/token-setup.ts

@@ -4,13 +4,17 @@ import {
   zoraCreator1155ImplABI,
   zoraCreatorFixedPriceSaleStrategyABI,
   zoraCreatorFixedPriceSaleStrategyAddress,
+  zoraCreatorMerkleMinterStrategyABI,
+  zoraCreatorMerkleMinterStrategyAddress,
 } from "@zoralabs/protocol-deployments";
 import { Address, encodeFunctionData, zeroAddress, Hex } from "viem";
 import * as semver from "semver";
 import {
+  AllowlistData,
   ContractProps,
   CreateNew1155TokenProps,
   New1155Token,
+  SalesConfigOrAllowList,
   SalesConfigParamsType,
 } from "./types";
 import { OPEN_EDITION_MINT_SIZE } from "src/constants";
@@ -24,16 +28,15 @@ type SetupMintersProps = {
   tokenId: bigint;
   chainId: number;
   fundsRecipient: Address;
-  salesConfig: Concrete<SalesConfigParamsType>;
+  salesConfigOrAllowList: SalesConfigOrAllowList;
 };
 
 // Sales end forever amount (uint64 max)
+const SALE_END_FOREVER = 18446744073709551615n;
 
 const saleSettingsOrDefault = (
   saleSettings?: SalesConfigParamsType,
 ): Concrete<SalesConfigParamsType> => {
-  const SALE_END_FOREVER = 18446744073709551615n;
-
   const DEFAULT_SALE_SETTINGS: Concrete<SalesConfigParamsType> = {
     currency: zeroAddress,
     // Free Mint
@@ -51,6 +54,36 @@ const saleSettingsOrDefault = (
   };
 };
 
+const allowListWithDefaults = (allowlist: AllowlistData) => {
+  const defaultAllowListSettings: Concrete<
+    Omit<AllowlistData, "presaleMerkleRoot">
+  > = {
+    // Sale start time – defaults to beginning of unix time
+    saleStart: 0n,
+    // This is the end of uint64, plenty of time
+    saleEnd: SALE_END_FOREVER,
+  };
+
+  return {
+    ...defaultAllowListSettings,
+    ...allowlist,
+  };
+};
+
+const getSalesConfigOrAllowListWithDefaults = ({
+  salesConfig,
+  allowlist,
+}: Pick<CreateNew1155TokenProps, "salesConfig" | "allowlist">) => {
+  if (!allowlist) {
+    return {
+      salesConfig: saleSettingsOrDefault(salesConfig),
+    };
+  }
+  return {
+    allowlist: allowListWithDefaults(allowlist),
+  };
+};
+
 function applyNew1155Defaults(
   props: CreateNew1155TokenProps,
   ownerAddress: Address,
@@ -68,8 +101,11 @@ function applyNew1155Defaults(
         ? OPEN_EDITION_MINT_SIZE
         : BigInt(props.maxSupply),
     royaltyBPS: props.royaltyBPS || 1000,
-    salesConfig: saleSettingsOrDefault(props.salesConfig),
     tokenMetadataURI: props.tokenMetadataURI,
+    salesConfigOrAllowList: getSalesConfigOrAllowListWithDefaults({
+      salesConfig: props.salesConfig,
+      allowlist: props.allowlist,
+    }),
   };
 }
 
@@ -187,24 +223,84 @@ function setupFixedPriceMinter({
   };
 }
 
-export function setupMinters({ salesConfig, ...rest }: SetupMintersProps): {
+function setupAllowListMinter({
+  chainId,
+  tokenId: nextTokenId,
+  allowlist,
+  fundsRecipient,
+}: {
+  chainId: number;
+  tokenId: bigint;
+  allowlist: Concrete<AllowlistData>;
+  fundsRecipient: Address;
+}) {
+  const merkleSaleStrategyAddress =
+    zoraCreatorMerkleMinterStrategyAddress[
+      chainId as keyof typeof zoraCreatorMerkleMinterStrategyAddress
+    ];
+
+  const merkleApproval = encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "addPermission",
+    args: [nextTokenId, merkleSaleStrategyAddress, PERMISSION_BITS.MINTER],
+  });
+
+  const merkleRoot = allowlist.presaleMerkleRoot.startsWith("0x")
+    ? allowlist.presaleMerkleRoot
+    : (`0x${allowlist.presaleMerkleRoot}` as Hex);
+
+  const saleData = encodeFunctionData({
+    abi: zoraCreatorMerkleMinterStrategyABI,
+    functionName: "setSale",
+    args: [
+      BigInt(nextTokenId),
+      {
+        presaleStart: allowlist.saleStart,
+        presaleEnd: allowlist.saleEnd,
+        merkleRoot,
+        fundsRecipient: fundsRecipient,
+      },
+    ],
+  });
+
+  const callSaleMerkle = encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "callSale",
+    args: [BigInt(nextTokenId), merkleSaleStrategyAddress, saleData],
+  });
+
+  return {
+    minter: merkleSaleStrategyAddress,
+    setupActions: [merkleApproval, callSaleMerkle],
+  };
+}
+
+export function setupMinters({
+  salesConfigOrAllowList: { salesConfig, allowlist },
+  ...rest
+}: SetupMintersProps): {
   minter: Address;
   setupActions: Hex[];
 } {
-  if (!salesConfig) throw new Error("No sales config for token");
-  const { currency: currencyAddress } = salesConfig;
-
-  if (currencyAddress === zeroAddress) {
-    return setupFixedPriceMinter({
-      ...salesConfig,
-      ...rest,
-    });
-  } else {
-    return setupErc20Minter({
-      ...salesConfig,
-      ...rest,
-    });
+  if (salesConfig) {
+    const { currency: currencyAddress } = salesConfig;
+
+    if (currencyAddress === zeroAddress) {
+      return setupFixedPriceMinter({
+        ...salesConfig,
+        ...rest,
+      });
+    } else {
+      return setupErc20Minter({
+        ...salesConfig,
+        ...rest,
+      });
+    }
   }
+  return setupAllowListMinter({
+    allowlist: allowlist as Concrete<AllowlistData>,
+    ...rest,
+  });
 }
 
 function buildSetupNewToken({
@@ -335,7 +431,8 @@ export function constructCreate1155TokenCalls(
     tokenId: nextTokenId,
     chainId,
     fundsRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
-    salesConfig: new1155TokenPropsWithDefaults.salesConfig,
+    salesConfigOrAllowList:
+      new1155TokenPropsWithDefaults.salesConfigOrAllowList,
   });
 
   const adminMintCall = makeAdminMintCall({

package/src/create/types.ts

@@ -32,26 +32,54 @@ export type CreateNew1155Params = {
   token: CreateNew1155TokenProps;
 };
 
-export interface CreateNew1155TokenProps {
+export type AllowlistData = {
+  saleStart?: bigint;
+  saleEnd?: bigint;
+  presaleMerkleRoot: `0x${string}`;
+};
+
+export type CreateNew1155TokenProps = {
   maxSupply?: bigint | number;
   tokenMetadataURI: string;
   royaltyBPS?: number;
-  salesConfig?: SalesConfigParamsType;
   createReferral?: Address;
   mintToCreatorCount?: number;
   payoutRecipient?: Address;
-}
+} & (
+  | {
+      salesConfig: SalesConfigParamsType;
+      allowlist?: undefined;
+    }
+  | {
+      salesConfig?: undefined;
+      allowlist: AllowlistData;
+    }
+  | {
+      salesConfig?: undefined;
+      allowlist?: undefined;
+    }
+);
 
 export interface ContractProps {
   nextTokenId: bigint;
   contractVersion: string;
 }
 
+export type SalesConfigOrAllowList =
+  | {
+      salesConfig: Concrete<SalesConfigParamsType>;
+      allowlist?: undefined;
+    }
+  | {
+      salesConfig: undefined;
+      allowlist: Concrete<AllowlistData>;
+    };
+
 export type New1155Token = {
   payoutRecipient: Address;
   createReferral: Address;
   maxSupply: bigint;
   royaltyBPS: number;
-  salesConfig: Concrete<SalesConfigParamsType>;
   tokenMetadataURI: string;
+  salesConfigOrAllowList: SalesConfigOrAllowList;
 };

package/src/index.ts

@@ -31,3 +31,7 @@ export * from "./create/types";
 export * from "./sdk";
 
 export * from "./ipfs";
+
+export { createAllowList } from "./allow-list/allow-list-client";
+
+export * from "./allow-list/types";

package/src/mint/mint-queries.ts

@@ -27,6 +27,7 @@ import {
 import { makeOnchainMintCall, parseMintCosts } from "./mint-transactions";
 import { buildPremintMintCall } from "src/premint/premint-client";
 import { IPublicClient } from "src/types";
+import { AllowListEntry } from "src/allow-list/types";
 
 export async function getMint({
   params,
@@ -129,11 +130,13 @@ export async function getMintsOfContract({
 
 export async function getMintCosts({
   params,
+  allowListEntry,
   mintGetter,
   premintGetter,
   publicClient,
 }: {
   params: GetMintCostsParameters;
+  allowListEntry?: Pick<AllowListEntry, "price">;
   mintGetter: IOnchainMintGetter;
   premintGetter: IPremintGetter;
   publicClient: IPublicClient;
@@ -150,6 +153,7 @@ export async function getMintCosts({
       mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
       salesConfig: salesConfigAndTokenInfo.salesConfig,
       quantityToMint: BigInt(quantityToMint),
+      allowListEntry,
     });
   }
 
@@ -258,6 +262,7 @@ const makeOnchainPrepareMint =
       salesConfig: result.salesConfig,
       quantityToMint: BigInt(params.quantityToMint),
       mintFeePerQuantity: result.mintFeePerQuantity,
+      allowListEntry: params.allowListEntry,
     }),
   });
 
@@ -286,6 +291,7 @@ const makePremintPrepareMint =
       mintFeePerQuantity: mintFee,
       quantityToMint: BigInt(params.quantityToMint),
       salesConfig: mintable.salesConfig,
+      allowListEntry: params.allowListEntry,
     }),
   });
 

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
       }
     }