@zoralabs/protocol-sdk 0.5.16 → 0.5.17

package/src/premint/premint-client.ts

@@ -9,7 +9,12 @@ import type {
   TypedDataDefinition,
   WalletClient,
 } from "viem";
-import { zoraCreator1155PremintExecutorImplABI } from "@zoralabs/protocol-deployments";
+import {
+  PremintConfigAndVersion,
+  TokenConfigWithVersion,
+  encodePremintConfig,
+  zoraCreator1155PremintExecutorImplABI,
+} from "@zoralabs/protocol-deployments";
 import {
   getPremintCollectionAddress,
   isValidSignature,
@@ -17,15 +22,17 @@ import {
   getPremintExecutorAddress,
   applyUpdateToPremint,
   makeNewPremint,
-  supportsPremintVersion,
+  supportedPremintVersions,
   getPremintMintCosts,
   makeMintRewardsRecipient,
   getDefaultFixedPriceMinterAddress,
+  emptyContractCreationConfig,
+  defaultAdditionalAdmins,
+  toContractCreationConfigOrAddress,
 } from "./preminter";
 import {
   PremintConfigVersion,
   ContractCreationConfig,
-  TokenConfigForVersion,
   TokenCreationConfigV1,
   TokenCreationConfigV2,
   TokenCreationConfig,
@@ -46,6 +53,10 @@ import {
   PublicClient,
   setupClient,
 } from "src/utils";
+import {
+  ContractCreationConfigAndAddress,
+  ContractCreationConfigOrAddress,
+} from "./contract-types";
 
 type PremintedV2LogType = DecodeEventLogReturnType<
   typeof zoraCreator1155PremintExecutorImplABI,
@@ -71,6 +82,47 @@ export const defaultTokenConfigV1MintArguments = (): Omit<
   royaltyBPS: 1000, // 10%,
 });
 
+const pickTokenConfigV1 = (tokenConfig: TokenConfigInput) => ({
+  maxSupply: tokenConfig.maxSupply,
+  maxTokensPerAddress: tokenConfig.maxTokensPerAddress,
+  pricePerToken: tokenConfig.pricePerToken,
+  mintDuration: tokenConfig.mintDuration,
+  mintStart: tokenConfig.mintStart,
+  royaltyBPS: tokenConfig.royaltyBPS,
+  tokenURI: tokenConfig.tokenURI,
+  royaltyRecipient: tokenConfig.payoutRecipient,
+});
+
+const pickTokenConfigV2 = (tokenConfig: TokenConfigInput) => ({
+  maxSupply: tokenConfig.maxSupply,
+  maxTokensPerAddress: tokenConfig.maxTokensPerAddress,
+  pricePerToken: tokenConfig.pricePerToken,
+  mintDuration: tokenConfig.mintDuration,
+  mintStart: tokenConfig.mintStart,
+  royaltyBPS: tokenConfig.royaltyBPS,
+  tokenURI: tokenConfig.tokenURI,
+  payoutRecipient: tokenConfig.payoutRecipient,
+  createReferral: tokenConfig.createReferral || zeroAddress,
+});
+
+const tokenConfigV1WithDefault = (
+  tokenConfig: TokenConfigInput,
+  fixedPriceMinter: Address,
+): TokenCreationConfigV1 => ({
+  ...pickTokenConfigV1(tokenConfig),
+  ...defaultTokenConfigV1MintArguments(),
+  fixedPriceMinter,
+});
+
+const tokenConfigV2WithDefault = (
+  tokenConfig: TokenConfigInput,
+  fixedPriceMinter: Address,
+): TokenCreationConfigV2 => ({
+  ...pickTokenConfigV2(tokenConfig),
+  ...defaultTokenConfigV2MintArguments(),
+  fixedPriceMinter,
+});
+
 export const defaultTokenConfigV2MintArguments = (): Omit<
   TokenCreationConfigV2,
   "fixedPriceMinter" | "tokenURI" | "payoutRecipient" | "createReferral"
@@ -83,46 +135,53 @@ export const defaultTokenConfigV2MintArguments = (): Omit<
   royaltyBPS: 1000, // 10%,
 });
 
