@zoralabs/protocol-sdk 0.5.17 → 0.7.0

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,27 +17,39 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  DEFAULT_SALE_SETTINGS: () => DEFAULT_SALE_SETTINGS,
+  Create1155Client: () => Create1155Client,
   Errors: () => Errors,
-  MintAPIClient: () => MintAPIClient,
+  MintClient: () => MintClient,
   PremintAPIClient: () => PremintAPIClient,
+  PremintClient: () => PremintClient,
   PremintConfigVersion: () => PremintConfigVersion3,
+  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,
-  create1155CreatorClient: () => create1155CreatorClient,
-  create1155TokenSetupArgs: () => create1155TokenSetupArgs,
-  createMintClient: () => createMintClient,
-  createPremintClient: () => createPremintClient,
+  createCollectorClient: () => createCollectorClient,
+  createCreatorClient: () => createCreatorClient,
   decodeCallFailedError: () => decodeCallFailedError,
   defaultAdditionalAdmins: () => defaultAdditionalAdmins,
   defaultTokenConfigV1MintArguments: () => defaultTokenConfigV1MintArguments,
@@ -45,17 +59,22 @@ __export(src_exports, {
   encodePostSignatureInput: () => encodePostSignatureInput,
   encodePremintForAPI: () => encodePremintForAPI,
   getApiNetworkConfigForChain: () => getApiNetworkConfigForChain,
+  getDataFromPremintReceipt: () => getDataFromPremintReceipt,
   getDefaultFixedPriceMinterAddress: () => getDefaultFixedPriceMinterAddress,
-  getMintCosts: () => getMintCosts,
   getMintsAccountBalanceWithPriceQuery: () => getMintsAccountBalanceWithPriceQuery,
   getMintsEthPrice: () => getMintsEthPrice,
   getPremintCollectionAddress: () => getPremintCollectionAddress,
   getPremintExecutorAddress: () => getPremintExecutorAddress,
   getPremintMintCosts: () => getPremintMintCosts,
+  getPremintMintCostsWithUnknownTokenPrice: () => getPremintMintCostsWithUnknownTokenPrice,
   getPremintMintFee: () => getPremintMintFee,
+  getPremintPricePerToken: () => getPremintPricePerToken,
   getPremintedLogFromReceipt: () => getPremintedLogFromReceipt,
+  getSignature: () => getSignature,
   getTokenIdFromCreateReceipt: () => getTokenIdFromCreateReceipt,
   isAuthorizedToCreatePremint: () => isAuthorizedToCreatePremint,
+  isPremintConfigV1: () => isPremintConfigV1,
+  isPremintConfigV2: () => isPremintConfigV2,
   isValidSignature: () => isValidSignature,
   makeCallWithEthSafeTransferData: () => makeCallWithEthSafeTransferData,
   makeMintRewardsRecipient: () => makeMintRewardsRecipient,
@@ -80,22 +99,245 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/premint/premint-client.ts
-var import_viem5 = require("viem");
+var import_viem4 = require("viem");
 var import_protocol_deployments3 = require("@zoralabs/protocol-deployments");
 
 // src/premint/preminter.ts
-var import_protocol_deployments = require("@zoralabs/protocol-deployments");
+var import_protocol_deployments2 = require("@zoralabs/protocol-deployments");
+var import_viem3 = require("viem");
+
+// src/apis/chain-constants.ts
+var import_chains = require("viem/chains");
+var import_viem2 = require("viem");
+
+// src/constants.ts
 var import_viem = require("viem");
-var getPremintExecutorAddress = () => import_protocol_deployments.zoraCreator1155PremintExecutorImplAddress[999];
+var ZORA_API_BASE = "https://api.zora.co/";
+var OPEN_EDITION_MINT_SIZE = BigInt("18446744073709551615");
+var SUBGRAPH_CONFIG_BASE = "https://api.goldsky.com/api/public/project_clhk16b61ay9t49vm6ntn4mkz/subgraphs";
+function getSubgraph(name, version) {
+  return `${SUBGRAPH_CONFIG_BASE}/${name}/${version}/gn`;
+}
+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)"
+]);
+
+// src/apis/chain-constants.ts
+var REWARD_PER_TOKEN = (0, import_viem2.parseEther)("0.000777");
+var networkConfigByChain = {
+  [import_chains.mainnet.id]: {
+    chainId: import_chains.mainnet.id,
+    isTestnet: false,
+    zoraCollectPathChainName: "eth",
+    zoraBackendChainName: "ETHEREUM-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-mainnet", "stable")
+  },
+  [import_chains.sepolia.id]: {
+    chainId: import_chains.sepolia.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "sep",
+    zoraBackendChainName: "ETHEREUM-SEPOLIA",
+    subgraphUrl: getSubgraph("zora-create-sepolia", "stable")
+  },
+  [import_chains.zora.id]: {
+    chainId: import_chains.zora.id,
+    isTestnet: false,
+    zoraCollectPathChainName: "zora",
+    zoraBackendChainName: "ZORA-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-zora-mainnet", "stable")
+  },
+  [import_chains.zoraSepolia.id]: {
+    chainId: import_chains.zoraSepolia.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "zsep",
+    zoraBackendChainName: "ZORA-SEPOLIA",
+    subgraphUrl: getSubgraph("zora-create-zora-sepolia", "stable")
+  },
+  [import_chains.optimism.id]: {
+    chainId: import_chains.optimism.id,
+    isTestnet: false,
+    zoraCollectPathChainName: "oeth",
+    zoraBackendChainName: "OPTIMISM-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-optimism", "stable")
+  },
+  [import_chains.arbitrum.id]: {
+    chainId: import_chains.arbitrum.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "arb",
+    zoraBackendChainName: "ARBITRUM-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-arbitrum-one", "stable")
+  },
+  [import_chains.base.id]: {
+    chainId: import_chains.base.id,
+    isTestnet: false,
+    zoraCollectPathChainName: "base",
+    zoraBackendChainName: "BASE-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-base-mainnet", "stable")
+  },
+  [import_chains.baseSepolia.id]: {
+    chainId: import_chains.baseSepolia.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "bsep",
+    zoraBackendChainName: "BASE-SEPOLIA",
+    subgraphUrl: getSubgraph("zora-create-base-sepolia", "stable")
+  },
+  [import_chains.foundry.id]: {
+    chainId: import_chains.foundry.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "zgor",
+    zoraBackendChainName: "ZORA-GOERLI",
+    subgraphUrl: getSubgraph("zora-create-zora-testnet", "stable")
+  }
+};
+
+// src/premint/conversions.ts
+var import_protocol_deployments = require("@zoralabs/protocol-deployments");
+var convertCollectionFromApi = (collection) => {
+  if (!collection)
+    return void 0;
+  return {
+    additionalAdmins: collection.additionalAdmins || [],
+    contractAdmin: collection.contractAdmin,
+    contractName: collection.contractName,
+    contractURI: collection.contractURI
+  };
+};
+var convertPremintFromApi = (premint) => {
+  if (premint.config_version === import_protocol_deployments.PremintConfigVersion.V1 || !premint.config_version) {
+    const tokenConfig = premint.tokenConfig;
+    return {
+      premintConfigVersion: import_protocol_deployments.PremintConfigVersion.V1,
+      premintConfig: {
+        deleted: premint.deleted,
+        uid: premint.uid,
+        version: premint.version,
+        tokenConfig: {
+          ...tokenConfig,
+          fixedPriceMinter: tokenConfig.fixedPriceMinter,
+          royaltyRecipient: tokenConfig.royaltyRecipient,
+          maxSupply: BigInt(tokenConfig.maxSupply),
+          pricePerToken: BigInt(tokenConfig.pricePerToken),
+          mintStart: BigInt(tokenConfig.mintStart),
+          mintDuration: BigInt(tokenConfig.mintDuration),
+          maxTokensPerAddress: BigInt(tokenConfig.maxTokensPerAddress)
+        }
+      }
+    };
+  } else {
+    const tokenConfig = premint.tokenConfig;
+    return {
+      premintConfigVersion: import_protocol_deployments.PremintConfigVersion.V2,
+      premintConfig: {
+        deleted: premint.deleted,
+        uid: premint.uid,
+        version: premint.version,
+        tokenConfig: {
+          ...tokenConfig,
+          fixedPriceMinter: tokenConfig.fixedPriceMinter,
+          payoutRecipient: tokenConfig.payoutRecipient,
+          createReferral: tokenConfig.createReferral,
+          maxSupply: BigInt(tokenConfig.maxSupply),
+          pricePerToken: BigInt(tokenConfig.pricePerToken),
+          mintStart: BigInt(tokenConfig.mintStart),
+          mintDuration: BigInt(tokenConfig.mintDuration),
+          maxTokensPerAddress: BigInt(tokenConfig.maxTokensPerAddress)
+        }
+      }
+    };
+  }
+};
+var convertGetPremintApiResponse = (response) => ({
+  collection: convertCollectionFromApi(response.collection),
+  collectionAddress: response.collection_address,
+  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,
+  ...premint
+}) => ({
+  ...premint,
+  config_version: "1",
+  tokenConfig: {
+    ...tokenConfig,
+    maxSupply: tokenConfig.maxSupply.toString(),
+    pricePerToken: tokenConfig.pricePerToken.toString(),
+    mintStart: tokenConfig.mintStart.toString(),
+    mintDuration: tokenConfig.mintDuration.toString(),
+    maxTokensPerAddress: tokenConfig.maxTokensPerAddress.toString()
+  }
+});
+var encodePremintV2ForAPI = ({
+  tokenConfig,
+  ...premint
+}) => ({
+  ...premint,
+  config_version: "2",
+  tokenConfig: {
+    ...tokenConfig,
+    maxSupply: tokenConfig.maxSupply.toString(),
+    pricePerToken: tokenConfig.pricePerToken.toString(),
+    mintStart: tokenConfig.mintStart.toString(),
+    mintDuration: tokenConfig.mintDuration.toString(),
+    maxTokensPerAddress: tokenConfig.maxTokensPerAddress.toString()
+  }
+});
+var encodePremintForAPI = ({
+  premintConfig,
+  premintConfigVersion
+}) => {
+  if (premintConfigVersion === import_protocol_deployments.PremintConfigVersion.V1) {
+    return encodePremintV1ForAPI(premintConfig);
+  }
+  if (premintConfigVersion === import_protocol_deployments.PremintConfigVersion.V2) {
+    return encodePremintV2ForAPI(premintConfig);
+  }
+  throw new Error(`Invalid premint config version ${premintConfigVersion}`);
+};
+var encodePostSignatureInput = ({
+  contract: collection,
+  contractAddress: collectionAddress,
+  premintConfigVersion,
+  premintConfig,
+  signature,
+  chainId
+}) => ({
+  premint: encodePremintForAPI({
+    premintConfig,
+    premintConfigVersion
+  }),
+  signature,
+  collection,
+  collection_address: collectionAddress,
+  chain_name: networkConfigByChain[chainId].zoraBackendChainName
+});
+var isPremintConfigV1 = (premintConfigAndVersion) => premintConfigAndVersion.premintConfigVersion === import_protocol_deployments.PremintConfigVersion.V1;
+var isPremintConfigV2 = (premintConfigAndVersion) => premintConfigAndVersion.premintConfigVersion === import_protocol_deployments.PremintConfigVersion.V2;
+
+// src/premint/preminter.ts
+var getPremintExecutorAddress = () => import_protocol_deployments2.zoraCreator1155PremintExecutorImplAddress[999];
 async function isAuthorizedToCreatePremint({
-  contractAdmin = import_viem.zeroAddress,
+  contractAdmin = import_viem3.zeroAddress,
   additionalAdmins = [],
   collectionAddress,
   publicClient,
   signer
 }) {
   return await publicClient.readContract({
-    abi: import_protocol_deployments.zoraCreator1155PremintExecutorImplABI,
+    abi: import_protocol_deployments2.zoraCreator1155PremintExecutorImplABI,
     address: getPremintExecutorAddress(),
     functionName: "isAuthorizedToCreatePremintWithAdditionalAdmins",
     args: [
@@ -110,8 +352,8 @@ async function recoverPremintSigner({
   signature,
   ...rest
 }) {
-  return await (0, import_viem.recoverTypedDataAddress)({
-    ...(0, import_protocol_deployments.premintTypedDataDefinition)(rest),
+  return await (0, import_viem3.recoverTypedDataAddress)({
+    ...(0, import_protocol_deployments2.premintTypedDataDefinition)(rest),
     signature
   });
 }
@@ -137,7 +379,7 @@ async function isValidSignature({
     verifyingContract: collectionAddress,
     chainId
   });
-  if (!import_viem.recoverAddress) {
+  if (!import_viem3.recoverAddress) {
     return {
       isAuthorized: false
     };
@@ -156,7 +398,7 @@ async function isValidSignature({
 }
 function migratePremintConfigToV2({
   premintConfig,
-  createReferral = import_viem.zeroAddress
+  createReferral = import_viem3.zeroAddress
 }) {
   return {
     ...premintConfig,
@@ -179,7 +421,7 @@ var recoverCreatorFromCreatorAttribution = async ({
   chainId,
   tokenContract
 }) => {
-  const hashedDomain = (0, import_viem.hashDomain)({
+  const hashedDomain = (0, import_viem3.hashDomain)({
     domain: {
       chainId,
       name: domainName,
@@ -202,8 +444,8 @@ var recoverCreatorFromCreatorAttribution = async ({
     }
   });
   const parts = ["0x1901", hashedDomain, structHash];
-  const hashedTypedData = (0, import_viem.keccak256)((0, import_viem.concat)(parts));
-  return await (0, import_viem.recoverAddress)({
+  const hashedTypedData = (0, import_viem3.keccak256)((0, import_viem3.concat)(parts));
+  return await (0, import_viem3.recoverAddress)({
     hash: hashedTypedData,
     signature
   });
@@ -213,7 +455,7 @@ var supportedPremintVersions = async ({
   publicClient
 }) => {
   return await publicClient.readContract({
-    abi: import_protocol_deployments.zoraCreator1155PremintExecutorImplABI,
+    abi: import_protocol_deployments2.zoraCreator1155PremintExecutorImplABI,
     address: getPremintExecutorAddress(),
     functionName: "supportedPremintSignatureVersions",
     args: [tokenContract]
@@ -228,13 +470,13 @@ var supportsPremintVersion = async ({
 };
 async function getPremintCollectionAddress({
   publicClient,
-  collection,
-  collectionAddress
+  contract: collection,
+  contractAddress: collectionAddress
 }) {
   if (typeof collection !== "undefined") {
     return publicClient.readContract({
       address: getPremintExecutorAddress(),
-      abi: import_protocol_deployments.zoraCreator1155PremintExecutorImplABI,
+      abi: import_protocol_deployments2.zoraCreator1155PremintExecutorImplABI,
       functionName: "getContractWithAdditionalAdminsAddress",
       args: [
         {
@@ -282,13 +524,13 @@ async function getPremintMintFee({
   try {
     return await publicClient.readContract({
       address: getPremintExecutorAddress(),
-      abi: import_protocol_deployments.zoraCreator1155PremintExecutorImplABI,
+      abi: import_protocol_deployments2.zoraCreator1155PremintExecutorImplABI,
       functionName: "mintFee",
       args: [tokenContract]
     });
   } catch (e) {
     console.error(e);
-    return (0, import_viem.parseEther)("0.000777");
+    return (0, import_viem3.parseEther)("0.000777");
   }
 }
 async function getPremintMintCosts({
@@ -298,23 +540,53 @@ async function getPremintMintCosts({
   quantityToMint
 }) {
   const mintFee = await getPremintMintFee({ tokenContract, publicClient });
+  const quantityToMintBigInt = BigInt(quantityToMint);
   return {
-    mintFee: mintFee * quantityToMint,
-    tokenPurchaseCost: tokenPrice * quantityToMint,
-    totalCost: (mintFee + tokenPrice) * quantityToMint
+    mintFee: mintFee * quantityToMintBigInt,
+    totalPurchaseCost: tokenPrice * quantityToMintBigInt,
+    totalCostEth: (mintFee + tokenPrice) * quantityToMintBigInt
   };
 }
+async function getPremintPricePerToken({
+  collection,
+  uid,
+  premintGetter
+}) {
+  const { premint: premintConfigWithVersion } = await premintGetter.get({
+    collectionAddress: collection,
+    uid
+  });
+  if (isPremintConfigV1(premintConfigWithVersion) || isPremintConfigV2(premintConfigWithVersion)) {
+    return premintConfigWithVersion.premintConfig.tokenConfig.pricePerToken;
+  }
+  throw new Error("Premint version not supported to get price");
+}
+async function getPremintMintCostsWithUnknownTokenPrice({
+  premintGetter,
+  uid,
+  ...rest
+}) {
+  const pricePerToken = await getPremintPricePerToken({
+    uid,
+    premintGetter,
+    collection: rest.tokenContract
+  });
+  return await getPremintMintCosts({
+    ...rest,
+    tokenPrice: pricePerToken
+  });
+}
 function makeMintRewardsRecipient({
-  mintReferral = import_viem.zeroAddress,
-  platformReferral = import_viem.zeroAddress
+  mintReferral = import_viem3.zeroAddress,
+  platformReferral = import_viem3.zeroAddress
 }) {
   return [mintReferral, platformReferral];
 }
 function getDefaultFixedPriceMinterAddress(chainId) {
-  return import_protocol_deployments.zoraCreatorFixedPriceSaleStrategyAddress[chainId];
+  return import_protocol_deployments2.zoraCreatorFixedPriceSaleStrategyAddress[chainId];
 }
 var emptyContractCreationConfig = () => ({
-  contractAdmin: import_viem.zeroAddress,
+  contractAdmin: import_viem3.zeroAddress,
   contractURI: "",
   contractName: "",
   additionalAdmins: []
@@ -331,12 +603,12 @@ var toContractCreationConfigOrAddress = ({
 }) => {
   if (typeof collection !== "undefined") {
     return {
-      collection
+      contract: collection
     };
   }
   if (typeof collectionAddress !== "undefined") {
     return {
-      collectionAddress
+      contractAddress: collectionAddress
     };
   }
   throw new Error("Must provide either a collection or a collection address");
@@ -419,19 +691,39 @@ var httpClient = {
   retries
 };
 
-// src/constants.ts
-var import_viem2 = require("viem");
-var ZORA_API_BASE = "https://api.zora.co/";
-var OPEN_EDITION_MINT_SIZE = BigInt("18446744073709551615");
-var SUBGRAPH_CONFIG_BASE = "https://api.goldsky.com/api/public/project_clhk16b61ay9t49vm6ntn4mkz/subgraphs";
-function getSubgraph(name, version) {
-  return `${SUBGRAPH_CONFIG_BASE}/${name}/${version}/gn`;
+// src/mint/types.ts
+var isOnChainMint = (mint2) => mint2.mintType !== "premint";
+var is1155Mint = (mint2) => mint2.mintType === "1155";
+function isErc20SaleStrategy(salesConfig) {
+  return salesConfig.saleType === "erc20";
 }
-var zora721Abi = (0, import_viem2.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 = `
+
+// 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 {
@@ -449,377 +741,265 @@ fragment SaleStrategy on SalesStrategyConfig {
     saleStart
     maxTokensPerAddress
   }
-}
-
-query ($id: ID!) {
-  zoraCreateToken(id: $id) {
-    id
+}`;
+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
       }
     }
-    salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
-      ...SaleStrategy
-    }
-  }
-}
+}`;
+var FRAGMENTS = `
+${NFT_SALE_STRATEGY_FRAGMENT}
+${TOKEN_FRAGMENT}
 `;
-
-// src/apis/chain-constants.ts
-var import_chains = require("viem/chains");
-var import_viem3 = require("viem");
-var REWARD_PER_TOKEN = (0, import_viem3.parseEther)("0.000777");
-var networkConfigByChain = {
-  [import_chains.mainnet.id]: {
-    chainId: import_chains.mainnet.id,
-    isTestnet: false,
-    zoraCollectPathChainName: "eth",
-    zoraBackendChainName: "ETHEREUM-MAINNET",
-    subgraphUrl: getSubgraph("zora-create-mainnet", "stable")
-  },
-  [import_chains.sepolia.id]: {
-    chainId: import_chains.sepolia.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "sep",
-    zoraBackendChainName: "ETHEREUM-SEPOLIA",
-    subgraphUrl: getSubgraph("zora-create-sepolia", "stable")
-  },
-  [import_chains.zora.id]: {
-    chainId: import_chains.zora.id,
-    isTestnet: false,
-    zoraCollectPathChainName: "zora",
-    zoraBackendChainName: "ZORA-MAINNET",
-    subgraphUrl: getSubgraph("zora-create-zora-mainnet", "stable")
-  },
-  [import_chains.zoraSepolia.id]: {
-    chainId: import_chains.zoraSepolia.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "zsep",
-    zoraBackendChainName: "ZORA-SEPOLIA",
-    subgraphUrl: getSubgraph("zora-create-zora-sepolia", "stable")
-  },
-  [import_chains.optimism.id]: {
-    chainId: import_chains.optimism.id,
-    isTestnet: false,
-    zoraCollectPathChainName: "oeth",
-    zoraBackendChainName: "OPTIMISM-MAINNET",
-    subgraphUrl: getSubgraph("zora-create-optimism", "stable")
-  },
-  [import_chains.arbitrum.id]: {
-    chainId: import_chains.arbitrum.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "arb",
-    zoraBackendChainName: "ARBITRUM-MAINNET",
-    subgraphUrl: getSubgraph("zora-create-arbitrum-one", "stable")
-  },
-  [import_chains.base.id]: {
-    chainId: import_chains.base.id,
-    isTestnet: false,
-    zoraCollectPathChainName: "base",
-    zoraBackendChainName: "BASE-MAINNET",
-    subgraphUrl: getSubgraph("zora-create-base-mainnet", "stable")
-  },
-  [import_chains.baseSepolia.id]: {
-    chainId: import_chains.baseSepolia.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "bsep",
-    zoraBackendChainName: "BASE-SEPOLIA",
-    subgraphUrl: getSubgraph("zora-create-base-sepolia", "stable")
-  },
-  [import_chains.foundry.id]: {
-    chainId: import_chains.foundry.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "zgor",
-    zoraBackendChainName: "ZORA-GOERLI",
-    subgraphUrl: getSubgraph("zora-create-zora-testnet", "stable")
+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/mint-api-client.ts
+// src/mint/subgraph-mint-getter.ts
 var getApiNetworkConfigForChain = (chainId) => {
   if (!networkConfigByChain[chainId]) {
     throw new Error(`chain id ${chainId} network not configured `);
   }
   return networkConfigByChain[chainId];
 };
-var MintAPIClient = class {
-  constructor(chainId, httpClient2) {
-    this.httpClient = httpClient2 || httpClient;
-    this.networkConfig = getApiNetworkConfigForChain(chainId);
-  }
-  async getSalesConfigAndTokenInfo({
-    tokenAddress,
-    tokenId,
-    saleType
-  }) {
-    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");
-    });
-  }
-};
-
-// src/premint/conversions.ts
-var import_protocol_deployments2 = require("@zoralabs/protocol-deployments");
-var convertCollectionFromApi = (collection) => {
-  if (!collection)
-    return void 0;
-  return {
-    additionalAdmins: collection.additionalAdmins || [],
-    contractAdmin: collection.contractAdmin,
-    contractName: collection.contractName,
-    contractURI: collection.contractURI
-  };
-};
-var convertPremintFromApi = (premint) => {
-  if (premint.config_version === import_protocol_deployments2.PremintConfigVersion.V1 || !premint.config_version) {
-    const tokenConfig = premint.tokenConfig;
+function parseSalesConfig(targetStrategy) {
+  if (targetStrategy.type === "FIXED_PRICE")
     return {
-      premintConfigVersion: import_protocol_deployments2.PremintConfigVersion.V1,
-      premintConfig: {
-        deleted: premint.deleted,
-        uid: premint.uid,
-        version: premint.version,
-        tokenConfig: {
-          ...tokenConfig,
-          fixedPriceMinter: tokenConfig.fixedPriceMinter,
-          royaltyRecipient: tokenConfig.royaltyRecipient,
-          maxSupply: BigInt(tokenConfig.maxSupply),
-          pricePerToken: BigInt(tokenConfig.pricePerToken),
-          mintStart: BigInt(tokenConfig.mintStart),
-          mintDuration: BigInt(tokenConfig.mintDuration),
-          maxTokensPerAddress: BigInt(tokenConfig.maxTokensPerAddress)
-        }
-      }
+      saleType: "fixedPrice",
+      ...targetStrategy.fixedPrice,
+      maxTokensPerAddress: BigInt(
+        targetStrategy.fixedPrice.maxTokensPerAddress
+      ),
+      pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken)
     };
-  } else {
-    const tokenConfig = premint.tokenConfig;
+  if (targetStrategy.type === "ERC_20_MINTER") {
     return {
-      premintConfigVersion: import_protocol_deployments2.PremintConfigVersion.V2,
-      premintConfig: {
-        deleted: premint.deleted,
-        uid: premint.uid,
-        version: premint.version,
-        tokenConfig: {
-          ...tokenConfig,
-          fixedPriceMinter: tokenConfig.fixedPriceMinter,
-          payoutRecipient: tokenConfig.payoutRecipient,
-          createReferral: tokenConfig.createReferral,
-          maxSupply: BigInt(tokenConfig.maxSupply),
-          pricePerToken: BigInt(tokenConfig.pricePerToken),
-          mintStart: BigInt(tokenConfig.mintStart),
-          mintDuration: BigInt(tokenConfig.mintDuration),
-          maxTokensPerAddress: BigInt(tokenConfig.maxTokensPerAddress)
-        }
-      }
+      saleType: "erc20",
+      ...targetStrategy.erc20Minter,
+      maxTokensPerAddress: BigInt(
+        targetStrategy.erc20Minter.maxTokensPerAddress
+      ),
+      pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken)
     };
   }
-};
-var convertGetPremintApiResponse = (response) => ({
-  ...convertPremintFromApi(response.premint),
-  collection: convertCollectionFromApi(response.collection),
-  collectionAddress: response.collection_address,
-  signature: response.signature
-});
-var encodePremintV1ForAPI = ({
-  tokenConfig,
-  ...premint
-}) => ({
-  ...premint,
-  config_version: "1",
-  tokenConfig: {
-    ...tokenConfig,
-    maxSupply: tokenConfig.maxSupply.toString(),
-    pricePerToken: tokenConfig.pricePerToken.toString(),
-    mintStart: tokenConfig.mintStart.toString(),
-    mintDuration: tokenConfig.mintDuration.toString(),
-    maxTokensPerAddress: tokenConfig.maxTokensPerAddress.toString()
-  }
-});
-var encodePremintV2ForAPI = ({
-  tokenConfig,
-  ...premint
-}) => ({
-  ...premint,
-  config_version: "2",
-  tokenConfig: {
-    ...tokenConfig,
-    maxSupply: tokenConfig.maxSupply.toString(),
-    pricePerToken: tokenConfig.pricePerToken.toString(),
-    mintStart: tokenConfig.mintStart.toString(),
-    mintDuration: tokenConfig.mintDuration.toString(),
-    maxTokensPerAddress: tokenConfig.maxTokensPerAddress.toString()
-  }
-});
-var encodePremintForAPI = ({
-  premintConfig,
-  premintConfigVersion
-}) => {
-  if (premintConfigVersion === import_protocol_deployments2.PremintConfigVersion.V1) {
-    return encodePremintV1ForAPI(premintConfig);
-  }
-  if (premintConfigVersion === import_protocol_deployments2.PremintConfigVersion.V2) {
-    return encodePremintV2ForAPI(premintConfig);
-  }
-  throw new Error(`Invalid premint config version ${premintConfigVersion}`);
-};
-var encodePostSignatureInput = ({
-  collection,
-  collectionAddress,
-  premintConfigVersion,
-  premintConfig,
-  signature,
-  chainId
-}) => ({
-  premint: encodePremintForAPI({
-    premintConfig,
-    premintConfigVersion
-  }),
-  signature,
-  collection,
-  collection_address: collectionAddress,
-  chain_name: networkConfigByChain[chainId].zoraBackendChainName
-});
-
-// src/premint/premint-api-client.ts
-var postSignature = async ({
-  httpClient: { post: post2, retries: retries2 } = httpClient,
-  ...data
-}) => retries2(
-  () => post2(`${ZORA_API_BASE}premint/signature`, data)
-);
-var getNextUID = async ({
-  chain_name,
-  collection_address,
-  httpClient: { retries: retries2, get: get2 } = httpClient
-}) => retries2(
-  () => get2(
-    `${ZORA_API_BASE}premint/signature/${chain_name}/${collection_address}/next_uid`
-  )
-);
-var getSignature = async ({
-  collection_address,
-  uid,
-  chain_name,
-  httpClient: { retries: retries2, get: get2 } = httpClient
-}) => {
-  const result = await retries2(
-    () => get2(
-      `${ZORA_API_BASE}premint/signature/${chain_name}/${collection_address}/${uid}`
-    )
+  throw new Error("Unknown saleType");
+}
+function getSaleEnd(a) {
+  return BigInt(
+    a.type === "ERC_20_MINTER" ? a.erc20Minter.saleEnd : a.fixedPrice.saleEnd
   );
-  return result;
-};
-var PremintAPIClient = class {
+}
+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.postSignature = async ({
-      signature,
-      ...rest
-    }) => {
-      const data = encodePostSignatureInput({
-        ...rest,
-        chainId: this.networkConfig.chainId,
-        signature
-      });
-      return postSignature({
-        ...data,
-        httpClient: this.httpClient
-      });
-    };
-    this.getNextUID = async (collectionAddress) => (await getNextUID({
-      collection_address: collectionAddress.toLowerCase(),
-      chain_name: this.networkConfig.zoraBackendChainName,
-      httpClient: this.httpClient
-    })).next_uid;
-    this.getSignature = async ({
-      collectionAddress,
-      uid
+    this.getMintable = async ({
+      tokenAddress,
+      tokenId,
+      preferredSaleType: saleType
     }) => {
-      const response = await getSignature({
-        collection_address: collectionAddress.toLowerCase(),
-        uid,
-        chain_name: this.networkConfig.zoraBackendChainName,
-        httpClient: this.httpClient
+      const token = await this.querySubgraphWithRetries(
+        buildNftTokenSalesQuery({
+          tokenId,
+          tokenAddress
+        })
+      );
+      if (!token) {
+        throw new Error("Cannot find token");
+      }
+      return parseTokenQueryResult({
+        token,
+        tokenId,
+        preferredSaleType: saleType
       });
-      return convertGetPremintApiResponse(response);
     };
     this.httpClient = httpClient2 || httpClient;
     this.networkConfig = getApiNetworkConfigForChain(chainId);
   }
+  async querySubgraphWithRetries({
+    query,
+    variables,
+    parseResponseData
+  }) {
+    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 import_viem4 = require("viem");
-var makeSimulateContractParamaters = (args) => args;
-function setupClient({ chain, httpClient: httpClient2, publicClient }) {
+function parseTokenQueryResult({
+  token,
+  tokenId,
+  preferredSaleType
+}) {
+  const targetStrategy = getTargetStrategy({
+    tokenId,
+    preferredSaleType,
+    token
+  });
+  const tokenInfo = parseTokenInfo(token);
+  const salesConfig = parseSalesConfig(targetStrategy);
+  if (isErc20SaleStrategy(salesConfig)) {
+    tokenInfo.mintFeePerQuantity = 0n;
+  }
   return {
-    chain,
-    httpClient: httpClient2 || httpClient,
-    publicClient: publicClient || (0, import_viem4.createPublicClient)({ chain, transport: (0, import_viem4.http)() })
+    ...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
   };
 }
 
@@ -828,8 +1008,7 @@ var defaultTokenConfigV1MintArguments = () => ({
   maxSupply: OPEN_EDITION_MINT_SIZE,
   maxTokensPerAddress: 0n,
   pricePerToken: 0n,
-  mintDuration: BigInt(60 * 60 * 24 * 7),
-  // 1 week
+  mintDuration: 0n,
   mintStart: 0n,
   royaltyMintSchedule: 0,
   royaltyBPS: 1e3
@@ -854,7 +1033,7 @@ var pickTokenConfigV2 = (tokenConfig) => ({
   royaltyBPS: tokenConfig.royaltyBPS,
   tokenURI: tokenConfig.tokenURI,
   payoutRecipient: tokenConfig.payoutRecipient,
-  createReferral: tokenConfig.createReferral || import_viem5.zeroAddress
+  createReferral: tokenConfig.createReferral || import_viem4.zeroAddress
 });
 var tokenConfigV1WithDefault = (tokenConfig, fixedPriceMinter) => ({
   ...pickTokenConfigV1(tokenConfig),
@@ -870,8 +1049,7 @@ var defaultTokenConfigV2MintArguments = () => ({
   maxSupply: OPEN_EDITION_MINT_SIZE,
   maxTokensPerAddress: 0n,
   pricePerToken: 0n,
-  mintDuration: BigInt(60 * 60 * 24 * 7),
-  // 1 week
+  mintDuration: 0n,
   mintStart: 0n,
   royaltyBPS: 1e3
   // 10%,
@@ -905,7 +1083,7 @@ var makeTokenConfigWithDefaults = ({
 function getPremintedLogFromReceipt(receipt) {
   for (const data of receipt.logs) {
     try {
-      const decodedLog = (0, import_viem5.decodeEventLog)({
+      const decodedLog = (0, import_viem4.decodeEventLog)({
         abi: import_protocol_deployments3.zoraCreator1155PremintExecutorImplABI,
         eventName: "PremintedV2",
         ...data
@@ -918,20 +1096,17 @@ function getPremintedLogFromReceipt(receipt) {
   }
 }
 var PremintClient = class {
-  constructor(chain, publicClient, httpClient2) {
-    this.chain = chain;
-    this.apiClient = new PremintAPIClient(chain.id, httpClient2);
+  constructor({
+    chainId,
+    publicClient,
+    premintApi
+  }) {
+    this.chainId = chainId;
+    this.apiClient = premintApi;
     this.publicClient = publicClient;
   }
-  getDataFromPremintReceipt(receipt) {
-    const premintedLog = getPremintedLogFromReceipt(receipt);
-    return {
-      premintedLog,
-      urls: this.makeUrls({
-        address: premintedLog?.contractAddress,
-        tokenId: premintedLog?.tokenId
-      })
-    };
+  getDataFromPremintReceipt(receipt, blockExplorerUrl) {
+    return getDataFromPremintReceipt(receipt, this.chainId, blockExplorerUrl);
   }
   /**
    * Prepares data for updating a premint
@@ -944,7 +1119,7 @@ var PremintClient = class {
       ...args,
       apiClient: this.apiClient,
       publicClient: this.publicClient,
-      chainId: this.chain.id
+      chainId: this.chainId
     });
   }
   /**
@@ -958,7 +1133,7 @@ var PremintClient = class {
       ...params,
       apiClient: this.apiClient,
       publicClient: this.publicClient,
-      chainId: this.chain.id
+      chainId: this.chainId
     });
   }
   /**
@@ -972,7 +1147,7 @@ var PremintClient = class {
       ...parameters,
       publicClient: this.publicClient,
       apiClient: this.apiClient,
-      chainId: this.chain.id
+      chainId: this.chainId
     });
   }
   /**
@@ -982,63 +1157,21 @@ var PremintClient = class {
    * @param uid UID for the desired premint
    * @returns PremintSignatureGetResponse of premint data from the API
    */
-  async getPremintSignature({
-    address,
-    uid
-  }) {
-    return await this.apiClient.getSignature({
-      collectionAddress: address,
-      uid
-    });
-  }
-  /**
-   * Gets the deterministic contract address for a premint collection
-   * @param collection Collection to get the address for
-   * @returns deterministic contract address
-   */
-  async getCollectionAddress(collection) {
-    return await getPremintCollectionAddress({
-      collection,
-      publicClient: this.publicClient
-    });
-  }
-  /**
-   * Check user signature for v1
-   *
-   * @param data Signature data from the API
-   * @returns isValid = signature is valid or not, recoveredSigner = signer from contract
-   */
-  async isValidSignature({
-    signature,
-    premintConfig,
-    premintConfigVersion,
-    ...collectionAndOrAddress
-  }) {
-    const collectionAddressToUse = await getPremintCollectionAddress({
-      ...collectionAndOrAddress,
-      publicClient: this.publicClient
-    });
-    const { isAuthorized, recoveredAddress } = await isValidSignature({
-      chainId: this.chain.id,
-      signature,
-      publicClient: this.publicClient,
-      premintConfig,
-      premintConfigVersion: premintConfigVersion || import_protocol_deployments4.PremintConfigVersion.V1,
-      collectionAddress: collectionAddressToUse,
-      collection: collectionAndOrAddress.collection
+  async getPremint({ address, uid }) {
+    return await this.apiClient.get({
+      collectionAddress: address,
+      uid
     });
-    return { isValid: isAuthorized, recoveredSigner: recoveredAddress };
   }
-  makeUrls({
-    uid,
-    address,
-    tokenId
-  }) {
-    return makeUrls({
-      uid,
-      address,
-      tokenId,
-      chain: this.chain
+  /**
+   * Gets the deterministic contract address for a premint collection
+   * @param collection Collection to get the address for
+   * @returns deterministic contract address
+   */
+  async getCollectionAddress(collection) {
+    return await getPremintCollectionAddress({
+      contract: collection,
+      publicClient: this.publicClient
     });
   }
   async getMintCosts({
@@ -1060,17 +1193,40 @@ var PremintClient = class {
    * @param parameters - Parameters for collecting the Premint {@link MakeMintParametersArguments}
    * @returns receipt, log, zoraURL
    */
-  async makeMintParameters(parameters) {
-    return await makeMintParameters({
-      ...parameters,
-      apiClient: this.apiClient,
+  async makeMintParameters({
+    minterAccount,
+    tokenContract,
+    uid,
+    mintArguments,
+    firstMinter
+  }) {
+    return await collectPremint({
+      uid,
+      tokenContract,
+      minterAccount,
+      quantityToMint: mintArguments?.quantityToMint || 1n,
+      mintComment: mintArguments?.mintComment,
+      mintReferral: mintArguments?.mintReferral,
+      mintRecipient: mintArguments?.mintRecipient,
+      firstMinter,
+      premintGetter: this.apiClient,
       publicClient: this.publicClient
     });
   }
 };
-function createPremintClient(clientConfig) {
-  const { chain, httpClient: httpClient2, publicClient } = setupClient(clientConfig);
-  return new PremintClient(chain, publicClient, httpClient2);
+function getDataFromPremintReceipt(receipt, chainId, blockExplorerUrl) {
+  const premintedLog = getPremintedLogFromReceipt(receipt);
+  return {
+    tokenId: premintedLog?.tokenId,
+    collectionAddres: premintedLog?.contractAddress,
+    premintedLog,
+    urls: makeUrls({
+      address: premintedLog?.contractAddress,
+      tokenId: premintedLog?.tokenId,
+      chainId,
+      blockExplorerUrl
+    })
+  };
 }
 function makePremintReturn({
   premintConfig,
@@ -1100,7 +1256,7 @@ function makePremintReturn({
     await submit({
       signature,
       checkSignature,
-      signerAccount
+      account: signerAccount
     });
     return {
       signature,
@@ -1110,7 +1266,7 @@ function makePremintReturn({
   const submit = async ({
     signature,
     checkSignature,
-    signerAccount
+    account
   }) => {
     if (checkSignature) {
       const isAuthorized = await isAuthorizedToCreatePremint({
@@ -1118,7 +1274,7 @@ function makePremintReturn({
         additionalAdmins: collection?.additionalAdmins,
         contractAdmin: collection?.contractAdmin,
         publicClient,
-        signer: signerAccount
+        signer: account
       });
       if (!isAuthorized) {
         throw new Error("Not authorized to create premint");
@@ -1161,7 +1317,7 @@ async function signPremint({
   };
 }
 async function createPremint({
-  tokenCreationConfig,
+  token: tokenCreationConfig,
   uid,
   publicClient,
   apiClient,
@@ -1184,7 +1340,7 @@ async function createPremint({
     premintConfig,
     premintConfigVersion,
     collectionAddress: collectionAddressToUse,
-    collection: collectionOrAddress.collection,
+    collection: collectionOrAddress.contract,
     publicClient,
     apiClient,
     chainId
@@ -1237,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
   });
@@ -1268,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
   });
@@ -1291,52 +1445,72 @@ async function deletePremint({
     chainId
   });
 }
-async function makeMintParameters({
+async function collectPremint({
   uid,
   tokenContract,
   minterAccount,
-  mintArguments,
+  quantityToMint,
+  mintComment = "",
+  mintReferral,
+  mintRecipient,
   firstMinter,
-  apiClient,
+  premintGetter,
   publicClient
 }) {
-  if (mintArguments && mintArguments?.quantityToMint < 1) {
+  if (typeof quantityToMint !== "undefined" && quantityToMint < 1) {
     throw new Error("Quantity to mint cannot be below 1");
   }
-  if (!minterAccount) {
-    throw new Error("Wallet not passed in");
-  }
-  const {
-    premintConfig,
-    premintConfigVersion,
-    collection,
-    collectionAddress,
-    signature
-  } = await apiClient.getSignature({
+  const premint = await premintGetter.get({
     collectionAddress: tokenContract,
     uid
   });
-  const numberToMint = BigInt(mintArguments?.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
-  })).totalCost;
+    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: mintArguments?.mintComment || "",
-    mintRecipient: mintArguments?.mintRecipient || (typeof minterAccount === "string" ? minterAccount : minterAccount.address),
+    mintComment,
+    mintRecipient: mintRecipientOrAccount({
+      mintRecipient,
+      minterAccount
+    }),
     mintRewardsRecipients: makeMintRewardsRecipient({
-      mintReferral: mintArguments?.mintReferral
+      mintReferral
     })
   };
   const collectionOrEmpty = collection ? defaultAdditionalAdmins(collection) : emptyContractCreationConfig();
-  const collectionAddressToSubmit = collection ? import_viem5.zeroAddress : collectionAddress;
+  const collectionAddressToSubmit = collection ? import_viem4.zeroAddress : collectionAddress;
   const firstMinterToSubmit = firstMinter || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
-  return makeSimulateContractParamaters({
+  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,
     functionName: "premint",
@@ -1345,31 +1519,29 @@ async function makeMintParameters({
     args: [
       collectionOrEmpty,
       collectionAddressToSubmit,
-      (0, import_protocol_deployments3.encodePremintConfig)({
-        premintConfig,
-        premintConfigVersion
-      }),
+      (0, import_protocol_deployments3.encodePremintConfig)(premint),
       signature,
-      numberToMint,
+      BigInt(quantityToMint),
       mintArgumentsContract,
       firstMinterToSubmit,
-      import_viem5.zeroAddress
+      import_viem4.zeroAddress
     ]
   });
-}
+};
 function makeUrls({
   uid,
   address,
   tokenId,
-  chain
+  chainId,
+  blockExplorerUrl
 }) {
   if ((!uid || !tokenId) && !address) {
     return { explorer: null, zoraCollect: null, zoraManage: null };
   }
   const zoraTokenPath = uid ? `premint-${uid}` : tokenId;
-  const network = getApiNetworkConfigForChain(chain.id);
+  const network = getApiNetworkConfigForChain(chainId);
   return {
-    explorer: tokenId ? `https://${chain.blockExplorers?.default.url}/token/${address}/instance/${tokenId}` : null,
+    explorer: tokenId ? `https://${blockExplorerUrl}/token/${address}/instance/${tokenId}` : null,
     zoraCollect: `https://${network.isTestnet ? "testnet." : ""}zora.co/collect/${network.zoraCollectPathChainName}:${address}/${zoraTokenPath}`,
     zoraManage: `https://${network.isTestnet ? "testnet." : ""}zora.co/collect/${network.zoraCollectPathChainName}:${address}/${zoraTokenPath}`
   };
@@ -1384,9 +1556,480 @@ var PremintConfigVersion3 = ((PremintConfigVersion4) => {
   return PremintConfigVersion4;
 })(PremintConfigVersion3 || {});
 
+// src/premint/premint-api-client.ts
+var postSignature = async ({
+  httpClient: { post: post2, retries: retries2 } = httpClient,
+  ...data
+}) => retries2(
+  () => post2(`${ZORA_API_BASE}premint/signature`, data)
+);
+var getNextUID = async ({
+  chainId,
+  collection_address,
+  httpClient: { retries: retries2, get: get2 } = httpClient
+}) => retries2(
+  () => get2(
+    `${ZORA_API_BASE}premint/signature/${getApiNetworkConfigForChain(chainId).zoraBackendChainName}/${collection_address}/next_uid`
+  )
+);
+var getSignature = async ({
+  collectionAddress,
+  uid,
+  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()}/${uid}`
+    )
+  );
+  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 = ({
+      signature,
+      ...rest
+    }) => {
+      const data = encodePostSignatureInput({
+        ...rest,
+        chainId: this.chainId,
+        signature
+      });
+      return postSignature({
+        ...data,
+        httpClient: this.httpClient
+      });
+    };
+    this.getNextUID = async (collectionAddress) => (await getNextUID({
+      collection_address: collectionAddress.toLowerCase(),
+      chainId: this.chainId,
+      httpClient: this.httpClient
+    })).next_uid;
+    this.get = async ({ collectionAddress, uid }) => {
+      return getSignature({
+        collectionAddress,
+        uid,
+        chainId: this.chainId,
+        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-transactions.ts
+var import_viem5 = require("viem");
+var import_protocol_deployments6 = require("@zoralabs/protocol-deployments");
+
+// 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");
+};
+
+// src/mint/mint-transactions.ts
+function makeOnchainMintCall({
+  token,
+  mintParams
+}) {
+  if (token.mintType === "721") {
+    return makePrepareMint721TokenParams({
+      salesConfigAndTokenInfo: token,
+      tokenContract: token.contract.address,
+      ...mintParams
+    });
+  }
+  return makePrepareMint1155TokenParams({
+    salesConfigAndTokenInfo: token,
+    tokenContract: token.contract.address,
+    tokenId: token.tokenId,
+    ...mintParams
+  });
+}
+function makePrepareMint1155TokenParams({
+  tokenContract,
+  tokenId,
+  salesConfigAndTokenInfo,
+  minterAccount,
+  mintComment,
+  mintReferral,
+  mintRecipient,
+  quantityToMint
+}) {
+  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
+    });
+  }
+  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 || ""
+      ]
+    });
+  }
+  throw new Error("Unsupported sale type");
+}
+function makePrepareMint721TokenParams({
+  salesConfigAndTokenInfo,
+  minterAccount,
+  tokenContract,
+  mintComment,
+  mintReferral,
+  mintRecipient,
+  quantityToMint
+}) {
+  const actualQuantityToMint = BigInt(quantityToMint || 1);
+  const mintValue = parseMintCosts({
+    mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
+    salesConfig: salesConfigAndTokenInfo.salesConfig,
+    quantityToMint: actualQuantityToMint
+  }).totalCostEth;
+  return makeContractParameters({
+    abi: zora721Abi,
+    address: tokenContract,
+    account: minterAccount,
+    functionName: "mintWithRewards",
+    value: mintValue,
+    args: [
+      mintRecipientOrAccount({ mintRecipient, minterAccount }),
+      actualQuantityToMint,
+      mintComment || "",
+      mintReferral || import_viem5.zeroAddress
+    ]
+  });
+}
+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 = mintFeePerQuantity * quantityToMint;
+  const tokenPurchaseCost = BigInt(salesConfig.pricePerToken) * quantityToMint;
+  const totalPurchaseCostCurrency = isErc20SaleStrategy(salesConfig) ? salesConfig.currency : void 0;
+  const totalPurchaseCostEth = totalPurchaseCostCurrency ? 0n : tokenPurchaseCost;
+  return {
+    mintFee: mintFeeForTokens,
+    totalPurchaseCost: tokenPurchaseCost,
+    totalPurchaseCostCurrency,
+    totalCostEth: mintFeeForTokens + totalPurchaseCostEth
+  };
+}
+
+// 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 mintGetter.getMintable({
+      tokenId,
+      tokenAddress: collection
+    });
+    return parseMintCosts({
+      mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
+      salesConfig: salesConfigAndTokenInfo.salesConfig,
+      quantityToMint: BigInt(quantityToMint)
+    });
+  }
+  return getPremintMintCostsWithUnknownTokenPrice({
+    premintGetter,
+    publicClient,
+    quantityToMint: BigInt(quantityToMint),
+    uid: params.uid,
+    tokenContract: collection
+  });
+}
+async function getPremintsOfContractMintable({
+  mintGetter,
+  premintGetter,
+  publicClient,
+  params
+}) {
+  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"
+      }
+    };
+  }
+  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 import_viem6 = require("viem");
-var import_protocol_deployments6 = require("@zoralabs/protocol-deployments");
 var MintError = class extends Error {
 };
 var MintInactiveError = class extends Error {
@@ -1396,260 +2039,439 @@ var Errors = {
   MintInactiveError
 };
 var MintClient = class {
-  constructor(chain, publicClient, httpClient2) {
-    this.apiClient = new MintAPIClient(chain.id, httpClient2);
+  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 MintTokenParams}
-   * @returns Parameters for simulating/executing the mint transaction
+   * @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 makePrepareMintTokenParams(parameters) {
-    return makePrepareMintTokenParams({
-      ...parameters,
-      apiClient: this.apiClient,
+  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
+    });
+  }
+  /**
+   * 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
     });
   }
 };
-function createMintClient(clientConfig) {
-  const { chain, publicClient, httpClient: httpClient2 } = setupClient(clientConfig);
-  return new MintClient(chain, publicClient, httpClient2);
-}
-async function makePrepareMintTokenParams({
+async function mint({
+  parameters,
   publicClient,
-  apiClient,
-  tokenId,
-  tokenAddress,
-  mintArguments,
-  ...rest
+  mintGetter,
+  premintGetter
 }) {
-  const salesConfigAndTokenInfo = await apiClient.getSalesConfigAndTokenInfo({
-    tokenId,
-    tokenAddress,
-    saleType: mintArguments.saleType
+  const { prepareMint } = await getMint({
+    params: parameters,
+    mintGetter,
+    premintGetter,
+    publicClient
   });
-  if (tokenId === void 0) {
-    return makePrepareMint721TokenParams({
-      salesConfigAndTokenInfo,
-      tokenAddress,
-      mintArguments,
-      ...rest
-    });
-  }
-  return makePrepareMint1155TokenParams({
-    salesConfigAndTokenInfo,
-    tokenAddress,
+  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,
-    mintArguments,
-    ...rest
+    tokenAddress: tokenContract,
+    preferredSaleType: saleType
+  });
+  return makeOnchainMintCall({
+    mintParams: parameters,
+    token: salesConfigAndTokenInfo
   });
 }
-async function makePrepareMint721TokenParams({
-  tokenAddress,
-  salesConfigAndTokenInfo,
-  minterAccount,
-  mintArguments
+
+// src/create/1155-create-helper.ts
+var import_protocol_deployments9 = require("@zoralabs/protocol-deployments");
+var import_viem8 = require("viem");
+
+// src/create/contract-setup.ts
+var import_protocol_deployments7 = require("@zoralabs/protocol-deployments");
+function new1155ContractVersion(chainId) {
+  const address = import_protocol_deployments7.contracts1155.addresses[chainId];
+  if (!address) {
+    throw new Error(`No contract address for chainId ${chainId}`);
+  }
+  return address.CONTRACT_1155_IMPL_VERSION;
+}
+async function getContractInfo({
+  publicClient,
+  chainId,
+  contract,
+  account
 }) {
-  const mintValue = getMintCosts({
-    salesConfigAndTokenInfo,
-    quantityToMint: BigInt(mintArguments.quantityToMint)
-  }).totalCost;
-  return makeSimulateContractParamaters({
-    abi: zora721Abi,
-    address: tokenAddress,
-    account: minterAccount,
-    functionName: "mintWithRewards",
-    value: mintValue,
+  const contractAddress = typeof contract === "string" ? contract : await publicClient.readContract({
+    abi: import_protocol_deployments7.zoraCreator1155FactoryImplABI,
+    // Since this address is deterministic we can hardcode a chain id safely here.
+    address: import_protocol_deployments7.zoraCreator1155FactoryImplAddress[chainId],
+    functionName: "deterministicContractAddress",
     args: [
-      mintArguments.mintToAddress,
-      BigInt(mintArguments.quantityToMint),
-      mintArguments.mintComment || "",
-      mintArguments.mintReferral || import_viem6.zeroAddress
+      account,
+      contract.uri,
+      contract.name,
+      contract.defaultAdmin || account
     ]
   });
+  let contractVersion;
+  let contractExists;
+  try {
+    contractVersion = await publicClient.readContract({
+      abi: import_protocol_deployments7.zoraCreator1155ImplABI,
+      address: contractAddress,
+      functionName: "contractVersion"
+    });
+    contractExists = true;
+  } catch (e) {
+    contractVersion = new1155ContractVersion(chainId);
+    contractExists = false;
+  }
+  const nextTokenId = contractExists ? await publicClient.readContract({
+    address: contractAddress,
+    abi: import_protocol_deployments7.zoraCreator1155ImplABI,
+    functionName: "nextTokenId"
+  }) : 1n;
+  return {
+    contractExists,
+    contractAddress,
+    contractVersion,
+    nextTokenId
+  };
 }
-function getMintCosts({
-  salesConfigAndTokenInfo,
-  quantityToMint
+
+// src/create/token-setup.ts
+var import_protocol_deployments8 = require("@zoralabs/protocol-deployments");
+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_viem7.zeroAddress,
+    // Free Mint
+    pricePerToken: 0n,
+    // Sale start time – defaults to beginning of unix time
+    saleStart: 0n,
+    // This is the end of uint64, plenty of time
+    saleEnd: SALE_END_FOREVER,
+    // 0 Here means no limit
+    maxTokensPerAddress: 0n
+  };
+  return {
+    ...DEFAULT_SALE_SETTINGS,
+    ...saleSettings
+  };
+};
+function applyNew1155Defaults(props, ownerAddress) {
+  const { payoutRecipient: fundsRecipient } = props;
+  const fundsRecipientOrOwner = fundsRecipient && fundsRecipient !== import_viem7.zeroAddress ? fundsRecipient : ownerAddress;
+  return {
+    payoutRecipient: fundsRecipientOrOwner,
+    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),
+    tokenMetadataURI: props.tokenMetadataURI
+  };
+}
+function setupErc20Minter({
+  pricePerToken,
+  chainId,
+  tokenId: nextTokenId,
+  currency,
+  saleStart,
+  saleEnd,
+  maxTokensPerAddress: mintLimit,
+  fundsRecipient
 }) {
-  const mintFeeForTokens = salesConfigAndTokenInfo.mintFeePerQuantity * quantityToMint;
-  const tokenPurchaseCost = BigInt(salesConfigAndTokenInfo.salesConfig.pricePerToken) * quantityToMint;
+  const erc20MinterAddress = import_protocol_deployments8.erc20MinterAddress[chainId];
+  if (!erc20MinterAddress)
+    throw new Error(`ERC20Minter not deployed on chainId ${chainId}`);
+  const erc20MinterApproval = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
+    functionName: "addPermission",
+    args: [BigInt(nextTokenId), erc20MinterAddress, PERMISSION_BITS.MINTER]
+  });
+  const saleData = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.erc20MinterABI,
+    functionName: "setSale",
+    args: [
+      BigInt(nextTokenId),
+      {
+        saleStart: saleStart || BigInt(0),
+        saleEnd: saleEnd || BigInt(0),
+        maxTokensPerAddress: BigInt(mintLimit || 0),
+        pricePerToken,
+        fundsRecipient,
+        currency
+      }
+    ]
+  });
+  const callSale = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
+    functionName: "callSale",
+    args: [BigInt(nextTokenId), erc20MinterAddress, saleData]
+  });
   return {
-    mintFee: mintFeeForTokens,
-    tokenPurchaseCost,
-    totalCost: mintFeeForTokens + tokenPurchaseCost
+    minter: erc20MinterAddress,
+    setupActions: [erc20MinterApproval, callSale]
   };
 }
-async function makePrepareMint1155TokenParams({
-  tokenId,
-  salesConfigAndTokenInfo,
-  minterAccount,
-  tokenAddress,
-  mintArguments
+function setupFixedPriceMinter({
+  pricePerToken: price,
+  tokenId: nextTokenId,
+  chainId,
+  saleStart,
+  saleEnd,
+  maxTokensPerAddress: mintLimit,
+  fundsRecipient
 }) {
-  const mintQuantity = BigInt(mintArguments.quantityToMint);
-  const mintValue = getMintCosts({
-    salesConfigAndTokenInfo,
-    quantityToMint: mintQuantity
-  }).totalCost;
-  switch (salesConfigAndTokenInfo.salesConfig.saleType) {
-    case "fixedPrice":
-      const fixedPriceArgs = mintArguments;
-      return makeSimulateContractParamaters({
-        abi: import_protocol_deployments6.zoraCreator1155ImplABI,
-        functionName: "mintWithRewards",
-        account: minterAccount,
-        value: mintValue,
-        address: tokenAddress,
-        /* args: minter, tokenId, quantity, minterArguments, mintReferral */
-        args: [
-          salesConfigAndTokenInfo.salesConfig.address || import_protocol_deployments6.zoraCreatorFixedPriceSaleStrategyAddress[999999999],
-          BigInt(tokenId),
-          mintQuantity,
-          (0, import_viem6.encodeAbiParameters)((0, import_viem6.parseAbiParameters)("address, string"), [
-            fixedPriceArgs.mintToAddress,
-            fixedPriceArgs.mintComment || ""
-          ]),
-          fixedPriceArgs.mintReferral || import_viem6.zeroAddress
-        ]
-      });
-    case "erc20":
-      const erc20Args = mintArguments;
-      return makeSimulateContractParamaters({
-        abi: import_protocol_deployments6.erc20MinterABI,
-        functionName: "mint",
-        account: minterAccount,
-        address: salesConfigAndTokenInfo?.salesConfig.address || import_protocol_deployments6.erc20MinterAddress[999999999],
-        /* args: mintTo, quantity, tokenAddress, tokenId, totalValue, currency, mintReferral, comment */
-        args: [
-          mintArguments.mintToAddress,
-          mintQuantity,
-          tokenAddress,
-          BigInt(tokenId),
-          salesConfigAndTokenInfo.salesConfig.pricePerToken,
-          salesConfigAndTokenInfo.salesConfig.currency,
-          erc20Args.mintReferral || import_viem6.zeroAddress,
-          erc20Args.mintComment || ""
-        ]
-      });
-    default:
-      throw new MintError("Unsupported sale type");
+  const fixedPriceStrategyAddress = import_protocol_deployments8.zoraCreatorFixedPriceSaleStrategyAddress[chainId];
+  const fixedPriceApproval = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
+    functionName: "addPermission",
+    args: [
+      BigInt(nextTokenId),
+      fixedPriceStrategyAddress,
+      PERMISSION_BITS.MINTER
+    ]
+  });
+  const saleData = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreatorFixedPriceSaleStrategyABI,
+    functionName: "setSale",
+    args: [
+      BigInt(nextTokenId),
+      {
+        pricePerToken: price,
+        saleStart: saleStart || BigInt(0),
+        saleEnd: saleEnd || BigInt(0),
+        maxTokensPerAddress: BigInt(mintLimit || 0),
+        fundsRecipient
+      }
+    ]
+  });
+  const callSale = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
+    functionName: "callSale",
+    args: [BigInt(nextTokenId), fixedPriceStrategyAddress, saleData]
+  });
+  return {
+    minter: fixedPriceStrategyAddress,
+    setupActions: [fixedPriceApproval, callSale]
+  };
+}
+function setupMinters({ salesConfig, ...rest }) {
+  if (!salesConfig)
+    throw new Error("No sales config for token");
+  const { currency: currencyAddress } = salesConfig;
+  if (currencyAddress === import_viem7.zeroAddress) {
+    return setupFixedPriceMinter({
+      ...salesConfig,
+      ...rest
+    });
+  } else {
+    return setupErc20Minter({
+      ...salesConfig,
+      ...rest
+    });
   }
 }
-
-// src/create/1155-create-helper.ts
-var import_protocol_deployments7 = require("@zoralabs/protocol-deployments");
-var import_viem7 = require("viem");
-var SALE_END_FOREVER = 18446744073709551615n;
-var ROYALTY_BPS_DEFAULT = 1e3;
-var DEFAULT_SALE_SETTINGS = {
-  fundsRecipient: import_viem7.zeroAddress,
-  // Free Mint
-  pricePerToken: 0n,
-  // Sale start time – defaults to beginning of unix time
-  saleStart: 0n,
-  // This is the end of uint64, plenty of time
-  saleEnd: SALE_END_FOREVER,
-  // 0 Here means no limit
-  maxTokensPerAddress: 0n
-};
-var PERMISSION_BIT_MINTER = 4n;
-function create1155TokenSetupArgs({
-  nextTokenId,
-  // How many NFTs upon initialization to mint to the creator
-  mintToCreatorCount,
-  tokenMetadataURI,
-  // Fixed price minter address – required minter
-  fixedPriceMinterAddress,
-  // Address to use as the create referral, optional.
-  createReferral,
-  // Optional max supply of the token. Default unlimited
-  maxSupply,
-  // wallet sending the transaction
-  account,
-  salesConfig,
-  royaltySettings
+function buildSetupNewToken({
+  tokenURI,
+  maxSupply = OPEN_EDITION_MINT_SIZE,
+  createReferral = import_viem7.zeroAddress,
+  contractVersion
 }) {
-  if (!maxSupply) {
-    maxSupply = OPEN_EDITION_MINT_SIZE;
-  }
-  maxSupply = BigInt(maxSupply);
-  mintToCreatorCount = BigInt(mintToCreatorCount);
-  const salesConfigWithDefaults = {
-    // Set static sales default.
-    ...DEFAULT_SALE_SETTINGS,
-    // Override with user settings.
-    ...salesConfig
-  };
-  const setupActions = [
-    (0, import_viem7.encodeFunctionData)({
-      abi: import_protocol_deployments7.zoraCreator1155ImplABI,
-      functionName: "assumeLastTokenIdMatches",
-      args: [nextTokenId - 1n]
-    }),
-    createReferral ? (0, import_viem7.encodeFunctionData)({
-      abi: import_protocol_deployments7.zoraCreator1155ImplABI,
+  if (contractSupportsMintRewards(contractVersion, "ERC1155")) {
+    return (0, import_viem7.encodeFunctionData)({
+      abi: import_protocol_deployments8.zoraCreator1155ImplABI,
       functionName: "setupNewTokenWithCreateReferral",
-      args: [tokenMetadataURI, maxSupply, createReferral]
-    }) : (0, import_viem7.encodeFunctionData)({
-      abi: import_protocol_deployments7.zoraCreator1155ImplABI,
-      functionName: "setupNewToken",
-      args: [tokenMetadataURI, maxSupply]
-    }),
-    (0, import_viem7.encodeFunctionData)({
-      abi: import_protocol_deployments7.zoraCreator1155ImplABI,
-      functionName: "addPermission",
-      args: [0n, fixedPriceMinterAddress, PERMISSION_BIT_MINTER]
-    }),
-    (0, import_viem7.encodeFunctionData)({
-      abi: import_protocol_deployments7.zoraCreator1155ImplABI,
-      functionName: "callSale",
+      args: [tokenURI, BigInt(maxSupply), createReferral]
+    });
+  }
+  if (createReferral !== import_viem7.zeroAddress) {
+    throw new Error(
+      "Contract does not support create referral, but one was provided"
+    );
+  }
+  return (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
+    functionName: "setupNewToken",
+    args: [tokenURI, BigInt(maxSupply)]
+  });
+}
+function setupRoyaltyConfig({
+  royaltyBPS,
+  royaltyRecipient,
+  nextTokenId
+}) {
+  if (royaltyBPS > 0 && royaltyRecipient != import_viem7.zeroAddress) {
+    return (0, import_viem7.encodeFunctionData)({
+      abi: import_protocol_deployments8.zoraCreator1155ImplABI,
+      functionName: "updateRoyaltiesForToken",
       args: [
         nextTokenId,
-        fixedPriceMinterAddress,
-        (0, import_viem7.encodeFunctionData)({
-          abi: import_protocol_deployments7.zoraCreatorFixedPriceSaleStrategyABI,
-          functionName: "setSale",
-          args: [nextTokenId, salesConfigWithDefaults]
-        })
+        {
+          royaltyBPS,
+          royaltyRecipient,
+          royaltyMintSchedule: 0
+        }
       ]
-    })
-  ];
-  if (mintToCreatorCount) {
-    setupActions.push(
-      (0, import_viem7.encodeFunctionData)({
-        abi: import_protocol_deployments7.zoraCreator1155ImplABI,
-        functionName: "adminMint",
-        args: [account, nextTokenId, mintToCreatorCount, "0x"]
-      })
-    );
+    });
   }
-  if (royaltySettings) {
-    setupActions.push(
-      (0, import_viem7.encodeFunctionData)({
-        abi: import_protocol_deployments7.zoraCreator1155ImplABI,
-        functionName: "updateRoyaltiesForToken",
-        args: [
-          nextTokenId,
-          {
-            royaltyMintSchedule: 0,
-            royaltyBPS: royaltySettings?.royaltyBPS || ROYALTY_BPS_DEFAULT,
-            royaltyRecipient: royaltySettings?.royaltyRecipient || account
-          }
-        ]
-      })
-    );
+  return null;
+}
+function makeAdminMintCall({
+  ownerAddress,
+  mintQuantity,
+  nextTokenId
+}) {
+  if (!mintQuantity || mintQuantity <= 0 || !ownerAddress) {
+    return null;
   }
-  return setupActions;
+  return (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
+    functionName: "adminMint",
+    args: [ownerAddress, nextTokenId, BigInt(mintQuantity), import_viem7.zeroAddress]
+  });
+}
+function constructCreate1155TokenCalls(props) {
+  const {
+    chainId,
+    nextTokenId,
+    mintToCreatorCount,
+    ownerAddress,
+    contractVersion
+  } = props;
+  const new1155TokenPropsWithDefaults = applyNew1155Defaults(
+    props,
+    ownerAddress
+  );
+  const verifyTokenIdExpected = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
+    functionName: "assumeLastTokenIdMatches",
+    args: [nextTokenId - 1n]
+  });
+  const setupNewToken = buildSetupNewToken({
+    tokenURI: new1155TokenPropsWithDefaults.tokenMetadataURI,
+    maxSupply: new1155TokenPropsWithDefaults.maxSupply,
+    createReferral: new1155TokenPropsWithDefaults.createReferral,
+    contractVersion
+  });
+  const royaltyConfig = setupRoyaltyConfig({
+    royaltyBPS: new1155TokenPropsWithDefaults.royaltyBPS,
+    royaltyRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
+    nextTokenId
+  });
+  const { minter, setupActions: mintersSetup } = setupMinters({
+    tokenId: nextTokenId,
+    chainId,
+    fundsRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
+    salesConfig: new1155TokenPropsWithDefaults.salesConfig
+  });
+  const adminMintCall = makeAdminMintCall({
+    ownerAddress,
+    mintQuantity: mintToCreatorCount,
+    nextTokenId
+  });
+  const setupActions = [
+    verifyTokenIdExpected,
+    setupNewToken,
+    ...mintersSetup,
+    royaltyConfig,
+    adminMintCall
+  ].filter((item) => item !== null);
+  return {
+    setupActions,
+    minter,
+    newToken: new1155TokenPropsWithDefaults
+  };
 }
+var contractSupportsMintRewards = (contractVersion, contractStandard) => {
+  if (!contractStandard || !contractVersion) {
+    return false;
+  }
+  const semVerContractVersion = semver2.coerce(contractVersion)?.raw;
+  if (!semVerContractVersion)
+    return false;
+  if (contractStandard === "ERC1155") {
+    return semver2.gte(semVerContractVersion, "1.3.5");
+  } else {
+    return semver2.gte(semVerContractVersion, "14.0.0");
+  }
+};
+
+// src/create/1155-create-helper.ts
+var ROYALTY_BPS_DEFAULT = 1e3;
 var getTokenIdFromCreateReceipt = (receipt) => {
   for (const data of receipt.logs) {
     try {
-      const decodedLog = (0, import_viem7.decodeEventLog)({
-        abi: import_protocol_deployments7.zoraCreator1155ImplABI,
+      const decodedLog = (0, import_viem8.decodeEventLog)({
+        abi: import_protocol_deployments9.zoraCreator1155ImplABI,
         eventName: "SetupNewToken",
         ...data
       });
@@ -1660,132 +2482,116 @@ var getTokenIdFromCreateReceipt = (receipt) => {
     }
   }
 };
-async function getContractExists(publicClient, contract, account) {
-  let contractAddress;
-  let contractExists = false;
-  if (typeof contract !== "string") {
-    contractAddress = await publicClient.readContract({
-      abi: import_protocol_deployments7.zoraCreator1155FactoryImplABI,
-      // Since this address is deterministic we can hardcode a chain id safely here.
-      address: import_protocol_deployments7.zoraCreator1155FactoryImplAddress[999],
-      functionName: "deterministicContractAddress",
+function makeCreateContractAndTokenCall({
+  contractExists,
+  contractAddress,
+  contract,
+  account,
+  royaltyBPS,
+  tokenSetupActions,
+  fundsRecipient
+}) {
+  if (!contractAddress && typeof contract === "string") {
+    throw new Error("Invariant: contract cannot be missing and an address");
+  }
+  if (!contractExists) {
+    if (typeof contract === "string") {
+      throw new Error("Invariant: expected contract object");
+    }
+    const accountAddress = typeof account === "string" ? account : account.address;
+    return makeContractParameters({
+      abi: import_protocol_deployments9.zoraCreator1155FactoryImplABI,
+      functionName: "createContractDeterministic",
+      account,
+      address: import_protocol_deployments9.zoraCreator1155FactoryImplAddress[999],
       args: [
-        account,
         contract.uri,
         contract.name,
-        contract.defaultAdmin || account
+        {
+          // deprecated
+          royaltyMintSchedule: 0,
+          royaltyBPS: royaltyBPS || ROYALTY_BPS_DEFAULT,
+          royaltyRecipient: fundsRecipient || accountAddress
+        },
+        contract.defaultAdmin || accountAddress,
+        tokenSetupActions
       ]
     });
-    try {
-      await publicClient.readContract({
-        abi: import_protocol_deployments7.zoraCreator1155ImplABI,
-        address: contractAddress,
-        functionName: "contractVersion"
-      });
-      contractExists = true;
-    } catch (e) {
-    }
-    return { contractAddress, contractExists };
   }
-  return {
-    contractExists: true,
-    contractAddress: contract
-  };
-}
-function create1155CreatorClient(clientConfig) {
-  const { publicClient } = setupClient(clientConfig);
-  async function createNew1155Token({
-    contract,
-    tokenMetadataURI,
-    mintToCreatorCount = 1,
-    salesConfig = {},
-    maxSupply,
+  return makeContractParameters({
+    abi: import_protocol_deployments9.zoraCreator1155ImplABI,
+    functionName: "multicall",
     account,
-    royaltySettings,
-    createReferral,
-    getAdditionalSetupActions
+    address: contractAddress,
+    args: [tokenSetupActions]
+  });
+}
+var Create1155Client = class {
+  constructor({
+    chainId,
+    publicClient
   }) {
-    const { contractExists, contractAddress } = await getContractExists(
-      publicClient,
-      contract,
-      account
-    );
-    let nextTokenId = 1n;
-    if (contractExists) {
-      nextTokenId = await publicClient.readContract({
-        abi: import_protocol_deployments7.zoraCreator1155ImplABI,
-        functionName: "nextTokenId",
-        address: contractAddress
-      });
-    }
-    const fixedPriceMinterAddress = await publicClient.readContract({
-      abi: import_protocol_deployments7.zoraCreator1155FactoryImplABI,
-      address: import_protocol_deployments7.zoraCreator1155FactoryImplAddress[999],
-      functionName: "fixedPriceMinter"
-    });
-    let tokenSetupActions = create1155TokenSetupArgs({
-      tokenMetadataURI,
-      nextTokenId,
-      salesConfig,
-      maxSupply,
-      fixedPriceMinterAddress,
-      account,
-      mintToCreatorCount,
-      royaltySettings,
-      createReferral
+    this.chainId = chainId;
+    this.publicClient = publicClient;
+  }
+  async createNew1155Token(props) {
+    return createNew1155Token({
+      ...props,
+      publicClient: this.publicClient,
+      chainId: this.chainId
     });
-    if (getAdditionalSetupActions) {
-      tokenSetupActions = [
-        ...getAdditionalSetupActions({ tokenId: nextTokenId, contractAddress }),
-        ...tokenSetupActions
-      ];
-    }
-    if (!contractAddress && typeof contract === "string") {
-      throw new Error("Invariant: contract cannot be missing and an address");
-    }
-    if (!contractExists && typeof contract !== "string") {
-      const request = makeSimulateContractParamaters({
-        abi: import_protocol_deployments7.zoraCreator1155FactoryImplABI,
-        functionName: "createContractDeterministic",
-        account,
-        address: import_protocol_deployments7.zoraCreator1155FactoryImplAddress[999],
-        args: [
-          contract.uri,
-          contract.name,
-          {
-            // deprecated
-            royaltyMintSchedule: 0,
-            royaltyBPS: royaltySettings?.royaltyBPS || ROYALTY_BPS_DEFAULT,
-            royaltyRecipient: royaltySettings?.royaltyRecipient || account
-          },
-          contract.defaultAdmin || account,
-          tokenSetupActions
-        ]
-      });
-      return {
-        request,
-        tokenSetupActions,
-        contractAddress,
-        contractExists
-      };
-    } else if (contractExists) {
-      const request = makeSimulateContractParamaters({
-        abi: import_protocol_deployments7.zoraCreator1155ImplABI,
-        functionName: "multicall",
-        account,
-        address: contractAddress,
-        args: [tokenSetupActions]
-      });
-      return {
-        request,
-        tokenSetupActions,
-        contractAddress,
-        contractExists
-      };
-    }
-    throw new Error("Unsupported contract argument type");
   }
-  return { createNew1155Token };
+};
+async function createNew1155Token({
+  contract,
+  account,
+  getAdditionalSetupActions,
+  token: tokenConfig,
+  publicClient,
+  chainId
+}) {
+  const { contractExists, contractAddress, nextTokenId, contractVersion } = await getContractInfo({
+    publicClient,
+    chainId,
+    contract,
+    account
+  });
+  const {
+    minter,
+    newToken,
+    setupActions: tokenSetupActions
+  } = constructCreate1155TokenCalls({
+    chainId,
+    ownerAddress: account,
+    contractVersion,
+    nextTokenId,
+    ...tokenConfig
+  });
+  const setupActions = getAdditionalSetupActions ? [
+    ...getAdditionalSetupActions({
+      tokenId: nextTokenId,
+      contractAddress
+    }),
+    ...tokenSetupActions
+  ] : tokenSetupActions;
+  const request = makeCreateContractAndTokenCall({
+    contractExists,
+    contractAddress,
+    contract,
+    account,
+    tokenSetupActions: setupActions,
+    royaltyBPS: tokenConfig.royaltyBPS,
+    fundsRecipient: tokenConfig.payoutRecipient
+  });
+  return {
+    parameters: request,
+    tokenSetupActions,
+    collectionAddress: contractAddress,
+    contractExists,
+    newTokenId: nextTokenId,
+    newToken,
+    minter
+  };
 }
 
 // src/mints/mints-queries.ts
@@ -1845,8 +2651,8 @@ var sumBalances = (mintAccountBalances) => {
 };
 
 // src/mints/mints-contracts.ts
-var import_protocol_deployments8 = require("@zoralabs/protocol-deployments");
-var import_viem8 = require("viem");
+var import_protocol_deployments10 = require("@zoralabs/protocol-deployments");
+var import_viem9 = require("viem");
 var addressOrAccountAddress = (address) => typeof address === "string" ? address : address.address;
 var mintWithEthParams = ({
   quantity,
@@ -1854,9 +2660,9 @@ var mintWithEthParams = ({
   chainId,
   pricePerMint,
   account
-}) => makeSimulateContractParamaters({
-  abi: import_protocol_deployments8.zoraMintsManagerImplConfig.abi,
-  address: import_protocol_deployments8.zoraMintsManagerImplConfig.address[chainId],
+}) => makeContractParameters({
+  abi: import_protocol_deployments10.zoraMintsManagerImplConfig.abi,
+  address: import_protocol_deployments10.zoraMintsManagerImplConfig.address[chainId],
   functionName: "mintWithEth",
   args: [quantity, recipient || addressOrAccountAddress(account)],
   value: pricePerMint * quantity,
@@ -1871,8 +2677,8 @@ var mintsBalanceOfAccountParams = ({
   account,
   chainId
 }) => ({
-  abi: import_protocol_deployments8.zoraMints1155Config.abi,
-  address: import_protocol_deployments8.zoraMints1155Config.address[chainId],
+  abi: import_protocol_deployments10.zoraMints1155Config.abi,
+  address: import_protocol_deployments10.zoraMints1155Config.address[chainId],
   functionName: "balanceOfAccount",
   args: [account]
 });
@@ -1881,8 +2687,8 @@ var encodeCollectOnManager = ({
   minter,
   zoraCreator1155TokenId,
   mintArguments
-}) => (0, import_viem8.encodeFunctionData)({
-  abi: import_protocol_deployments8.zoraMintsManagerImplConfig.abi,
+}) => (0, import_viem9.encodeFunctionData)({
+  abi: import_protocol_deployments10.zoraMintsManagerImplConfig.abi,
   functionName: "collect",
   args: [
     zoraCreator1155Contract,
@@ -1910,9 +2716,9 @@ function collectWithMintsParams({
     minter,
     mintArguments
   });
-  return makeSimulateContractParamaters({
-    abi: import_protocol_deployments8.zoraMints1155Config.abi,
-    address: import_protocol_deployments8.zoraMints1155Config.address[chainId],
+  return makeContractParameters({
+    abi: import_protocol_deployments10.zoraMints1155Config.abi,
+    address: import_protocol_deployments10.zoraMints1155Config.address[chainId],
     functionName: "transferBatchToManagerAndCall",
     args: [tokenIds, quantities, call],
     // if it is a paid mint, the aadditional value will be sent to the manager contract and forwarded to the creator 1155 contract
@@ -1925,12 +2731,12 @@ function getMintsEthPrice({
   publicClient
 }) {
   const chainId = publicClient.chain?.id;
-  if (!chainId || !import_protocol_deployments8.zoraMintsManagerImplAddress[chainId]) {
+  if (!chainId || !import_protocol_deployments10.zoraMintsManagerImplAddress[chainId]) {
     throw new Error(`Chain id ${chainId} not supported`);
   }
   return publicClient.readContract({
-    abi: import_protocol_deployments8.zoraMintsManagerImplABI,
-    address: import_protocol_deployments8.zoraMintsManagerImplAddress[chainId],
+    abi: import_protocol_deployments10.zoraMintsManagerImplABI,
+    address: import_protocol_deployments10.zoraMintsManagerImplAddress[chainId],
     functionName: "getEthPrice"
   });
 }
@@ -1954,7 +2760,7 @@ function makePermitTransferBatchAndTypeData({
     safeTransferData
   };
   const typedData = {
-    ...(0, import_protocol_deployments8.mintsSafeTransferBatchTypedDataDefinition)({
+    ...(0, import_protocol_deployments10.mintsSafeTransferBatchTypedDataDefinition)({
       chainId,
       message: permit
     }),
@@ -1985,7 +2791,7 @@ function makePermitTransferTypeData({
     safeTransferData
   };
   const typedData = {
-    ...(0, import_protocol_deployments8.mintsSafeTransferTypedDataDefinition)({
+    ...(0, import_protocol_deployments10.mintsSafeTransferTypedDataDefinition)({
       chainId,
       message: permit
     }),
@@ -2001,9 +2807,9 @@ var encodePremintOnManager = ({
   premintConfig,
   premintSignature,
   mintArguments,
-  signerContract = import_viem8.zeroAddress
-}) => (0, import_viem8.encodeFunctionData)({
-  abi: import_protocol_deployments8.zoraMintsManagerImplConfig.abi,
+  signerContract = import_viem9.zeroAddress
+}) => (0, import_viem9.encodeFunctionData)({
+  abi: import_protocol_deployments10.zoraMintsManagerImplConfig.abi,
   functionName: "collectPremintV2",
   args: [
     contractCreationConfig,
@@ -2042,7 +2848,7 @@ var makePermitToCollectPremintOrNonPremint = ({
     nonce,
     deadline,
     safeTransferData,
-    to: import_protocol_deployments8.zoraMintsManagerImplConfig.address[chainId]
+    to: import_protocol_deployments10.zoraMintsManagerImplConfig.address[chainId]
   });
 };
 function collectPremintV2WithMintsParams({
@@ -2056,9 +2862,9 @@ function collectPremintV2WithMintsParams({
   const call = encodePremintOnManager({
     ...rest
   });
-  return makeSimulateContractParamaters({
-    abi: import_protocol_deployments8.zoraMints1155Config.abi,
-    address: import_protocol_deployments8.zoraMints1155Config.address[chainId],
+  return makeContractParameters({
+    abi: import_protocol_deployments10.zoraMints1155Config.abi,
+    address: import_protocol_deployments10.zoraMints1155Config.address[chainId],
     functionName: "transferBatchToManagerAndCall",
     args: [tokenIds, quantities, call],
     value: getPaidMintValue(quantities, paidMintPricePerToken),
@@ -2069,21 +2875,21 @@ 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)({
-    abi: import_protocol_deployments8.zoraMintsManagerImplABI,
+  return (0, import_viem9.decodeErrorResult)({
+    abi: import_protocol_deployments10.zoraMintsManagerImplABI,
     data: internalErrorData
   });
 }
 
 // src/mints/mints-eth-unwrapper-and-caller.ts
-var import_protocol_deployments9 = require("@zoralabs/protocol-deployments");
-var import_viem9 = require("viem");
+var import_protocol_deployments11 = require("@zoralabs/protocol-deployments");
+var import_viem10 = require("viem");
 var makeCallWithEthSafeTransferData = ({
   address: addressToCall,
   call: functionToCall,
   value: valueToSend
-}) => (0, import_viem9.encodeFunctionData)({
-  abi: import_protocol_deployments9.iUnwrapAndForwardActionABI,
+}) => (0, import_viem10.encodeFunctionData)({
+  abi: import_protocol_deployments11.iUnwrapAndForwardActionABI,
   functionName: "callWithEth",
   args: [addressToCall, functionToCall, valueToSend]
 });
@@ -2103,27 +2909,70 @@ var unwrapAndForwardEthPermitAndTypedDataDefinition = ({
   tokenIds,
   quantities,
   safeTransferData: safeTransferData || makeCallWithEthSafeTransferData(callWithEth),
-  to: import_protocol_deployments9.mintsEthUnwrapperAndCallerAddress[chainId],
+  to: import_protocol_deployments11.mintsEthUnwrapperAndCallerAddress[chainId],
   nonce
 });
+
+// src/sdk.ts
+function createCreatorClient(clientConfig) {
+  const premintClient = new PremintClient({
+    chainId: clientConfig.chainId,
+    publicClient: clientConfig.publicClient,
+    premintApi: clientConfig.premintApi || new PremintAPIClient(clientConfig.chainId)
+  });
+  const create1155CreatorClient = new Create1155Client({
+    chainId: clientConfig.chainId,
+    publicClient: clientConfig.publicClient
+  });
+  return {
+    createPremint: (p) => premintClient.createPremint(p),
+    updatePremint: (p) => premintClient.updatePremint(p),
+    deletePremint: (p) => premintClient.deletePremint(p),
+    create1155: (p) => create1155CreatorClient.createNew1155Token(p)
+  };
+}
+function createCollectorClient(params) {
+  const premintGetterToUse = params.premintGetter || new PremintAPIClient(params.chainId);
+  const mintGetterToUse = params.mintGetter || new SubgraphMintGetter(params.chainId);
+  const mintClient = new MintClient({
+    publicClient: params.publicClient,
+    premintGetter: premintGetterToUse,
+    mintGetter: mintGetterToUse
+  });
+  return {
+    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)
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DEFAULT_SALE_SETTINGS,
+  Create1155Client,
   Errors,
-  MintAPIClient,
+  MintClient,
   PremintAPIClient,
+  PremintClient,
   PremintConfigVersion,
+  SubgraphMintGetter,
   ZORA_API_BASE,
   applyUpdateToPremint,
+  buildPremintMintCall,
+  collectOnchain,
+  collectPremint,
   collectPremintV2WithMintsParams,
   collectWithMintsParams,
   convertCollectionFromApi,
   convertGetPremintApiResponse,
+  convertGetPremintOfCollectionApiResponse,
   convertPremintFromApi,
-  create1155CreatorClient,
-  create1155TokenSetupArgs,
-  createMintClient,
-  createPremintClient,
+  createCollectorClient,
+  createCreatorClient,
   decodeCallFailedError,
   defaultAdditionalAdmins,
   defaultTokenConfigV1MintArguments,
@@ -2133,17 +2982,22 @@ var unwrapAndForwardEthPermitAndTypedDataDefinition = ({
   encodePostSignatureInput,
   encodePremintForAPI,
   getApiNetworkConfigForChain,
+  getDataFromPremintReceipt,
   getDefaultFixedPriceMinterAddress,
-  getMintCosts,
   getMintsAccountBalanceWithPriceQuery,
   getMintsEthPrice,
   getPremintCollectionAddress,
   getPremintExecutorAddress,
   getPremintMintCosts,
+  getPremintMintCostsWithUnknownTokenPrice,
   getPremintMintFee,
+  getPremintPricePerToken,
   getPremintedLogFromReceipt,
+  getSignature,
   getTokenIdFromCreateReceipt,
   isAuthorizedToCreatePremint,
+  isPremintConfigV1,
+  isPremintConfigV2,
   isValidSignature,
   makeCallWithEthSafeTransferData,
   makeMintRewardsRecipient,