@zoralabs/protocol-sdk 0.7.2-ALLOWLIST.0 → 0.7.3-SPARKS.0

package/src/create/token-setup.ts

@@ -4,17 +4,13 @@ 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";
@@ -28,15 +24,16 @@ type SetupMintersProps = {
   tokenId: bigint;
   chainId: number;
   fundsRecipient: Address;
-  salesConfigOrAllowList: SalesConfigOrAllowList;
+  salesConfig: Concrete<SalesConfigParamsType>;
 };
 
 // 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
@@ -54,36 +51,6 @@ 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,
@@ -101,11 +68,8 @@ 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,
-    }),
   };
 }
 
@@ -223,84 +187,24 @@ function setupFixedPriceMinter({
   };
 }
 
-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): {
+export function setupMinters({ salesConfig, ...rest }: SetupMintersProps): {
   minter: Address;
   setupActions: Hex[];
 } {
-  if (salesConfig) {
-    const { currency: currencyAddress } = salesConfig;
-
-    if (currencyAddress === zeroAddress) {
-      return setupFixedPriceMinter({
-        ...salesConfig,
-        ...rest,
-      });
-    } else {
-      return setupErc20Minter({
-        ...salesConfig,
-        ...rest,
-      });
-    }
+  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,
+    });
   }
-  return setupAllowListMinter({
-    allowlist: allowlist as Concrete<AllowlistData>,
-    ...rest,
-  });
 }
 
 function buildSetupNewToken({
@@ -431,8 +335,7 @@ export function constructCreate1155TokenCalls(
     tokenId: nextTokenId,
     chainId,
     fundsRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
-    salesConfigOrAllowList:
-      new1155TokenPropsWithDefaults.salesConfigOrAllowList,
+    salesConfig: new1155TokenPropsWithDefaults.salesConfig,
   });
 
   const adminMintCall = makeAdminMintCall({

package/src/create/types.ts

@@ -32,54 +32,26 @@ export type CreateNew1155Params = {
   token: CreateNew1155TokenProps;
 };
 
-export type AllowlistData = {
-  saleStart?: bigint;
-  saleEnd?: bigint;
-  presaleMerkleRoot: `0x${string}`;
-};
-
-export type CreateNew1155TokenProps = {
+export interface 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,7 +31,3 @@ 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,7 +27,6 @@ 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,
@@ -130,13 +129,11 @@ 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;
@@ -153,7 +150,6 @@ export async function getMintCosts({
       mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
       salesConfig: salesConfigAndTokenInfo.salesConfig,
       quantityToMint: BigInt(quantityToMint),
-      allowListEntry,
     });
   }
 
@@ -262,7 +258,6 @@ const makeOnchainPrepareMint =
       salesConfig: result.salesConfig,
       quantityToMint: BigInt(params.quantityToMint),
       mintFeePerQuantity: result.mintFeePerQuantity,
-      allowListEntry: params.allowListEntry,
     }),
   });
 
@@ -291,7 +286,6 @@ const makePremintPrepareMint =
       mintFeePerQuantity: mintFee,
       quantityToMint: BigInt(params.quantityToMint),
       salesConfig: mintable.salesConfig,
-      allowListEntry: params.allowListEntry,
     }),
   });
 

package/src/mint/mint-transactions.ts

@@ -5,13 +5,12 @@ import {
   zeroAddress,
   Account,
   SimulateContractParameters,
-  Hex,
 } from "viem";
 import {
   erc20MinterABI,
   zoraCreator1155ImplABI,
 } from "@zoralabs/protocol-deployments";
