@zoralabs/protocol-sdk 0.8.0 → 0.9.1

package/src/create/minter-defaults.ts

@@ -0,0 +1,134 @@
+import { Concrete } from "src/utils";
+import {
+  SalesConfigParamsType,
+  AllowListParamType,
+  Erc20ParamsType,
+  FixedPriceParamsType,
+  SaleStartAndEnd,
+  MaxTokensPerAddress,
+  ConcreteSalesConfig,
+  TimedSaleParamsType,
+} from "./types";
+import { fetchTokenMetadata } from "src/ipfs/token-metadata";
+
+// Sales end forever amount (uint64 max)
+export const SALE_END_FOREVER = 18446744073709551615n;
+
+const DEFAULT_SALE_START_AND_END: Concrete<SaleStartAndEnd> = {
+  // Sale start time – defaults to beginning of unix time
+  saleStart: 0n,
+  // This is the end of uint64, plenty of time
+  saleEnd: SALE_END_FOREVER,
+};
+
+const DEFAULT_MAX_TOKENS_PER_ADDRESS: Concrete<MaxTokensPerAddress> = {
+  maxTokensPerAddress: 0n,
+};
+
+const erc20SaleSettingsWithDefaults = (
+  params: Erc20ParamsType,
+): Concrete<Erc20ParamsType> => ({
+  ...DEFAULT_SALE_START_AND_END,
+  ...DEFAULT_MAX_TOKENS_PER_ADDRESS,
+  ...params,
+});
+
+const allowListWithDefaults = (
+  allowlist: AllowListParamType,
+): Concrete<AllowListParamType> => {
+  return {
+    ...DEFAULT_SALE_START_AND_END,
+    ...allowlist,
+  };
+};
+
+const fixedPriceSettingsWithDefaults = (
+  params: FixedPriceParamsType,
+): Concrete<FixedPriceParamsType> => ({
+  ...DEFAULT_SALE_START_AND_END,
+  ...DEFAULT_MAX_TOKENS_PER_ADDRESS,
+  type: "fixedPrice",
+  ...params,
+});
+
+export const parseNameIntoSymbol = (name: string) => {
+  if (name === "") {
+    throw new Error("Name must be provided to generate a symbol");
+  }
+  const result =
+    "$" +
+    name
+      // Remove all non-alphanumeric characters
+      .replace(/[^a-zA-Z0-9]/g, "")
+      // and leading dollar signs
+      .replace(/^\$+/, "")
+      .toUpperCase()
+      // Remove all vowels and spaces
+      .replace(/[AEIOU\s]/g, "")
+      // Strip down to 4 characters
+      .slice(0, 4);
+
+  if (result === "$") {
+    throw new Error("Not enough valid characters to generate a symbol");
+  }
+
+  return result;
+};
+
+async function fetchTokenNameFromMetadata(
+  tokenMetadataURI: string,
+): Promise<string> {
+  const tokenMetadata = await fetchTokenMetadata(tokenMetadataURI);
+
+  if (!tokenMetadata.name) {
+    throw new Error("No name found in token metadata");
+  }
+
+  return tokenMetadata.name;
+}
+const timedSaleSettingsWithDefaults = async (
+  params: TimedSaleParamsType,
+  tokenMetadataURI: string,
+): Promise<Concrete<TimedSaleParamsType>> => {
+  // If the name is not provided, try to fetch it from the metadata
+  const erc20Name =
+    params.erc20Name || (await fetchTokenNameFromMetadata(tokenMetadataURI));
+  const symbol = params.erc20Symbol || parseNameIntoSymbol(erc20Name);
+
+  return {
+    type: "timed",
+    ...DEFAULT_SALE_START_AND_END,
+    erc20Name,
+    erc20Symbol: symbol,
+  };
+};
+
+const isAllowList = (
+  salesConfig: SalesConfigParamsType,
+): salesConfig is AllowListParamType => salesConfig.type === "allowlistMint";
+const isErc20 = (
+  salesConfig: SalesConfigParamsType,
+): salesConfig is Erc20ParamsType => salesConfig.type === "erc20Mint";
+const isFixedPrice = (
+  salesConfig: SalesConfigParamsType,
+): salesConfig is FixedPriceParamsType => {
+  return (salesConfig as FixedPriceParamsType).pricePerToken > 0n;
+};
+
+export const getSalesConfigWithDefaults = async (
+  salesConfig: SalesConfigParamsType | undefined,
+  tokenMetadataURI: string,
+): Promise<ConcreteSalesConfig> => {
+  if (!salesConfig) return timedSaleSettingsWithDefaults({}, tokenMetadataURI);
+  if (isAllowList(salesConfig)) {
+    return allowListWithDefaults(salesConfig);
+  }
+  if (isErc20(salesConfig)) {
+    return erc20SaleSettingsWithDefaults(salesConfig);
+  }
+  if (isFixedPrice(salesConfig)) {
+    return fixedPriceSettingsWithDefaults(salesConfig);
+  }
+
+  return timedSaleSettingsWithDefaults(salesConfig, tokenMetadataURI);
+};

