@zoralabs/protocol-sdk 0.6.0 → 0.7.0

package/dist/index.js

@@ -49,41 +49,6 @@ 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
 var REWARD_PER_TOKEN = parseEther("0.000777");
@@ -212,10 +177,22 @@ var convertPremintFromApi = (premint) => {
   }
 };
 var convertGetPremintApiResponse = (response) => ({
-  ...convertPremintFromApi(response.premint),
   collection: convertCollectionFromApi(response.collection),
   collectionAddress: response.collection_address,
-  signature: response.signature
+  signature: response.signature,
+  signer: response.signer,
+  premint: convertPremintFromApi(response.premint)
+});
+var convertGetPremintOfCollectionApiResponse = (response) => ({
+  collection: convertCollectionFromApi({
+    contractAdmin: response.contract_admin,
+    contractName: response.contract_name,
+    contractURI: response.contract_uri
+  }),
+  premints: response.premints.map((premint) => ({
+    premint: convertPremintFromApi(premint),
+    signature: premint.signature
+  }))
 });
 var encodePremintV1ForAPI = ({
   tokenConfig,
@@ -504,7 +481,7 @@ async function getPremintPricePerToken({
   uid,
   premintGetter
 }) {
-  const premintConfigWithVersion = await premintGetter.getSignature({
+  const { premint: premintConfigWithVersion } = await premintGetter.get({
     collectionAddress: collection,
     uid
   });
@@ -646,6 +623,144 @@ var httpClient = {
   retries
 };
 
+// src/mint/types.ts
+var isOnChainMint = (mint2) => mint2.mintType !== "premint";
+var is1155Mint = (mint2) => mint2.mintType === "1155";
+function isErc20SaleStrategy(salesConfig) {
+  return salesConfig.saleType === "erc20";
+}
+
+// src/utils.ts
+var makeContractParameters = (args) => args;
+function mintRecipientOrAccount({
+  mintRecipient,
+  minterAccount
+}) {
+  return mintRecipient || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
+}
+async function querySubgraphWithRetries({
+  httpClient: httpClient2,
+  subgraphUrl,
+  query,
+  variables
+}) {
+  const { retries: retries2, post: post2 } = httpClient2;
+  const result = await retries2(async () => {
+    return await post2(subgraphUrl, {
+      query,
+      variables
+    });
+  });
+  return result?.data;
+}
+
+// src/mint/subgraph-queries.ts
+var NFT_SALE_STRATEGY_FRAGMENT = `
+fragment SaleStrategy on SalesStrategyConfig {
+  type
+  fixedPrice {
+    address
+    pricePerToken
+    saleEnd
+    saleStart
+    maxTokensPerAddress
+  }
+  erc20Minter {
+    address
+    pricePerToken
+    currency
+    saleEnd
+    saleStart
+    maxTokensPerAddress
+  }
+}`;
+var TOKEN_FRAGMENT = `
+fragment Token on ZoraCreateToken {
+    creator
+    tokenId
+    uri
+    totalMinted
+    maxSupply
+    tokenStandard
+    salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
+      ...SaleStrategy
+    }
+    contract {
+      address
+      mintFeePerQuantity
+      contractVersion
+      contractURI
+      name
+      salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
+        ...SaleStrategy
+      }
+    }
+}`;
+var FRAGMENTS = `
+${NFT_SALE_STRATEGY_FRAGMENT}
+${TOKEN_FRAGMENT}
+`;
+function buildNftTokenSalesQuery({
+  tokenId,
+  tokenAddress
+}) {
+  return {
+    query: `
+${FRAGMENTS}
+query ($id: ID!) {
+  zoraCreateToken(id: $id) {
+    ...Token 
+  }
+}
+`,
+    variables: {
+      id: tokenId !== void 0 ? (
+        // Generic Token ID types all stringify down to the base numeric equivalent.
+        `${tokenAddress.toLowerCase()}-${tokenId}`
+      ) : `${tokenAddress.toLowerCase()}-0`
+    },
+    parseResponseData: (responseData) => responseData?.zoraCreateToken
+  };
+}
+function buildContractTokensQuery({
+  tokenAddress
+}) {
+  return {
+    query: `
+${FRAGMENTS}
+query ($contract: Bytes!) {
+  zoraCreateTokens(
+     where: {address: $contract}
+  ) {
+     ...Token
+  }
+}
+`,
+    variables: {
+      contract: tokenAddress.toLowerCase()
+    },
+    parseResponseData: (responseData) => responseData?.zoraCreateTokens
+  };
+}
+function buildPremintsOfContractQuery({
+  tokenAddress
+}) {
+  return {
+    query: `
+      query ($contractAddress: Bytes!) {
+        premints(where:{contractAddress:$contractAddress}) {
+          uid
+          tokenId
+        }
+      }
+    `,
+    variables: {
+      contractAddress: tokenAddress.toLowerCase()
+    },
+    parseResponseData: (responseData) => responseData?.premints
+  };
+}
+
 // src/mint/subgraph-mint-getter.ts
 var getApiNetworkConfigForChain = (chainId) => {
   if (!networkConfigByChain[chainId]) {
@@ -653,92 +768,171 @@ var getApiNetworkConfigForChain = (chainId) => {
   }
   return networkConfigByChain[chainId];
 };
+function parseSalesConfig(targetStrategy) {
+  if (targetStrategy.type === "FIXED_PRICE")
+    return {
+      saleType: "fixedPrice",
+      ...targetStrategy.fixedPrice,
+      maxTokensPerAddress: BigInt(
+        targetStrategy.fixedPrice.maxTokensPerAddress
+      ),
+      pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken)
+    };
+  if (targetStrategy.type === "ERC_20_MINTER") {
+    return {
+      saleType: "erc20",
+      ...targetStrategy.erc20Minter,
+      maxTokensPerAddress: BigInt(
+        targetStrategy.erc20Minter.maxTokensPerAddress
+      ),
+      pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken)
+    };
+  }
+  throw new Error("Unknown saleType");
+}
+function getSaleEnd(a) {
+  return BigInt(
+    a.type === "ERC_20_MINTER" ? a.erc20Minter.saleEnd : a.fixedPrice.saleEnd
+  );
+}
+function getTargetStrategy({
+  tokenId,
+  preferredSaleType,
+  token
+}) {
+  const allStrategies = (typeof tokenId !== "undefined" ? token.salesStrategies : token.contract.salesStrategies) || [];
+  const saleStrategies = allStrategies.sort(
+    (a, b) => getSaleEnd(a) > getSaleEnd(b) ? 1 : -1
+  );
+  let targetStrategy;
+  if (!preferredSaleType) {
+    targetStrategy = saleStrategies[0];
+    if (!targetStrategy) {
+      throw new Error("Cannot find sale strategy");
+    }
+  } else {
+    const mappedSaleType = preferredSaleType === "erc20" ? "ERC_20_MINTER" : "FIXED_PRICE";
+    targetStrategy = saleStrategies.find(
+      (strategy) => strategy.type === mappedSaleType
+    );
+    if (!targetStrategy) {
+      const targetStrategy2 = saleStrategies.find(
+        (strategy) => strategy.type === "FIXED_PRICE" || strategy.type === "ERC_20_MINTER"
+      );
+      if (!targetStrategy2)
+        throw new Error("Cannot find valid sale strategy");
+      return targetStrategy2;
+    }
+  }
+  return targetStrategy;
+}
 var SubgraphMintGetter = class {
   constructor(chainId, httpClient2) {
+    this.getMintable = async ({
+      tokenAddress,
+      tokenId,
+      preferredSaleType: saleType
+    }) => {
+      const token = await this.querySubgraphWithRetries(
+        buildNftTokenSalesQuery({
+          tokenId,
+          tokenAddress
+        })
+      );
+      if (!token) {
+        throw new Error("Cannot find token");
+      }
+      return parseTokenQueryResult({
+        token,
+        tokenId,
+        preferredSaleType: saleType
+      });
+    };
     this.httpClient = httpClient2 || httpClient;
     this.networkConfig = getApiNetworkConfigForChain(chainId);
   }
-  async getSalesConfigAndTokenInfo({
-    tokenAddress,
-    tokenId,
-    saleType
+  async querySubgraphWithRetries({
+    query,
+    variables,
+    parseResponseData
   }) {
-    const { retries: retries2, post: post2 } = this.httpClient;
-    return retries2(async () => {
-      const response = await post2(this.networkConfig.subgraphUrl, {
-        query: NFT_SALE_QUERY,
-        variables: {
-          id: tokenId !== void 0 ? (
-            // Generic Token ID types all stringify down to the base numeric equivalent.
-            `${tokenAddress.toLowerCase()}-${tokenId}`
-          ) : `${tokenAddress.toLowerCase()}-0`
-        }
-      });
-      const token = response.data?.zoraCreateToken;
-      if (!token) {
-        throw new Error("Cannot find a token to mint");
-      }
-      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}`);
-        }
-      }
-      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");
+    const responseData = await querySubgraphWithRetries({
+      httpClient: this.httpClient,
+      subgraphUrl: this.networkConfig.subgraphUrl,
+      query,
+      variables
     });
+    return parseResponseData(responseData);
+  }
+  async getContractMintable({
+    tokenAddress,
+    preferredSaleType
+  }) {
+    const tokens = await this.querySubgraphWithRetries(
+      buildContractTokensQuery({
+        tokenAddress
+      })
+    );
+    if (!tokens)
+      return [];
+    return tokens.filter((x) => x.tokenId !== "0").map(
+      (token) => parseTokenQueryResult({
+        token,
+        tokenId: token.tokenId,
+        preferredSaleType
+      })
+    );
+  }
+  async getContractPremintTokenIds({
+    tokenAddress
+  }) {
+    const premints = await this.querySubgraphWithRetries(
+      buildPremintsOfContractQuery({
+        tokenAddress
+      })
+    );
+    return premints?.map((premint) => ({
+      tokenId: BigInt(premint.tokenId),
+      uid: +premint.uid
+    })) || [];
   }
 };
-
-// src/utils.ts
-var makeContractParameters = (args) => args;
-function mintRecipientOrAccount({
-  mintRecipient,
-  minterAccount
+function parseTokenQueryResult({
+  token,
+  tokenId,
+  preferredSaleType
 }) {
-  return mintRecipient || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
+  const targetStrategy = getTargetStrategy({
+    tokenId,
+    preferredSaleType,
+    token
+  });
+  const tokenInfo = parseTokenInfo(token);
+  const salesConfig = parseSalesConfig(targetStrategy);
+  if (isErc20SaleStrategy(salesConfig)) {
+    tokenInfo.mintFeePerQuantity = 0n;
+  }
+  return {
+    ...tokenInfo,
+    salesConfig
+  };
+}
+function parseTokenInfo(token) {
+  return {
+    contract: {
+      address: token.contract.address,
+      name: token.contract.name,
+      URI: token.contract.contractURI
+    },
+    tokenURI: token.uri,
+    tokenId: token.tokenId ? BigInt(token.tokenId) : void 0,
+    mintType: token.tokenStandard === "ERC721" ? "721" : "1155",
+    creator: token.creator,
+    totalMinted: BigInt(token.totalMinted),
+    maxSupply: BigInt(token.maxSupply),
+    mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity),
+    contractVersion: token.contract.contractVersion
+  };
 }
 
 // src/premint/premint-client.ts
@@ -896,7 +1090,7 @@ var PremintClient = class {
    * @returns PremintSignatureGetResponse of premint data from the API
    */
   async getPremint({ address, uid }) {
-    return await this.apiClient.getSignature({
+    return await this.apiClient.get({
       collectionAddress: address,
       uid
     });
@@ -1131,10 +1325,9 @@ async function updatePremint({
   chainId
 }) {
   const {
-    premintConfig,
-    collection: collectionCreationConfig,
-    premintConfigVersion
-  } = await apiClient.getSignature({
+    premint: { premintConfig, premintConfigVersion },
+    collection: collectionCreationConfig
+  } = await apiClient.get({
     collectionAddress: collection,
     uid
   });
@@ -1162,11 +1355,10 @@ async function deletePremint({
   chainId
 }) {
   const {
-    premintConfig,
-    premintConfigVersion,
+    premint: { premintConfig, premintConfigVersion },
     collection: collectionCreationConfig,
     collectionAddress
-  } = await apiClient.getSignature({
+  } = await apiClient.get({
     collectionAddress: collection,
     uid
   });
@@ -1200,26 +1392,39 @@ async function collectPremint({
   if (typeof quantityToMint !== "undefined" && quantityToMint < 1) {
     throw new Error("Quantity to mint cannot be below 1");
   }
-  const {
-    premintConfig,
-    premintConfigVersion,
-    collection,
-    collectionAddress,
-    signature
-  } = await premintGetter.getSignature({
+  const premint = await premintGetter.get({
     collectionAddress: tokenContract,
     uid
   });
-  const numberToMint = BigInt(quantityToMint || 1);
-  if (premintConfigVersion === PremintConfigVersion2.V3) {
-    throw new Error("PremintV3 not supported in premint SDK");
-  }
-  const value = (await getPremintMintCosts({
+  const mintFee = await getPremintMintFee({
     tokenContract,
-    quantityToMint: numberToMint,
-    publicClient,
-    tokenPrice: premintConfig.tokenConfig.pricePerToken
-  })).totalCostEth;
+    publicClient
+  });
+  return buildPremintMintCall({
+    mintArguments: {
+      minterAccount,
+      quantityToMint,
+      firstMinter,
+      mintComment,
+      mintRecipient,
+      mintReferral
+    },
+    mintFee,
+    premint
+  });
+}
+var buildPremintMintCall = ({
+  mintArguments: {
+    minterAccount,
+    mintComment = "",
+    mintRecipient,
+    mintReferral,
+    firstMinter,
+    quantityToMint
+  },
+  premint: { collection, collectionAddress, premint, signature },
+  mintFee
+}) => {
   const mintArgumentsContract = {
     mintComment,
     mintRecipient: mintRecipientOrAccount({
@@ -1233,6 +1438,10 @@ async function collectPremint({
   const collectionOrEmpty = collection ? defaultAdditionalAdmins(collection) : emptyContractCreationConfig();
   const collectionAddressToSubmit = collection ? zeroAddress2 : collectionAddress;
   const firstMinterToSubmit = firstMinter || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
+  if (premint.premintConfigVersion === PremintConfigVersion2.V3) {
+    throw new Error("PremintV3 not supported in premint SDK");
+  }
+  const value = (mintFee + premint.premintConfig.tokenConfig.pricePerToken) * BigInt(quantityToMint);
   return makeContractParameters({
     account: minterAccount,
     abi: zoraCreator1155PremintExecutorImplABI2,
@@ -1242,18 +1451,15 @@ async function collectPremint({
     args: [
       collectionOrEmpty,
       collectionAddressToSubmit,
-      encodePremintConfig({
-        premintConfig,
-        premintConfigVersion
-      }),
+      encodePremintConfig(premint),
       signature,
-      numberToMint,
+      BigInt(quantityToMint),
       mintArgumentsContract,
       firstMinterToSubmit,
       zeroAddress2
     ]
   });
-}
+};
 function makeUrls({
   uid,
   address,
@@ -1314,6 +1520,19 @@ var getSignature = async ({
   );
   return convertGetPremintApiResponse(result);
 };
+var getOfCollection = async ({
+  collectionAddress,
+  chainId,
+  httpClient: { retries: retries2, get: get2 } = httpClient
+}) => {
+  const chainName = getApiNetworkConfigForChain(chainId).zoraBackendChainName;
+  const result = await retries2(
+    () => get2(
+      `${ZORA_API_BASE}premint/signature/${chainName}/${collectionAddress.toLowerCase()}`
+    )
+  );
+  return convertGetPremintOfCollectionApiResponse(result);
+};
 var PremintAPIClient = class {
   constructor(chainId, httpClient2) {
     this.postSignature = ({
@@ -1335,10 +1554,7 @@ var PremintAPIClient = class {
       chainId: this.chainId,
       httpClient: this.httpClient
     })).next_uid;
-    this.getSignature = async ({
-      collectionAddress,
-      uid
-    }) => {
+    this.get = async ({ collectionAddress, uid }) => {
       return getSignature({
         collectionAddress,
         uid,
@@ -1346,180 +1562,109 @@ var PremintAPIClient = class {
         httpClient: this.httpClient
       });
     };
+    this.getOfCollection = async ({
+      collectionAddress
+    }) => {
+      return getOfCollection({
+        collectionAddress,
+        chainId: this.chainId,
+        httpClient: this.httpClient
+      });
+    };
     this.chainId = chainId;
     this.httpClient = httpClient2 || httpClient;
   }
 };
 
-// src/mint/mint-client.ts
+// src/mint/mint-transactions.ts
 import {
   encodeAbiParameters,
   parseAbiParameters,
-  zeroAddress as zeroAddress3,
-  erc20Abi
+  zeroAddress as zeroAddress3
 } from "viem";
 import {
   erc20MinterABI,
-  erc20MinterAddress,
-  zoraCreator1155ImplABI as zoraCreator1155ImplABI2,
-  zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress2
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI2
 } from "@zoralabs/protocol-deployments";
 
-// src/mint/types.ts
-var isOnChainMint = (mint2) => mint2.mintType !== "premint";
-var is1155Mint = (mint2) => mint2.mintType === "1155";
-function isErc20SaleStrategy(salesConfig) {
-  return salesConfig.saleType === "erc20";
-}
-
-// src/mint/mint-client.ts
-var MintError = class extends Error {
-};
-var MintInactiveError = class extends Error {
-};
-var Errors = {
-  MintError,
-  MintInactiveError
-};
-var MintClient = class {
-  constructor({
-    chainId,
-    publicClient,
-    premintGetter,
-    mintGetter
-  }) {
-    this.chainId = chainId;
-    this.publicClient = publicClient;
-    this.mintGetter = mintGetter;
-    this.premintGetter = premintGetter;
-  }
-  /**
-   * Returns the parameters needed to prepare a transaction mint a token.
-   * Works with premint, onchain 1155, and onchain 721.
-   *
-   * @param parameters - Parameters for collecting the token {@link MakeMintParametersArguments}
-   * @returns Parameters for simulating/executing the mint transaction
-   */
-  async mint(parameters) {
-    return mint({
-      parameters,
-      chainId: this.chainId,
-      publicClient: this.publicClient,
-      mintGetter: this.mintGetter,
-      premintGetter: this.premintGetter
-    });
-  }
-  /**
-   * Gets the costs to mint the quantity of tokens specified for a mint.
-   * @param parameters - Parameters for the mint {@link GetMintCostsParameters}
-   * @returns Costs to mint the quantity of tokens specified
-   */
-  async getMintCosts(parameters) {
-    return getMintCosts({
-      ...parameters,
-      mintGetter: this.mintGetter,
-      premintGetter: this.premintGetter,
-      publicClient: this.publicClient
-    });
+// src/mint/utils.ts
+import * as semver from "semver";
+var contractSupportsNewMintFunction = (contractVersion) => {
+  if (!contractVersion) {
+    return false;
   }
+  const semVerContractVersion = semver.coerce(contractVersion)?.raw;
+  if (!semVerContractVersion)
+    return false;
+  return semver.gte(semVerContractVersion, "2.9.0");
 };
-function isPremintCollect(parameters) {
-  return parameters.mintType === "premint";
-}
-function is721Collect(parameters) {
-  return parameters.mintType === "721";
-}
-async function mint({
-  parameters,
-  chainId,
-  publicClient,
-  mintGetter,
-  premintGetter
+
+// src/mint/mint-transactions.ts
+function makeOnchainMintCall({
+  token,
+  mintParams
 }) {
-  if (isPremintCollect(parameters)) {
-    return {
-      parameters: await collectPremint({
-        ...parameters,
-        premintGetter,
-        publicClient
-      })
-    };
+  if (token.mintType === "721") {
+    return makePrepareMint721TokenParams({
+      salesConfigAndTokenInfo: token,
+      tokenContract: token.contract.address,
+      ...mintParams
+    });
   }
-  return {
-    parameters: await collectOnchain({
-      ...parameters,
-      mintGetter,
-      chainId
-    })
-  };
-}
-function requestErc20ApprovalForMint({
-  account,
-  tokenAddress,
-  quantityErc20,
-  erc20MinterAddress: erc20MinterAddress2
-}) {
-  return makeContractParameters({
-    abi: erc20Abi,
-    address: tokenAddress,
-    account,
-    functionName: "approve",
-    args: [erc20MinterAddress2, quantityErc20]
+  return makePrepareMint1155TokenParams({
+    salesConfigAndTokenInfo: token,
+    tokenContract: token.contract.address,
+    tokenId: token.tokenId,
+    ...mintParams
   });
 }
-async function getNecessaryErc20Approval({
-  chainId,
-  account,
-  tokenAddress,
-  quantityErc20,
-  publicClient
+function makePrepareMint1155TokenParams({
+  tokenContract,
+  tokenId,
+  salesConfigAndTokenInfo,
+  minterAccount,
+  mintComment,
+  mintReferral,
+  mintRecipient,
+  quantityToMint
 }) {
-  const destination = erc20MinterAddress[chainId];
-  const allowance = await publicClient.readContract({
-    abi: erc20Abi,
-    address: tokenAddress,
-    functionName: "allowance",
-    account,
-    args: [
-      destination,
-      erc20MinterAddress[chainId]
-    ]
-  });
-  if (allowance < quantityErc20) {
-    return requestErc20ApprovalForMint({
-      erc20MinterAddress: destination,
-      account,
-      tokenAddress,
-      quantityErc20: quantityErc20 - allowance
+  const mintQuantity = BigInt(quantityToMint || 1);
+  const mintTo = mintRecipientOrAccount({ mintRecipient, minterAccount });
+  const saleType = salesConfigAndTokenInfo.salesConfig.saleType;
+  if (saleType === "fixedPrice") {
+    return makeEthMintCall({
+      mintComment,
+      minterAccount,
+      mintQuantity,
+      mintReferral,
+      mintTo,
+      salesConfigAndTokenInfo,
+      tokenContract,
+      tokenId
     });
   }
-  return void 0;
-}
-async function collectOnchain({
-  chainId,
-  mintGetter,
-  ...parameters
-}) {
-  const { tokenContract, saleType } = parameters;
-  const tokenId = is1155Mint(parameters) ? parameters.tokenId : void 0;
-  const salesConfigAndTokenInfo = await mintGetter.getSalesConfigAndTokenInfo({
-    tokenId,
-    tokenAddress: tokenContract,
-    saleType
-  });
-  if (is721Collect(parameters)) {
-    return makePrepareMint721TokenParams({
-      salesConfigAndTokenInfo,
-      ...parameters
+  if (saleType === "erc20") {
+    return makeContractParameters({
+      abi: erc20MinterABI,
+      functionName: "mint",
+      account: minterAccount,
+      address: salesConfigAndTokenInfo.salesConfig.address,
+      /* args: mintTo, quantity, tokenAddress, tokenId, totalValue, currency, mintReferral, comment */
+      args: [
+        mintTo,
+        mintQuantity,
+        tokenContract,
+        BigInt(tokenId),
+        salesConfigAndTokenInfo.salesConfig.pricePerToken * mintQuantity,
+        salesConfigAndTokenInfo.salesConfig.currency,
+        mintReferral || zeroAddress3,
+        mintComment || ""
+      ]
     });
   }
-  return makePrepareMint1155TokenParams({
-    salesConfigAndTokenInfo,
-    chainId,
-    ...parameters
-  });
+  throw new Error("Unsupported sale type");
 }
-async function makePrepareMint721TokenParams({
+function makePrepareMint721TokenParams({
   salesConfigAndTokenInfo,
   minterAccount,
   tokenContract,
@@ -1530,7 +1675,8 @@ async function makePrepareMint721TokenParams({
 }) {
   const actualQuantityToMint = BigInt(quantityToMint || 1);
   const mintValue = parseMintCosts({
-    salesConfigAndTokenInfo,
+    mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
+    salesConfig: salesConfigAndTokenInfo.salesConfig,
     quantityToMint: actualQuantityToMint
   }).totalCostEth;
   return makeContractParameters({
@@ -1547,15 +1693,65 @@ async function makePrepareMint721TokenParams({
     ]
   });
 }
-function parseMintCosts({
+function makeEthMintCall({
+  tokenContract,
+  tokenId,
   salesConfigAndTokenInfo,
+  minterAccount,
+  mintComment,
+  mintReferral,
+  mintQuantity,
+  mintTo
+}) {
+  const mintValue = parseMintCosts({
+    mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
+    salesConfig: salesConfigAndTokenInfo.salesConfig,
+    quantityToMint: mintQuantity
+  }).totalCostEth;
+  const minterArguments = encodeAbiParameters(
+    parseAbiParameters("address, string"),
+    [mintTo, mintComment || ""]
+  );
+  if (contractSupportsNewMintFunction(salesConfigAndTokenInfo.contractVersion)) {
+    return makeContractParameters({
+      abi: zoraCreator1155ImplABI2,
+      functionName: "mint",
+      account: minterAccount,
+      value: mintValue,
+      address: tokenContract,
+      args: [
+        salesConfigAndTokenInfo.salesConfig.address,
+        BigInt(tokenId),
+        mintQuantity,
+        mintReferral ? [mintReferral] : [],
+        minterArguments
+      ]
+    });
+  }
+  return makeContractParameters({
+    abi: zoraCreator1155ImplABI2,
+    functionName: "mintWithRewards",
+    account: minterAccount,
+    value: mintValue,
+    address: tokenContract,
+    /* args: minter, tokenId, quantity, minterArguments, mintReferral */
+    args: [
+      salesConfigAndTokenInfo.salesConfig.address,
+      BigInt(tokenId),
+      mintQuantity,
+      minterArguments,
+      mintReferral || zeroAddress3
+    ]
+  });
+}
+function parseMintCosts({
+  salesConfig,
+  mintFeePerQuantity,
   quantityToMint
 }) {
-  const mintFeeForTokens = salesConfigAndTokenInfo.mintFeePerQuantity * quantityToMint;
-  const tokenPurchaseCost = BigInt(salesConfigAndTokenInfo.salesConfig.pricePerToken) * quantityToMint;
-  const totalPurchaseCostCurrency = isErc20SaleStrategy(
-    salesConfigAndTokenInfo.salesConfig
-  ) ? salesConfigAndTokenInfo.salesConfig.currency : void 0;
+  const mintFeeForTokens = mintFeePerQuantity * quantityToMint;
+  const tokenPurchaseCost = BigInt(salesConfig.pricePerToken) * quantityToMint;
+  const totalPurchaseCostCurrency = isErc20SaleStrategy(salesConfig) ? salesConfig.currency : void 0;
   const totalPurchaseCostEth = totalPurchaseCostCurrency ? 0n : tokenPurchaseCost;
   return {
     mintFee: mintFeeForTokens,
@@ -1564,85 +1760,329 @@ function parseMintCosts({
     totalCostEth: mintFeeForTokens + totalPurchaseCostEth
   };
 }
-async function getMintCosts(params) {
-  const { quantityMinted: quantityToMint, collection, publicClient } = params;
+
+// src/mint/mint-queries.ts
+import { zeroAddress as zeroAddress4 } from "viem";
+async function getMint({
+  params,
+  mintGetter,
+  premintGetter,
+  publicClient
+}) {
+  const { tokenContract } = params;
   if (isOnChainMint(params)) {
     const tokenId = is1155Mint(params) ? params.tokenId : void 0;
-    const salesConfigAndTokenInfo = await params.mintGetter.getSalesConfigAndTokenInfo({
+    const result = await mintGetter.getMintable({
+      tokenId,
+      tokenAddress: tokenContract,
+      preferredSaleType: params.preferredSaleType
+    });
+    return toMintableReturn(result);
+  }
+  const premint = await premintGetter.get({
+    collectionAddress: tokenContract,
+    uid: params.uid
+  });
+  const mintFee = await getPremintMintFee({
+    publicClient,
+    tokenContract
+  });
+  return toPremintMintReturn({ premint, mintFee });
+}
+async function getPremintsOfCollectionWithTokenIds({
+  premintGetter,
+  mintGetter,
+  tokenContract
+}) {
+  const { collection, premints } = await premintGetter.getOfCollection({
+    collectionAddress: tokenContract
+  });
+  const premintUidsAndTokenIds = await mintGetter.getContractPremintTokenIds({
+    tokenAddress: tokenContract
+  });
+  const premintsWithTokenId = premints.map((premint) => ({
+    ...premint,
+    tokenId: premintUidsAndTokenIds.find(
+      ({ uid }) => uid === premint.premint.premintConfig.uid
+    )?.tokenId
+  }));
+  return {
+    collection,
+    premints: premintsWithTokenId
+  };
+}
+async function getMintsOfContract({
+  params,
+  mintGetter,
+  premintGetter,
+  publicClient
+}) {
+  const onchainMints = (await mintGetter.getContractMintable({
+    tokenAddress: params.tokenContract
+  })).map(toMintableReturn);
+  const offchainMints = await getPremintsOfContractMintable({
+    mintGetter,
+    premintGetter,
+    publicClient,
+    params: {
+      tokenContract: params.tokenContract
+    }
+  });
+  const tokens = [...onchainMints, ...offchainMints];
+  return {
+    tokens,
+    contract: tokens[0]?.token.contract
+  };
+}
+async function getMintCosts({
+  params,
+  mintGetter,
+  premintGetter,
+  publicClient
+}) {
+  const { quantityMinted: quantityToMint, collection } = params;
+  if (isOnChainMint(params)) {
+    const tokenId = is1155Mint(params) ? params.tokenId : void 0;
+    const salesConfigAndTokenInfo = await mintGetter.getMintable({
       tokenId,
       tokenAddress: collection
     });
     return parseMintCosts({
-      salesConfigAndTokenInfo,
+      mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
+      salesConfig: salesConfigAndTokenInfo.salesConfig,
       quantityToMint: BigInt(quantityToMint)
     });
   }
   return getPremintMintCostsWithUnknownTokenPrice({
-    premintGetter: params.premintGetter,
+    premintGetter,
     publicClient,
     quantityToMint: BigInt(quantityToMint),
     uid: params.uid,
     tokenContract: collection
   });
 }
-function makePrepareMint1155TokenParams({
-  tokenContract,
-  tokenId,
-  salesConfigAndTokenInfo,
-  minterAccount,
-  mintComment,
-  mintReferral,
-  mintRecipient,
-  quantityToMint,
-  chainId
+async function getPremintsOfContractMintable({
+  mintGetter,
+  premintGetter,
+  publicClient,
+  params
 }) {
-  const mintQuantity = BigInt(quantityToMint || 1);
-  const mintTo = mintRecipientOrAccount({ mintRecipient, minterAccount });
-  const saleType = salesConfigAndTokenInfo.salesConfig.saleType;
-  if (saleType === "fixedPrice") {
-    const mintValue = parseMintCosts({
-      salesConfigAndTokenInfo,
-      quantityToMint: mintQuantity
-    }).totalCostEth;
-    return makeContractParameters({
-      abi: zoraCreator1155ImplABI2,
-      functionName: "mintWithRewards",
-      account: minterAccount,
-      value: mintValue,
-      address: tokenContract,
-      /* args: minter, tokenId, quantity, minterArguments, mintReferral */
-      args: [
-        salesConfigAndTokenInfo.salesConfig.address || zoraCreatorFixedPriceSaleStrategyAddress2[chainId],
-        BigInt(tokenId),
-        mintQuantity,
-        encodeAbiParameters(parseAbiParameters("address, string"), [
-          mintTo,
-          mintComment || ""
-        ]),
-        mintReferral || zeroAddress3
-      ]
+  const { premints, collection } = await getPremintsOfCollectionWithTokenIds({
+    mintGetter,
+    premintGetter,
+    tokenContract: params.tokenContract
+  });
+  const offChainPremints = premints.filter(
+    (premint) => (
+      // if premint's uid is not in the list of uids from the subgraph, it is offchain
+      typeof premint.tokenId === "undefined"
+    )
+  );
+  if (offChainPremints.length === 0)
+    return [];
+  const mintFee = await getPremintMintFee({
+    publicClient,
+    tokenContract: params.tokenContract
+  });
+  return offChainPremints.map((premint) => {
+    return toPremintMintReturn({
+      premint: {
+        premint: premint.premint,
+        // todo: fix when api returns signer
+        signer: zeroAddress4,
+        collection,
+        collectionAddress: params.tokenContract,
+        signature: premint.signature
+      },
+      mintFee
     });
+  });
+}
+function parsePremint({
+  premint,
+  mintFee
+}) {
+  if (isPremintConfigV1(premint.premint) || isPremintConfigV2(premint.premint)) {
+    return {
+      creator: premint.signer,
+      maxSupply: premint.premint.premintConfig.tokenConfig.maxSupply,
+      mintFeePerQuantity: mintFee,
+      mintType: "premint",
+      uid: premint.premint.premintConfig.uid,
+      contract: {
+        address: premint.collectionAddress,
+        name: premint.collection.contractName,
+        URI: premint.collection.contractURI
+      },
+      tokenURI: premint.premint.premintConfig.tokenConfig.tokenURI,
+      totalMinted: 0n,
+      salesConfig: {
+        duration: premint.premint.premintConfig.tokenConfig.mintDuration,
+        maxTokensPerAddress: premint.premint.premintConfig.tokenConfig.maxTokensPerAddress,
+        pricePerToken: premint.premint.premintConfig.tokenConfig.pricePerToken,
+        saleType: "premint"
+      }
+    };
   }
-  if (saleType === "erc20") {
-    return makeContractParameters({
-      abi: erc20MinterABI,
-      functionName: "mint",
-      account: minterAccount,
-      address: salesConfigAndTokenInfo?.salesConfig.address || erc20MinterAddress[chainId],
-      /* args: mintTo, quantity, tokenAddress, tokenId, totalValue, currency, mintReferral, comment */
-      args: [
-        mintTo,
-        mintQuantity,
-        tokenContract,
-        BigInt(tokenId),
-        salesConfigAndTokenInfo.salesConfig.pricePerToken * mintQuantity,
-        salesConfigAndTokenInfo.salesConfig.currency,
-        mintReferral || zeroAddress3,
-        mintComment || ""
-      ]
+  throw new Error("Invalid premint config version");
+}
+var makeOnchainPrepareMint = (result) => (params) => ({
+  parameters: makeOnchainMintCall({ token: result, mintParams: params }),
+  erc20Approval: getRequiredErc20Approvals(params, result),
+  costs: parseMintCosts({
+    salesConfig: result.salesConfig,
+    quantityToMint: BigInt(params.quantityToMint),
+    mintFeePerQuantity: result.mintFeePerQuantity
+  })
+});
+function toMintableReturn(result) {
+  return { token: result, prepareMint: makeOnchainPrepareMint(result) };
+}
+var makePremintPrepareMint = (mintable, mintFee, premint) => (params) => ({
+  parameters: buildPremintMintCall({
+    mintArguments: params,
+    mintFee,
+    premint
+  }),
+  costs: parseMintCosts({
+    mintFeePerQuantity: mintFee,
+    quantityToMint: BigInt(params.quantityToMint),
+    salesConfig: mintable.salesConfig
+  })
+});
+function toPremintMintReturn({
+  premint,
+  mintFee
+}) {
+  const mintable = parsePremint({ premint, mintFee });
+  return {
+    token: mintable,
+    prepareMint: makePremintPrepareMint(mintable, mintFee, premint)
+  };
+}
+function getRequiredErc20Approvals(params, result) {
+  if (result.salesConfig.saleType !== "erc20")
+    return void 0;
+  return {
+    quantity: result.salesConfig.pricePerToken * BigInt(params.quantityToMint),
+    approveTo: result.salesConfig.address,
+    erc20: result.salesConfig.currency
+  };
+}
+
+// src/mint/mint-client.ts
+var MintError = class extends Error {
+};
+var MintInactiveError = class extends Error {
+};
+var Errors = {
+  MintError,
+  MintInactiveError
+};
+var MintClient = class {
+  constructor({
+    publicClient,
+    premintGetter,
+    mintGetter
+  }) {
+    this.publicClient = publicClient;
+    this.mintGetter = mintGetter;
+    this.premintGetter = premintGetter;
+  }
+  /**
+   * Returns the parameters needed to prepare a transaction mint a token.
+   * Works with premint, onchain 1155, and onchain 721.
+   *
+   * @param parameters - Parameters for collecting the token {@link MakeMintParametersArguments}
+   * @returns Parameters for simulating/executing the mint transaction, any necessary erc20 approval, and costs to mint
+   */
+  async mint(parameters) {
+    return mint({
+      parameters,
+      publicClient: this.publicClient,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter
+    });
+  }
+  /**
+   * Gets an 1155, 721, or premint, and returns both information about it, and a function
+   * that can be used to build a mint transaction for a quantity of items to mint.
+   * @param parameters - Token to get {@link GetMintParameters}
+   * @Returns Information about the mint and a function to build a mint transaction {@link MintableReturn}
+   */
+  async get(parameters) {
+    return getMint({
+      params: parameters,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter,
+      publicClient: this.publicClient
+    });
+  }
+  /**
+   * Gets onchain and premint tokens of an 1155 contract.  For each token returns both information about it, and a function
+   * that can be used to build a mint transaction for a quantity of items to mint.
+   * @param parameters - Contract address to get tokens for {@link GetMintsOfContractParameters}
+   * @Returns Array of tokens, each containing information about the token and a function to build a mint transaction.
+   */
+  async getOfContract(params) {
+    return getMintsOfContract({
+      params,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter,
+      publicClient: this.publicClient
     });
   }
-  throw new MintError("Unsupported sale type");
+  /**
+   * Gets the costs to mint the quantity of tokens specified for a mint.
+   * @param parameters - Parameters for the mint {@link GetMintCostsParameters}
+   * @returns Costs to mint the quantity of tokens specified
+   */
+  async getMintCosts(parameters) {
+    return getMintCosts({
+      params: parameters,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter,
+      publicClient: this.publicClient
+    });
+  }
+};
+async function mint({
+  parameters,
+  publicClient,
+  mintGetter,
+  premintGetter
+}) {
+  const { prepareMint } = await getMint({
+    params: parameters,
+    mintGetter,
+    premintGetter,
+    publicClient
+  });
+  return prepareMint({
+    minterAccount: parameters.minterAccount,
+    quantityToMint: parameters.quantityToMint,
+    firstMinter: parameters.firstMinter,
+    mintComment: parameters.mintComment,
+    mintRecipient: parameters.mintRecipient,
+    mintReferral: parameters.mintReferral
+  });
+}
+async function collectOnchain({
+  chainId,
+  mintGetter,
+  ...parameters
+}) {
+  const { tokenContract, preferredSaleType: saleType } = parameters;
+  const tokenId = is1155Mint(parameters) ? parameters.tokenId : void 0;
+  const salesConfigAndTokenInfo = await mintGetter.getMintable({
+    tokenId,
+    tokenAddress: tokenContract,
+    preferredSaleType: saleType
+  });
+  return makeOnchainMintCall({
+    mintParams: parameters,
+    token: salesConfigAndTokenInfo
+  });
 }
 
 // src/create/1155-create-helper.ts
@@ -1717,17 +2157,17 @@ import {
   erc20MinterAddress as erc20MinterAddresses,
   zoraCreator1155ImplABI as zoraCreator1155ImplABI4,
   zoraCreatorFixedPriceSaleStrategyABI,
-  zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress3
+  zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress2
 } from "@zoralabs/protocol-deployments";
-import { encodeFunctionData, zeroAddress as zeroAddress4 } from "viem";
-import * as semver from "semver";
+import { encodeFunctionData, zeroAddress as zeroAddress5 } from "viem";
+import * as semver2 from "semver";
 var PERMISSION_BITS = {
   MINTER: 2n ** 2n
 };
 var saleSettingsOrDefault = (saleSettings) => {
   const SALE_END_FOREVER = 18446744073709551615n;
   const DEFAULT_SALE_SETTINGS = {
-    currency: zeroAddress4,
+    currency: zeroAddress5,
     // Free Mint
     pricePerToken: 0n,
     // Sale start time – defaults to beginning of unix time
@@ -1744,10 +2184,10 @@ var saleSettingsOrDefault = (saleSettings) => {
 };
 function applyNew1155Defaults(props, ownerAddress) {
   const { payoutRecipient: fundsRecipient } = props;
-  const fundsRecipientOrOwner = fundsRecipient && fundsRecipient !== zeroAddress4 ? fundsRecipient : ownerAddress;
+  const fundsRecipientOrOwner = fundsRecipient && fundsRecipient !== zeroAddress5 ? fundsRecipient : ownerAddress;
   return {
     payoutRecipient: fundsRecipientOrOwner,
-    createReferral: props.createReferral || zeroAddress4,
+    createReferral: props.createReferral || zeroAddress5,
     maxSupply: typeof props.maxSupply === "undefined" ? OPEN_EDITION_MINT_SIZE : BigInt(props.maxSupply),
     royaltyBPS: props.royaltyBPS || 1e3,
     salesConfig: saleSettingsOrDefault(props.salesConfig),
@@ -1764,13 +2204,13 @@ function setupErc20Minter({
   maxTokensPerAddress: mintLimit,
   fundsRecipient
 }) {
-  const erc20MinterAddress2 = erc20MinterAddresses[chainId];
-  if (!erc20MinterAddress2)
+  const erc20MinterAddress = erc20MinterAddresses[chainId];
+  if (!erc20MinterAddress)
     throw new Error(`ERC20Minter not deployed on chainId ${chainId}`);
   const erc20MinterApproval = encodeFunctionData({
     abi: zoraCreator1155ImplABI4,
     functionName: "addPermission",
-    args: [BigInt(nextTokenId), erc20MinterAddress2, PERMISSION_BITS.MINTER]
+    args: [BigInt(nextTokenId), erc20MinterAddress, PERMISSION_BITS.MINTER]
   });
   const saleData = encodeFunctionData({
     abi: erc20MinterABI2,
@@ -1790,10 +2230,10 @@ function setupErc20Minter({
   const callSale = encodeFunctionData({
     abi: zoraCreator1155ImplABI4,
     functionName: "callSale",
-    args: [BigInt(nextTokenId), erc20MinterAddress2, saleData]
+    args: [BigInt(nextTokenId), erc20MinterAddress, saleData]
   });
   return {
-    minter: erc20MinterAddress2,
+    minter: erc20MinterAddress,
     setupActions: [erc20MinterApproval, callSale]
   };
 }
@@ -1806,7 +2246,7 @@ function setupFixedPriceMinter({
   maxTokensPerAddress: mintLimit,
   fundsRecipient
 }) {
-  const fixedPriceStrategyAddress = zoraCreatorFixedPriceSaleStrategyAddress3[chainId];
+  const fixedPriceStrategyAddress = zoraCreatorFixedPriceSaleStrategyAddress2[chainId];
   const fixedPriceApproval = encodeFunctionData({
     abi: zoraCreator1155ImplABI4,
     functionName: "addPermission",
@@ -1844,7 +2284,7 @@ function setupMinters({ salesConfig, ...rest }) {
   if (!salesConfig)
     throw new Error("No sales config for token");
   const { currency: currencyAddress } = salesConfig;
-  if (currencyAddress === zeroAddress4) {
+  if (currencyAddress === zeroAddress5) {
     return setupFixedPriceMinter({
       ...salesConfig,
       ...rest
@@ -1859,7 +2299,7 @@ function setupMinters({ salesConfig, ...rest }) {
 function buildSetupNewToken({
   tokenURI,
   maxSupply = OPEN_EDITION_MINT_SIZE,
-  createReferral = zeroAddress4,
+  createReferral = zeroAddress5,
   contractVersion
 }) {
   if (contractSupportsMintRewards(contractVersion, "ERC1155")) {
@@ -1869,7 +2309,7 @@ function buildSetupNewToken({
       args: [tokenURI, BigInt(maxSupply), createReferral]
     });
   }
-  if (createReferral !== zeroAddress4) {
+  if (createReferral !== zeroAddress5) {
     throw new Error(
       "Contract does not support create referral, but one was provided"
     );
@@ -1885,7 +2325,7 @@ function setupRoyaltyConfig({
   royaltyRecipient,
   nextTokenId
 }) {
-  if (royaltyBPS > 0 && royaltyRecipient != zeroAddress4) {
+  if (royaltyBPS > 0 && royaltyRecipient != zeroAddress5) {
     return encodeFunctionData({
       abi: zoraCreator1155ImplABI4,
       functionName: "updateRoyaltiesForToken",
@@ -1912,7 +2352,7 @@ function makeAdminMintCall({
   return encodeFunctionData({
     abi: zoraCreator1155ImplABI4,
     functionName: "adminMint",
-    args: [ownerAddress, nextTokenId, BigInt(mintQuantity), zeroAddress4]
+    args: [ownerAddress, nextTokenId, BigInt(mintQuantity), zeroAddress5]
   });
 }
 function constructCreate1155TokenCalls(props) {
@@ -1971,13 +2411,13 @@ var contractSupportsMintRewards = (contractVersion, contractStandard) => {
   if (!contractStandard || !contractVersion) {
     return false;
   }
-  const semVerContractVersion = semver.coerce(contractVersion)?.raw;
+  const semVerContractVersion = semver2.coerce(contractVersion)?.raw;
   if (!semVerContractVersion)
     return false;
   if (contractStandard === "ERC1155") {
-    return semver.gte(semVerContractVersion, "1.3.5");
+    return semver2.gte(semVerContractVersion, "1.3.5");
   } else {
-    return semver.gte(semVerContractVersion, "14.0.0");
+    return semver2.gte(semVerContractVersion, "14.0.0");
   }
 };
 
@@ -2178,7 +2618,7 @@ import {
 import {
   decodeErrorResult,
   encodeFunctionData as encodeFunctionData2,
-  zeroAddress as zeroAddress5
+  zeroAddress as zeroAddress6
 } from "viem";
 var addressOrAccountAddress = (address) => typeof address === "string" ? address : address.address;
 var mintWithEthParams = ({
@@ -2334,7 +2774,7 @@ var encodePremintOnManager = ({
   premintConfig,
   premintSignature,
   mintArguments,
-  signerContract = zeroAddress5
+  signerContract = zeroAddress6
 }) => encodeFunctionData2({
   abi: zoraMintsManagerImplConfig.abi,
   functionName: "collectPremintV2",
@@ -2465,17 +2905,18 @@ function createCollectorClient(params) {
   const premintGetterToUse = params.premintGetter || new PremintAPIClient(params.chainId);
   const mintGetterToUse = params.mintGetter || new SubgraphMintGetter(params.chainId);
   const mintClient = new MintClient({
-    chainId: params.chainId,
     publicClient: params.publicClient,
     premintGetter: premintGetterToUse,
     mintGetter: mintGetterToUse
   });
   return {
-    getPremint: (p) => premintGetterToUse.getSignature({
+    getPremint: (p) => premintGetterToUse.get({
       collectionAddress: p.address,
       uid: p.uid
     }),
     getCollectDataFromPremintReceipt: (p) => getDataFromPremintReceipt(p, params.chainId),
+    getToken: (p) => mintClient.get(p),
+    getTokensOfContract: (p) => mintClient.getOfContract(p),
     mint: (p) => mintClient.mint(p),
     getMintCosts: (p) => mintClient.getMintCosts(p)
   };
@@ -2490,12 +2931,14 @@ export {
   SubgraphMintGetter,
   ZORA_API_BASE,
   applyUpdateToPremint,
+  buildPremintMintCall,
   collectOnchain,
   collectPremint,
   collectPremintV2WithMintsParams,
   collectWithMintsParams,
   convertCollectionFromApi,
   convertGetPremintApiResponse,
+  convertGetPremintOfCollectionApiResponse,
   convertPremintFromApi,
   createCollectorClient,
   createCreatorClient,
@@ -2510,10 +2953,8 @@ export {
   getApiNetworkConfigForChain,
   getDataFromPremintReceipt,
   getDefaultFixedPriceMinterAddress,
-  getMintCosts,
   getMintsAccountBalanceWithPriceQuery,
   getMintsEthPrice,
-  getNecessaryErc20Approval,
   getPremintCollectionAddress,
   getPremintExecutorAddress,
   getPremintMintCosts,
@@ -2533,15 +2974,12 @@ export {
   makePermitToCollectPremintOrNonPremint,
   makePermitTransferBatchAndTypeData,
   makePermitTransferTypeData,
-  makePrepareMint1155TokenParams,
   makeUrls,
   migratePremintConfigToV2,
   mintWithEthParams,
   mintsBalanceOfAccountParams,
-  parseMintCosts,
   recoverCreatorFromCreatorAttribution,
   recoverPremintSigner,
-  requestErc20ApprovalForMint,
   selectMintsToCollectWithFromQueryResult,
   sumBalances,
   supportedPremintVersions,