@zoralabs/protocol-sdk 0.5.15 → 0.5.17

package/src/premint/premint-client.ts

@@ -1,14 +1,20 @@
-import { createPublicClient, decodeEventLog, http, zeroAddress } from "viem";
+import { decodeEventLog, zeroAddress } from "viem";
 import type {
   Account,
   Address,
   Chain,
   Hex,
-  PublicClient,
+  SimulateContractParameters,
   TransactionReceipt,
+  TypedDataDefinition,
   WalletClient,
 } from "viem";
-import { zoraCreator1155PremintExecutorImplABI } from "@zoralabs/protocol-deployments";
+import {
+  PremintConfigAndVersion,
+  TokenConfigWithVersion,
+  encodePremintConfig,
+  zoraCreator1155PremintExecutorImplABI,
+} from "@zoralabs/protocol-deployments";
 import {
   getPremintCollectionAddress,
   isValidSignature,
@@ -16,15 +22,17 @@ import {
   getPremintExecutorAddress,
   applyUpdateToPremint,
   makeNewPremint,
-  supportsPremintVersion,
+  supportedPremintVersions,
   getPremintMintCosts,
   makeMintRewardsRecipient,
   getDefaultFixedPriceMinterAddress,
+  emptyContractCreationConfig,
+  defaultAdditionalAdmins,
+  toContractCreationConfigOrAddress,
 } from "./preminter";
 import {
   PremintConfigVersion,
   ContractCreationConfig,
-  TokenConfigForVersion,
   TokenCreationConfigV1,
   TokenCreationConfigV2,
   TokenCreationConfig,
@@ -39,7 +47,16 @@ import { OPEN_EDITION_MINT_SIZE } from "../constants";
 import { IHttpClient } from "src/apis/http-api-base";
 import { getApiNetworkConfigForChain } from "src/mint/mint-api-client";
 import { MintCosts } from "src/mint/mint-client";
-import { makeSimulateContractParamaters } from "src/utils";
+import {
+  ClientConfig,
+  makeSimulateContractParamaters,
+  PublicClient,
+  setupClient,
+} from "src/utils";
+import {
+  ContractCreationConfigAndAddress,
+  ContractCreationConfigOrAddress,
+} from "./contract-types";
 
 type PremintedV2LogType = DecodeEventLogReturnType<
   typeof zoraCreator1155PremintExecutorImplABI,
@@ -52,12 +69,6 @@ type URLSReturnType = {
   zoraManage: null | string;
 };
 
-type SignedPremintResponse = {
-  urls: URLSReturnType;
-  uid: number;
-  verifyingContract: Address;
-};
-
 export const defaultTokenConfigV1MintArguments = (): Omit<
   TokenCreationConfigV1,
   "fixedPriceMinter" | "tokenURI" | "royaltyRecipient"
@@ -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,
-  creatorAccount,
+  supportedPremintVersions,
 }: {
   chainId: number;
-  premintConfigVersion: T;
-  tokenCreationConfig: Partial<TokenConfigForVersion<T>> & { tokenURI: string };
-  creatorAccount: 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: creatorAccount,
-      ...(tokenCreationConfig as Partial<TokenCreationConfigV1>),
-    } as TokenCreationConfigV1;
-  } else if (premintConfigVersion === PremintConfigVersion.V2) {
     return {
-      fixedPriceMinter,
-      ...defaultTokenConfigV2MintArguments(),
-      payoutRecipient: creatorAccount,
-      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,
+    ),
+  };
 };
 
 /**
@@ -149,7 +208,6 @@ export function getPremintedLogFromReceipt(
 }
 /**
  * Preminter API to access ZORA Premint functionality.
- * Currently only supports V1 premints.
  */
 class PremintClient {
   readonly apiClient: PremintAPIClient;
@@ -158,13 +216,12 @@ class PremintClient {
 
   constructor(
     chain: Chain,
-    publicClient?: PublicClient,
-    httpClient?: IHttpClient,
+    publicClient: PublicClient,
+    httpClient: IHttpClient,
   ) {
     this.chain = chain;
     this.apiClient = new PremintAPIClient(chain.id, httpClient);
-    this.publicClient =
-      publicClient || createPublicClient({ chain, transport: http() });
+    this.publicClient = publicClient;
   }
 
   getDataFromPremintReceipt(receipt: TransactionReceipt) {
@@ -179,219 +236,51 @@ class PremintClient {
   }
 
   /**
-   * Update existing premint given collection address and UID of existing premint.
-   *
-   * 1. Loads existing premint token
-   * 2. Updates with settings passed into function
-   * 3. Increments the version field
-   * 4. Re-signs the premint
-   * 5. Uploads the premint to the ZORA API
-   *
-   * Updates existing premint
-   * @param settings Settings for the new premint
-   * @param settings.account Account to sign the premint update from. Taken from walletClient if none passed in.
-   * @param settings.collection Collection information for the mint
-   * @param settings.walletClient viem wallet client to use to sign
-   * @param settings.uid UID
-   * @param settings.token Mint argument settings, optional settings are overridden with sensible defaults.
-   *
-   */
-  async updatePremint({
-    walletClient,
-    uid,
-    collection,
-    account,
-    tokenConfigUpdates,
-  }: {
-    walletClient: WalletClient;
-    uid: number;
-    account?: Account | Address;
-    collection: Address;
-    tokenConfigUpdates: Partial<TokenCreationConfig>;
-  }): Promise<SignedPremintResponse> {
-    const {
-      premintConfig,
-      collection: collectionCreationConfig,
-      premintConfigVersion,
-    } = await this.apiClient.getSignature({
-      collectionAddress: collection,
-      uid: uid,
-    });
-
-    const updatedPremint = applyUpdateToPremint({
-      uid: premintConfig.uid,
-      version: premintConfig.version,
-      tokenConfig: premintConfig.tokenConfig,
-      tokenConfigUpdates: tokenConfigUpdates,
-    });
-
-    return await this.signAndSubmitPremint({
-      walletClient,
-      account,
-      checkSignature: true,
-      verifyingContract: collection,
-      collection: collectionCreationConfig,
-      premintConfig: updatedPremint,
-      premintConfigVersion: premintConfigVersion,
-    });
-  }
-
-  /**
-   * Delete premint.
-   *
-   * 1. Loads current premint from collection address with UID
-   * 2. Increments version and marks as deleted
-   * 3. Signs new premint version
-   * 4. Sends to ZORA Premint API
-   *
-   * Deletes existing premint
-   * @param settings.collection collection address
-   * @param settings.uid UID
-   * @param settings.walletClient viem wallet client to use to sign
+   * Prepares data for updating a premint
    *
+   * @param parameters - Parameters for updating the premint {@link UpdatePremintParams}
+   * @returns A PremintReturn. {@link PremintReturn}
    */
-  async deletePremint({
-    walletClient,
-    uid,
-    account,
-    collection,
-  }: {
-    walletClient: WalletClient;
-    uid: number;
-    account?: Account | Address;
-    collection: Address;
-  }) {
-    const {
-      premintConfig,
-      premintConfigVersion,
-      collection: collectionCreationConfig,
-    } = await this.apiClient.getSignature({
-      collectionAddress: collection,
-      uid: uid,
-    });
-
-    const deletedPremint = {
-      ...premintConfig,
-      version: premintConfig.version + 1,
-      deleted: true,
-    };
-
-    return await this.signAndSubmitPremint({
-      walletClient,
-      account,
-      checkSignature: false,
-      verifyingContract: collection,
-      collection: collectionCreationConfig,
-      premintConfig: deletedPremint,
-      premintConfigVersion,
+  async updatePremint(args: UpdatePremintParams): Promise<PremintReturn<any>> {
+    return await updatePremint({
+      ...args,
+      apiClient: this.apiClient,
+      publicClient: this.publicClient,
+      chainId: this.chain.id,
     });
   }
 
   /**
-   * Internal function to sign and submit a premint request.
+   * Prepares data for deleting a premint
    *
-   * @param premintArguments Arguments to premint
-   * @returns
+   * @param parameters - Parameters for deleting the premint {@link DeletePremintParams}
+   * @returns A PremintReturn. {@link PremintReturn}
    */
-  private async signAndSubmitPremint<T extends PremintConfigVersion>(
-    params: SignAndSubmitPremintParams<T>,
-  ): Promise<SignedPremintResponse> {
-    const { verifyingContract } = await signAndSubmitPremint({
+  async deletePremint(
+    params: DeletePremintParams,
+  ): Promise<PremintReturn<any>> {
+    return deletePremint({
       ...params,
-      chainId: this.chain.id,
       apiClient: this.apiClient,
       publicClient: this.publicClient,
+      chainId: this.chain.id,
     });
-
-    const uid = params.premintConfig.uid;
-
-    return {
-      urls: this.makeUrls({ address: verifyingContract, uid }),
-      uid,
-      verifyingContract,
-    };
   }
 
   /**
-   * Create premint
+   * Prepares data for creating a premint
    *
-   * @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.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
+   * @param parameters - Parameters for creating the premint {@link CreatePremintParameters}
+   * @returns A PremintReturn. {@link PremintReturn}
    */
-  async createPremint<
-    T extends PremintConfigVersion = PremintConfigVersion.V2,
-  >({
-    creatorAccount,
-    collection,
-    tokenCreationConfig,
-    premintConfigVersion,
-    walletClient,
-    uid,
-    checkSignature = false,
-  }: {
-    creatorAccount: Address | Account;
-    checkSignature?: boolean;
-    walletClient: WalletClient;
-    collection: ContractCreationConfig;
-    tokenCreationConfig: Partial<TokenConfigForVersion<T>> & {
-      tokenURI: string;
-    };
-    premintConfigVersion?: T;
-    uid?: number;
-  }) {
-    const newContractAddress = await getPremintCollectionAddress({
+  async createPremint(
+    parameters: CreatePremintParameters,
+  ): Promise<PremintReturn<any>> {
+    return createPremint({
+      ...parameters,
       publicClient: this.publicClient,
-      collection,
-    });
-
-    let uidToUse = uid;
-
-    if (typeof uidToUse !== "number") {
-      uidToUse = await this.apiClient.getNextUID(newContractAddress);
-    }
-
-    const actualVersion = premintConfigVersion || PremintConfigVersion.V1;
-
-    if (
-      !(await supportsPremintVersion({
-        version: actualVersion,
-        publicClient: this.publicClient,
-        tokenContract: newContractAddress,
-      }))
-    ) {
-      throw new Error(
-        `Premint version ${actualVersion} not supported by contract`,
-      );
-    }
-
-    const premintConfig = makeNewPremint({
-      tokenConfig: makeTokenConfigWithDefaults({
-        // @ts-ignore
-        premintConfigVersion: actualVersion,
-        tokenCreationConfig,
-        creatorAccount:
-          typeof creatorAccount === "string"
-            ? creatorAccount
-            : creatorAccount.address,
-        chainId: this.chain.id,
-      }),
-      uid: uidToUse,
-    });
-
-    return await this.signAndSubmitPremint({
-      verifyingContract: newContractAddress,
-      premintConfig,
-      premintConfigVersion: actualVersion,
-      checkSignature,
-      account: creatorAccount,
-      walletClient,
-      collection,
+      apiClient: this.apiClient,
+      chainId: this.chain.id,
     });
   }
 
@@ -435,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 };
@@ -494,125 +388,499 @@ class PremintClient {
   }
 
   /**
-   * Execute premint on-chain
+   * Prepares the parameters to collect a premint; it brings the contract and token onchain, then collects
+   * tokens on that contract for the mint recipient.
    *
-   * @param settings.data Data from the API for the mint
-   * @param settings.account Optional account (if omitted taken from wallet client) for the account executing the premint.
-   * @param settings.walletClient WalletClient to send execution from.
-   * @param settings.mintArguments User minting arguments.
-   * @param settings.mintArguments.quantityToMint Quantity to mint, optional, defaults to 1.
-   * @param settings.mintArguments.mintComment Optional mint comment, optional, omits when not included.
-   * @param settings.publicClient Optional public client for preflight checks.
+   * @param parameters - Parameters for collecting the Premint {@link MakeMintParametersArguments}
    * @returns receipt, log, zoraURL
    */
-  async makeMintParameters({
-    uid,
-    tokenContract,
-    minterAccount,
-    mintArguments,
-  }: {
-    uid: number;
-    tokenContract: Address;
-    minterAccount: Account | Address;
-    mintArguments?: {
-      quantityToMint: number;
-      mintComment?: string;
-      mintReferral?: Address;
-      platformReferral?: Address;
-      mintRecipient?: Address;
-    };
-  }) {
-    if (mintArguments && mintArguments?.quantityToMint < 1) {
-      throw new Error("Quantity to mint cannot be below 1");
-    }
+  async makeMintParameters(parameters: MakeMintParametersArguments) {
+    return await makeMintParameters({
+      ...parameters,
+      apiClient: this.apiClient,
+      publicClient: this.publicClient,
+    });
+  }
+}
 
-    if (!minterAccount) {
-      throw new Error("Wallet not passed in");
-    }
+export function createPremintClient(clientConfig: ClientConfig) {
+  const { chain, httpClient, publicClient } = setupClient(clientConfig);
+  return new PremintClient(chain, publicClient, httpClient);
+}
 
-    const { premintConfig, premintConfigVersion, collection, signature } =
-      await this.getPremintSignature({
-        address: tokenContract,
-        uid,
-      });
+type PremintContext = {
+  publicClient: PublicClient;
+  apiClient: PremintAPIClient;
+  chainId: number;
+};
 
-    const numberToMint = BigInt(mintArguments?.quantityToMint || 1);
+/** ======= ADMIN ======= */
 
-    if (premintConfigVersion === PremintConfigVersion.V3) {
-      throw new Error("PremintV3 not supported in premint SDK");
-    }
+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;
+};
 
-    const value = (
-      await getPremintMintCosts({
-        tokenContract,
-        quantityToMint: numberToMint,
-        publicClient: this.publicClient,
-        tokenPrice: premintConfig.tokenConfig.pricePerToken,
-      })
-    ).totalCost;
-
-    const mintArgumentsContract: PremintMintArguments = {
-      mintComment: mintArguments?.mintComment || "",
-      mintRecipient:
-        mintArguments?.mintRecipient ||
-        (typeof minterAccount === "string"
-          ? minterAccount
-          : minterAccount.address),
-      mintRewardsRecipients: makeMintRewardsRecipient({
-        mintReferral: mintArguments?.mintReferral,
-        platformReferral: mintArguments?.platformReferral,
-      }),
+export type SignAndSubmitReturn = {
+  /** The signature of the Premint  */
+  signature: Hex;
+  /** The account that signed the Premint */
+  signerAccount: 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;
+};
+
+type PremintReturn<T extends PremintConfigVersion> = {
+  /** The typedDataDefinition of the Premint which is to be signed the creator. */
+  typedDataDefinition: TypedDataDefinition;
+  /** The deterministic collection address of the Premint */
+  collectionAddress: Address;
+  /** Signs the Premint, and submits it and the signature to the Zora Premint API */
+  signAndSubmit: (params: SignAndSubmitParams) => Promise<SignAndSubmitReturn>;
+  /** For the case where the premint is signed externally, takes the signature for the Premint, and submits it and the Premint to the Zora Premint API */
+  submit: (params: SubmitParams) => void;
+} & PremintConfigWithVersion<T>;
+
+function makePremintReturn<T extends PremintConfigVersion>({
+  premintConfig,
+  premintConfigVersion,
+  publicClient,
+  apiClient,
+  chainId,
+  ...collectionAndAddress
+}: PremintConfigWithVersion<T> &
+  ContractCreationConfigAndAddress &
+  PremintContext): PremintReturn<T> {
+  const { collection, collectionAddress } = collectionAndAddress;
+  const typedDataDefinition = premintTypedDataDefinition({
+    verifyingContract: collectionAddress,
+    premintConfig,
+    premintConfigVersion,
+    chainId,
+  });
+
+  const signAndSubmit = async ({
+    walletClient,
+    account,
+    checkSignature,
+  }: SignAndSubmitParams): Promise<SignAndSubmitReturn> => {
+    const { signature, signerAccount } = await signPremint({
+      account,
+      walletClient,
+      typedDataDefinition,
+    });
+
+    await submit({
+      signature,
+      checkSignature,
+      signerAccount,
+    });
+
+    return {
+      signature,
+      signerAccount,
     };
+  };
 
-    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,
-          premintConfig,
-          signature,
-          numberToMint,
-          mintArgumentsContract,
-        ],
+  const submit = async ({
+    signature,
+    checkSignature,
+    signerAccount,
+  }: {
+    signature: Hex;
+    checkSignature?: boolean;
+    signerAccount: Account | Address;
+  }) => {
+    if (checkSignature) {
+      const isAuthorized = await isAuthorizedToCreatePremint({
+        collectionAddress,
+        additionalAdmins: collection?.additionalAdmins,
+        contractAdmin: collection?.contractAdmin,
+        publicClient,
+        signer: signerAccount,
       });
+
+      if (!isAuthorized) {
+        throw new Error("Not authorized to create premint");
+      }
     }
 
-    throw new Error(`Invalid premint config version ${premintConfigVersion}`);
+    await apiClient.postSignature({
+      ...toContractCreationConfigOrAddress(collectionAndAddress),
+      signature: signature,
+      premintConfig,
+      premintConfigVersion,
+    });
+  };
+
+  return {
+    premintConfig,
+    premintConfigVersion,
+    typedDataDefinition,
+    collectionAddress,
+    signAndSubmit,
+    submit,
+  };
+}
+
+async function signPremint({
+  account,
+  walletClient,
+  typedDataDefinition,
+}: {
+  /** The account that is to sign the premint */
+  account?: Address | Account;
+  /** WalletClient used to sign the premint */
+  walletClient: WalletClient;
+  /** Data  */
+  typedDataDefinition: TypedDataDefinition;
+}) {
+  if (!account) {
+    account = walletClient.account;
   }
+  if (!account) {
+    throw new Error("No account provided");
+  }
+
+  const signature = await walletClient.signTypedData({
+    account,
+    ...typedDataDefinition,
+  });
+
+  return {
+    signature,
+    signerAccount: account,
+  };
 }
 
-export function createPremintClient({
-  chain,
-  httpClient,
+/** CREATE */
+
+type CreatePremintParameters = {
+  /** tokenCreationConfig Token creation settings, optional settings are overridden with sensible defaults */
+  tokenCreationConfig: TokenConfigInput;
+  /** uid the UID to use – optional and retrieved as a fresh UID from ZORA by default. */
+  uid?: number;
+} & ContractCreationConfigOrAddress;
+
+async function createPremint({
+  tokenCreationConfig,
+  uid,
   publicClient,
+  apiClient,
+  chainId,
+  ...collectionOrAddress
+}: CreatePremintParameters & PremintContext) {
+  const {
+    premintConfig,
+    premintConfigVersion,
+    collectionAddress: collectionAddressToUse,
+  } = await prepareCreatePremintConfig({
+    ...collectionOrAddress,
+    tokenCreationConfig,
+    uid,
+    publicClient,
+    apiClient,
+    chainId,
+  });
+
+  return makePremintReturn({
+    premintConfig,
+    premintConfigVersion,
+    collectionAddress: collectionAddressToUse,
+    collection: collectionOrAddress.collection,
+    publicClient,
+    apiClient,
+    chainId,
+  });
+}
+
+type PreparePremintReturn = {
+  collectionAddress: Address;
+} & PremintConfigAndVersion;
+
+async function prepareCreatePremintConfig({
+  tokenCreationConfig,
+  uid,
+  publicClient,
+  apiClient,
+  chainId,
+  ...collectionOrAddress
 }: {
-  chain: Chain;
-  publicClient?: PublicClient;
-  httpClient?: IHttpClient;
+  tokenCreationConfig: TokenConfigInput;
+  uid?: number;
+} & PremintContext &
+  ContractCreationConfigOrAddress): Promise<PreparePremintReturn> {
+  const newContractAddress = await getPremintCollectionAddress({
+    publicClient,
+    ...collectionOrAddress,
+  });
+
+  let uidToUse = uid;
+
+  if (typeof uidToUse !== "number") {
+    uidToUse = await apiClient.getNextUID(newContractAddress);
+  }
+
+  const supportedVersions = await supportedPremintVersions({
+    tokenContract: newContractAddress,
+    publicClient,
+  });
+
+  const tokenConfigAndVersion = makeTokenConfigWithDefaults({
+    tokenCreationConfig,
+    chainId,
+    supportedPremintVersions: supportedVersions,
+  });
+
+  const premintConfig = makeNewPremint({
+    ...tokenConfigAndVersion,
+    uid: uidToUse,
+  });
+
+  const premintConfigAndVersion = {
+    premintConfig,
+    premintConfigVersion: tokenConfigAndVersion.premintConfigVersion,
+  } as PremintConfigAndVersion;
+
+  return {
+    ...premintConfigAndVersion,
+    collectionAddress: newContractAddress,
+  };
+}
+
+/** UPDATE */
+
+export type UpdatePremintParams = {
+  /** uid of the Premint to update */
+  uid: number;
+  /** address of the Premint to update */
+  collection: Address;
+  /** update to apply to the Premint */
+  tokenConfigUpdates: Partial<TokenCreationConfig>;
+};
+
+async function updatePremint({
+  uid,
+  collection,
+  tokenConfigUpdates,
+  apiClient,
+  publicClient,
+  chainId,
+}: UpdatePremintParams & {
+  apiClient: PremintAPIClient;
+  publicClient: PublicClient;
+  chainId: number;
 }) {
-  return new PremintClient(chain, publicClient, httpClient);
+  const {
+    premintConfig,
+    collection: collectionCreationConfig,
+    premintConfigVersion,
+  } = await apiClient.getSignature({
+    collectionAddress: collection,
+    uid: uid,
+  });
+
+  const updatedPremint = applyUpdateToPremint({
+    uid: premintConfig.uid,
+    version: premintConfig.version,
+    tokenConfig: premintConfig.tokenConfig,
+    tokenConfigUpdates: tokenConfigUpdates,
+  });
+
+  return makePremintReturn({
+    premintConfig: updatedPremint,
+    premintConfigVersion,
+    collectionAddress: collection,
+    collection: collectionCreationConfig,
+    publicClient,
+    apiClient,
+    chainId,
+  });
+}
+
+/** DELETE */
+
+export type DeletePremintParams = {
+  /** id of the premint to delete */
+  uid: number;
+  /** collection address of the Premint to delete */
+  collection: Address;
+};
+
+async function deletePremint({
+  uid,
+  collection,
+  publicClient,
+  apiClient,
+  chainId,
+}: DeletePremintParams & {
+  apiClient: PremintAPIClient;
+  publicClient: PublicClient;
+  chainId: number;
+}) {
+  const {
+    premintConfig,
+    premintConfigVersion,
+    collection: collectionCreationConfig,
+    collectionAddress,
+  } = await apiClient.getSignature({
+    collectionAddress: collection,
+    uid: uid,
+  });
+
+  const deletedPremint = {
+    ...premintConfig,
+    version: premintConfig.version + 1,
+    deleted: true,
+  };
+
+  return makePremintReturn({
+    premintConfig: deletedPremint,
+    premintConfigVersion,
+    collectionAddress,
+    collection: collectionCreationConfig,
+    publicClient,
+    apiClient,
+    chainId,
+  });
+}
+
+export type MakeMintParametersArguments = {
+  /** uid of the Premint to mint */
+  uid: number;
+  /** Premint contract address */
+  tokenContract: Address;
+  /** Account to execute the mint */
+  minterAccount: Account | Address;
+  /** Minting settings */
+  mintArguments?: {
+    /** Quantity of tokens to mint */
+    quantityToMint: number;
+    /** Comment to add to the mint */
+    mintComment?: string;
+    /** Address to receive the mint referral reward */
+    mintReferral?: Address;
+    /** 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({
+  uid,
+  tokenContract,
+  minterAccount,
+  mintArguments,
+  firstMinter,
+  apiClient,
+  publicClient,
+}: MakeMintParametersArguments & {
+  apiClient: PremintAPIClient;
+  publicClient: PublicClient;
+}): Promise<
+  SimulateContractParameters<
+    typeof zoraCreator1155PremintExecutorImplABI,
+    "premintV1" | "premintV2",
+    any,
+    any,
+    any,
+    Account | Address
+  >
+> {
+  if (mintArguments && mintArguments?.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,
+    collectionAddress,
+    signature,
+  } = await apiClient.getSignature({
+    collectionAddress: tokenContract,
+    uid,
+  });
+
+  const numberToMint = BigInt(mintArguments?.quantityToMint || 1);
+
+  if (premintConfigVersion === PremintConfigVersion.V3) {
+    throw new Error("PremintV3 not supported in premint SDK");
+  }
+
+  const value = (
+    await getPremintMintCosts({
+      tokenContract,
+      quantityToMint: numberToMint,
+      publicClient,
+      tokenPrice: premintConfig.tokenConfig.pricePerToken,
+    })
+  ).totalCost;
+
+  const mintArgumentsContract: PremintMintArguments = {
+    mintComment: mintArguments?.mintComment || "",
+    mintRecipient:
+      mintArguments?.mintRecipient ||
+      (typeof minterAccount === "string"
+        ? minterAccount
+        : minterAccount.address),
+    mintRewardsRecipients: makeMintRewardsRecipient({
+      mintReferral: mintArguments?.mintReferral,
+    }),
+  };
+
+  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,
+        premintConfigVersion,
+      }),
+      signature,
+      numberToMint,
+      mintArgumentsContract,
+      firstMinterToSubmit,
+      zeroAddress,
+    ],
+  });
 }
 
-function makeUrls({
+export function makeUrls({
   uid,
   address,
   tokenId,
@@ -647,66 +915,3 @@ function makeUrls({
     }:${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,
-      publicClient,
-      signer: typeof account === "string" ? account : account.address,
-      collectionAddress: await getPremintCollectionAddress({
-        collection,
-        publicClient,
-      }),
-    });
-    if (!isAuthorized) {
-      throw new Error("Not authorized to create premint");
-    }
-  }
-
-  const premint = await apiClient.postSignature({
-    collection: collection,
-    signature: signature,
-    ...premintConfigAndVersion,
-  });
-
-  return { premint, verifyingContract };
-}