@zoralabs/protocol-sdk 0.5.16 → 0.6.0

package/src/premint/premint-client.ts

@@ -2,50 +2,57 @@ import { decodeEventLog, zeroAddress } from "viem";
 import type {
   Account,
   Address,
-  Chain,
   Hex,
   SimulateContractParameters,
   TransactionReceipt,
   TypedDataDefinition,
   WalletClient,
 } from "viem";
-import { zoraCreator1155PremintExecutorImplABI } from "@zoralabs/protocol-deployments";
+import {
+  PremintConfigAndVersion,
+  TokenConfigWithVersion,
+  encodePremintConfig,
+  zoraCreator1155PremintExecutorImplABI,
+} from "@zoralabs/protocol-deployments";
 import {
   getPremintCollectionAddress,
-  isValidSignature,
   isAuthorizedToCreatePremint,
   getPremintExecutorAddress,
   applyUpdateToPremint,
   makeNewPremint,
-  supportsPremintVersion,
+  supportedPremintVersions,
   getPremintMintCosts,
   makeMintRewardsRecipient,
   getDefaultFixedPriceMinterAddress,
+  emptyContractCreationConfig,
+  defaultAdditionalAdmins,
+  toContractCreationConfigOrAddress,
 } from "./preminter";
 import {
   PremintConfigVersion,
   ContractCreationConfig,
-  TokenConfigForVersion,
   TokenCreationConfigV1,
   TokenCreationConfigV2,
   TokenCreationConfig,
-  PremintConfigForVersion,
   PremintConfigWithVersion,
   PremintMintArguments,
   premintTypedDataDefinition,
 } from "@zoralabs/protocol-deployments";
-import { PremintAPIClient } from "./premint-api-client";
+import { IPremintAPI, IPremintGetter } from "./premint-api-client";
 import type { DecodeEventLogReturnType } from "viem";
 import { OPEN_EDITION_MINT_SIZE } from "../constants";
-import { IHttpClient } from "src/apis/http-api-base";
-import { getApiNetworkConfigForChain } from "src/mint/mint-api-client";
+import { getApiNetworkConfigForChain } from "src/mint/subgraph-mint-getter";
 import { MintCosts } from "src/mint/mint-client";
 import {
-  ClientConfig,
-  makeSimulateContractParamaters,
+  makeContractParameters,
+  mintRecipientOrAccount,
   PublicClient,
-  setupClient,
 } from "src/utils";
+import {
+  ContractCreationConfigAndAddress,
+  ContractCreationConfigOrAddress,
+} from "./contract-types";
+import { MakePremintMintParametersArguments } from "src/mint/types";
 
 type PremintedV2LogType = DecodeEventLogReturnType<
   typeof zoraCreator1155PremintExecutorImplABI,
@@ -65,12 +72,53 @@ export const defaultTokenConfigV1MintArguments = (): Omit<
   maxSupply: OPEN_EDITION_MINT_SIZE,
   maxTokensPerAddress: 0n,
   pricePerToken: 0n,
-  mintDuration: BigInt(60 * 60 * 24 * 7), // 1 week
+  mintDuration: 0n,
   mintStart: 0n,
   royaltyMintSchedule: 0,
   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"
@@ -78,51 +126,67 @@ export const defaultTokenConfigV2MintArguments = (): Omit<
   maxSupply: OPEN_EDITION_MINT_SIZE,
   maxTokensPerAddress: 0n,
   pricePerToken: 0n,
-  mintDuration: BigInt(60 * 60 * 24 * 7), // 1 week
+  mintDuration: 0n,
   mintStart: 0n,
   royaltyBPS: 1000, // 10%,
 });
 