-const makeTokenConfigWithDefaults = <T extends PremintConfigVersion>({
+type TokenConfigInput = {
+  tokenURI: string;
+  payoutRecipient: Address;
+  createReferral?: Address;
+  maxSupply?: bigint;
+  maxTokensPerAddress?: bigint;
+  pricePerToken?: bigint;
+  mintDuration?: bigint;
+  mintStart?: bigint;
+  royaltyBPS?: number;
+};
+
+const makeTokenConfigWithDefaults = ({
   chainId,
-  premintConfigVersion,
   tokenCreationConfig,
-  payoutRecipient,
+  supportedPremintVersions,
 }: {
   chainId: number;
-  premintConfigVersion: T;
-  tokenCreationConfig: Partial<TokenConfigForVersion<T>> & { tokenURI: string };
-  payoutRecipient: Address;
-}): TokenConfigForVersion<T> => {
-  if (premintConfigVersion === PremintConfigVersion.V3) {
-    throw new Error("PremintV3 not supported in SDK");
-  }
-
-  const fixedPriceMinter =
-    (
-      tokenCreationConfig as
-        | Partial<TokenCreationConfigV1>
-        | Partial<TokenCreationConfigV2>
-    ).fixedPriceMinter || getDefaultFixedPriceMinterAddress(chainId);
+  tokenCreationConfig: TokenConfigInput;
+  supportedPremintVersions: PremintConfigVersion[];
+}): TokenConfigWithVersion<
+  PremintConfigVersion.V1 | PremintConfigVersion.V2
+> => {
+  const fixedPriceMinter = getDefaultFixedPriceMinterAddress(chainId);
+
+  if (!supportedPremintVersions.includes(PremintConfigVersion.V2)) {
+    // we need to return a token config v1
+    if (tokenCreationConfig.createReferral) {
+      throw new Error("Contract does not support create referral");
+    }
 
-  if (premintConfigVersion === PremintConfigVersion.V1) {
     return {
-      fixedPriceMinter,
-      ...defaultTokenConfigV1MintArguments(),
-      royaltyRecipient: payoutRecipient,
-      ...(tokenCreationConfig as Partial<TokenCreationConfigV1>),
-    } as TokenCreationConfigV1;
-  } else if (premintConfigVersion === PremintConfigVersion.V2) {
-    return {
-      fixedPriceMinter,
-      ...defaultTokenConfigV2MintArguments(),
-      payoutRecipient: payoutRecipient,
-      createReferral: zeroAddress,
-      ...tokenCreationConfig,
+      premintConfigVersion: PremintConfigVersion.V1,
+      tokenConfig: tokenConfigV1WithDefault(
+        tokenCreationConfig,
+        fixedPriceMinter,
+      ),
     };
-  } else {
-    throw new Error(`Invalid premint config version ${premintConfigVersion}`);
   }
+
+  return {
+    premintConfigVersion: PremintConfigVersion.V2,
+    tokenConfig: tokenConfigV2WithDefault(
+      tokenCreationConfig,
+      fixedPriceMinter,
+    ),
+  };
 };
 
 /**
@@ -214,8 +273,8 @@ class PremintClient {
    * @param parameters - Parameters for creating the premint {@link CreatePremintParameters}
    * @returns A PremintReturn. {@link PremintReturn}
    */
-  async createPremint<T extends PremintConfigVersion = PremintConfigVersion.V2>(
-    parameters: CreatePremintParameters<T>,
+  async createPremint(
+    parameters: CreatePremintParameters,
   ): Promise<PremintReturn<any>> {
     return createPremint({
       ...parameters,
@@ -265,25 +324,30 @@ class PremintClient {
    */
   async isValidSignature<T extends PremintConfigVersion>({
     signature,
-    collection,
     premintConfig,
     premintConfigVersion,
+    ...collectionAndOrAddress
   }: {
     signature: Hex;
-    collection: ContractCreationConfig;
     premintConfig: PremintConfigForVersion<T>;
     premintConfigVersion?: T;
-  }): Promise<{
+  } & ContractCreationConfigOrAddress): Promise<{
     isValid: boolean;
     recoveredSigner: Address | undefined;
   }> {
+    const collectionAddressToUse = await getPremintCollectionAddress({
+      ...collectionAndOrAddress,
+      publicClient: this.publicClient,
+    });
+
     const { isAuthorized, recoveredAddress } = await isValidSignature({
       chainId: this.chain.id,
       signature: signature as Hex,
-      collection: collection,
       publicClient: this.publicClient,
       premintConfig,
       premintConfigVersion: premintConfigVersion || PremintConfigVersion.V1,
+      collectionAddress: collectionAddressToUse,
+      collection: collectionAndOrAddress.collection,
     });
 
     return { isValid: isAuthorized, recoveredSigner: recoveredAddress };
@@ -344,11 +408,6 @@ export function createPremintClient(clientConfig: ClientConfig) {
   return new PremintClient(chain, publicClient, httpClient);
 }
 
-type ContractCreationConfigWithoutAdditionalAdmins = Omit<
-  ContractCreationConfig,
-  "additionalAdmins"
->;
-
 type PremintContext = {
   publicClient: PublicClient;
   apiClient: PremintAPIClient;
@@ -396,15 +455,14 @@ type PremintReturn<T extends PremintConfigVersion> = {
 function makePremintReturn<T extends PremintConfigVersion>({
   premintConfig,
   premintConfigVersion,
-  collectionAddress,
-  collection,
   publicClient,
   apiClient,
   chainId,
-}: PremintConfigWithVersion<T> & {
-  collectionAddress: Address;
-  collection: ContractCreationConfigWithoutAdditionalAdmins;
-} & PremintContext): PremintReturn<T> {
+  ...collectionAndAddress
+}: PremintConfigWithVersion<T> &
+  ContractCreationConfigAndAddress &
+  PremintContext): PremintReturn<T> {
+  const { collection, collectionAddress } = collectionAndAddress;
   const typedDataDefinition = premintTypedDataDefinition({
     verifyingContract: collectionAddress,
     premintConfig,
@@ -445,21 +503,21 @@ function makePremintReturn<T extends PremintConfigVersion>({
     signerAccount: Account | Address;
   }) => {
     if (checkSignature) {
-      await validateSignature({
-        collection: {
-          ...collection,
-          additionalAdmins: [],
-        },
+      const isAuthorized = await isAuthorizedToCreatePremint({
+        collectionAddress,
+        additionalAdmins: collection?.additionalAdmins,
+        contractAdmin: collection?.contractAdmin,
         publicClient,
-        signerAccount,
+        signer: signerAccount,
       });
+
+      if (!isAuthorized) {
+        throw new Error("Not authorized to create premint");
+      }
     }
 
     await apiClient.postSignature({
-      collection: {
-        ...collection,
-        additionalAdmins: [],
-      },
+      ...toContractCreationConfigOrAddress(collectionAndAddress),
       signature: signature,
       premintConfig,
       premintConfigVersion,
@@ -506,66 +564,30 @@ async function signPremint({
   };
 }
 
-const validateSignature = async ({
-  collection,
-  publicClient,
-  signerAccount,
-}: {
-  collection: ContractCreationConfig;
-  publicClient: PublicClient;
-  signerAccount: Address | Account;
-}) => {
-  const isAuthorized = await isAuthorizedToCreatePremint({
-    collection,
-    publicClient,
-    signer:
-      typeof signerAccount === "string" ? signerAccount : signerAccount.address,
-    collectionAddress: await getPremintCollectionAddress({
-      collection,
-      publicClient,
-    }),
-  });
-  if (!isAuthorized) {
-    throw new Error("Not authorized to create premint");
-  }
-};
-
 /** CREATE */
 
-type CreatePremintParameters<T extends PremintConfigVersion> = {
-  /** The account to receive the creator reward if it's a free mint, and the paid mint fee if it's a paid mint */
-  payoutRecipient: Address;
-  /** Collection information for the mint */
-  collection: ContractCreationConfigWithoutAdditionalAdmins;
+type CreatePremintParameters = {
   /** tokenCreationConfig Token creation settings, optional settings are overridden with sensible defaults */
-  tokenCreationConfig: Partial<TokenConfigForVersion<T>> & {
-    tokenURI: string;
-  };
-  /** Premint config version to use, defaults to V2 */
-  premintConfigVersion?: T;
+  tokenCreationConfig: TokenConfigInput;
   /** uid the UID to use – optional and retrieved as a fresh UID from ZORA by default. */
   uid?: number;
-};
+} & ContractCreationConfigOrAddress;
 
-async function createPremint<T extends PremintConfigVersion>({
-  payoutRecipient: creatorAccount,
-  collection,
+async function createPremint({
   tokenCreationConfig,
-  premintConfigVersion,
   uid,
   publicClient,
   apiClient,
   chainId,
-}: CreatePremintParameters<T> & PremintContext) {
+  ...collectionOrAddress
+}: CreatePremintParameters & PremintContext) {
   const {
     premintConfig,
-    premintConfigVersion: actualVersion,
-    collectionAddress,
-  } = await prepareCreatePremintConfig<T>({
-    payoutRecipient: creatorAccount,
-    collection,
-    tokenCreationConfig,
     premintConfigVersion,
+    collectionAddress: collectionAddressToUse,
+  } = await prepareCreatePremintConfig({
+    ...collectionOrAddress,
+    tokenCreationConfig,
     uid,
     publicClient,
     apiClient,
@@ -574,42 +596,34 @@ async function createPremint<T extends PremintConfigVersion>({
 
   return makePremintReturn({
     premintConfig,
-    premintConfigVersion: actualVersion,
-    collectionAddress,
-    collection,
+    premintConfigVersion,
+    collectionAddress: collectionAddressToUse,
+    collection: collectionOrAddress.collection,
     publicClient,
     apiClient,
     chainId,
   });
 }
 
-async function prepareCreatePremintConfig<T extends PremintConfigVersion>({
-  payoutRecipient,
-  collection,
+type PreparePremintReturn = {
+  collectionAddress: Address;
+} & PremintConfigAndVersion;
+
+async function prepareCreatePremintConfig({
   tokenCreationConfig,
-  premintConfigVersion,
   uid,
   publicClient,
   apiClient,
   chainId,
+  ...collectionOrAddress
 }: {
-  payoutRecipient: Address | Account;
-  collection: Omit<ContractCreationConfig, "additionalAdmins"> & {
-    additionalAdmins?: Address[];
-  };
-  tokenCreationConfig: Partial<TokenConfigForVersion<T>> & {
-    tokenURI: string;
-  };
-  premintConfigVersion?: T;
+  tokenCreationConfig: TokenConfigInput;
   uid?: number;
-} & PremintContext) {
-  const collectionWithAdditionalAdmins: ContractCreationConfig = {
-    ...collection,
-    additionalAdmins: collection.additionalAdmins || [],
-  };
+} & PremintContext &
+  ContractCreationConfigOrAddress): Promise<PreparePremintReturn> {
   const newContractAddress = await getPremintCollectionAddress({
     publicClient,
-    collection: collectionWithAdditionalAdmins,
+    ...collectionOrAddress,
   });
 
   let uidToUse = uid;
@@ -618,37 +632,29 @@ async function prepareCreatePremintConfig<T extends PremintConfigVersion>({
     uidToUse = await apiClient.getNextUID(newContractAddress);
   }
 
-  const actualVersion = premintConfigVersion || PremintConfigVersion.V1;
+  const supportedVersions = await supportedPremintVersions({
+    tokenContract: newContractAddress,
+    publicClient,
+  });
 
-  if (
-    !(await supportsPremintVersion({
-      version: actualVersion,
-      publicClient,
-      tokenContract: newContractAddress,
-    }))
-  ) {
-    throw new Error(
-      `Premint version ${actualVersion} not supported by contract`,
-    );
-  }
+  const tokenConfigAndVersion = makeTokenConfigWithDefaults({
+    tokenCreationConfig,
+    chainId,
+    supportedPremintVersions: supportedVersions,
+  });
 
   const premintConfig = makeNewPremint({
-    tokenConfig: makeTokenConfigWithDefaults({
-      // @ts-ignore
-      premintConfigVersion: actualVersion,
-      tokenCreationConfig,
-      payoutRecipient:
-        typeof payoutRecipient === "string"
-          ? payoutRecipient
-          : payoutRecipient.address,
-      chainId,
-    }),
+    ...tokenConfigAndVersion,
     uid: uidToUse,
   });
 
-  return {
+  const premintConfigAndVersion = {
     premintConfig,
-    premintConfigVersion: actualVersion,
+    premintConfigVersion: tokenConfigAndVersion.premintConfigVersion,
+  } as PremintConfigAndVersion;
+
+  return {
+    ...premintConfigAndVersion,
     collectionAddress: newContractAddress,
   };
 }
@@ -727,6 +733,7 @@ async function deletePremint({
     premintConfig,
     premintConfigVersion,
     collection: collectionCreationConfig,
+    collectionAddress,
   } = await apiClient.getSignature({
     collectionAddress: collection,
     uid: uid,
@@ -741,7 +748,7 @@ async function deletePremint({
   return makePremintReturn({
     premintConfig: deletedPremint,
     premintConfigVersion,
-    collectionAddress: collection,
+    collectionAddress,
     collection: collectionCreationConfig,
     publicClient,
     apiClient,
@@ -767,6 +774,8 @@ export type MakeMintParametersArguments = {
     /** Address to receive the minted tokens */
     mintRecipient?: Address;
   };
+  /** Account to receive first minter reward, if this mint brings the premint onchain */
+  firstMinter?: Address;
 };
 
 /** ======== MINTING ======== */
@@ -776,6 +785,7 @@ async function makeMintParameters({
   tokenContract,
   minterAccount,
   mintArguments,
+  firstMinter,
   apiClient,
   publicClient,
 }: MakeMintParametersArguments & {
@@ -799,11 +809,16 @@ async function makeMintParameters({
     throw new Error("Wallet not passed in");
   }
 
-  const { premintConfig, premintConfigVersion, collection, signature } =
-    await apiClient.getSignature({
-      collectionAddress: tokenContract,
-      uid,
-    });
+  const {
+    premintConfig,
+    premintConfigVersion,
+    collection,
+    collectionAddress,
+    signature,
+  } = await apiClient.getSignature({
+    collectionAddress: tokenContract,
+    uid,
+  });
 
   const numberToMint = BigInt(mintArguments?.quantityToMint || 1);
 
@@ -832,39 +847,37 @@ async function makeMintParameters({
     }),
   };
 
-  if (premintConfigVersion === PremintConfigVersion.V1) {
-    return makeSimulateContractParamaters({
-      account: minterAccount,
-      abi: zoraCreator1155PremintExecutorImplABI,
-      functionName: "premintV1",
-      value,
-      address: getPremintExecutorAddress(),
-      args: [
-        collection,
-        premintConfig,
-        signature,
-        numberToMint,
-        mintArgumentsContract,
-      ],
-    });
-  } else if (premintConfigVersion === PremintConfigVersion.V2) {
-    return makeSimulateContractParamaters({
-      account: minterAccount,
-      abi: zoraCreator1155PremintExecutorImplABI,
-      functionName: "premintV2",
-      value,
-      address: getPremintExecutorAddress(),
-      args: [
-        collection,
+  const collectionOrEmpty: ContractCreationConfig = collection
+    ? defaultAdditionalAdmins(collection)
+    : emptyContractCreationConfig();
+  const collectionAddressToSubmit = collection
+    ? zeroAddress
+    : collectionAddress;
+
+  const firstMinterToSubmit: Address =
+    firstMinter ||
+    (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
+
+  return makeSimulateContractParamaters({
+    account: minterAccount,
+    abi: zoraCreator1155PremintExecutorImplABI,
+    functionName: "premint",
+    value,
+    address: getPremintExecutorAddress(),
+    args: [
+      collectionOrEmpty,
+      collectionAddressToSubmit,
+      encodePremintConfig({
         premintConfig,
-        signature,
-        numberToMint,
-        mintArgumentsContract,
-      ],
-    });
-  }
-
-  throw new Error(`Invalid premint config version ${premintConfigVersion}`);
+        premintConfigVersion,
+      }),
+      signature,
+      numberToMint,
+      mintArgumentsContract,
+      firstMinterToSubmit,
+      zeroAddress,
+    ],
+  });
 }
 
 export function makeUrls({