-import { zora721Abi } from "src/constants";
+import { zora721Abi, zora1155LegacyAbi } from "src/constants";
 import {
   GenericTokenIdTypes,
   SimulateContractParametersWithAccount,
@@ -22,7 +21,6 @@ import { MakeMintParametersArgumentsBase } from "./types";
 
 import { contractSupportsNewMintFunction } from "./utils";
 import { OnchainSalesConfigAndTokenInfo } from "./types";
-import { AllowListEntry } from "src/allow-list/types";
 
 export function makeOnchainMintCall({
   token,
@@ -61,7 +59,6 @@ export function makePrepareMint1155TokenParams({
   mintReferral,
   mintRecipient,
   quantityToMint,
-  allowListEntry,
 }: {
   salesConfigAndTokenInfo: MintableParameters;
   tokenId: GenericTokenIdTypes;
@@ -73,7 +70,6 @@ export function makePrepareMint1155TokenParams({
   | "mintReferral"
   | "quantityToMint"
   | "mintRecipient"
-  | "allowListEntry"
 >): SimulateContractParameters<any, any, any, any, any, Address | Account> {
   const mintQuantity = BigInt(quantityToMint || 1);
 
@@ -81,7 +77,7 @@ export function makePrepareMint1155TokenParams({
 
   const saleType = salesConfigAndTokenInfo.salesConfig.saleType;
 
-  if (saleType === "fixedPrice" || saleType === "allowlist") {
+  if (saleType === "fixedPrice") {
     return makeEthMintCall({
       mintComment,
       minterAccount,
@@ -91,7 +87,6 @@ export function makePrepareMint1155TokenParams({
       salesConfigAndTokenInfo,
       tokenContract,
       tokenId,
-      allowListEntry,
     });
   }
 
@@ -142,7 +137,6 @@ function makePrepareMint721TokenParams({
     mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
     salesConfig: salesConfigAndTokenInfo.salesConfig,
     quantityToMint: actualQuantityToMint,
-    allowListEntry: undefined,
   }).totalCostEth;
 
   return makeContractParameters({
@@ -160,37 +154,6 @@ 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,
@@ -200,7 +163,6 @@ function makeEthMintCall({
   mintReferral,
   mintQuantity,
   mintTo,
-  allowListEntry,
 }: {
   minterAccount: Account | Address;
   tokenContract: Address;
@@ -210,26 +172,17 @@ 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 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");
-  }
+  const minterArguments = encodeAbiParameters(
+    parseAbiParameters("address, string"),
+    [mintTo, mintComment || ""],
+  );
 
   // if based on contract version it has the new mint function,
   // call the new mint function.
@@ -254,7 +207,7 @@ function makeEthMintCall({
 
   // otherwise call the deprecated mint function
   return makeContractParameters({
-    abi: zoraCreator1155ImplABI,
+    abi: zora1155LegacyAbi,
     functionName: "mintWithRewards",
     account: minterAccount,
     value: mintValue,
@@ -270,37 +223,18 @@ 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 =
-    paidMintCost(salesConfig, allowListEntry) * quantityToMint;
+  const tokenPurchaseCost = BigInt(salesConfig.pricePerToken) * quantityToMint;
 
   const totalPurchaseCostCurrency = isErc20SaleStrategy(salesConfig)
     ? salesConfig.currency

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

@@ -16,12 +16,14 @@ import {
 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]) {
@@ -53,23 +55,14 @@ 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) {
-  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);
+  return BigInt(
+    a.type === "ERC_20_MINTER" ? a.erc20Minter.saleEnd : a.fixedPrice.saleEnd,
+  );
 }
 
 function getTargetStrategy({
@@ -115,6 +108,7 @@ function getTargetStrategy({
 
   return targetStrategy;
 }
+
 export class SubgraphMintGetter implements IOnchainMintGetter {
   httpClient: IHttpClient;
   networkConfig: NetworkConfig;
@@ -124,6 +118,18 @@ export class SubgraphMintGetter implements IOnchainMintGetter {
     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;
+  }
+
   async querySubgraphWithRetries<T>({
     query,
     variables,
@@ -155,8 +161,11 @@ export class SubgraphMintGetter implements IOnchainMintGetter {
       throw new Error("Cannot find token");
     }
 
+    const defaultMintFee = await this.getContractMintFee(token.contract);
+
     return parseTokenQueryResult({
-      token,
+      token: token,
+      defaultMintFee,
       tokenId,
       preferredSaleType: saleType,
     });
@@ -175,7 +184,9 @@ export class SubgraphMintGetter implements IOnchainMintGetter {
       }),
     );
 
-    if (!tokens) return [];
+    if (!tokens || tokens.length === 0) return [];
+
+    const defaultMintFee = await this.getContractMintFee(tokens[0]!.contract);
 
     return tokens
       .filter((x) => x.tokenId !== "0")
@@ -184,6 +195,7 @@ export class SubgraphMintGetter implements IOnchainMintGetter {
           token,
           tokenId: token.tokenId,
           preferredSaleType,
+          defaultMintFee,
         }),
       );
   }
@@ -212,10 +224,12 @@ function parseTokenQueryResult({
   token,
   tokenId,
   preferredSaleType,
+  defaultMintFee,
 }: {
   token: TokenQueryResult;
   tokenId?: GenericTokenIdTypes;
   preferredSaleType?: SaleType;
+  defaultMintFee: bigint;
 }): OnchainSalesConfigAndTokenInfo {
   const targetStrategy = getTargetStrategy({
     tokenId,
@@ -223,7 +237,7 @@ function parseTokenQueryResult({
     token,
   });
 
-  const tokenInfo = parseTokenInfo(token);
+  const tokenInfo = parseTokenInfo(token, defaultMintFee);
 
   const salesConfig = parseSalesConfig(targetStrategy);
 
@@ -237,7 +251,17 @@ function parseTokenQueryResult({
   };
 }
 
-function parseTokenInfo(token: TokenQueryResult): OnchainMintable {
+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 {
   return {
     contract: {
       address: token.contract.address,
@@ -250,7 +274,7 @@ function parseTokenInfo(token: TokenQueryResult): OnchainMintable {
     creator: token.creator,
     totalMinted: BigInt(token.totalMinted),
     maxSupply: BigInt(token.maxSupply),
-    mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity),
+    mintFeePerQuantity: defaultMintFee,
     contractVersion: token.contract.contractVersion,
   };
 }