@zoralabs/protocol-sdk 0.6.0 → 0.7.0

package/dist/index.cjs

@@ -39,12 +39,14 @@ __export(src_exports, {
   SubgraphMintGetter: () => SubgraphMintGetter,
   ZORA_API_BASE: () => ZORA_API_BASE,
   applyUpdateToPremint: () => applyUpdateToPremint,
+  buildPremintMintCall: () => buildPremintMintCall,
   collectOnchain: () => collectOnchain,
   collectPremint: () => collectPremint,
   collectPremintV2WithMintsParams: () => collectPremintV2WithMintsParams,
   collectWithMintsParams: () => collectWithMintsParams,
   convertCollectionFromApi: () => convertCollectionFromApi,
   convertGetPremintApiResponse: () => convertGetPremintApiResponse,
+  convertGetPremintOfCollectionApiResponse: () => convertGetPremintOfCollectionApiResponse,
   convertPremintFromApi: () => convertPremintFromApi,
   createCollectorClient: () => createCollectorClient,
   createCreatorClient: () => createCreatorClient,
@@ -59,10 +61,8 @@ __export(src_exports, {
   getApiNetworkConfigForChain: () => getApiNetworkConfigForChain,
   getDataFromPremintReceipt: () => getDataFromPremintReceipt,
   getDefaultFixedPriceMinterAddress: () => getDefaultFixedPriceMinterAddress,
-  getMintCosts: () => getMintCosts,
   getMintsAccountBalanceWithPriceQuery: () => getMintsAccountBalanceWithPriceQuery,
   getMintsEthPrice: () => getMintsEthPrice,
-  getNecessaryErc20Approval: () => getNecessaryErc20Approval,
   getPremintCollectionAddress: () => getPremintCollectionAddress,
   getPremintExecutorAddress: () => getPremintExecutorAddress,
   getPremintMintCosts: () => getPremintMintCosts,
@@ -82,15 +82,12 @@ __export(src_exports, {
   makePermitToCollectPremintOrNonPremint: () => makePermitToCollectPremintOrNonPremint,
   makePermitTransferBatchAndTypeData: () => makePermitTransferBatchAndTypeData,
   makePermitTransferTypeData: () => makePermitTransferTypeData,
-  makePrepareMint1155TokenParams: () => makePrepareMint1155TokenParams,
   makeUrls: () => makeUrls,
   migratePremintConfigToV2: () => migratePremintConfigToV2,
   mintWithEthParams: () => mintWithEthParams,
   mintsBalanceOfAccountParams: () => mintsBalanceOfAccountParams,
-  parseMintCosts: () => parseMintCosts,
   recoverCreatorFromCreatorAttribution: () => recoverCreatorFromCreatorAttribution,
   recoverPremintSigner: () => recoverPremintSigner,
-  requestErc20ApprovalForMint: () => requestErc20ApprovalForMint,
   selectMintsToCollectWithFromQueryResult: () => selectMintsToCollectWithFromQueryResult,
   sumBalances: () => sumBalances,
   supportedPremintVersions: () => supportedPremintVersions,
@@ -125,41 +122,6 @@ var zora721Abi = (0, import_viem.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 = (0, import_viem2.parseEther)("0.000777");
@@ -286,10 +248,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,
@@ -578,7 +552,7 @@ async function getPremintPricePerToken({
   uid,
   premintGetter
 }) {
-  const premintConfigWithVersion = await premintGetter.getSignature({
+  const { premint: premintConfigWithVersion } = await premintGetter.get({
     collectionAddress: collection,
     uid
   });
@@ -717,6 +691,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]) {
@@ -724,92 +836,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
@@ -967,7 +1158,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
     });
@@ -1202,10 +1393,9 @@ async function updatePremint({
   chainId
 }) {
   const {
-    premintConfig,
-    collection: collectionCreationConfig,
-    premintConfigVersion
-  } = await apiClient.getSignature({
+    premint: { premintConfig, premintConfigVersion },
+    collection: collectionCreationConfig
+  } = await apiClient.get({
     collectionAddress: collection,
     uid
   });
@@ -1233,11 +1423,10 @@ async function deletePremint({
   chainId
 }) {
   const {
-    premintConfig,
-    premintConfigVersion,
+    premint: { premintConfig, premintConfigVersion },
     collection: collectionCreationConfig,
     collectionAddress
-  } = await apiClient.getSignature({
+  } = await apiClient.get({
     collectionAddress: collection,
     uid
   });
@@ -1271,26 +1460,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 === import_protocol_deployments4.PremintConfigVersion.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({
@@ -1304,6 +1506,10 @@ async function collectPremint({
   const collectionOrEmpty = collection ? defaultAdditionalAdmins(collection) : emptyContractCreationConfig();
   const collectionAddressToSubmit = collection ? import_viem4.zeroAddress : collectionAddress;
   const firstMinterToSubmit = firstMinter || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
+  if (premint.premintConfigVersion === import_protocol_deployments4.PremintConfigVersion.V3) {
+    throw new Error("PremintV3 not supported in premint SDK");
+  }
+  const value = (mintFee + premint.premintConfig.tokenConfig.pricePerToken) * BigInt(quantityToMint);
   return makeContractParameters({
     account: minterAccount,
     abi: import_protocol_deployments3.zoraCreator1155PremintExecutorImplABI,
@@ -1313,18 +1519,15 @@ async function collectPremint({
     args: [
       collectionOrEmpty,
       collectionAddressToSubmit,
-      (0, import_protocol_deployments3.encodePremintConfig)({
-        premintConfig,
-        premintConfigVersion
-      }),
+      (0, import_protocol_deployments3.encodePremintConfig)(premint),
       signature,
-      numberToMint,
+      BigInt(quantityToMint),
       mintArgumentsContract,
       firstMinterToSubmit,
       import_viem4.zeroAddress
     ]
   });
-}
+};
 function makeUrls({
   uid,
   address,
@@ -1383,6 +1586,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 = ({
@@ -1404,10 +1620,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,
@@ -1415,170 +1628,102 @@ 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
 var import_viem5 = require("viem");
 var import_protocol_deployments6 = require("@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
+var semver = __toESM(require("semver"), 1);
+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: import_viem5.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 = import_protocol_deployments6.erc20MinterAddress[chainId];
-  const allowance = await publicClient.readContract({
-    abi: import_viem5.erc20Abi,
-    address: tokenAddress,
-    functionName: "allowance",
-    account,
-    args: [
-      destination,
-      import_protocol_deployments6.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: import_protocol_deployments6.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 || import_viem5.zeroAddress,
+        mintComment || ""
+      ]
     });
   }
-  return makePrepareMint1155TokenParams({
-    salesConfigAndTokenInfo,
-    chainId,
-    ...parameters
-  });
+  throw new Error("Unsupported sale type");
 }
-async function makePrepareMint721TokenParams({
+function makePrepareMint721TokenParams({
   salesConfigAndTokenInfo,
   minterAccount,
   tokenContract,
@@ -1589,7 +1734,8 @@ async function makePrepareMint721TokenParams({
 }) {
   const actualQuantityToMint = BigInt(quantityToMint || 1);
   const mintValue = parseMintCosts({
-    salesConfigAndTokenInfo,
+    mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
+    salesConfig: salesConfigAndTokenInfo.salesConfig,
     quantityToMint: actualQuantityToMint
   }).totalCostEth;
   return makeContractParameters({
@@ -1606,15 +1752,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 = (0, import_viem5.encodeAbiParameters)(
+    (0, import_viem5.parseAbiParameters)("address, string"),
+    [mintTo, mintComment || ""]
+  );
+  if (contractSupportsNewMintFunction(salesConfigAndTokenInfo.contractVersion)) {
+    return makeContractParameters({
+      abi: import_protocol_deployments6.zoraCreator1155ImplABI,
+      functionName: "mint",
+      account: minterAccount,
+      value: mintValue,
+      address: tokenContract,
+      args: [
+        salesConfigAndTokenInfo.salesConfig.address,
+        BigInt(tokenId),
+        mintQuantity,
+        mintReferral ? [mintReferral] : [],
+        minterArguments
+      ]
+    });
+  }
+  return makeContractParameters({
+    abi: import_protocol_deployments6.zoraCreator1155ImplABI,
+    functionName: "mintWithRewards",
+    account: minterAccount,
+    value: mintValue,
+    address: tokenContract,
+    /* args: minter, tokenId, quantity, minterArguments, mintReferral */
+    args: [
+      salesConfigAndTokenInfo.salesConfig.address,
+      BigInt(tokenId),
+      mintQuantity,
+      minterArguments,
+      mintReferral || import_viem5.zeroAddress
+    ]
+  });
+}
+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,
@@ -1623,90 +1819,334 @@ function parseMintCosts({
     totalCostEth: mintFeeForTokens + totalPurchaseCostEth
   };
 }
-async function getMintCosts(params) {
-  const { quantityMinted: quantityToMint, collection, publicClient } = params;
+
+// src/mint/mint-queries.ts
+var import_viem6 = require("viem");
+async function getMint({
+  params,
+  mintGetter,
+  premintGetter,
+  publicClient
+}) {
+  const { tokenContract } = params;
+  if (isOnChainMint(params)) {
+    const tokenId = is1155Mint(params) ? params.tokenId : void 0;
+    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 params.mintGetter.getSalesConfigAndTokenInfo({
+    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: import_protocol_deployments6.zoraCreator1155ImplABI,
-      functionName: "mintWithRewards",
-      account: minterAccount,
-      value: mintValue,
-      address: tokenContract,
-      /* args: minter, tokenId, quantity, minterArguments, mintReferral */
-      args: [
-        salesConfigAndTokenInfo.salesConfig.address || import_protocol_deployments6.zoraCreatorFixedPriceSaleStrategyAddress[chainId],
-        BigInt(tokenId),
-        mintQuantity,
-        (0, import_viem5.encodeAbiParameters)((0, import_viem5.parseAbiParameters)("address, string"), [
-          mintTo,
-          mintComment || ""
-        ]),
-        mintReferral || import_viem5.zeroAddress
-      ]
+  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: import_viem6.zeroAddress,
+        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: import_protocol_deployments6.erc20MinterABI,
-      functionName: "mint",
-      account: minterAccount,
-      address: salesConfigAndTokenInfo?.salesConfig.address || import_protocol_deployments6.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 || import_viem5.zeroAddress,
-        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
     });
   }
-  throw new MintError("Unsupported sale type");
+  /**
+   * 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
+    });
+  }
+  /**
+   * 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
 var import_protocol_deployments9 = require("@zoralabs/protocol-deployments");
-var import_viem7 = require("viem");
+var import_viem8 = require("viem");
 
 // src/create/contract-setup.ts
 var import_protocol_deployments7 = require("@zoralabs/protocol-deployments");
@@ -1763,15 +2203,15 @@ async function getContractInfo({
 
 // src/create/token-setup.ts
 var import_protocol_deployments8 = require("@zoralabs/protocol-deployments");
-var import_viem6 = require("viem");
-var semver = __toESM(require("semver"), 1);
+var import_viem7 = require("viem");
+var semver2 = __toESM(require("semver"), 1);
 var PERMISSION_BITS = {
   MINTER: 2n ** 2n
 };
 var saleSettingsOrDefault = (saleSettings) => {
   const SALE_END_FOREVER = 18446744073709551615n;
   const DEFAULT_SALE_SETTINGS = {
-    currency: import_viem6.zeroAddress,
+    currency: import_viem7.zeroAddress,
     // Free Mint
     pricePerToken: 0n,
     // Sale start time – defaults to beginning of unix time
@@ -1788,10 +2228,10 @@ var saleSettingsOrDefault = (saleSettings) => {
 };
 function applyNew1155Defaults(props, ownerAddress) {
   const { payoutRecipient: fundsRecipient } = props;
-  const fundsRecipientOrOwner = fundsRecipient && fundsRecipient !== import_viem6.zeroAddress ? fundsRecipient : ownerAddress;
+  const fundsRecipientOrOwner = fundsRecipient && fundsRecipient !== import_viem7.zeroAddress ? fundsRecipient : ownerAddress;
   return {
     payoutRecipient: fundsRecipientOrOwner,
-    createReferral: props.createReferral || import_viem6.zeroAddress,
+    createReferral: props.createReferral || import_viem7.zeroAddress,
     maxSupply: typeof props.maxSupply === "undefined" ? OPEN_EDITION_MINT_SIZE : BigInt(props.maxSupply),
     royaltyBPS: props.royaltyBPS || 1e3,
     salesConfig: saleSettingsOrDefault(props.salesConfig),
@@ -1808,15 +2248,15 @@ function setupErc20Minter({
   maxTokensPerAddress: mintLimit,
   fundsRecipient
 }) {
-  const erc20MinterAddress2 = import_protocol_deployments8.erc20MinterAddress[chainId];
-  if (!erc20MinterAddress2)
+  const erc20MinterAddress = import_protocol_deployments8.erc20MinterAddress[chainId];
+  if (!erc20MinterAddress)
     throw new Error(`ERC20Minter not deployed on chainId ${chainId}`);
-  const erc20MinterApproval = (0, import_viem6.encodeFunctionData)({
+  const erc20MinterApproval = (0, import_viem7.encodeFunctionData)({
     abi: import_protocol_deployments8.zoraCreator1155ImplABI,
     functionName: "addPermission",
-    args: [BigInt(nextTokenId), erc20MinterAddress2, PERMISSION_BITS.MINTER]
+    args: [BigInt(nextTokenId), erc20MinterAddress, PERMISSION_BITS.MINTER]
   });
-  const saleData = (0, import_viem6.encodeFunctionData)({
+  const saleData = (0, import_viem7.encodeFunctionData)({
     abi: import_protocol_deployments8.erc20MinterABI,
     functionName: "setSale",
     args: [
@@ -1831,13 +2271,13 @@ function setupErc20Minter({
       }
     ]
   });
-  const callSale = (0, import_viem6.encodeFunctionData)({
+  const callSale = (0, import_viem7.encodeFunctionData)({
     abi: import_protocol_deployments8.zoraCreator1155ImplABI,
     functionName: "callSale",
-    args: [BigInt(nextTokenId), erc20MinterAddress2, saleData]
+    args: [BigInt(nextTokenId), erc20MinterAddress, saleData]
   });
   return {
-    minter: erc20MinterAddress2,
+    minter: erc20MinterAddress,
     setupActions: [erc20MinterApproval, callSale]
   };
 }
@@ -1851,7 +2291,7 @@ function setupFixedPriceMinter({
   fundsRecipient
 }) {
   const fixedPriceStrategyAddress = import_protocol_deployments8.zoraCreatorFixedPriceSaleStrategyAddress[chainId];
-  const fixedPriceApproval = (0, import_viem6.encodeFunctionData)({
+  const fixedPriceApproval = (0, import_viem7.encodeFunctionData)({
     abi: import_protocol_deployments8.zoraCreator1155ImplABI,
     functionName: "addPermission",
     args: [
@@ -1860,7 +2300,7 @@ function setupFixedPriceMinter({
       PERMISSION_BITS.MINTER
     ]
   });
-  const saleData = (0, import_viem6.encodeFunctionData)({
+  const saleData = (0, import_viem7.encodeFunctionData)({
     abi: import_protocol_deployments8.zoraCreatorFixedPriceSaleStrategyABI,
     functionName: "setSale",
     args: [
@@ -1874,7 +2314,7 @@ function setupFixedPriceMinter({
       }
     ]
   });
-  const callSale = (0, import_viem6.encodeFunctionData)({
+  const callSale = (0, import_viem7.encodeFunctionData)({
     abi: import_protocol_deployments8.zoraCreator1155ImplABI,
     functionName: "callSale",
     args: [BigInt(nextTokenId), fixedPriceStrategyAddress, saleData]
@@ -1888,7 +2328,7 @@ function setupMinters({ salesConfig, ...rest }) {
   if (!salesConfig)
     throw new Error("No sales config for token");
   const { currency: currencyAddress } = salesConfig;
-  if (currencyAddress === import_viem6.zeroAddress) {
+  if (currencyAddress === import_viem7.zeroAddress) {
     return setupFixedPriceMinter({
       ...salesConfig,
       ...rest
@@ -1903,22 +2343,22 @@ function setupMinters({ salesConfig, ...rest }) {
 function buildSetupNewToken({
   tokenURI,
   maxSupply = OPEN_EDITION_MINT_SIZE,
-  createReferral = import_viem6.zeroAddress,
+  createReferral = import_viem7.zeroAddress,
   contractVersion
 }) {
   if (contractSupportsMintRewards(contractVersion, "ERC1155")) {
-    return (0, import_viem6.encodeFunctionData)({
+    return (0, import_viem7.encodeFunctionData)({
       abi: import_protocol_deployments8.zoraCreator1155ImplABI,
       functionName: "setupNewTokenWithCreateReferral",
       args: [tokenURI, BigInt(maxSupply), createReferral]
     });
   }
-  if (createReferral !== import_viem6.zeroAddress) {
+  if (createReferral !== import_viem7.zeroAddress) {
     throw new Error(
       "Contract does not support create referral, but one was provided"
     );
   }
-  return (0, import_viem6.encodeFunctionData)({
+  return (0, import_viem7.encodeFunctionData)({
     abi: import_protocol_deployments8.zoraCreator1155ImplABI,
     functionName: "setupNewToken",
     args: [tokenURI, BigInt(maxSupply)]
@@ -1929,8 +2369,8 @@ function setupRoyaltyConfig({
   royaltyRecipient,
   nextTokenId
 }) {
-  if (royaltyBPS > 0 && royaltyRecipient != import_viem6.zeroAddress) {
-    return (0, import_viem6.encodeFunctionData)({
+  if (royaltyBPS > 0 && royaltyRecipient != import_viem7.zeroAddress) {
+    return (0, import_viem7.encodeFunctionData)({
       abi: import_protocol_deployments8.zoraCreator1155ImplABI,
       functionName: "updateRoyaltiesForToken",
       args: [
@@ -1953,10 +2393,10 @@ function makeAdminMintCall({
   if (!mintQuantity || mintQuantity <= 0 || !ownerAddress) {
     return null;
   }
-  return (0, import_viem6.encodeFunctionData)({
+  return (0, import_viem7.encodeFunctionData)({
     abi: import_protocol_deployments8.zoraCreator1155ImplABI,
     functionName: "adminMint",
-    args: [ownerAddress, nextTokenId, BigInt(mintQuantity), import_viem6.zeroAddress]
+    args: [ownerAddress, nextTokenId, BigInt(mintQuantity), import_viem7.zeroAddress]
   });
 }
 function constructCreate1155TokenCalls(props) {
@@ -1971,7 +2411,7 @@ function constructCreate1155TokenCalls(props) {
     props,
     ownerAddress
   );
-  const verifyTokenIdExpected = (0, import_viem6.encodeFunctionData)({
+  const verifyTokenIdExpected = (0, import_viem7.encodeFunctionData)({
     abi: import_protocol_deployments8.zoraCreator1155ImplABI,
     functionName: "assumeLastTokenIdMatches",
     args: [nextTokenId - 1n]
@@ -2015,13 +2455,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");
   }
 };
 
@@ -2030,7 +2470,7 @@ var ROYALTY_BPS_DEFAULT = 1e3;
 var getTokenIdFromCreateReceipt = (receipt) => {
   for (const data of receipt.logs) {
     try {
-      const decodedLog = (0, import_viem7.decodeEventLog)({
+      const decodedLog = (0, import_viem8.decodeEventLog)({
         abi: import_protocol_deployments9.zoraCreator1155ImplABI,
         eventName: "SetupNewToken",
         ...data
@@ -2212,7 +2652,7 @@ var sumBalances = (mintAccountBalances) => {
 
 // src/mints/mints-contracts.ts
 var import_protocol_deployments10 = require("@zoralabs/protocol-deployments");
-var import_viem8 = require("viem");
+var import_viem9 = require("viem");
 var addressOrAccountAddress = (address) => typeof address === "string" ? address : address.address;
 var mintWithEthParams = ({
   quantity,
@@ -2247,7 +2687,7 @@ var encodeCollectOnManager = ({
   minter,
   zoraCreator1155TokenId,
   mintArguments
-}) => (0, import_viem8.encodeFunctionData)({
+}) => (0, import_viem9.encodeFunctionData)({
   abi: import_protocol_deployments10.zoraMintsManagerImplConfig.abi,
   functionName: "collect",
   args: [
@@ -2367,8 +2807,8 @@ var encodePremintOnManager = ({
   premintConfig,
   premintSignature,
   mintArguments,
-  signerContract = import_viem8.zeroAddress
-}) => (0, import_viem8.encodeFunctionData)({
+  signerContract = import_viem9.zeroAddress
+}) => (0, import_viem9.encodeFunctionData)({
   abi: import_protocol_deployments10.zoraMintsManagerImplConfig.abi,
   functionName: "collectPremintV2",
   args: [
@@ -2435,7 +2875,7 @@ function decodeCallFailedError(error) {
   if (error.data?.errorName !== "CallFailed")
     throw new Error("Not a CallFailed error");
   const internalErrorData = error.data?.args?.[0];
-  return (0, import_viem8.decodeErrorResult)({
+  return (0, import_viem9.decodeErrorResult)({
     abi: import_protocol_deployments10.zoraMintsManagerImplABI,
     data: internalErrorData
   });
@@ -2443,12 +2883,12 @@ function decodeCallFailedError(error) {
 
 // src/mints/mints-eth-unwrapper-and-caller.ts
 var import_protocol_deployments11 = require("@zoralabs/protocol-deployments");
-var import_viem9 = require("viem");
+var import_viem10 = require("viem");
 var makeCallWithEthSafeTransferData = ({
   address: addressToCall,
   call: functionToCall,
   value: valueToSend
-}) => (0, import_viem9.encodeFunctionData)({
+}) => (0, import_viem10.encodeFunctionData)({
   abi: import_protocol_deployments11.iUnwrapAndForwardActionABI,
   functionName: "callWithEth",
   args: [addressToCall, functionToCall, valueToSend]
@@ -2495,17 +2935,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)
   };
@@ -2521,12 +2962,14 @@ function createCollectorClient(params) {
   SubgraphMintGetter,
   ZORA_API_BASE,
   applyUpdateToPremint,
+  buildPremintMintCall,
   collectOnchain,
   collectPremint,
   collectPremintV2WithMintsParams,
   collectWithMintsParams,
   convertCollectionFromApi,
   convertGetPremintApiResponse,
+  convertGetPremintOfCollectionApiResponse,
   convertPremintFromApi,
   createCollectorClient,
   createCreatorClient,
@@ -2541,10 +2984,8 @@ function createCollectorClient(params) {
   getApiNetworkConfigForChain,
   getDataFromPremintReceipt,
   getDefaultFixedPriceMinterAddress,
-  getMintCosts,
   getMintsAccountBalanceWithPriceQuery,
   getMintsEthPrice,
-  getNecessaryErc20Approval,
   getPremintCollectionAddress,
   getPremintExecutorAddress,
   getPremintMintCosts,
@@ -2564,15 +3005,12 @@ function createCollectorClient(params) {
   makePermitToCollectPremintOrNonPremint,
   makePermitTransferBatchAndTypeData,
   makePermitTransferTypeData,
-  makePrepareMint1155TokenParams,
   makeUrls,
   migratePremintConfigToV2,
   mintWithEthParams,
   mintsBalanceOfAccountParams,
-  parseMintCosts,
   recoverCreatorFromCreatorAttribution,
   recoverPremintSigner,
-  requestErc20ApprovalForMint,
   selectMintsToCollectWithFromQueryResult,
   sumBalances,
   supportedPremintVersions,