package/src/create/minter-setup.ts

@@ -0,0 +1,293 @@
+import {
+  erc20MinterABI,
+  erc20MinterAddress as erc20MinterAddresses,
+  zoraCreator1155ImplABI,
+  zoraCreatorFixedPriceSaleStrategyABI,
+  zoraCreatorFixedPriceSaleStrategyAddress,
+  zoraCreatorMerkleMinterStrategyABI,
+  zoraCreatorMerkleMinterStrategyAddress,
+  zoraTimedSaleStrategyABI,
+  zoraTimedSaleStrategyAddress,
+} from "@zoralabs/protocol-deployments";
+import { Address, encodeFunctionData, Hex } from "viem";
+import {
+  AllowlistData,
+  ConcreteSalesConfig,
+  AllowListParamType,
+  Erc20ParamsType,
+  FixedPriceParamsType,
+  TimedSaleParamsType,
+} from "./types";
+import { Concrete } from "src/utils";
+
+const PERMISSION_BITS = {
+  MINTER: 2n ** 2n,
+};
+
+type SetupErc20MinterProps = {
+  chainId: number;
+  tokenId: bigint;
+  fundsRecipient: Address;
+} & Concrete<Erc20ParamsType>;
+
+type SetupMintersProps = {
+  tokenId: bigint;
+  chainId: number;
+  fundsRecipient: Address;
+  salesConfig: ConcreteSalesConfig;
+};
+
+function setupErc20Minter({
+  pricePerToken,
+  chainId,
+  tokenId: nextTokenId,
+  currency,
+  saleStart,
+  saleEnd,
+  maxTokensPerAddress: mintLimit,
+  fundsRecipient,
+}: SetupErc20MinterProps): {
+  minter: Address;
+  setupActions: Hex[];
+} {
+  const erc20MinterAddress =
+    erc20MinterAddresses[chainId as keyof typeof erc20MinterAddresses];
+  if (!erc20MinterAddress)
+    throw new Error(`ERC20Minter not deployed on chainId ${chainId}`);
+
+  const erc20MinterApproval = encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "addPermission",
+    args: [BigInt(nextTokenId), erc20MinterAddress, PERMISSION_BITS.MINTER],
+  });
+
+  const saleData = encodeFunctionData({
+    abi: erc20MinterABI,
+    functionName: "setSale",
+    args: [
+      BigInt(nextTokenId),
+      {
+        saleStart: saleStart || BigInt(0),
+        saleEnd: saleEnd || BigInt(0),
+        maxTokensPerAddress: BigInt(mintLimit || 0),
+        pricePerToken: pricePerToken,
+        fundsRecipient,
+        currency: currency,
+      },
+    ],
+  });
+
+  const callSale = encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "callSale",
+    args: [BigInt(nextTokenId), erc20MinterAddress, saleData],
+  });
+
+  return {
+    minter: erc20MinterAddress,
+    setupActions: [erc20MinterApproval, callSale],
+  };
+}
+
+type SetupFixedPriceMinterProps = {
+  fundsRecipient: Address;
+  tokenId: bigint;
+  chainId: number;
+} & Concrete<FixedPriceParamsType>;
+
+function setupFixedPriceMinter({
+  pricePerToken: price,
+  tokenId: nextTokenId,
+  chainId,
+  saleStart,
+  saleEnd,
+  maxTokensPerAddress: mintLimit,
+  fundsRecipient,
+}: SetupFixedPriceMinterProps): { minter: Address; setupActions: Hex[] } {
+  const fixedPriceStrategyAddress =
+    zoraCreatorFixedPriceSaleStrategyAddress[
+      chainId as keyof typeof zoraCreatorFixedPriceSaleStrategyAddress
+    ];
+  const fixedPriceApproval = encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "addPermission",
+    args: [
+      BigInt(nextTokenId),
+      fixedPriceStrategyAddress,
+      PERMISSION_BITS.MINTER,
+    ],
+  });
+
+  const saleData = encodeFunctionData({
+    abi: zoraCreatorFixedPriceSaleStrategyABI,
+    functionName: "setSale",
+    args: [
+      BigInt(nextTokenId),
+      {
+        pricePerToken: price,
+        saleStart: saleStart || BigInt(0),
+        saleEnd: saleEnd || BigInt(0),
+        maxTokensPerAddress: BigInt(mintLimit || 0),
+        fundsRecipient,
+      },
+    ],
+  });
+
+  const callSale = encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "callSale",
+    args: [BigInt(nextTokenId), fixedPriceStrategyAddress, saleData],
+  });
+
+  return {
+    minter: fixedPriceStrategyAddress,
+    setupActions: [fixedPriceApproval, callSale],
+  };
+}
+
+type SetupTimedMinterProps = {
+  tokenId: bigint;
+  chainId: number;
+} & Concrete<TimedSaleParamsType>;
+
+function setupTimedSaleMinter({
+  chainId,
+  tokenId,
+  erc20Name: erc20zName,
+  erc20Symbol: erc20zSymbol,
+  saleStart,
+  saleEnd,
+}: SetupTimedMinterProps): {
+  minter: Address;
+  setupActions: Hex[];
+} {
+  const minterAddress =
+    zoraTimedSaleStrategyAddress[
+      chainId as keyof typeof zoraTimedSaleStrategyAddress
+    ];
+  const fixedPriceApproval = encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "addPermission",
+    args: [BigInt(tokenId), minterAddress, PERMISSION_BITS.MINTER],
+  });
+
+  const saleData = encodeFunctionData({
+    abi: zoraTimedSaleStrategyABI,
+    functionName: "setSale",
+    args: [
+      BigInt(tokenId),
+      {
+        saleStart,
+        saleEnd,
+        name: erc20zName,
+        symbol: erc20zSymbol,
+      },
+    ],
+  });
+
+  const callSale = encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "callSale",
+    args: [BigInt(tokenId), minterAddress, saleData],
+  });
+
+  return {
+    minter: minterAddress,
+    setupActions: [fixedPriceApproval, callSale],
+  };
+}
+
+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],
+  };
+}
+
+const isAllowList = (
+  salesConfig: ConcreteSalesConfig,
+): salesConfig is Concrete<AllowListParamType> =>
+  salesConfig.type === "allowlistMint";
+const isErc20 = (
+  salesConfig: ConcreteSalesConfig,
+): salesConfig is Concrete<Erc20ParamsType> => salesConfig.type === "erc20Mint";
+const isFixedPrice = (
+  salesConfig: ConcreteSalesConfig,
+): salesConfig is Concrete<FixedPriceParamsType> =>
+  salesConfig.type === "fixedPrice" ||
+  (salesConfig as unknown as Concrete<FixedPriceParamsType>).pricePerToken >
+    BigInt(0);
+
+export function setupMinters({ salesConfig, ...rest }: SetupMintersProps): {
+  minter: Address;
+  setupActions: Hex[];
+} {
+  if (isErc20(salesConfig)) {
+    return setupErc20Minter({
+      ...salesConfig,
+      ...rest,
+    });
+  }
+  if (isAllowList(salesConfig)) {
+    return setupAllowListMinter({
+      allowlist: salesConfig,
+      ...rest,
+    });
+  }
+
+  if (isFixedPrice(salesConfig))
+    return setupFixedPriceMinter({
+      ...salesConfig,
+      ...rest,
+    });
+
+  return setupTimedSaleMinter({
+    ...salesConfig,
+    ...rest,
+  });
+}