-const makeTokenConfigWithDefaults = <T extends PremintConfigVersion>({
+type TokenConfigInput = {
+  /** Metadata URI of the token to create. */
+  tokenURI: string;
+  /** Account to receive creator rewards if it's a free mint, and token price value if its a paid mint. Defaults to the premint signing account. */
+  payoutRecipient: Address;
+  /** Optional: account to receive the create referral award. */
+  createReferral?: Address;
+  /** Optional: max supply of tokens that can be minted.  Defaults to unlimited.  */
+  maxSupply?: bigint;
+  /** Optional: max tokens that can be minted for an address, 0 if unlimited. Defaults to unlimited. */
+  maxTokensPerAddress?: bigint;
+  /** Optional: price per token, if this is a paid mint. 0 if a free mint.  Defaults to 0, or a free mint. */
+  pricePerToken?: bigint;
+  /** Optional: duration of the mint, starting from the time the premint is brought onchain. 0 for infinite.  Defaults to infinite. */
+  mintDuration?: bigint;
+  /** Optional: earliest time the premint can be brought onchain and minted. 0 for immediately.  Defaults to immediately. */
+  mintStart?: bigint;
+  /** Optional: The royalty amount in basis points for secondary sales, in basis points.  Defaults to 1000. */
+  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,
+    ),
+  };
 };
 
 /**
@@ -150,30 +214,30 @@ export function getPremintedLogFromReceipt(
 /**
  * Preminter API to access ZORA Premint functionality.
  */
