@zoralabs/protocol-sdk 0.3.5 → 0.4.1

package/src/premint/premint-client.ts

@@ -1,4 +1,4 @@
-import { createPublicClient, decodeEventLog, http } from "viem";
+import { createPublicClient, decodeEventLog, http, zeroAddress } from "viem";
 import type {
   Account,
   Address,
@@ -14,40 +14,36 @@ import {
   zoraCreatorFixedPriceSaleStrategyAddress,
 } from "@zoralabs/protocol-deployments";
 import {
-  PremintConfigAndVersion,
-  PremintConfigV1,
-  PremintConfigV2,
-  PremintConfigVersion,
   getPremintCollectionAddress,
   premintTypedDataDefinition,
-  ContractCreationConfig,
   isValidSignature,
   isAuthorizedToCreatePremint,
   getPremintExecutorAddress,
+  applyUpdateToPremint,
+  markPremintDeleted,
+  makeNewPremint,
+  supportsPremintVersion,
+  getPremintMintCosts,
+  makeMintRewardsRecipient,
 } from "./preminter";
-import type {
-  PremintSignatureGetResponse,
-  PremintSignatureResponse,
-} from "./premint-api-client";
+import {
+  PremintConfigV2,
+  PremintConfigVersion,
+  ContractCreationConfig,
+  TokenConfigForVersion,
+  PremintConfigWithVersion,
+  TokenCreationConfigV1,
+  TokenCreationConfigV2,
+  TokenCreationConfig,
+  PremintConfigForVersion,
+} from "./contract-types";
+import type { PremintSignatureResponse } from "./premint-api-client";
 import { PremintAPIClient } from "./premint-api-client";
 import type { DecodeEventLogReturnType } from "viem";
 import { OPEN_EDITION_MINT_SIZE } from "../constants";
-import { REWARD_PER_TOKEN } from "src/apis/chain-constants";
 import { IHttpClient } from "src/apis/http-api-base";
 import { getApiNetworkConfigForChain } from "src/mint/mint-api-client";
-
-type MintArgumentsSettings = {
-  tokenURI: string;
-  maxSupply?: bigint;
-  maxTokensPerAddress?: bigint;
-  pricePerToken?: bigint;
-  mintStart?: bigint;
-  mintDuration?: bigint;
-  royaltyMintSchedule?: number;
-  royaltyBPS?: number;
-  royaltyRecipient?: Address;
-  fixedPriceMinter?: Address;
-};
+import { MintCosts } from "src/mint/mint-client";
 
 type PremintedLogType = DecodeEventLogReturnType<
   typeof zoraCreator1155PremintExecutorImplABI,
@@ -67,7 +63,10 @@ type SignedPremintResponse = {
   premint: PremintSignatureResponse;
 };
 
-export const DefaultMintArguments = {
+export const defaultTokenConfigV1MintArguments = (): Omit<
+  TokenCreationConfigV1,
+  "fixedPriceMinter" | "tokenURI" | "royaltyRecipient"
+> => ({
   maxSupply: OPEN_EDITION_MINT_SIZE,
   maxTokensPerAddress: 0n,
   pricePerToken: 0n,
@@ -75,6 +74,50 @@ export const DefaultMintArguments = {
   mintStart: 0n,
   royaltyMintSchedule: 0,
   royaltyBPS: 1000, // 10%,
+});
+
+export const defaultTokenConfigV2MintArguments = (): Omit<
+  TokenCreationConfigV2,
+  "fixedPriceMinter" | "tokenURI" | "payoutRecipient" | "createReferral"
+> => ({
+  maxSupply: OPEN_EDITION_MINT_SIZE,
+  maxTokensPerAddress: 0n,
+  pricePerToken: 0n,
+  mintDuration: BigInt(60 * 60 * 24 * 7), // 1 week
+  mintStart: 0n,
+  royaltyBPS: 1000, // 10%,
+});
+
+const makeTokenConfigWithDefaults = <T extends PremintConfigVersion>({
+  premintConfigVersion,
+  tokenCreationConfig,
+  creatorAccount,
+}: {
+  premintConfigVersion: PremintConfigVersion;
+  tokenCreationConfig: Partial<TokenConfigForVersion<T>> & { tokenURI: string };
+  creatorAccount: Address;
+}): TokenConfigForVersion<T> => {
+  const fixedPriceMinter =
+    tokenCreationConfig.fixedPriceMinter || getDefaultFixedPriceMinterAddress();
+
+  if (premintConfigVersion === PremintConfigVersion.V1) {
+    return {
+      fixedPriceMinter,
+      ...defaultTokenConfigV1MintArguments(),
+      royaltyRecipient: creatorAccount,
+      ...tokenCreationConfig,
+    };
+  } else if (premintConfigVersion === PremintConfigVersion.V2) {
+    return {
+      fixedPriceMinter,
+      ...defaultTokenConfigV2MintArguments(),
+      payoutRecipient: creatorAccount,
+      createReferral: zeroAddress,
+      ...tokenCreationConfig,
+    };
+  } else {
+    throw new Error(`Invalid premint config version ${premintConfigVersion}`);
+  }
 };
 
 /**
@@ -99,85 +142,6 @@ export function getPremintedLogFromReceipt(
     } catch (err: any) {}
   }
 }
-
-/**
- * Convert server to on-chain types for a premint
- *
- * @param premint Premint object from the server to convert to one that's compatible with viem
- * @returns Viem type-compatible premint object
- */
-export const convertPremintV1 = (
-  premint: PremintSignatureGetResponse["premint"],
-) => ({
-  ...premint,
-  tokenConfig: {
-    ...premint.tokenConfig,
-    fixedPriceMinter: premint.tokenConfig.fixedPriceMinter as Address,
-    royaltyRecipient: premint.tokenConfig.royaltyRecipient as Address,
-    maxSupply: BigInt(premint.tokenConfig.maxSupply),
-    pricePerToken: BigInt(premint.tokenConfig.pricePerToken),
-    mintStart: BigInt(premint.tokenConfig.mintStart),
-    mintDuration: BigInt(premint.tokenConfig.mintDuration),
-    maxTokensPerAddress: BigInt(premint.tokenConfig.maxTokensPerAddress),
-  },
-});
-
-export const convertCollection = (
-  collection: PremintSignatureGetResponse["collection"],
-) => ({
-  ...collection,
-  contractAdmin: collection.contractAdmin as Address,
-});
-
-/**
- * Convert on-chain types for a premint to a server safe type
- *
- * @param premint Premint object from viem to convert to a JSON compatible type.
- * @returns JSON compatible premint
- */
-export const encodePremintV1ForAPI = ({
-  tokenConfig,
-  ...premint
-}: PremintConfigV1) => ({
-  ...premint,
-  tokenConfig: {
-    ...tokenConfig,
-    maxSupply: tokenConfig.maxSupply.toString(),
-    pricePerToken: tokenConfig.pricePerToken.toString(),
-    mintStart: tokenConfig.mintStart.toString(),
-    mintDuration: tokenConfig.mintDuration.toString(),
-    maxTokensPerAddress: tokenConfig.maxTokensPerAddress.toString(),
-  },
-});
-
-export const encodePremintV2ForAPI = ({
-  tokenConfig,
-  ...premint
-}: PremintConfigV2) => ({
-  ...premint,
-  tokenConfig: {
-    ...tokenConfig,
-    maxSupply: tokenConfig.maxSupply.toString(),
-    pricePerToken: tokenConfig.pricePerToken.toString(),
-    mintStart: tokenConfig.mintStart.toString(),
-    mintDuration: tokenConfig.mintDuration.toString(),
-    maxTokensPerAddress: tokenConfig.maxTokensPerAddress.toString(),
-  },
-});
-
-export const encodePremintForAPI = ({
-  premintConfig,
-  premintConfigVersion,
-}: PremintConfigAndVersion) => {
-  if (premintConfigVersion === PremintConfigVersion.V1) {
-    return encodePremintV1ForAPI(premintConfig);
-  }
-  if (premintConfigVersion === PremintConfigVersion.V2) {
-    return encodePremintV2ForAPI(premintConfig);
-  }
-  throw new Error(`Invalid premint config version ${premintConfigVersion}`);
-};
-
 /**
  * Preminter API to access ZORA Premint functionality.
  * Currently only supports V1 premints.
@@ -198,17 +162,6 @@ class PremintClient {
       publicClient || createPublicClient({ chain, transport: http() });
   }
 
-  /**
-   * The fixed price minter address is the same across all chains for our current
-   * deployer strategy.
-   * Can be overridden as needed by making a parent class.
-   *
-   * @returns Fixed price sale strategy
-   */
-  getFixedPriceMinterAddress() {
-    return zoraCreatorFixedPriceSaleStrategyAddress[999];
-  }
-
   getDataFromPremintReceipt(receipt: TransactionReceipt) {
     const premintedLog = getPremintedLogFromReceipt(receipt);
     return {
@@ -242,44 +195,39 @@ class PremintClient {
     walletClient,
     uid,
     collection,
-    token,
     account,
+    tokenConfigUpdates,
   }: {
     walletClient: WalletClient;
     uid: number;
-    token: MintArgumentsSettings;
     account?: Account | Address;
     collection: Address;
+    tokenConfigUpdates: Partial<TokenCreationConfig>;
   }): Promise<SignedPremintResponse> {
-    const signatureResponse = await this.apiClient.getSignature({
-      collection_address: collection.toLowerCase(),
+    const {
+      premintConfig,
+      collection: collectionCreationConfig,
+      premintConfigVersion,
+    } = await this.apiClient.getSignature({
+      collectionAddress: collection,
       uid: uid,
     });
 
-    const convertedPremint = convertPremintV1(signatureResponse.premint);
-    const signerData = {
-      ...signatureResponse,
-      premint: {
-        ...convertedPremint,
-        tokenConfig: {
-          ...convertedPremint.tokenConfig,
-          ...token,
-        },
-      },
-    };
+    const updatedPremint = applyUpdateToPremint({
+      uid: premintConfig.uid,
+      version: premintConfig.version,
+      tokenConfig: premintConfig.tokenConfig,
+      tokenConfigUpdates: tokenConfigUpdates,
+    });
 
     return await this.signAndSubmitPremint({
       walletClient,
       account,
-      checkSignature: false,
+      checkSignature: true,
       verifyingContract: collection,
-      uid: uid,
-      collection: {
-        ...signerData.collection,
-        contractAdmin: signerData.collection.contractAdmin as Address,
-      },
-      premintConfig: signerData.premint,
-      premintConfigVersion: PremintConfigVersion.V1,
+      collection: collectionCreationConfig,
+      premintConfig: updatedPremint,
+      premintConfigVersion: premintConfigVersion,
     });
   }
 
@@ -308,29 +256,25 @@ class PremintClient {
     account?: Account | Address;
     collection: Address;
   }) {
-    const signatureResponse = await this.apiClient.getSignature({
-      collection_address: collection.toLowerCase(),
+    const {
+      premintConfig,
+      premintConfigVersion,
+      collection: collectionCreationConfig,
+    } = await this.apiClient.getSignature({
+      collectionAddress: collection,
       uid: uid,
     });
 
-    const signerData = {
-      ...signatureResponse,
-      collection: convertCollection(signatureResponse.collection),
-      premint: {
-        ...convertPremintV1(signatureResponse.premint),
-        deleted: true,
-      },
-    };
+    const deletedPremint = markPremintDeleted(premintConfig);
 
     return await this.signAndSubmitPremint({
       walletClient,
       account,
       checkSignature: false,
       verifyingContract: collection,
-      uid: uid,
-      collection: signerData.collection,
-      premintConfig: signerData.premint,
-      premintConfigVersion: PremintConfigVersion.V1,
+      collection: collectionCreationConfig,
+      premintConfig: deletedPremint,
+      premintConfigVersion,
     });
   }
 
@@ -340,66 +284,17 @@ class PremintClient {
    * @param premintArguments Arguments to premint
    * @returns
    */
-  private async signAndSubmitPremint({
-    walletClient,
-    verifyingContract,
-    uid,
-    account,
-    checkSignature,
-    collection,
-    ...premintConfigAndVersion
-  }: {
-    uid: number;
-    walletClient: WalletClient;
-    verifyingContract: Address;
-    checkSignature: boolean;
-    account?: Address | Account;
-    collection: PremintSignatureGetResponse["collection"];
-  } & PremintConfigAndVersion) {
-    if (!account) {
-      account = walletClient.account;
-    }
-    if (!account) {
-      throw new Error("No account provided");
-    }
-
-    const signature = await walletClient.signTypedData({
-      account,
-      ...premintTypedDataDefinition({
-        verifyingContract,
-        ...premintConfigAndVersion,
-        chainId: this.chain.id,
-      }),
+  private async signAndSubmitPremint<T extends PremintConfigVersion>(
+    params: SignAndSubmitPremintParams<T>,
+  ) {
+    const { premint, verifyingContract } = await signAndSubmitPremint({
+      ...params,
+      chainId: this.chain.id,
+      apiClient: this.apiClient,
+      publicClient: this.publicClient,
     });
 
-    if (checkSignature) {
-      const convertedCollection = convertCollection(collection);
-      const isAuthorized = await isAuthorizedToCreatePremint({
-        collection: convertCollection(collection),
-        signature,
-        publicClient: this.publicClient,
-        signer: typeof account === "string" ? account : account.address,
-        collectionAddress: await this.getCollectionAddress(convertedCollection),
-        ...premintConfigAndVersion,
-      });
-      if (!isAuthorized) {
-        throw new Error("Not authorized to create premint");
-      }
-    }
-
-    if (
-      premintConfigAndVersion.premintConfigVersion === PremintConfigVersion.V2
-    ) {
-      throw new Error("premint config v2 not supported yet");
-    }
-
-    const apiData = {
-      collection,
-      premint: encodePremintV1ForAPI(premintConfigAndVersion.premintConfig),
-      signature: signature,
-    };
-
-    const premint = await this.apiClient.postSignature(apiData);
+    const uid = params.premintConfig.uid;
 
     return {
       urls: this.makeUrls({ address: verifyingContract, uid }),
@@ -415,73 +310,73 @@ class PremintClient {
    * @param settings Settings for the new premint
    * @param settings.account Account to sign the premint with. Taken from walletClient if none passed in.
    * @param settings.collection Collection information for the mint
-   * @param settings.token Mint argument settings, optional settings are overridden with sensible defaults.
-   * @param settings.publicClient Public client (optional) – instantiated if not passed in with defaults.
-   * @param settings.walletClient Required wallet client for signing the premint message.
-   * @param settings.executionSettings Execution settings for premint options
-   * @param settings.executionSettings.deleted If this UID should be deleted. If omitted, set to false.
-   * @param settings.executionSettings.uid the UID to use – optional and retrieved as a fresh UID from ZORA by default.
+   * @param settings.tokenCreationConfig Mint argument settings, optional settings are overridden with sensible defaults.
+   * @param setings.premintConfigVersion Premint config version to use, defaults to V2
+   * @param settings.uid the UID to use – optional and retrieved as a fresh UID from ZORA by default.
    * @param settings.checkSignature if the signature should have a pre-flight check. Not required but helpful for debugging.
    * @returns premint url, uid, newContractAddress, and premint object
    */
-  async createPremint({
-    account,
+  async createPremint<
+    T extends PremintConfigVersion = PremintConfigVersion.V1,
+  >({
+    creatorAccount,
     collection,
-    token,
+    tokenCreationConfig,
+    premintConfigVersion,
     walletClient,
-    executionSettings,
+    uid,
     checkSignature = false,
   }: {
-    account: Address;
+    creatorAccount: Address;
     checkSignature?: boolean;
     walletClient: WalletClient;
-    collection: PremintSignatureGetResponse["collection"];
-    token: MintArgumentsSettings;
-    executionSettings?: {
-      deleted?: boolean;
-      uid?: number;
+    collection: ContractCreationConfig;
+    tokenCreationConfig: Partial<TokenConfigForVersion<T>> & {
+      tokenURI: string;
     };
+    premintConfigVersion?: T;
+    uid?: number;
   }) {
     const newContractAddress = await getPremintCollectionAddress({
       publicClient: this.publicClient,
-      collection: convertCollection(collection),
+      collection,
     });
 
-    const tokenConfig = {
-      ...DefaultMintArguments,
-      fixedPriceMinter: this.getFixedPriceMinterAddress(),
-      royaltyRecipient: account,
-      ...token,
-    };
+    let uidToUse = uid;
 
-    let uid = executionSettings?.uid;
-    if (!uid) {
-      const uidResponse = await this.apiClient.getNextUID({
-        collection_address: newContractAddress.toLowerCase(),
-      });
-      uid = uidResponse.next_uid;
+    if (typeof uidToUse !== "number") {
+      uidToUse = await this.apiClient.getNextUID(newContractAddress);
     }
 
-    if (!uid) {
-      throw new Error("UID is missing but required");
-    }
+    const actualVersion = premintConfigVersion || PremintConfigVersion.V1;
 
-    let deleted = executionSettings?.deleted || false;
+    if (
+      !(await supportsPremintVersion({
+        version: actualVersion,
+        publicClient: this.publicClient,
+        tokenContract: newContractAddress,
+      }))
+    ) {
+      throw new Error(
+        `Premint version ${actualVersion} not supported by contract`,
+      );
+    }
 
-    const premintConfig: PremintConfigV1 = {
-      tokenConfig: tokenConfig,
-      uid,
-      version: 1,
-      deleted,
-    };
+    const premintConfig = makeNewPremint({
+      tokenConfig: makeTokenConfigWithDefaults({
+        premintConfigVersion: actualVersion,
+        tokenCreationConfig,
+        creatorAccount,
+      }),
+      uid: uidToUse,
+    });
 
     return await this.signAndSubmitPremint({
-      uid,
       verifyingContract: newContractAddress,
       premintConfig,
-      premintConfigVersion: PremintConfigVersion.V1,
+      premintConfigVersion: actualVersion,
       checkSignature,
-      account,
+      account: creatorAccount,
       walletClient,
       collection,
     });
@@ -494,15 +389,15 @@ class PremintClient {
    * @param uid UID for the desired premint
    * @returns PremintSignatureGetResponse of premint data from the API
    */
-  async getPremintData({
+  async getPremintSignature({
     address,
     uid,
   }: {
-    address: string;
+    address: Address;
     uid: number;
-  }): Promise<PremintSignatureGetResponse> {
+  }) {
     return await this.apiClient.getSignature({
-      collection_address: address,
+      collectionAddress: address,
       uid,
     });
   }
@@ -525,21 +420,27 @@ class PremintClient {
    * @param data Signature data from the API
    * @returns isValid = signature is valid or not, recoveredSigner = signer from contract
    */
-  async isValidSignature({
+  async isValidSignature<T extends PremintConfigVersion>({
     signature,
-    premint,
     collection,
-  }: PremintSignatureResponse): Promise<{
+    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,
-      premintConfig: convertPremintV1(premint),
-      premintConfigVersion: PremintConfigVersion.V1,
-      collection: convertCollection(collection),
+      collection: collection,
       publicClient: this.publicClient,
+      premintConfig,
+      premintConfigVersion: premintConfigVersion || PremintConfigVersion.V1,
     });
 
     return { isValid: isAuthorized, recoveredSigner: recoveredAddress };
@@ -554,29 +455,29 @@ class PremintClient {
     tokenId?: bigint;
     address?: Address;
   }): URLSReturnType {
-    if ((!uid || !tokenId) && !address) {
-      return { explorer: null, zoraCollect: null, zoraManage: null };
-    }
-
-    const zoraTokenPath = uid ? `premint-${uid}` : tokenId;
-
-    const network = getApiNetworkConfigForChain(this.chain.id);
+    return makeUrls({
+      uid,
+      address,
+      tokenId,
+      chain: this.chain,
+    });
+  }
 
-    return {
-      explorer: tokenId
-        ? `https://${this.chain.blockExplorers?.default.url}/token/${address}/instance/${tokenId}`
-        : null,
-      zoraCollect: `https://${
-        network.isTestnet ? "testnet." : ""
-      }zora.co/collect/${
-        network.zoraPathChainName
-      }:${address}/${zoraTokenPath}`,
-      zoraManage: `https://${
-        network.isTestnet ? "testnet." : ""
-      }zora.co/collect/${
-        network.zoraPathChainName
-      }:${address}/${zoraTokenPath}`,
-    };
+  async getMintCosts({
+    tokenContract,
+    quantityToMint,
+    tokenCreationConfig,
+  }: {
+    quantityToMint: bigint;
+    tokenContract: Address;
+    tokenCreationConfig: TokenCreationConfig;
+  }): Promise<MintCosts> {
+    return await getPremintMintCosts({
+      publicClient: this.publicClient,
+      quantityToMint,
+      tokenContract,
+      tokenPrice: tokenCreationConfig.pricePerToken,
+    });
   }
 
   /**
@@ -592,54 +493,98 @@ class PremintClient {
    * @returns receipt, log, zoraURL
    */
   async makeMintParameters({
-    data,
+    uid,
+    tokenContract,
     account,
     mintArguments,
   }: {
-    data: PremintSignatureGetResponse;
+    uid: number;
+    tokenContract: Address;
     account: Account | Address;
     mintArguments?: {
       quantityToMint: number;
       mintComment?: string;
+      mintReferral?: Address;
+      platformReferral?: Address;
+      mintRecipient?: Address;
     };
-  }): Promise<
-    SimulateContractParameters<
-      typeof zoraCreator1155PremintExecutorImplABI,
-      "premint"
-    >
-  > {
+  }): Promise<SimulateContractParameters> {
     if (mintArguments && mintArguments?.quantityToMint < 1) {
       throw new Error("Quantity to mint cannot be below 1");
     }
 
-    const numberToMint = BigInt(mintArguments?.quantityToMint || 1);
-    const args = [
-      convertCollection(data.collection),
-      convertPremintV1(data.premint),
-      data.signature as Hex,
-      numberToMint,
-      mintArguments?.mintComment || "",
-    ] as const;
-
     if (!account) {
       throw new Error("Wallet not passed in");
     }
 
-    const value = numberToMint * REWARD_PER_TOKEN;
+    const { premintConfig, premintConfigVersion, collection, signature } =
+      await this.getPremintSignature({
+        address: tokenContract,
+        uid,
+      });
 
-    const request = {
-      account,
-      abi: zoraCreator1155PremintExecutorImplABI,
-      functionName: "premint",
-      value,
-      address: getPremintExecutorAddress(),
-      args,
-    } satisfies SimulateContractParameters<
-      typeof zoraCreator1155PremintExecutorImplABI,
-      "premint"
-    >;
-
-    return request;
+    const numberToMint = BigInt(mintArguments?.quantityToMint || 1);
+
+    const value = (
+      await getPremintMintCosts({
+        tokenContract,
+        quantityToMint: numberToMint,
+        publicClient: this.publicClient,
+        tokenPrice: premintConfig.tokenConfig.pricePerToken,
+      })
+    ).totalCost;
+
+    if (premintConfigVersion === PremintConfigVersion.V1) {
+      return {
+        account,
+        abi: zoraCreator1155PremintExecutorImplABI,
+        functionName: "premint",
+        value,
+        address: getPremintExecutorAddress(),
+        args: [
+          collection,
+          premintConfig,
+          signature,
+          numberToMint,
+          mintArguments?.mintComment || "",
+        ],
+      } satisfies SimulateContractParameters<
+        typeof zoraCreator1155PremintExecutorImplABI,
+        "premint"
+      >;
+    } else if (premintConfigVersion === PremintConfigVersion.V2) {
+      const toPost = premintConfig as PremintConfigV2;
+      const accountAddress =
+        typeof account === "string" ? account : account.address;
+
+      return {
+        account,
+        abi: zoraCreator1155PremintExecutorImplABI,
+        functionName: "premintV2",
+        value,
+        address: getPremintExecutorAddress(),
+        // args are:  ContractCreationConfig calldata contractConfig, PremintConfigV2 calldata premintConfig, bytes calldata signature, uint256 quantityToMint, MintArguments calldata mintArguments
+        args: [
+          collection,
+          toPost,
+          signature,
+          numberToMint,
+          {
+            mintComment: mintArguments?.mintComment || "",
+            mintRecipient: mintArguments?.mintRecipient || accountAddress,
+            mintRewardsRecipients: makeMintRewardsRecipient({
+              mintReferral: mintArguments?.mintReferral,
+              platformReferral: mintArguments?.platformReferral,
+            }),
+          },
+        ],
+      } satisfies SimulateContractParameters<
+        typeof zoraCreator1155PremintExecutorImplABI,
+        "premintV2"
+      >;
+    }
+
+    throw new Error(`Invalid premint config version ${premintConfigVersion}`);
   }
 }
 
@@ -654,3 +599,104 @@ export function createPremintClient({
 }) {
   return new PremintClient(chain, publicClient, httpClient);
 }
+
+function makeUrls({
+  uid,
+  address,
+  tokenId,
+  chain,
+}: {
+  uid?: number;
+  tokenId?: bigint;
+  address?: Address;
+  chain: Chain;
+}): URLSReturnType {
+  if ((!uid || !tokenId) && !address) {
+    return { explorer: null, zoraCollect: null, zoraManage: null };
+  }
+
+  const zoraTokenPath = uid ? `premint-${uid}` : tokenId;
+
+  const network = getApiNetworkConfigForChain(chain.id);
+
+  return {
+    explorer: tokenId
+      ? `https://${chain.blockExplorers?.default.url}/token/${address}/instance/${tokenId}`
+      : null,
+    zoraCollect: `https://${
+      network.isTestnet ? "testnet." : ""
+    }zora.co/collect/${network.zoraPathChainName}:${address}/${zoraTokenPath}`,
+    zoraManage: `https://${
+      network.isTestnet ? "testnet." : ""
+    }zora.co/collect/${network.zoraPathChainName}:${address}/${zoraTokenPath}`,
+  };
+}
+
+type SignAndSubmitPremintParams<T extends PremintConfigVersion> = {
+  walletClient: WalletClient;
+  verifyingContract: Address;
+  checkSignature: boolean;
+  account?: Address | Account;
+  collection: ContractCreationConfig;
+} & PremintConfigWithVersion<T>;
+
+async function signAndSubmitPremint<T extends PremintConfigVersion>({
+  walletClient,
+  verifyingContract,
+  account,
+  checkSignature,
+  collection,
+  chainId,
+  publicClient,
+  apiClient,
+  ...premintConfigAndVersion
+}: SignAndSubmitPremintParams<T> & {
+  chainId: number;
+  publicClient: PublicClient;
+  apiClient: PremintAPIClient;
+}) {
+  if (!account) {
+    account = walletClient.account;
+  }
+  if (!account) {
+    throw new Error("No account provided");
+  }
+
+  const signature = await walletClient.signTypedData({
+    account,
+    ...premintTypedDataDefinition({
+      verifyingContract,
+      ...premintConfigAndVersion,
+      chainId,
+    }),
+  });
+
+  if (checkSignature) {
+    const isAuthorized = await isAuthorizedToCreatePremint({
+      collection,
+      signature,
+      publicClient,
+      signer: typeof account === "string" ? account : account.address,
+      collectionAddress: await getPremintCollectionAddress({
+        collection,
+        publicClient,
+      }),
+      ...premintConfigAndVersion,
+    });
+    if (!isAuthorized) {
+      throw new Error("Not authorized to create premint");
+    }
+  }
+
+  const premint = await apiClient.postSignature({
+    collection: collection,
+    signature: signature,
+    ...premintConfigAndVersion,
+  });
+
+  return { premint, verifyingContract };
+}
+
+function getDefaultFixedPriceMinterAddress() {
+  return zoraCreatorFixedPriceSaleStrategyAddress[999];
+}