package/src/create/token-setup.ts

@@ -1,60 +1,15 @@
-import {
-  erc20MinterABI,
-  erc20MinterAddress as erc20MinterAddresses,
-  zoraCreator1155ImplABI,
-  zoraCreatorFixedPriceSaleStrategyABI,
-  zoraCreatorFixedPriceSaleStrategyAddress,
-} from "@zoralabs/protocol-deployments";
+import { zoraCreator1155ImplABI } from "@zoralabs/protocol-deployments";
 import { Address, encodeFunctionData, zeroAddress, Hex } from "viem";
 import * as semver from "semver";
-import {
-  ContractProps,
-  CreateNew1155TokenProps,
-  New1155Token,
-  SalesConfigParamsType,
-} from "./types";
+import { ContractProps, CreateNew1155TokenProps, New1155Token } from "./types";
 import { OPEN_EDITION_MINT_SIZE } from "src/constants";
-import { Concrete } from "src/utils";
+import { getSalesConfigWithDefaults } from "./minter-defaults";
+import { setupMinters } from "./minter-setup";
 
-export const PERMISSION_BITS = {
-  MINTER: 2n ** 2n,
-};
-
-type SetupMintersProps = {
-  tokenId: bigint;
-  chainId: number;
-  fundsRecipient: Address;
-  salesConfig: Concrete<SalesConfigParamsType>;
-};
-
-// Sales end forever amount (uint64 max)
-
-const saleSettingsOrDefault = (
-  saleSettings?: SalesConfigParamsType,
-): Concrete<SalesConfigParamsType> => {
-  const SALE_END_FOREVER = 18446744073709551615n;
-
-  const DEFAULT_SALE_SETTINGS: Concrete<SalesConfigParamsType> = {
-    currency: zeroAddress,
-    // Free Mint
-    pricePerToken: 0n,
-    // Sale start time – defaults to beginning of unix time
-    saleStart: 0n,
-    // This is the end of uint64, plenty of time
-    saleEnd: SALE_END_FOREVER,
-    // 0 Here means no limit
-    maxTokensPerAddress: 0n,
-  };
-  return {
-    ...DEFAULT_SALE_SETTINGS,
-    ...saleSettings,
-  };
-};
-
-function applyNew1155Defaults(
+async function applyNew1155Defaults(
   props: CreateNew1155TokenProps,
   ownerAddress: Address,
-): New1155Token {
+): Promise<New1155Token> {
   const { payoutRecipient: fundsRecipient } = props;
   const fundsRecipientOrOwner =
     fundsRecipient && fundsRecipient !== zeroAddress
@@ -68,145 +23,14 @@ function applyNew1155Defaults(
         ? OPEN_EDITION_MINT_SIZE
         : BigInt(props.maxSupply),
     royaltyBPS: props.royaltyBPS || 1000,
-    salesConfig: saleSettingsOrDefault(props.salesConfig),
     tokenMetadataURI: props.tokenMetadataURI,
+    salesConfig: await getSalesConfigWithDefaults(
+      props.salesConfig,
+      props.tokenMetadataURI,
+    ),
   };
 }
 
-type SetupErc20MinterProps = {
-  chainId: number;
-  tokenId: bigint;
-  fundsRecipient: Address;
-} & Concrete<SalesConfigParamsType>;
-
-function setupErc20Minter({
-  pricePerToken,
-  chainId,
-  tokenId: nextTokenId,
-  currency,
-  saleStart,
-  saleEnd,
-  maxTokensPerAddress: mintLimit,
-  fundsRecipient,
-}: SetupErc20MinterProps): {
-  minter: Address;
-  setupActions: Hex[];
-} {
-  const erc20MinterAddress =
-    erc20MinterAddresses[chainId as keyof typeof erc20MinterAddresses];
-  if (!erc20MinterAddress)
-    throw new Error(`ERC20Minter not deployed on chainId ${chainId}`);
-
-  const erc20MinterApproval = encodeFunctionData({
-    abi: zoraCreator1155ImplABI,
-    functionName: "addPermission",
-    args: [BigInt(nextTokenId), erc20MinterAddress, PERMISSION_BITS.MINTER],
-  });
-
-  const saleData = encodeFunctionData({
-    abi: erc20MinterABI,
-    functionName: "setSale",
-    args: [
-      BigInt(nextTokenId),
-      {
-        saleStart: saleStart || BigInt(0),
-        saleEnd: saleEnd || BigInt(0),
-        maxTokensPerAddress: BigInt(mintLimit || 0),
-        pricePerToken: pricePerToken,
-        fundsRecipient,
-        currency: currency,
-      },
-    ],
-  });
-
-  const callSale = encodeFunctionData({
-    abi: zoraCreator1155ImplABI,
-    functionName: "callSale",
-    args: [BigInt(nextTokenId), erc20MinterAddress, saleData],
-  });
-
-  return {
-    minter: erc20MinterAddress,
-    setupActions: [erc20MinterApproval, callSale],
-  };
-}
-
-type SetupFixedPriceMinterProps = {
-  fundsRecipient: Address;
-  tokenId: bigint;
-  chainId: number;
-} & Concrete<Omit<SalesConfigParamsType, "currency">>;
-
-function setupFixedPriceMinter({
-  pricePerToken: price,
-  tokenId: nextTokenId,
-  chainId,
-  saleStart,
-  saleEnd,
-  maxTokensPerAddress: mintLimit,
-  fundsRecipient,
-}: SetupFixedPriceMinterProps): { minter: Address; setupActions: Hex[] } {
-  const fixedPriceStrategyAddress =
-    zoraCreatorFixedPriceSaleStrategyAddress[
-      chainId as keyof typeof zoraCreatorFixedPriceSaleStrategyAddress
-    ];
-  const fixedPriceApproval = encodeFunctionData({
-    abi: zoraCreator1155ImplABI,
-    functionName: "addPermission",
-    args: [
-      BigInt(nextTokenId),
-      fixedPriceStrategyAddress,
-      PERMISSION_BITS.MINTER,
-    ],
-  });
-
-  const saleData = encodeFunctionData({
-    abi: zoraCreatorFixedPriceSaleStrategyABI,
-    functionName: "setSale",
-    args: [
-      BigInt(nextTokenId),
-      {
-        pricePerToken: price,
-        saleStart: saleStart || BigInt(0),
-        saleEnd: saleEnd || BigInt(0),
-        maxTokensPerAddress: BigInt(mintLimit || 0),
-        fundsRecipient,
-      },
-    ],
-  });
-
-  const callSale = encodeFunctionData({
-    abi: zoraCreator1155ImplABI,
-    functionName: "callSale",
-    args: [BigInt(nextTokenId), fixedPriceStrategyAddress, saleData],
-  });
-
-  return {
-    minter: fixedPriceStrategyAddress,
-    setupActions: [fixedPriceApproval, callSale],
-  };
-}
-
-export function setupMinters({ salesConfig, ...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,
-    });
-  }
-}
-
 function buildSetupNewToken({
   tokenURI,
   maxSupply = OPEN_EDITION_MINT_SIZE,
@@ -288,17 +112,17 @@ function makeAdminMintCall({
   });
 }
 
-export function constructCreate1155TokenCalls(
+export async function constructCreate1155TokenCalls(
   props: CreateNew1155TokenProps &
     ContractProps & {
       ownerAddress: Address;
       chainId: number;
     },
-): {
+): Promise<{
   setupActions: `0x${string}`[];
   newToken: New1155Token;
   minter: Address;
-} {
+}> {
   const {
     chainId,
     nextTokenId,
@@ -307,7 +131,7 @@ export function constructCreate1155TokenCalls(
     contractVersion,
   } = props;
 
-  const new1155TokenPropsWithDefaults = applyNew1155Defaults(
+  const new1155TokenPropsWithDefaults = await applyNew1155Defaults(
     props,
     ownerAddress,
   );