-class PremintClient {
-  readonly apiClient: PremintAPIClient;
+export class PremintClient {
+  readonly apiClient: IPremintAPI;
   readonly publicClient: PublicClient;
-  readonly chain: Chain;
+  readonly chainId: number;
 
-  constructor(
-    chain: Chain,
-    publicClient: PublicClient,
-    httpClient: IHttpClient,
-  ) {
-    this.chain = chain;
-    this.apiClient = new PremintAPIClient(chain.id, httpClient);
+  constructor({
+    chainId,
+    publicClient,
+    premintApi,
+  }: {
+    chainId: number;
+    publicClient: PublicClient;
+    premintApi: IPremintAPI;
+  }) {
+    this.chainId = chainId;
+    this.apiClient = premintApi;
     this.publicClient = publicClient;
   }
 
-  getDataFromPremintReceipt(receipt: TransactionReceipt) {
-    const premintedLog = getPremintedLogFromReceipt(receipt);
-    return {
-      premintedLog,
-      urls: this.makeUrls({
-        address: premintedLog?.contractAddress,
-        tokenId: premintedLog?.tokenId,
-      }),
-    };
+  getDataFromPremintReceipt(
+    receipt: TransactionReceipt,
+    blockExplorerUrl?: string,
+  ) {
+    return getDataFromPremintReceipt(receipt, this.chainId, blockExplorerUrl);
   }
 
   /**
@@ -187,7 +251,7 @@ class PremintClient {
       ...args,
       apiClient: this.apiClient,
       publicClient: this.publicClient,
-      chainId: this.chain.id,
+      chainId: this.chainId,
     });
   }
 
@@ -204,7 +268,7 @@ class PremintClient {
       ...params,
       apiClient: this.apiClient,
       publicClient: this.publicClient,
-      chainId: this.chain.id,
+      chainId: this.chainId,
     });
   }
 
@@ -214,14 +278,14 @@ 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,
       publicClient: this.publicClient,
       apiClient: this.apiClient,
-      chainId: this.chain.id,
+      chainId: this.chainId,
     });
   }
 
@@ -232,13 +296,7 @@ class PremintClient {
    * @param uid UID for the desired premint
    * @returns PremintSignatureGetResponse of premint data from the API
    */
-  async getPremintSignature({
-    address,
-    uid,
-  }: {
-    address: Address;
-    uid: number;
-  }) {
+  async getPremint({ address, uid }: { address: Address; uid: number }) {
     return await this.apiClient.getSignature({
       collectionAddress: address,
       uid,
@@ -252,57 +310,8 @@ class PremintClient {
    */
   async getCollectionAddress(collection: ContractCreationConfig) {
     return await getPremintCollectionAddress({
-      collection,
-      publicClient: this.publicClient,
-    });
-  }
-
-  /**
-   * Check user signature for v1
-   *
-   * @param data Signature data from the API
-   * @returns isValid = signature is valid or not, recoveredSigner = signer from contract
-   */
-  async isValidSignature<T extends PremintConfigVersion>({
-    signature,
-    collection,
-    premintConfig,
-    premintConfigVersion,
-  }: {
-    signature: Hex;
-    collection: ContractCreationConfig;
-    premintConfig: PremintConfigForVersion<T>;
-    premintConfigVersion?: T;
-  }): Promise<{
-    isValid: boolean;
-    recoveredSigner: Address | undefined;
-  }> {
-    const { isAuthorized, recoveredAddress } = await isValidSignature({
-      chainId: this.chain.id,
-      signature: signature as Hex,
-      collection: collection,
+      contract: collection,
       publicClient: this.publicClient,
-      premintConfig,
-      premintConfigVersion: premintConfigVersion || PremintConfigVersion.V1,
-    });
-
-    return { isValid: isAuthorized, recoveredSigner: recoveredAddress };
-  }
-
-  protected makeUrls({
-    uid,
-    address,
-    tokenId,
-  }: {
-    uid?: number;
-    tokenId?: bigint;
-    address?: Address;
-  }): URLSReturnType {
-    return makeUrls({
-      uid,
-      address,
-      tokenId,
-      chain: this.chain,
     });
   }
 
@@ -330,28 +339,50 @@ class PremintClient {
    * @param parameters - Parameters for collecting the Premint {@link MakeMintParametersArguments}
    * @returns receipt, log, zoraURL
    */
-  async makeMintParameters(parameters: MakeMintParametersArguments) {
-    return await makeMintParameters({
-      ...parameters,
-      apiClient: this.apiClient,
+  async makeMintParameters({
+    minterAccount,
+    tokenContract,
+    uid,
+    mintArguments,
+    firstMinter,
+  }: MakeMintParametersArguments) {
+    return await collectPremint({
+      uid,
+      tokenContract,
+      minterAccount,
+      quantityToMint: mintArguments?.quantityToMint || 1n,
+      mintComment: mintArguments?.mintComment,
+      mintReferral: mintArguments?.mintReferral,
+      mintRecipient: mintArguments?.mintRecipient,
+      firstMinter,
+      premintGetter: this.apiClient,
       publicClient: this.publicClient,
     });
   }
 }
 
-export function createPremintClient(clientConfig: ClientConfig) {
-  const { chain, httpClient, publicClient } = setupClient(clientConfig);
-  return new PremintClient(chain, publicClient, httpClient);
+export function getDataFromPremintReceipt(
+  receipt: TransactionReceipt,
+  chainId: number,
+  blockExplorerUrl?: string,
+) {
+  const premintedLog = getPremintedLogFromReceipt(receipt);
+  return {
+    tokenId: premintedLog?.tokenId,
+    collectionAddres: premintedLog?.contractAddress,
+    premintedLog,
+    urls: makeUrls({
+      address: premintedLog?.contractAddress,
+      tokenId: premintedLog?.tokenId,
+      chainId,
+      blockExplorerUrl,
+    }),
+  };
 }
 
-type ContractCreationConfigWithoutAdditionalAdmins = Omit<
-  ContractCreationConfig,
-  "additionalAdmins"
->;
-
 type PremintContext = {
   publicClient: PublicClient;
-  apiClient: PremintAPIClient;
+  apiClient: IPremintAPI;
   chainId: number;
 };
 
@@ -360,11 +391,7 @@ type PremintContext = {
 export type SignAndSubmitParams = {
   /** The WalletClient used to sign the premint */
   walletClient: WalletClient;
-  /** The account that is to sign the premint */
-  account: Account | Address;
-  /** If the signature should be checked before submitting it to the api */
-  checkSignature?: boolean;
-};
+} & CheckSignatureParams;
 
 export type SignAndSubmitReturn = {
   /** The signature of the Premint  */
@@ -373,14 +400,23 @@ export type SignAndSubmitReturn = {
   signerAccount: Account | Address;
 };
 
+export type CheckSignatureParams =
+  | {
+      /** If the premint signature should be validated before submitting to the API */
+      checkSignature: true;
+      /** Account that signed the premint */
+      account: Account | Address;
+    }
+  | {
+      /** If the premint signature should be validated before submitting to the API */
+      checkSignature?: false;
+      account?: Account | Address;
+    };
+
 export type SubmitParams = {
   /** The signature of the Premint */
   signature: Hex;
-  /** If the premint signature should be validated before submitting to the API */
-  checkSignature?: boolean;
-  /** The account that signed the premint */
-  signerAccount: Account | Address;
-};
+} & CheckSignatureParams;
 
 type PremintReturn<T extends PremintConfigVersion> = {
   /** The typedDataDefinition of the Premint which is to be signed the creator. */
@@ -396,15 +432,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,
@@ -414,7 +449,7 @@ function makePremintReturn<T extends PremintConfigVersion>({
 
   const signAndSubmit = async ({
     walletClient,
-    account,
+    account: account,
     checkSignature,
   }: SignAndSubmitParams): Promise<SignAndSubmitReturn> => {
     const { signature, signerAccount } = await signPremint({
@@ -426,7 +461,7 @@ function makePremintReturn<T extends PremintConfigVersion>({
     await submit({
       signature,
       checkSignature,
-      signerAccount,
+      account: signerAccount,
     });
 
     return {
@@ -438,28 +473,24 @@ function makePremintReturn<T extends PremintConfigVersion>({
   const submit = async ({
     signature,
     checkSignature,
-    signerAccount,
-  }: {
-    signature: Hex;
-    checkSignature?: boolean;
-    signerAccount: Account | Address;
-  }) => {
+    account,
+  }: SubmitParams) => {
     if (checkSignature) {
-      await validateSignature({
-        collection: {
-          ...collection,
-          additionalAdmins: [],
-        },
+      const isAuthorized = await isAuthorizedToCreatePremint({
+        collectionAddress,
+        additionalAdmins: collection?.additionalAdmins,
+        contractAdmin: collection?.contractAdmin,
         publicClient,
-        signerAccount,
+        signer: account,
       });
+
+      if (!isAuthorized) {
+        throw new Error("Not authorized to create premint");
+      }
     }
 
     await apiClient.postSignature({
-      collection: {
-        ...collection,
-        additionalAdmins: [],
-      },
+      ...toContractCreationConfigOrAddress(collectionAndAddress),
       signature: signature,
       premintConfig,
       premintConfigVersion,
@@ -506,66 +537,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;
+  token: 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,
-  tokenCreationConfig,
-  premintConfigVersion,
+async function createPremint({
+  token: tokenCreationConfig,
   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 +569,34 @@ async function createPremint<T extends PremintConfigVersion>({
 
   return makePremintReturn({
     premintConfig,
-    premintConfigVersion: actualVersion,
-    collectionAddress,
-    collection,
+    premintConfigVersion,
+    collectionAddress: collectionAddressToUse,
+    collection: collectionOrAddress.contract,
     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 +605,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,
   };
 }
@@ -672,7 +651,7 @@ async function updatePremint({
   publicClient,
   chainId,
 }: UpdatePremintParams & {
-  apiClient: PremintAPIClient;
+  apiClient: IPremintAPI;
   publicClient: PublicClient;
   chainId: number;
 }) {
@@ -719,7 +698,7 @@ async function deletePremint({
   apiClient,
   chainId,
 }: DeletePremintParams & {
-  apiClient: PremintAPIClient;
+  apiClient: IPremintAPI;
   publicClient: PublicClient;
   chainId: number;
 }) {
@@ -727,6 +706,7 @@ async function deletePremint({
     premintConfig,
     premintConfigVersion,
     collection: collectionCreationConfig,
+    collectionAddress,
   } = await apiClient.getSignature({
     collectionAddress: collection,
     uid: uid,
@@ -741,7 +721,7 @@ async function deletePremint({
   return makePremintReturn({
     premintConfig: deletedPremint,
     premintConfigVersion,
-    collectionAddress: collection,
+    collectionAddress,
     collection: collectionCreationConfig,
     publicClient,
     apiClient,
@@ -767,45 +747,52 @@ 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 ======== */
 
-async function makeMintParameters({
+export async function collectPremint({
   uid,
   tokenContract,
   minterAccount,
-  mintArguments,
-  apiClient,
+  quantityToMint,
+  mintComment = "",
+  mintReferral,
+  mintRecipient,
+  firstMinter,
+  premintGetter,
   publicClient,
-}: MakeMintParametersArguments & {
-  apiClient: PremintAPIClient;
+}: Omit<MakePremintMintParametersArguments, "mintType"> & {
+  premintGetter: IPremintGetter;
   publicClient: PublicClient;
 }): Promise<
   SimulateContractParameters<
     typeof zoraCreator1155PremintExecutorImplABI,
-    "premintV1" | "premintV2",
+    "premint",
     any,
     any,
     any,
     Account | Address
   >
 > {
-  if (mintArguments && mintArguments?.quantityToMint < 1) {
+  if (typeof quantityToMint !== "undefined" && quantityToMint < 1) {
     throw new Error("Quantity to mint cannot be below 1");
   }
 
-  if (!minterAccount) {
-    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 premintGetter.getSignature({
+    collectionAddress: tokenContract,
+    uid,
+  });
 
-  const numberToMint = BigInt(mintArguments?.quantityToMint || 1);
+  const numberToMint = BigInt(quantityToMint || 1);
 
   if (premintConfigVersion === PremintConfigVersion.V3) {
     throw new Error("PremintV3 not supported in premint SDK");
@@ -818,65 +805,64 @@ async function makeMintParameters({
       publicClient,
       tokenPrice: premintConfig.tokenConfig.pricePerToken,
     })
-  ).totalCost;
+  ).totalCostEth;
 
   const mintArgumentsContract: PremintMintArguments = {
-    mintComment: mintArguments?.mintComment || "",
-    mintRecipient:
-      mintArguments?.mintRecipient ||
-      (typeof minterAccount === "string"
-        ? minterAccount
-        : minterAccount.address),
+    mintComment: mintComment,
+    mintRecipient: mintRecipientOrAccount({
+      mintRecipient,
+      minterAccount,
+    }),
     mintRewardsRecipients: makeMintRewardsRecipient({
-      mintReferral: mintArguments?.mintReferral,
+      mintReferral,
     }),
   };
 
-  if (premintConfigVersion === PremintConfigVersion.V1) {
-    return makeSimulateContractParamaters({
-      account: minterAccount,
-      abi: zoraCreator1155PremintExecutorImplABI,
-      functionName: "premintV1",
-      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 makeContractParameters({
+    account: minterAccount,
+    abi: zoraCreator1155PremintExecutorImplABI,
+    functionName: "premint",
+    value,
+    address: getPremintExecutorAddress(),
+    args: [
+      collectionOrEmpty,
+      collectionAddressToSubmit,
+      encodePremintConfig({
         premintConfig,
-        signature,
-        numberToMint,
-        mintArgumentsContract,
-      ],
-    });
-  } else if (premintConfigVersion === PremintConfigVersion.V2) {
-    return makeSimulateContractParamaters({
-      account: minterAccount,
-      abi: zoraCreator1155PremintExecutorImplABI,
-      functionName: "premintV2",
-      value,
-      address: getPremintExecutorAddress(),
-      args: [
-        collection,
-        premintConfig,
-        signature,
-        numberToMint,
-        mintArgumentsContract,
-      ],
-    });
-  }
-
-  throw new Error(`Invalid premint config version ${premintConfigVersion}`);
+        premintConfigVersion,
+      }),
+      signature,
+      numberToMint,
+      mintArgumentsContract,
+      firstMinterToSubmit,
+      zeroAddress,
+    ],
+  });
 }
 
 export function makeUrls({
   uid,
   address,
   tokenId,
-  chain,
+  chainId,
+  blockExplorerUrl,
 }: {
   uid?: number;
   tokenId?: bigint;
   address?: Address;
-  chain: Chain;
+  chainId: number;
+  blockExplorerUrl?: string;
 }): URLSReturnType {
   if ((!uid || !tokenId) && !address) {
     return { explorer: null, zoraCollect: null, zoraManage: null };
@@ -884,11 +870,11 @@ export function makeUrls({
 
   const zoraTokenPath = uid ? `premint-${uid}` : tokenId;
 
-  const network = getApiNetworkConfigForChain(chain.id);
+  const network = getApiNetworkConfigForChain(chainId);
 
   return {
     explorer: tokenId
-      ? `https://${chain.blockExplorers?.default.url}/token/${address}/instance/${tokenId}`
+      ? `https://${blockExplorerUrl}/token/${address}/instance/${tokenId}`
       : null,
     zoraCollect: `https://${
       network.isTestnet ? "testnet." : ""