@zoralabs/protocol-sdk 0.5.17 → 0.7.0

package/dist/index.js

@@ -20,8 +20,243 @@ import {
   keccak256,
   concat,
   recoverAddress,
-  parseEther
+  parseEther as parseEther2
 } from "viem";
+
+// src/apis/chain-constants.ts
+import {
+  arbitrum,
+  base,
+  baseSepolia,
+  foundry,
+  mainnet,
+  optimism,
+  sepolia,
+  zora,
+  zoraSepolia
+} from "viem/chains";
+import { parseEther } from "viem";
+
+// src/constants.ts
+import { parseAbi } from "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`;
+}
+var zora721Abi = parseAbi([
+  "function mintWithRewards(address recipient, uint256 quantity, string calldata comment, address mintReferral) external payable",
+  "function zoraFeeForAmount(uint256 amount) public view returns (address, uint256)"
+]);
+
+// src/apis/chain-constants.ts
+var REWARD_PER_TOKEN = parseEther("0.000777");
+var networkConfigByChain = {
+  [mainnet.id]: {
+    chainId: mainnet.id,
+    isTestnet: false,
+    zoraCollectPathChainName: "eth",
+    zoraBackendChainName: "ETHEREUM-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-mainnet", "stable")
+  },
+  [sepolia.id]: {
+    chainId: sepolia.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "sep",
+    zoraBackendChainName: "ETHEREUM-SEPOLIA",
+    subgraphUrl: getSubgraph("zora-create-sepolia", "stable")
+  },
+  [zora.id]: {
+    chainId: zora.id,
+    isTestnet: false,
+    zoraCollectPathChainName: "zora",
+    zoraBackendChainName: "ZORA-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-zora-mainnet", "stable")
+  },
+  [zoraSepolia.id]: {
+    chainId: zoraSepolia.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "zsep",
+    zoraBackendChainName: "ZORA-SEPOLIA",
+    subgraphUrl: getSubgraph("zora-create-zora-sepolia", "stable")
+  },
+  [optimism.id]: {
+    chainId: optimism.id,
+    isTestnet: false,
+    zoraCollectPathChainName: "oeth",
+    zoraBackendChainName: "OPTIMISM-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-optimism", "stable")
+  },
+  [arbitrum.id]: {
+    chainId: arbitrum.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "arb",
+    zoraBackendChainName: "ARBITRUM-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-arbitrum-one", "stable")
+  },
+  [base.id]: {
+    chainId: base.id,
+    isTestnet: false,
+    zoraCollectPathChainName: "base",
+    zoraBackendChainName: "BASE-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-base-mainnet", "stable")
+  },
+  [baseSepolia.id]: {
+    chainId: baseSepolia.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "bsep",
+    zoraBackendChainName: "BASE-SEPOLIA",
+    subgraphUrl: getSubgraph("zora-create-base-sepolia", "stable")
+  },
+  [foundry.id]: {
+    chainId: foundry.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "zgor",
+    zoraBackendChainName: "ZORA-GOERLI",
+    subgraphUrl: getSubgraph("zora-create-zora-testnet", "stable")
+  }
+};
+
+// src/premint/conversions.ts
+import {
+  PremintConfigVersion
+} from "@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 === PremintConfigVersion.V1 || !premint.config_version) {
+    const tokenConfig = premint.tokenConfig;
+    return {
+      premintConfigVersion: 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: 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 === PremintConfigVersion.V1) {
+    return encodePremintV1ForAPI(premintConfig);
+  }
+  if (premintConfigVersion === 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 === PremintConfigVersion.V1;
+var isPremintConfigV2 = (premintConfigAndVersion) => premintConfigAndVersion.premintConfigVersion === PremintConfigVersion.V2;
+
+// src/premint/preminter.ts
 var getPremintExecutorAddress = () => zoraCreator1155PremintExecutorImplAddress[999];
 async function isAuthorizedToCreatePremint({
   contractAdmin = zeroAddress,
@@ -164,8 +399,8 @@ var supportsPremintVersion = async ({
 };
 async function getPremintCollectionAddress({
   publicClient,
-  collection,
-  collectionAddress
+  contract: collection,
+  contractAddress: collectionAddress
 }) {
   if (typeof collection !== "undefined") {
     return publicClient.readContract({
@@ -224,7 +459,7 @@ async function getPremintMintFee({
     });
   } catch (e) {
     console.error(e);
-    return parseEther("0.000777");
+    return parseEther2("0.000777");
   }
 }
 async function getPremintMintCosts({
@@ -234,12 +469,42 @@ 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 = zeroAddress,
   platformReferral = zeroAddress
@@ -267,12 +532,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");
@@ -358,19 +623,39 @@ var httpClient = {
   retries
 };
 
-// src/constants.ts
-import { parseAbi } from "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 = 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 {
@@ -388,392 +673,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}
+`;
+function buildNftTokenSalesQuery({
+  tokenId,
+  tokenAddress
+}) {
+  return {
+    query: `
+${FRAGMENTS}
+query ($id: ID!) {
+  zoraCreateToken(id: $id) {
+    ...Token 
   }
 }
-`;
-
-// src/apis/chain-constants.ts
-import {
-  arbitrum,
-  base,
-  baseSepolia,
-  foundry,
-  mainnet,
-  optimism,
-  sepolia,
-  zora,
-  zoraSepolia
-} from "viem/chains";
-import { parseEther as parseEther2 } from "viem";
-var REWARD_PER_TOKEN = parseEther2("0.000777");
-var networkConfigByChain = {
-  [mainnet.id]: {
-    chainId: mainnet.id,
-    isTestnet: false,
-    zoraCollectPathChainName: "eth",
-    zoraBackendChainName: "ETHEREUM-MAINNET",
-    subgraphUrl: getSubgraph("zora-create-mainnet", "stable")
-  },
-  [sepolia.id]: {
-    chainId: sepolia.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "sep",
-    zoraBackendChainName: "ETHEREUM-SEPOLIA",
-    subgraphUrl: getSubgraph("zora-create-sepolia", "stable")
-  },
-  [zora.id]: {
-    chainId: zora.id,
-    isTestnet: false,
-    zoraCollectPathChainName: "zora",
-    zoraBackendChainName: "ZORA-MAINNET",
-    subgraphUrl: getSubgraph("zora-create-zora-mainnet", "stable")
-  },
-  [zoraSepolia.id]: {
-    chainId: zoraSepolia.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "zsep",
-    zoraBackendChainName: "ZORA-SEPOLIA",
-    subgraphUrl: getSubgraph("zora-create-zora-sepolia", "stable")
-  },
-  [optimism.id]: {
-    chainId: optimism.id,
-    isTestnet: false,
-    zoraCollectPathChainName: "oeth",
-    zoraBackendChainName: "OPTIMISM-MAINNET",
-    subgraphUrl: getSubgraph("zora-create-optimism", "stable")
-  },
-  [arbitrum.id]: {
-    chainId: arbitrum.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "arb",
-    zoraBackendChainName: "ARBITRUM-MAINNET",
-    subgraphUrl: getSubgraph("zora-create-arbitrum-one", "stable")
-  },
-  [base.id]: {
-    chainId: base.id,
-    isTestnet: false,
-    zoraCollectPathChainName: "base",
-    zoraBackendChainName: "BASE-MAINNET",
-    subgraphUrl: getSubgraph("zora-create-base-mainnet", "stable")
-  },
-  [baseSepolia.id]: {
-    chainId: baseSepolia.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "bsep",
-    zoraBackendChainName: "BASE-SEPOLIA",
-    subgraphUrl: getSubgraph("zora-create-base-sepolia", "stable")
-  },
-  [foundry.id]: {
-    chainId: foundry.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "zgor",
-    zoraBackendChainName: "ZORA-GOERLI",
-    subgraphUrl: getSubgraph("zora-create-zora-testnet", "stable")
+`,
+    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
-import {
-  PremintConfigVersion
-} from "@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 === PremintConfigVersion.V1 || !premint.config_version) {
-    const tokenConfig = premint.tokenConfig;
+function parseSalesConfig(targetStrategy) {
+  if (targetStrategy.type === "FIXED_PRICE")
     return {
-      premintConfigVersion: 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: 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 === PremintConfigVersion.V1) {
-    return encodePremintV1ForAPI(premintConfig);
-  }
-  if (premintConfigVersion === 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
-import {
-  createPublicClient,
-  http
-} from "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 {
+    ...tokenInfo,
+    salesConfig
+  };
+}
+function parseTokenInfo(token) {
   return {
-    chain,
-    httpClient: httpClient2 || httpClient,
-    publicClient: publicClient || createPublicClient({ chain, transport: http() })
+    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
   };
 }
 
@@ -782,8 +940,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
@@ -824,8 +981,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%,
@@ -872,20 +1028,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
@@ -898,7 +1051,7 @@ var PremintClient = class {
       ...args,
       apiClient: this.apiClient,
       publicClient: this.publicClient,
-      chainId: this.chain.id
+      chainId: this.chainId
     });
   }
   /**
@@ -912,7 +1065,7 @@ var PremintClient = class {
       ...params,
       apiClient: this.apiClient,
       publicClient: this.publicClient,
-      chainId: this.chain.id
+      chainId: this.chainId
     });
   }
   /**
@@ -926,7 +1079,7 @@ var PremintClient = class {
       ...parameters,
       publicClient: this.publicClient,
       apiClient: this.apiClient,
-      chainId: this.chain.id
+      chainId: this.chainId
     });
   }
   /**
@@ -936,11 +1089,8 @@ 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({
+  async getPremint({ address, uid }) {
+    return await this.apiClient.get({
       collectionAddress: address,
       uid
     });
@@ -948,51 +1098,12 @@ var PremintClient = class {
   /**
    * 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 || PremintConfigVersion2.V1,
-      collectionAddress: collectionAddressToUse,
-      collection: collectionAndOrAddress.collection
-    });
-    return { isValid: isAuthorized, recoveredSigner: recoveredAddress };
-  }
-  makeUrls({
-    uid,
-    address,
-    tokenId
-  }) {
-    return makeUrls({
-      uid,
-      address,
-      tokenId,
-      chain: this.chain
+   * @returns deterministic contract address
+   */
+  async getCollectionAddress(collection) {
+    return await getPremintCollectionAddress({
+      contract: collection,
+      publicClient: this.publicClient
     });
   }
   async getMintCosts({
@@ -1014,17 +1125,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,
@@ -1054,7 +1188,7 @@ function makePremintReturn({
     await submit({
       signature,
       checkSignature,
-      signerAccount
+      account: signerAccount
     });
     return {
       signature,
@@ -1064,7 +1198,7 @@ function makePremintReturn({
   const submit = async ({
     signature,
     checkSignature,
-    signerAccount
+    account
   }) => {
     if (checkSignature) {
       const isAuthorized = await isAuthorizedToCreatePremint({
@@ -1072,7 +1206,7 @@ function makePremintReturn({
         additionalAdmins: collection?.additionalAdmins,
         contractAdmin: collection?.contractAdmin,
         publicClient,
-        signer: signerAccount
+        signer: account
       });
       if (!isAuthorized) {
         throw new Error("Not authorized to create premint");
@@ -1115,7 +1249,7 @@ async function signPremint({
   };
 }
 async function createPremint({
-  tokenCreationConfig,
+  token: tokenCreationConfig,
   uid,
   publicClient,
   apiClient,
@@ -1138,7 +1272,7 @@ async function createPremint({
     premintConfig,
     premintConfigVersion,
     collectionAddress: collectionAddressToUse,
-    collection: collectionOrAddress.collection,
+    collection: collectionOrAddress.contract,
     publicClient,
     apiClient,
     chainId
@@ -1191,10 +1325,9 @@ async function updatePremint({
   chainId
 }) {
   const {
-    premintConfig,
-    collection: collectionCreationConfig,
-    premintConfigVersion
-  } = await apiClient.getSignature({
+    premint: { premintConfig, premintConfigVersion },
+    collection: collectionCreationConfig
+  } = await apiClient.get({
     collectionAddress: collection,
     uid
   });
@@ -1222,11 +1355,10 @@ async function deletePremint({
   chainId
 }) {
   const {
-    premintConfig,
-    premintConfigVersion,
+    premint: { premintConfig, premintConfigVersion },
     collection: collectionCreationConfig,
     collectionAddress
-  } = await apiClient.getSignature({
+  } = await apiClient.get({
     collectionAddress: collection,
     uid
   });
@@ -1245,52 +1377,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 === PremintConfigVersion2.V3) {
-    throw new Error("PremintV3 not supported in premint SDK");
-  }
-  const value = (await getPremintMintCosts({
+  const mintFee = await getPremintMintFee({
     tokenContract,
-    quantityToMint: numberToMint,
-    publicClient,
-    tokenPrice: premintConfig.tokenConfig.pricePerToken
-  })).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 ? zeroAddress2 : collectionAddress;
   const firstMinterToSubmit = firstMinter || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
-  return makeSimulateContractParamaters({
+  if (premint.premintConfigVersion === PremintConfigVersion2.V3) {
+    throw new Error("PremintV3 not supported in premint SDK");
+  }
+  const value = (mintFee + premint.premintConfig.tokenConfig.pricePerToken) * BigInt(quantityToMint);
+  return makeContractParameters({
     account: minterAccount,
     abi: zoraCreator1155PremintExecutorImplABI2,
     functionName: "premint",
@@ -1299,31 +1451,29 @@ async function makeMintParameters({
     args: [
       collectionOrEmpty,
       collectionAddressToSubmit,
-      encodePremintConfig({
-        premintConfig,
-        premintConfigVersion
-      }),
+      encodePremintConfig(premint),
       signature,
-      numberToMint,
+      BigInt(quantityToMint),
       mintArgumentsContract,
       firstMinterToSubmit,
       zeroAddress2
     ]
   });
-}
+};
 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}`
   };
@@ -1340,18 +1490,487 @@ 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
+import {
+  encodeAbiParameters,
+  parseAbiParameters,
+  zeroAddress as zeroAddress3
+} from "viem";
+import {
+  erc20MinterABI,
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI2
+} from "@zoralabs/protocol-deployments";
+
+// src/mint/utils.ts
+import * as semver from "semver";
+var contractSupportsNewMintFunction = (contractVersion) => {
+  if (!contractVersion) {
+    return false;
+  }
+  const semVerContractVersion = semver.coerce(contractVersion)?.raw;
+  if (!semVerContractVersion)
+    return false;
+  return semver.gte(semVerContractVersion, "2.9.0");
+};
+
+// 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: erc20MinterABI,
+      functionName: "mint",
+      account: minterAccount,
+      address: salesConfigAndTokenInfo.salesConfig.address,
+      /* args: mintTo, quantity, tokenAddress, tokenId, totalValue, currency, mintReferral, comment */
+      args: [
+        mintTo,
+        mintQuantity,
+        tokenContract,
+        BigInt(tokenId),
+        salesConfigAndTokenInfo.salesConfig.pricePerToken * mintQuantity,
+        salesConfigAndTokenInfo.salesConfig.currency,
+        mintReferral || zeroAddress3,
+        mintComment || ""
+      ]
+    });
+  }
+  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 || zeroAddress3
+    ]
+  });
+}
+function makeEthMintCall({
+  tokenContract,
+  tokenId,
+  salesConfigAndTokenInfo,
+  minterAccount,
+  mintComment,
+  mintReferral,
+  mintQuantity,
+  mintTo
+}) {
+  const mintValue = parseMintCosts({
+    mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
+    salesConfig: salesConfigAndTokenInfo.salesConfig,
+    quantityToMint: mintQuantity
+  }).totalCostEth;
+  const minterArguments = encodeAbiParameters(
+    parseAbiParameters("address, string"),
+    [mintTo, mintComment || ""]
+  );
+  if (contractSupportsNewMintFunction(salesConfigAndTokenInfo.contractVersion)) {
+    return makeContractParameters({
+      abi: zoraCreator1155ImplABI2,
+      functionName: "mint",
+      account: minterAccount,
+      value: mintValue,
+      address: tokenContract,
+      args: [
+        salesConfigAndTokenInfo.salesConfig.address,
+        BigInt(tokenId),
+        mintQuantity,
+        mintReferral ? [mintReferral] : [],
+        minterArguments
+      ]
+    });
+  }
+  return makeContractParameters({
+    abi: zoraCreator1155ImplABI2,
+    functionName: "mintWithRewards",
+    account: minterAccount,
+    value: mintValue,
+    address: tokenContract,
+    /* args: minter, tokenId, quantity, minterArguments, mintReferral */
+    args: [
+      salesConfigAndTokenInfo.salesConfig.address,
+      BigInt(tokenId),
+      mintQuantity,
+      minterArguments,
+      mintReferral || zeroAddress3
+    ]
+  });
+}
+function parseMintCosts({
+  salesConfig,
+  mintFeePerQuantity,
+  quantityToMint
+}) {
+  const mintFeeForTokens = 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
+import { zeroAddress as zeroAddress4 } from "viem";
+async function getMint({
+  params,
+  mintGetter,
+  premintGetter,
+  publicClient
+}) {
+  const { tokenContract } = params;
+  if (isOnChainMint(params)) {
+    const tokenId = is1155Mint(params) ? params.tokenId : void 0;
+    const 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: zeroAddress4,
+        collection,
+        collectionAddress: params.tokenContract,
+        signature: premint.signature
+      },
+      mintFee
+    });
+  });
+}
+function parsePremint({
+  premint,
+  mintFee
+}) {
+  if (isPremintConfigV1(premint.premint) || isPremintConfigV2(premint.premint)) {
+    return {
+      creator: premint.signer,
+      maxSupply: premint.premint.premintConfig.tokenConfig.maxSupply,
+      mintFeePerQuantity: mintFee,
+      mintType: "premint",
+      uid: premint.premint.premintConfig.uid,
+      contract: {
+        address: premint.collectionAddress,
+        name: premint.collection.contractName,
+        URI: premint.collection.contractURI
+      },
+      tokenURI: premint.premint.premintConfig.tokenConfig.tokenURI,
+      totalMinted: 0n,
+      salesConfig: {
+        duration: premint.premint.premintConfig.tokenConfig.mintDuration,
+        maxTokensPerAddress: premint.premint.premintConfig.tokenConfig.maxTokensPerAddress,
+        pricePerToken: premint.premint.premintConfig.tokenConfig.pricePerToken,
+        saleType: "premint"
+      }
+    };
+  }
+  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
-import {
-  encodeAbiParameters,
-  parseAbiParameters,
-  zeroAddress as zeroAddress3
-} from "viem";
-import {
-  erc20MinterABI,
-  erc20MinterAddress,
-  zoraCreator1155ImplABI as zoraCreator1155ImplABI2,
-  zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress2
-} from "@zoralabs/protocol-deployments";
 var MintError = class extends Error {
 };
 var MintInactiveError = class extends Error {
@@ -1361,265 +1980,454 @@ 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
+import {
+  zoraCreator1155FactoryImplABI as zoraCreator1155FactoryImplABI2,
+  zoraCreator1155FactoryImplAddress as zoraCreator1155FactoryImplAddress2,
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI5
+} from "@zoralabs/protocol-deployments";
+import { decodeEventLog as decodeEventLog2 } from "viem";
+
+// src/create/contract-setup.ts
+import {
+  contracts1155,
+  zoraCreator1155FactoryImplABI,
+  zoraCreator1155FactoryImplAddress,
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI3
+} from "@zoralabs/protocol-deployments";
+function new1155ContractVersion(chainId) {
+  const address = 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: zoraCreator1155FactoryImplABI,
+    // Since this address is deterministic we can hardcode a chain id safely here.
+    address: zoraCreator1155FactoryImplAddress[chainId],
+    functionName: "deterministicContractAddress",
     args: [
-      mintArguments.mintToAddress,
-      BigInt(mintArguments.quantityToMint),
-      mintArguments.mintComment || "",
-      mintArguments.mintReferral || zeroAddress3
+      account,
+      contract.uri,
+      contract.name,
+      contract.defaultAdmin || account
     ]
   });
-}
-function getMintCosts({
-  salesConfigAndTokenInfo,
-  quantityToMint
-}) {
-  const mintFeeForTokens = salesConfigAndTokenInfo.mintFeePerQuantity * quantityToMint;
-  const tokenPurchaseCost = BigInt(salesConfigAndTokenInfo.salesConfig.pricePerToken) * quantityToMint;
+  let contractVersion;
+  let contractExists;
+  try {
+    contractVersion = await publicClient.readContract({
+      abi: zoraCreator1155ImplABI3,
+      address: contractAddress,
+      functionName: "contractVersion"
+    });
+    contractExists = true;
+  } catch (e) {
+    contractVersion = new1155ContractVersion(chainId);
+    contractExists = false;
+  }
+  const nextTokenId = contractExists ? await publicClient.readContract({
+    address: contractAddress,
+    abi: zoraCreator1155ImplABI3,
+    functionName: "nextTokenId"
+  }) : 1n;
   return {
-    mintFee: mintFeeForTokens,
-    tokenPurchaseCost,
-    totalCost: mintFeeForTokens + tokenPurchaseCost
+    contractExists,
+    contractAddress,
+    contractVersion,
+    nextTokenId
   };
 }
-async function makePrepareMint1155TokenParams({
-  tokenId,
-  salesConfigAndTokenInfo,
-  minterAccount,
-  tokenAddress,
-  mintArguments
-}) {
-  const mintQuantity = BigInt(mintArguments.quantityToMint);
-  const mintValue = getMintCosts({
-    salesConfigAndTokenInfo,
-    quantityToMint: mintQuantity
-  }).totalCost;
-  switch (salesConfigAndTokenInfo.salesConfig.saleType) {
-    case "fixedPrice":
-      const fixedPriceArgs = mintArguments;
-      return makeSimulateContractParamaters({
-        abi: zoraCreator1155ImplABI2,
-        functionName: "mintWithRewards",
-        account: minterAccount,
-        value: mintValue,
-        address: tokenAddress,
-        /* args: minter, tokenId, quantity, minterArguments, mintReferral */
-        args: [
-          salesConfigAndTokenInfo.salesConfig.address || zoraCreatorFixedPriceSaleStrategyAddress2[999999999],
-          BigInt(tokenId),
-          mintQuantity,
-          encodeAbiParameters(parseAbiParameters("address, string"), [
-            fixedPriceArgs.mintToAddress,
-            fixedPriceArgs.mintComment || ""
-          ]),
-          fixedPriceArgs.mintReferral || zeroAddress3
-        ]
-      });
-    case "erc20":
-      const erc20Args = mintArguments;
-      return makeSimulateContractParamaters({
-        abi: erc20MinterABI,
-        functionName: "mint",
-        account: minterAccount,
-        address: salesConfigAndTokenInfo?.salesConfig.address || erc20MinterAddress[999999999],
-        /* args: mintTo, quantity, tokenAddress, tokenId, totalValue, currency, mintReferral, comment */
-        args: [
-          mintArguments.mintToAddress,
-          mintQuantity,
-          tokenAddress,
-          BigInt(tokenId),
-          salesConfigAndTokenInfo.salesConfig.pricePerToken,
-          salesConfigAndTokenInfo.salesConfig.currency,
-          erc20Args.mintReferral || zeroAddress3,
-          erc20Args.mintComment || ""
-        ]
-      });
-    default:
-      throw new MintError("Unsupported sale type");
-  }
-}
 
-// src/create/1155-create-helper.ts
+// src/create/token-setup.ts
 import {
-  zoraCreator1155FactoryImplABI,
-  zoraCreator1155FactoryImplAddress,
-  zoraCreator1155ImplABI as zoraCreator1155ImplABI3,
-  zoraCreatorFixedPriceSaleStrategyABI
+  erc20MinterABI as erc20MinterABI2,
+  erc20MinterAddress as erc20MinterAddresses,
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI4,
+  zoraCreatorFixedPriceSaleStrategyABI,
+  zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress2
 } from "@zoralabs/protocol-deployments";
-import { decodeEventLog as decodeEventLog2, encodeFunctionData, zeroAddress as zeroAddress4 } from "viem";
-var SALE_END_FOREVER = 18446744073709551615n;
-var ROYALTY_BPS_DEFAULT = 1e3;
-var DEFAULT_SALE_SETTINGS = {
-  fundsRecipient: zeroAddress4,
-  // 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
+import { encodeFunctionData, zeroAddress as zeroAddress5 } from "viem";
+import * as semver2 from "semver";
+var PERMISSION_BITS = {
+  MINTER: 2n ** 2n
 };
-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
-}) {
-  if (!maxSupply) {
-    maxSupply = OPEN_EDITION_MINT_SIZE;
-  }
-  maxSupply = BigInt(maxSupply);
-  mintToCreatorCount = BigInt(mintToCreatorCount);
-  const salesConfigWithDefaults = {
-    // Set static sales default.
+var saleSettingsOrDefault = (saleSettings) => {
+  const SALE_END_FOREVER = 18446744073709551615n;
+  const DEFAULT_SALE_SETTINGS = {
+    currency: zeroAddress5,
+    // 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,
-    // Override with user settings.
-    ...salesConfig
+    ...saleSettings
   };
-  const setupActions = [
-    encodeFunctionData({
-      abi: zoraCreator1155ImplABI3,
-      functionName: "assumeLastTokenIdMatches",
-      args: [nextTokenId - 1n]
-    }),
-    createReferral ? encodeFunctionData({
-      abi: zoraCreator1155ImplABI3,
+};
+function applyNew1155Defaults(props, ownerAddress) {
+  const { payoutRecipient: fundsRecipient } = props;
+  const fundsRecipientOrOwner = fundsRecipient && fundsRecipient !== zeroAddress5 ? fundsRecipient : ownerAddress;
+  return {
+    payoutRecipient: fundsRecipientOrOwner,
+    createReferral: props.createReferral || zeroAddress5,
+    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 erc20MinterAddress = erc20MinterAddresses[chainId];
+  if (!erc20MinterAddress)
+    throw new Error(`ERC20Minter not deployed on chainId ${chainId}`);
+  const erc20MinterApproval = encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    functionName: "addPermission",
+    args: [BigInt(nextTokenId), erc20MinterAddress, PERMISSION_BITS.MINTER]
+  });
+  const saleData = encodeFunctionData({
+    abi: erc20MinterABI2,
+    functionName: "setSale",
+    args: [
+      BigInt(nextTokenId),
+      {
+        saleStart: saleStart || BigInt(0),
+        saleEnd: saleEnd || BigInt(0),
+        maxTokensPerAddress: BigInt(mintLimit || 0),
+        pricePerToken,
+        fundsRecipient,
+        currency
+      }
+    ]
+  });
+  const callSale = encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    functionName: "callSale",
+    args: [BigInt(nextTokenId), erc20MinterAddress, saleData]
+  });
+  return {
+    minter: erc20MinterAddress,
+    setupActions: [erc20MinterApproval, callSale]
+  };
+}
+function setupFixedPriceMinter({
+  pricePerToken: price,
+  tokenId: nextTokenId,
+  chainId,
+  saleStart,
+  saleEnd,
+  maxTokensPerAddress: mintLimit,
+  fundsRecipient
+}) {
+  const fixedPriceStrategyAddress = zoraCreatorFixedPriceSaleStrategyAddress2[chainId];
+  const fixedPriceApproval = encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    functionName: "addPermission",
+    args: [
+      BigInt(nextTokenId),
+      fixedPriceStrategyAddress,
+      PERMISSION_BITS.MINTER
+    ]
+  });
+  const saleData = encodeFunctionData({
+    abi: zoraCreatorFixedPriceSaleStrategyABI,
+    functionName: "setSale",
+    args: [
+      BigInt(nextTokenId),
+      {
+        pricePerToken: price,
+        saleStart: saleStart || BigInt(0),
+        saleEnd: saleEnd || BigInt(0),
+        maxTokensPerAddress: BigInt(mintLimit || 0),
+        fundsRecipient
+      }
+    ]
+  });
+  const callSale = encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    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 === zeroAddress5) {
+    return setupFixedPriceMinter({
+      ...salesConfig,
+      ...rest
+    });
+  } else {
+    return setupErc20Minter({
+      ...salesConfig,
+      ...rest
+    });
+  }
+}
+function buildSetupNewToken({
+  tokenURI,
+  maxSupply = OPEN_EDITION_MINT_SIZE,
+  createReferral = zeroAddress5,
+  contractVersion
+}) {
+  if (contractSupportsMintRewards(contractVersion, "ERC1155")) {
+    return encodeFunctionData({
+      abi: zoraCreator1155ImplABI4,
       functionName: "setupNewTokenWithCreateReferral",
-      args: [tokenMetadataURI, maxSupply, createReferral]
-    }) : encodeFunctionData({
-      abi: zoraCreator1155ImplABI3,
-      functionName: "setupNewToken",
-      args: [tokenMetadataURI, maxSupply]
-    }),
-    encodeFunctionData({
-      abi: zoraCreator1155ImplABI3,
-      functionName: "addPermission",
-      args: [0n, fixedPriceMinterAddress, PERMISSION_BIT_MINTER]
-    }),
-    encodeFunctionData({
-      abi: zoraCreator1155ImplABI3,
-      functionName: "callSale",
+      args: [tokenURI, BigInt(maxSupply), createReferral]
+    });
+  }
+  if (createReferral !== zeroAddress5) {
+    throw new Error(
+      "Contract does not support create referral, but one was provided"
+    );
+  }
+  return encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    functionName: "setupNewToken",
+    args: [tokenURI, BigInt(maxSupply)]
+  });
+}
+function setupRoyaltyConfig({
+  royaltyBPS,
+  royaltyRecipient,
+  nextTokenId
+}) {
+  if (royaltyBPS > 0 && royaltyRecipient != zeroAddress5) {
+    return encodeFunctionData({
+      abi: zoraCreator1155ImplABI4,
+      functionName: "updateRoyaltiesForToken",
       args: [
         nextTokenId,
-        fixedPriceMinterAddress,
-        encodeFunctionData({
-          abi: zoraCreatorFixedPriceSaleStrategyABI,
-          functionName: "setSale",
-          args: [nextTokenId, salesConfigWithDefaults]
-        })
+        {
+          royaltyBPS,
+          royaltyRecipient,
+          royaltyMintSchedule: 0
+        }
       ]
-    })
-  ];
-  if (mintToCreatorCount) {
-    setupActions.push(
-      encodeFunctionData({
-        abi: zoraCreator1155ImplABI3,
-        functionName: "adminMint",
-        args: [account, nextTokenId, mintToCreatorCount, "0x"]
-      })
-    );
+    });
   }
-  if (royaltySettings) {
-    setupActions.push(
-      encodeFunctionData({
-        abi: zoraCreator1155ImplABI3,
-        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 encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    functionName: "adminMint",
+    args: [ownerAddress, nextTokenId, BigInt(mintQuantity), zeroAddress5]
+  });
+}
+function constructCreate1155TokenCalls(props) {
+  const {
+    chainId,
+    nextTokenId,
+    mintToCreatorCount,
+    ownerAddress,
+    contractVersion
+  } = props;
+  const new1155TokenPropsWithDefaults = applyNew1155Defaults(
+    props,
+    ownerAddress
+  );
+  const verifyTokenIdExpected = encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    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 = decodeEventLog2({
-        abi: zoraCreator1155ImplABI3,
+        abi: zoraCreator1155ImplABI5,
         eventName: "SetupNewToken",
         ...data
       });
@@ -1630,132 +2438,116 @@ var getTokenIdFromCreateReceipt = (receipt) => {
     }
   }
 };
-async function getContractExists(publicClient, contract, account) {
-  let contractAddress;
-  let contractExists = false;
-  if (typeof contract !== "string") {
-    contractAddress = await publicClient.readContract({
-      abi: zoraCreator1155FactoryImplABI,
-      // Since this address is deterministic we can hardcode a chain id safely here.
-      address: 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: zoraCreator1155FactoryImplABI2,
+      functionName: "createContractDeterministic",
+      account,
+      address: zoraCreator1155FactoryImplAddress2[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: zoraCreator1155ImplABI3,
-        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: zoraCreator1155ImplABI5,
+    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: zoraCreator1155ImplABI3,
-        functionName: "nextTokenId",
-        address: contractAddress
-      });
-    }
-    const fixedPriceMinterAddress = await publicClient.readContract({
-      abi: zoraCreator1155FactoryImplABI,
-      address: 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: zoraCreator1155FactoryImplABI,
-        functionName: "createContractDeterministic",
-        account,
-        address: 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: zoraCreator1155ImplABI3,
-        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
@@ -1826,7 +2618,7 @@ import {
 import {
   decodeErrorResult,
   encodeFunctionData as encodeFunctionData2,
-  zeroAddress as zeroAddress5
+  zeroAddress as zeroAddress6
 } from "viem";
 var addressOrAccountAddress = (address) => typeof address === "string" ? address : address.address;
 var mintWithEthParams = ({
@@ -1835,7 +2627,7 @@ var mintWithEthParams = ({
   chainId,
   pricePerMint,
   account
-}) => makeSimulateContractParamaters({
+}) => makeContractParameters({
   abi: zoraMintsManagerImplConfig.abi,
   address: zoraMintsManagerImplConfig.address[chainId],
   functionName: "mintWithEth",
@@ -1891,7 +2683,7 @@ function collectWithMintsParams({
     minter,
     mintArguments
   });
-  return makeSimulateContractParamaters({
+  return makeContractParameters({
     abi: zoraMints1155Config.abi,
     address: zoraMints1155Config.address[chainId],
     functionName: "transferBatchToManagerAndCall",
@@ -1982,7 +2774,7 @@ var encodePremintOnManager = ({
   premintConfig,
   premintSignature,
   mintArguments,
-  signerContract = zeroAddress5
+  signerContract = zeroAddress6
 }) => encodeFunctionData2({
   abi: zoraMintsManagerImplConfig.abi,
   functionName: "collectPremintV2",
@@ -2037,7 +2829,7 @@ function collectPremintV2WithMintsParams({
   const call = encodePremintOnManager({
     ...rest
   });
-  return makeSimulateContractParamaters({
+  return makeContractParameters({
     abi: zoraMints1155Config.abi,
     address: zoraMints1155Config.address[chainId],
     functionName: "transferBatchToManagerAndCall",
@@ -2090,23 +2882,66 @@ var unwrapAndForwardEthPermitAndTypedDataDefinition = ({
   to: 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)
+  };
+}
 export {
-  DEFAULT_SALE_SETTINGS,
+  Create1155Client,
   Errors,
-  MintAPIClient,
+  MintClient,
   PremintAPIClient,
+  PremintClient,
   PremintConfigVersion3 as PremintConfigVersion,
+  SubgraphMintGetter,
   ZORA_API_BASE,
   applyUpdateToPremint,
+  buildPremintMintCall,
+  collectOnchain,
+  collectPremint,
   collectPremintV2WithMintsParams,
   collectWithMintsParams,
   convertCollectionFromApi,
   convertGetPremintApiResponse,
+  convertGetPremintOfCollectionApiResponse,
   convertPremintFromApi,
-  create1155CreatorClient,
-  create1155TokenSetupArgs,
-  createMintClient,
-  createPremintClient,
+  createCollectorClient,
+  createCreatorClient,
   decodeCallFailedError,
   defaultAdditionalAdmins,
   defaultTokenConfigV1MintArguments,
@@ -2116,17 +2951,22 @@ export {
   encodePostSignatureInput,
   encodePremintForAPI,
   getApiNetworkConfigForChain,
+  getDataFromPremintReceipt,
   getDefaultFixedPriceMinterAddress,
-  getMintCosts,
   getMintsAccountBalanceWithPriceQuery,
   getMintsEthPrice,
   getPremintCollectionAddress,
   getPremintExecutorAddress,
   getPremintMintCosts,
+  getPremintMintCostsWithUnknownTokenPrice,
   getPremintMintFee,
+  getPremintPricePerToken,
   getPremintedLogFromReceipt,
+  getSignature,
   getTokenIdFromCreateReceipt,
   isAuthorizedToCreatePremint,
+  isPremintConfigV1,
+  isPremintConfigV2,
   isValidSignature,
   makeCallWithEthSafeTransferData,
   makeMintRewardsRecipient,