@zoralabs/protocol-sdk 0.7.6 → 0.9.0

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,
   );

package/src/create/types.ts

@@ -1,57 +1,126 @@
 import { Concrete } from "src/utils";
-import { Address, Hex } from "viem";
-
-export type ContractType =
-  | {
-      name: string;
-      uri: string;
-      defaultAdmin?: Address;
-    }
-  | Address;
-
-export type SalesConfigParamsType = {
-  // defaults to 0
-  pricePerToken?: bigint;
+import { Account, Address, Hex, SimulateContractParameters } from "viem";
+
+export type NewContractParams = {
+  name: string;
+  uri: string;
+  defaultAdmin?: Address;
+};
+
+export type SaleStartAndEnd = {
   // defaults to 0, in seconds
   saleStart?: bigint;
   // defaults to forever, in seconds
   saleEnd?: bigint;
+};
+
+export type MaxTokensPerAddress = {
   // max tokens that can be minted per address
   maxTokensPerAddress?: bigint;
-  // if an erc20 mint, the erc20 address.  Leave null for eth mints
-  currency?: Address;
 };
 
-export type CreateNew1155Params = {
+export type FixedPriceParamsType = SaleStartAndEnd &
+  MaxTokensPerAddress & {
+    type?: "fixedPrice";
+    // the price per token, if it is a priced mint
+    pricePerToken: bigint;
+  };
+
+export type TimedSaleParamsType = SaleStartAndEnd & {
+  type?: "timed";
+  // Name of the erc20z token to create for the secondary sale.  If not provided, fetches the metadata from the tokenMetadataURI and uses the name from it.
+  erc20Name?: string;
+  // Symbol of the erc20z token to create for the secondary sale.  If not provided, extracts it from the name.
+  erc20Symbol?: string;
+};
+
+export type Erc20ParamsType = SaleStartAndEnd &
+  MaxTokensPerAddress & {
+    type: "erc20Mint";
+    // if the erc20 address of the token to mint against
+    currency: Address;
+    // price in currency per token
+    pricePerToken: bigint;
+  };
+
+export type AllowListParamType = SaleStartAndEnd & {
+  type: "allowlistMint";
+  // the merkle root of the allowlist
+  presaleMerkleRoot: `0x${string}`;
+};
+
+export type SalesConfigParamsType =
+  | AllowListParamType
+  | Erc20ParamsType
+  | FixedPriceParamsType
+  | TimedSaleParamsType;
+
+export type CreateNew1155ParamsBase = {
   account: Address;
-  contract: ContractType;
-  getAdditionalSetupActions?: (args: {
-    tokenId: bigint;
-    contractAddress: Address;
-  }) => Hex[];
+  getAdditionalSetupActions?: (args: { tokenId: bigint }) => Hex[];
   token: CreateNew1155TokenProps;
 };
 
-export interface CreateNew1155TokenProps {
+export type CreateNew1155ContractParams = CreateNew1155ParamsBase & {
+  contract: NewContractParams;
+};
+
+export type CreateNew1155TokenParams = CreateNew1155ParamsBase & {
+  contractAddress: Address;
+};
+
+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;
+};
 
 export interface ContractProps {
   nextTokenId: bigint;
   contractVersion: string;
 }
 
+export type ConcreteSalesConfig =
+  | Concrete<FixedPriceParamsType>
+  | Concrete<Erc20ParamsType>
+  | Concrete<AllowListParamType>
+  | Concrete<TimedSaleParamsType>;
+
 export type New1155Token = {
   payoutRecipient: Address;
   createReferral: Address;
   maxSupply: bigint;
   royaltyBPS: number;
-  salesConfig: Concrete<SalesConfigParamsType>;
   tokenMetadataURI: string;
+  salesConfig: ConcreteSalesConfig;
 };
+
+export type CreateNew1155TokenReturn = {
+  parameters: SimulateContractParameters<
+    any,
+    any,
+    any,
+    any,
+    any,
+    Account | Address
+  >;
+  tokenSetupActions: Hex[];
+  newTokenId: bigint;
+  newToken: New1155Token;
+  minter: Address;
+  contractVersion: string;
+};
+
+export type CreateNew1155ContractAndTokenReturn = {
+  contractAddress: Address;
+} & CreateNew1155TokenReturn;