@zoralabs/protocol-sdk 0.5.14 → 0.5.16

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/premint/premint-client.ts
-import { createPublicClient, decodeEventLog, http, zeroAddress as zeroAddress2 } from "viem";
+import { decodeEventLog, zeroAddress as zeroAddress2 } from "viem";
 import { zoraCreator1155PremintExecutorImplABI as zoraCreator1155PremintExecutorImplABI2 } from "@zoralabs/protocol-deployments";
 
 // src/premint/preminter.ts
@@ -26,6 +26,8 @@ async function isAuthorizedToCreatePremint({
   publicClient,
   signer
 }) {
+  if (collection.additionalAdmins.length > 0)
+    throw new Error("additionalAdmins not supported yet.");
   return await publicClient.readContract({
     abi: preminterAbi,
     address: getPremintExecutorAddress(),
@@ -331,6 +333,41 @@ var zora721Abi = parseAbi([
   "function mintWithRewards(address recipient, uint256 quantity, string calldata comment, address mintReferral) external payable",
   "function zoraFeeForAmount(uint256 amount) public view returns (address, uint256)"
 ]);
+var NFT_SALE_QUERY = `
+fragment SaleStrategy on SalesStrategyConfig {
+  type
+  fixedPrice {
+    address
+    pricePerToken
+    saleEnd
+    saleStart
+    maxTokensPerAddress
+  }
+  erc20Minter {
+    address
+    pricePerToken
+    currency
+    saleEnd
+    saleStart
+    maxTokensPerAddress
+  }
+}
+
+query ($id: ID!) {
+  zoraCreateToken(id: $id) {
+    id
+    contract {
+      mintFeePerQuantity
+      salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
+        ...SaleStrategy
+      }
+    }
+    salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
+      ...SaleStrategy
+    }
+  }
+}
+`;
 
 // src/apis/chain-constants.ts
 import {
@@ -426,38 +463,13 @@ var MintAPIClient = class {
   }
   async getSalesConfigAndTokenInfo({
     tokenAddress,
-    tokenId
+    tokenId,
+    saleType
   }) {
     const { retries: retries2, post: post2 } = this.httpClient;
     return retries2(async () => {
       const response = await post2(this.networkConfig.subgraphUrl, {
-        query: `
-          fragment SaleStrategy on SalesStrategyConfig {
-            type
-            fixedPrice {
-              address
-              pricePerToken
-              saleEnd
-              saleStart
-              maxTokensPerAddress
-            }
-          }
-
-          query ($id: ID!) {
-            zoraCreateToken(id: $id) {
-              id
-              contract {
-                mintFeePerQuantity
-                salesStrategies(where: { type: "FIXED_PRICE" }) {
-                  ...SaleStrategy
-                }
-              }
-              salesStrategies(where: { type: "FIXED_PRICE" }) {
-                ...SaleStrategy
-              }
-            }
-          }
-        `,
+        query: NFT_SALE_QUERY,
         variables: {
           id: tokenId !== void 0 ? (
             // Generic Token ID types all stringify down to the base numeric equivalent.
@@ -469,17 +481,56 @@ var MintAPIClient = class {
       if (!token) {
         throw new Error("Cannot find a token to mint");
       }
-      const saleStrategies = tokenId !== void 0 ? token.salesStrategies : token.contract.salesStrategies;
-      const fixedPrice = saleStrategies?.sort(
-        (a, b) => BigInt(a.fixedPrice.saleEnd) > BigInt(b.fixedPrice.saleEnd) ? 1 : -1
-      )?.find(() => true)?.fixedPrice;
-      if (!fixedPrice) {
-        throw new Error("Cannot find fixed price sale strategy");
+      const allStrategies = (typeof tokenId !== "undefined" ? token.salesStrategies : token.contract.salesStrategies) || [];
+      const saleStrategies = allStrategies.sort(
+        (a, b) => BigInt(
+          a.type === "ERC_20_MINTER" ? a.erc20Minter.saleEnd : a.fixedPrice.saleEnd
+        ) > BigInt(
+          b.type === "FIXED_PRICE" ? b.fixedPrice.saleEnd : b.erc20Minter.saleEnd
+        ) ? 1 : -1
+      );
+      let targetStrategy;
+      if (!saleType) {
+        targetStrategy = saleStrategies[0];
+        if (!targetStrategy) {
+          throw new Error("Cannot find sale strategy");
+        }
+      } else {
+        const mappedSaleType = saleType === "erc20" ? "ERC_20_MINTER" : "FIXED_PRICE";
+        targetStrategy = saleStrategies.find(
+          (strategy) => strategy.type === mappedSaleType
+        );
+        if (!targetStrategy) {
+          throw new Error(`Cannot find sale strategy for ${mappedSaleType}`);
+        }
       }
-      return {
-        fixedPrice,
-        mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
-      };
+      if (targetStrategy.type === "FIXED_PRICE") {
+        return {
+          salesConfig: {
+            saleType: "fixedPrice",
+            ...targetStrategy.fixedPrice,
+            maxTokensPerAddress: BigInt(
+              targetStrategy.fixedPrice.maxTokensPerAddress
+            ),
+            pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken)
+          },
+          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
+        };
+      }
+      if (targetStrategy.type === "ERC_20_MINTER") {
+        return {
+          salesConfig: {
+            saleType: "erc20",
+            ...targetStrategy.erc20Minter,
+            maxTokensPerAddress: BigInt(
+              targetStrategy.erc20Minter.maxTokensPerAddress
+            ),
+            pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken)
+          },
+          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
+        };
+      }
+      throw new Error("Invalid saleType");
     });
   }
 };
@@ -670,7 +721,18 @@ var PremintAPIClient = class {
 };
 
 // src/utils.ts
+import {
+  createPublicClient,
+  http
+} from "viem";
 var makeSimulateContractParamaters = (args) => args;
+function setupClient({ chain, httpClient: httpClient2, publicClient }) {
+  return {
+    chain,
+    httpClient: httpClient2 || httpClient,
+    publicClient: publicClient || createPublicClient({ chain, transport: http() })
+  };
+}
 
 // src/premint/premint-client.ts
 var defaultTokenConfigV1MintArguments = () => ({
@@ -698,7 +760,7 @@ var makeTokenConfigWithDefaults = ({
   chainId,
   premintConfigVersion,
   tokenCreationConfig,
-  creatorAccount
+  payoutRecipient
 }) => {
   if (premintConfigVersion === PremintConfigVersion2.V3) {
     throw new Error("PremintV3 not supported in SDK");
@@ -708,14 +770,14 @@ var makeTokenConfigWithDefaults = ({
     return {
       fixedPriceMinter,
       ...defaultTokenConfigV1MintArguments(),
-      royaltyRecipient: creatorAccount,
+      royaltyRecipient: payoutRecipient,
       ...tokenCreationConfig
     };
   } else if (premintConfigVersion === PremintConfigVersion2.V2) {
     return {
       fixedPriceMinter,
       ...defaultTokenConfigV2MintArguments(),
-      payoutRecipient: creatorAccount,
+      payoutRecipient,
       createReferral: zeroAddress2,
       ...tokenCreationConfig
     };
@@ -742,7 +804,7 @@ var PremintClient = class {
   constructor(chain, publicClient, httpClient2) {
     this.chain = chain;
     this.apiClient = new PremintAPIClient(chain.id, httpClient2);
-    this.publicClient = publicClient || createPublicClient({ chain, transport: http() });
+    this.publicClient = publicClient;
   }
   getDataFromPremintReceipt(receipt) {
     const premintedLog = getPremintedLogFromReceipt(receipt);
@@ -755,174 +817,45 @@ var PremintClient = class {
     };
   }
   /**
-   * 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.
+   * Prepares data for updating a premint
    *
+   * @param parameters - Parameters for updating the premint {@link UpdatePremintParams}
+   * @returns A PremintReturn. {@link PremintReturn}
    */
-  async updatePremint({
-    walletClient,
-    uid,
-    collection,
-    account,
-    tokenConfigUpdates
-  }) {
-    const {
-      premintConfig,
-      collection: collectionCreationConfig,
-      premintConfigVersion
-    } = await this.apiClient.getSignature({
-      collectionAddress: collection,
-      uid
-    });
-    const updatedPremint = applyUpdateToPremint({
-      uid: premintConfig.uid,
-      version: premintConfig.version,
-      tokenConfig: premintConfig.tokenConfig,
-      tokenConfigUpdates
-    });
-    return await this.signAndSubmitPremint({
-      walletClient,
-      account,
-      checkSignature: true,
-      verifyingContract: collection,
-      collection: collectionCreationConfig,
-      premintConfig: updatedPremint,
-      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
-   *
-   */
-  async deletePremint({
-    walletClient,
-    uid,
-    account,
-    collection
-  }) {
-    const {
-      premintConfig,
-      premintConfigVersion,
-      collection: collectionCreationConfig
-    } = await this.apiClient.getSignature({
-      collectionAddress: collection,
-      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) {
+    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}
    */
-  async signAndSubmitPremint(params) {
-    const { verifyingContract } = await signAndSubmitPremint({
+  async deletePremint(params) {
+    return deletePremint({
       ...params,
-      chainId: this.chain.id,
       apiClient: this.apiClient,
-      publicClient: this.publicClient
+      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({
-    creatorAccount,
-    collection,
-    tokenCreationConfig,
-    premintConfigVersion,
-    walletClient,
-    uid,
-    checkSignature = false
-  }) {
-    const newContractAddress = await getPremintCollectionAddress({
-      publicClient: this.publicClient,
-      collection
-    });
-    let uidToUse = uid;
-    if (typeof uidToUse !== "number") {
-      uidToUse = await this.apiClient.getNextUID(newContractAddress);
-    }
-    const actualVersion = premintConfigVersion || PremintConfigVersion2.V1;
-    if (!await supportsPremintVersion({
-      version: actualVersion,
+  async createPremint(parameters) {
+    return createPremint({
+      ...parameters,
       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
     });
   }
   /**
@@ -999,91 +932,342 @@ var PremintClient = class {
     });
   }
   /**
-   * 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
-  }) {
-    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, signature } = await this.getPremintSignature({
-      address: tokenContract,
-      uid
+  async makeMintParameters(parameters) {
+    return await makeMintParameters({
+      ...parameters,
+      apiClient: this.apiClient,
+      publicClient: this.publicClient
     });
-    const numberToMint = BigInt(mintArguments?.quantityToMint || 1);
-    if (premintConfigVersion === PremintConfigVersion2.V3) {
-      throw new Error("PremintV3 not supported in premint SDK");
-    }
-    const value = (await getPremintMintCosts({
-      tokenContract,
-      quantityToMint: numberToMint,
-      publicClient: this.publicClient,
-      tokenPrice: premintConfig.tokenConfig.pricePerToken
-    })).totalCost;
-    const mintArgumentsContract = {
-      mintComment: mintArguments?.mintComment || "",
-      mintRecipient: mintArguments?.mintRecipient || (typeof minterAccount === "string" ? minterAccount : minterAccount.address),
-      mintRewardsRecipients: makeMintRewardsRecipient({
-        mintReferral: mintArguments?.mintReferral,
-        platformReferral: mintArguments?.platformReferral
-      })
+  }
+};
+function createPremintClient(clientConfig) {
+  const { chain, httpClient: httpClient2, publicClient } = setupClient(clientConfig);
+  return new PremintClient(chain, publicClient, httpClient2);
+}
+function makePremintReturn({
+  premintConfig,
+  premintConfigVersion,
+  collectionAddress,
+  collection,
+  publicClient,
+  apiClient,
+  chainId
+}) {
+  const typedDataDefinition = premintTypedDataDefinition2({
+    verifyingContract: collectionAddress,
+    premintConfig,
+    premintConfigVersion,
+    chainId
+  });
+  const signAndSubmit = async ({
+    walletClient,
+    account,
+    checkSignature
+  }) => {
+    const { signature, signerAccount } = await signPremint({
+      account,
+      walletClient,
+      typedDataDefinition
+    });
+    await submit({
+      signature,
+      checkSignature,
+      signerAccount
+    });
+    return {
+      signature,
+      signerAccount
     };
-    if (premintConfigVersion === PremintConfigVersion2.V1) {
-      return makeSimulateContractParamaters({
-        account: minterAccount,
-        abi: zoraCreator1155PremintExecutorImplABI2,
-        functionName: "premintV1",
-        value,
-        address: getPremintExecutorAddress(),
-        args: [
-          collection,
-          premintConfig,
-          signature,
-          numberToMint,
-          mintArgumentsContract
-        ]
-      });
-    } else if (premintConfigVersion === PremintConfigVersion2.V2) {
-      return makeSimulateContractParamaters({
-        account: minterAccount,
-        abi: zoraCreator1155PremintExecutorImplABI2,
-        functionName: "premintV2",
-        value,
-        address: getPremintExecutorAddress(),
-        args: [
-          collection,
-          premintConfig,
-          signature,
-          numberToMint,
-          mintArgumentsContract
-        ]
+  };
+  const submit = async ({
+    signature,
+    checkSignature,
+    signerAccount
+  }) => {
+    if (checkSignature) {
+      await validateSignature({
+        collection: {
+          ...collection,
+          additionalAdmins: []
+        },
+        publicClient,
+        signerAccount
       });
     }
-    throw new Error(`Invalid premint config version ${premintConfigVersion}`);
+    await apiClient.postSignature({
+      collection: {
+        ...collection,
+        additionalAdmins: []
+      },
+      signature,
+      premintConfig,
+      premintConfigVersion
+    });
+  };
+  return {
+    premintConfig,
+    premintConfigVersion,
+    typedDataDefinition,
+    collectionAddress,
+    signAndSubmit,
+    submit
+  };
+}
+async function signPremint({
+  account,
+  walletClient,
+  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
+  };
+}
+var validateSignature = async ({
+  collection,
+  publicClient,
+  signerAccount
+}) => {
+  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");
   }
 };
-function createPremintClient({
-  chain,
-  httpClient: httpClient2,
+async function createPremint({
+  payoutRecipient: creatorAccount,
+  collection,
+  tokenCreationConfig,
+  premintConfigVersion,
+  uid,
+  publicClient,
+  apiClient,
+  chainId
+}) {
+  const {
+    premintConfig,
+    premintConfigVersion: actualVersion,
+    collectionAddress
+  } = await prepareCreatePremintConfig({
+    payoutRecipient: creatorAccount,
+    collection,
+    tokenCreationConfig,
+    premintConfigVersion,
+    uid,
+    publicClient,
+    apiClient,
+    chainId
+  });
+  return makePremintReturn({
+    premintConfig,
+    premintConfigVersion: actualVersion,
+    collectionAddress,
+    collection,
+    publicClient,
+    apiClient,
+    chainId
+  });
+}
+async function prepareCreatePremintConfig({
+  payoutRecipient,
+  collection,
+  tokenCreationConfig,
+  premintConfigVersion,
+  uid,
+  publicClient,
+  apiClient,
+  chainId
+}) {
+  const collectionWithAdditionalAdmins = {
+    ...collection,
+    additionalAdmins: collection.additionalAdmins || []
+  };
+  const newContractAddress = await getPremintCollectionAddress({
+    publicClient,
+    collection: collectionWithAdditionalAdmins
+  });
+  let uidToUse = uid;
+  if (typeof uidToUse !== "number") {
+    uidToUse = await apiClient.getNextUID(newContractAddress);
+  }
+  const actualVersion = premintConfigVersion || PremintConfigVersion2.V1;
+  if (!await supportsPremintVersion({
+    version: actualVersion,
+    publicClient,
+    tokenContract: newContractAddress
+  })) {
+    throw new Error(
+      `Premint version ${actualVersion} not supported by contract`
+    );
+  }
+  const premintConfig = makeNewPremint({
+    tokenConfig: makeTokenConfigWithDefaults({
+      // @ts-ignore
+      premintConfigVersion: actualVersion,
+      tokenCreationConfig,
+      payoutRecipient: typeof payoutRecipient === "string" ? payoutRecipient : payoutRecipient.address,
+      chainId
+    }),
+    uid: uidToUse
+  });
+  return {
+    premintConfig,
+    premintConfigVersion: actualVersion,
+    collectionAddress: newContractAddress
+  };
+}
+async function updatePremint({
+  uid,
+  collection,
+  tokenConfigUpdates,
+  apiClient,
+  publicClient,
+  chainId
+}) {
+  const {
+    premintConfig,
+    collection: collectionCreationConfig,
+    premintConfigVersion
+  } = await apiClient.getSignature({
+    collectionAddress: collection,
+    uid
+  });
+  const updatedPremint = applyUpdateToPremint({
+    uid: premintConfig.uid,
+    version: premintConfig.version,
+    tokenConfig: premintConfig.tokenConfig,
+    tokenConfigUpdates
+  });
+  return makePremintReturn({
+    premintConfig: updatedPremint,
+    premintConfigVersion,
+    collectionAddress: collection,
+    collection: collectionCreationConfig,
+    publicClient,
+    apiClient,
+    chainId
+  });
+}
+async function deletePremint({
+  uid,
+  collection,
+  publicClient,
+  apiClient,
+  chainId
+}) {
+  const {
+    premintConfig,
+    premintConfigVersion,
+    collection: collectionCreationConfig
+  } = await apiClient.getSignature({
+    collectionAddress: collection,
+    uid
+  });
+  const deletedPremint = {
+    ...premintConfig,
+    version: premintConfig.version + 1,
+    deleted: true
+  };
+  return makePremintReturn({
+    premintConfig: deletedPremint,
+    premintConfigVersion,
+    collectionAddress: collection,
+    collection: collectionCreationConfig,
+    publicClient,
+    apiClient,
+    chainId
+  });
+}
+async function makeMintParameters({
+  uid,
+  tokenContract,
+  minterAccount,
+  mintArguments,
+  apiClient,
   publicClient
 }) {
-  return new PremintClient(chain, publicClient, httpClient2);
+  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, signature } = await apiClient.getSignature({
+    collectionAddress: tokenContract,
+    uid
+  });
+  const numberToMint = BigInt(mintArguments?.quantityToMint || 1);
+  if (premintConfigVersion === PremintConfigVersion2.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 = {
+    mintComment: mintArguments?.mintComment || "",
+    mintRecipient: mintArguments?.mintRecipient || (typeof minterAccount === "string" ? minterAccount : minterAccount.address),
+    mintRewardsRecipients: makeMintRewardsRecipient({
+      mintReferral: mintArguments?.mintReferral
+    })
+  };
+  if (premintConfigVersion === PremintConfigVersion2.V1) {
+    return makeSimulateContractParamaters({
+      account: minterAccount,
+      abi: zoraCreator1155PremintExecutorImplABI2,
+      functionName: "premintV1",
+      value,
+      address: getPremintExecutorAddress(),
+      args: [
+        collection,
+        premintConfig,
+        signature,
+        numberToMint,
+        mintArgumentsContract
+      ]
+    });
+  } else if (premintConfigVersion === PremintConfigVersion2.V2) {
+    return makeSimulateContractParamaters({
+      account: minterAccount,
+      abi: zoraCreator1155PremintExecutorImplABI2,
+      functionName: "premintV2",
+      value,
+      address: getPremintExecutorAddress(),
+      args: [
+        collection,
+        premintConfig,
+        signature,
+        numberToMint,
+        mintArgumentsContract
+      ]
+    });
+  }
+  throw new Error(`Invalid premint config version ${premintConfigVersion}`);
 }
 function makeUrls({
   uid,
@@ -1102,52 +1286,6 @@ function makeUrls({
     zoraManage: `https://${network.isTestnet ? "testnet." : ""}zora.co/collect/${network.zoraCollectPathChainName}:${address}/${zoraTokenPath}`
   };
 }
-async function signAndSubmitPremint({
-  walletClient,
-  verifyingContract,
-  account,
-  checkSignature,
-  collection,
-  chainId,
-  publicClient,
-  apiClient,
-  ...premintConfigAndVersion
-}) {
-  if (!account) {
-    account = walletClient.account;
-  }
-  if (!account) {
-    throw new Error("No account provided");
-  }
-  const signature = await walletClient.signTypedData({
-    account,
-    ...premintTypedDataDefinition2({
-      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,
-    signature,
-    ...premintConfigAndVersion
-  });
-  return { premint, verifyingContract };
-}
 
 // src/premint/contract-types.ts
 import { PremintConfigVersion as PremintConfigVersionOrig } from "@zoralabs/protocol-deployments";
@@ -1160,13 +1298,13 @@ var PremintConfigVersion3 = ((PremintConfigVersion4) => {
 
 // src/mint/mint-client.ts
 import {
-  createPublicClient as createPublicClient2,
   encodeAbiParameters,
   parseAbiParameters,
-  zeroAddress as zeroAddress3,
-  http as http2
+  zeroAddress as zeroAddress3
 } from "viem";
 import {
+  erc20MinterABI,
+  erc20MinterAddress,
   zoraCreator1155ImplABI as zoraCreator1155ImplABI2,
   zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress2
 } from "@zoralabs/protocol-deployments";
@@ -1181,30 +1319,24 @@ var Errors = {
 var MintClient = class {
   constructor(chain, publicClient, httpClient2) {
     this.apiClient = new MintAPIClient(chain.id, httpClient2);
-    this.publicClient = publicClient || createPublicClient2({ chain, transport: http2() });
+    this.publicClient = publicClient;
   }
   /**
    * Returns the parameters needed to prepare a transaction mint a token.
-   * @param param0.minterAccount The account that will mint the token.
-   * @param param0.mintable The mintable token to mint.
-   * @param param0.mintArguments The arguments for the mint (mint recipient, comment, mint referral, quantity to mint)
-   * @returns
+   *
+   * @param parameters - Parameters for collecting the token {@link MintTokenParams}
+   * @returns Parameters for simulating/executing the mint transaction
    */
-  async makePrepareMintTokenParams({
-    ...rest
-  }) {
+  async makePrepareMintTokenParams(parameters) {
     return makePrepareMintTokenParams({
-      ...rest,
+      ...parameters,
       apiClient: this.apiClient,
       publicClient: this.publicClient
     });
   }
 };
-function createMintClient({
-  chain,
-  publicClient,
-  httpClient: httpClient2
-}) {
+function createMintClient(clientConfig) {
+  const { chain, publicClient, httpClient: httpClient2 } = setupClient(clientConfig);
   return new MintClient(chain, publicClient, httpClient2);
 }
 async function makePrepareMintTokenParams({
@@ -1212,16 +1344,19 @@ async function makePrepareMintTokenParams({
   apiClient,
   tokenId,
   tokenAddress,
+  mintArguments,
   ...rest
 }) {
   const salesConfigAndTokenInfo = await apiClient.getSalesConfigAndTokenInfo({
     tokenId,
-    tokenAddress
+    tokenAddress,
+    saleType: mintArguments.saleType
   });
   if (tokenId === void 0) {
     return makePrepareMint721TokenParams({
       salesConfigAndTokenInfo,
       tokenAddress,
+      mintArguments,
       ...rest
     });
   }
@@ -1229,6 +1364,7 @@ async function makePrepareMintTokenParams({
     salesConfigAndTokenInfo,
     tokenAddress,
     tokenId,
+    mintArguments,
     ...rest
   });
 }
@@ -1261,7 +1397,7 @@ function getMintCosts({
   quantityToMint
 }) {
   const mintFeeForTokens = salesConfigAndTokenInfo.mintFeePerQuantity * quantityToMint;
-  const tokenPurchaseCost = BigInt(salesConfigAndTokenInfo.fixedPrice.pricePerToken) * quantityToMint;
+  const tokenPurchaseCost = BigInt(salesConfigAndTokenInfo.salesConfig.pricePerToken) * quantityToMint;
   return {
     mintFee: mintFeeForTokens,
     tokenPurchaseCost,
@@ -1280,24 +1416,49 @@ async function makePrepareMint1155TokenParams({
     salesConfigAndTokenInfo,
     quantityToMint: mintQuantity
   }).totalCost;
-  return makeSimulateContractParamaters({
-    abi: zoraCreator1155ImplABI2,
-    functionName: "mintWithRewards",
-    account: minterAccount,
-    value: mintValue,
-    address: tokenAddress,
-    /* args: minter, tokenId, quantity, minterArguments, mintReferral */
-    args: [
-      salesConfigAndTokenInfo?.fixedPrice.address || zoraCreatorFixedPriceSaleStrategyAddress2[999],
-      BigInt(tokenId),
-      mintQuantity,
-      encodeAbiParameters(parseAbiParameters("address, string"), [
-        mintArguments.mintToAddress,
-        mintArguments.mintComment || ""
-      ]),
-      mintArguments.mintReferral || zeroAddress3
-    ]
-  });
+  switch (salesConfigAndTokenInfo.salesConfig.saleType) {
+    case "fixedPrice":
+      const fixedPriceArgs = mintArguments;
+      return makeSimulateContractParamaters({
+        abi: zoraCreator1155ImplABI2,
+        functionName: "mintWithRewards",
+        account: minterAccount,
+        value: mintValue,
+        address: tokenAddress,
+        /* args: minter, tokenId, quantity, minterArguments, mintReferral */
+        args: [
+          salesConfigAndTokenInfo.salesConfig.address || zoraCreatorFixedPriceSaleStrategyAddress2[999999999],
+          BigInt(tokenId),
+          mintQuantity,
+          encodeAbiParameters(parseAbiParameters("address, string"), [
+            fixedPriceArgs.mintToAddress,
+            fixedPriceArgs.mintComment || ""
+          ]),
+          fixedPriceArgs.mintReferral || zeroAddress3
+        ]
+      });
+    case "erc20":
+      const erc20Args = mintArguments;
+      return makeSimulateContractParamaters({
+        abi: erc20MinterABI,
+        functionName: "mint",
+        account: minterAccount,
+        address: salesConfigAndTokenInfo?.salesConfig.address || erc20MinterAddress[999999999],
+        /* args: mintTo, quantity, tokenAddress, tokenId, totalValue, currency, mintReferral, comment */
+        args: [
+          mintArguments.mintToAddress,
+          mintQuantity,
+          tokenAddress,
+          BigInt(tokenId),
+          salesConfigAndTokenInfo.salesConfig.pricePerToken,
+          salesConfigAndTokenInfo.salesConfig.currency,
+          erc20Args.mintReferral || zeroAddress3,
+          erc20Args.mintComment || ""
+        ]
+      });
+    default:
+      throw new MintError("Unsupported sale type");
+  }
 }
 
 // src/create/1155-create-helper.ts
@@ -1457,9 +1618,8 @@ async function getContractExists(publicClient, contract, account) {
     contractAddress: contract
   };
 }
-function create1155CreatorClient({
-  publicClient
-}) {
+function create1155CreatorClient(clientConfig) {
+  const { publicClient } = setupClient(clientConfig);
   async function createNew1155Token({
     contract,
     tokenMetadataURI,
@@ -1928,6 +2088,7 @@ export {
   makePermitToCollectPremintOrNonPremint,
   makePermitTransferBatchAndTypeData,
   makePermitTransferTypeData,
+  makeUrls,
   migratePremintConfigToV2,
   mintWithEthParams,
   mintsBalanceOfAccountParams,