@zoralabs/protocol-sdk 0.6.0 → 0.7.1

package/dist/index.js

@@ -42,48 +42,13 @@ 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`;
+function getSubgraph(name, version2) {
+  return `${SUBGRAPH_CONFIG_BASE}/${name}/${version2}/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)"
 ]);
-var NFT_SALE_QUERY = `
-fragment SaleStrategy on SalesStrategyConfig {
-  type
-  fixedPrice {
-    address
-    pricePerToken
-    saleEnd
-    saleStart
-    maxTokensPerAddress
-  }
-  erc20Minter {
-    address
-    pricePerToken
-    currency
-    saleEnd
-    saleStart
-    maxTokensPerAddress
-  }
-}
-
-query ($id: ID!) {
-  zoraCreateToken(id: $id) {
-    id
-    contract {
-      mintFeePerQuantity
-      salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
-        ...SaleStrategy
-      }
-    }
-    salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
-      ...SaleStrategy
-    }
-  }
-}
-`;
 
 // src/apis/chain-constants.ts
 var REWARD_PER_TOKEN = parseEther("0.000777");
@@ -212,10 +177,22 @@ var convertPremintFromApi = (premint) => {
   }
 };
 var convertGetPremintApiResponse = (response) => ({
-  ...convertPremintFromApi(response.premint),
   collection: convertCollectionFromApi(response.collection),
   collectionAddress: response.collection_address,
-  signature: response.signature
+  signature: response.signature,
+  signer: response.signer,
+  premint: convertPremintFromApi(response.premint)
+});
+var convertGetPremintOfCollectionApiResponse = (response) => ({
+  collection: convertCollectionFromApi({
+    contractAdmin: response.contract_admin,
+    contractName: response.contract_name,
+    contractURI: response.contract_uri
+  }),
+  premints: response.premints.map((premint) => ({
+    premint: convertPremintFromApi(premint),
+    signature: premint.signature
+  }))
 });
 var encodePremintV1ForAPI = ({
   tokenConfig,
@@ -369,7 +346,7 @@ function migratePremintConfigToV2({
   };
 }
 var recoverCreatorFromCreatorAttribution = async ({
-  creatorAttribution: { version, domainName, structHash, signature },
+  creatorAttribution: { version: version2, domainName, structHash, signature },
   chainId,
   tokenContract
 }) => {
@@ -378,7 +355,7 @@ var recoverCreatorFromCreatorAttribution = async ({
       chainId,
       name: domainName,
       verifyingContract: tokenContract,
-      version
+      version: version2
     },
     types: {
       EIP712Domain: [
@@ -414,11 +391,11 @@ var supportedPremintVersions = async ({
   });
 };
 var supportsPremintVersion = async ({
-  version,
+  version: version2,
   tokenContract,
   publicClient
 }) => {
-  return (await supportedPremintVersions({ tokenContract, publicClient })).includes(version);
+  return (await supportedPremintVersions({ tokenContract, publicClient })).includes(version2);
 };
 async function getPremintCollectionAddress({
   publicClient,
@@ -442,7 +419,7 @@ async function getPremintCollectionAddress({
 }
 function applyUpdateToPremint({
   uid,
-  version,
+  version: version2,
   tokenConfig,
   tokenConfigUpdates
 }) {
@@ -453,7 +430,7 @@ function applyUpdateToPremint({
   const result = {
     deleted: false,
     uid,
-    version: version + 1,
+    version: version2 + 1,
     tokenConfig: updatedTokenConfig
   };
   return result;
@@ -504,7 +481,7 @@ async function getPremintPricePerToken({
   uid,
   premintGetter
 }) {
-  const premintConfigWithVersion = await premintGetter.getSignature({
+  const { premint: premintConfigWithVersion } = await premintGetter.get({
     collectionAddress: collection,
     uid
   });
@@ -646,6 +623,144 @@ var httpClient = {
   retries
 };
 
+// src/mint/types.ts
+var isOnChainMint = (mint2) => mint2.mintType !== "premint";
+var is1155Mint = (mint2) => mint2.mintType === "1155";
+function isErc20SaleStrategy(salesConfig) {
+  return salesConfig.saleType === "erc20";
+}
+
+// src/utils.ts
+var makeContractParameters = (args) => args;
+function mintRecipientOrAccount({
+  mintRecipient,
+  minterAccount
+}) {
+  return mintRecipient || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
+}
+async function querySubgraphWithRetries({
+  httpClient: httpClient2,
+  subgraphUrl,
+  query,
+  variables
+}) {
+  const { retries: retries2, post: post2 } = httpClient2;
+  const result = await retries2(async () => {
+    return await post2(subgraphUrl, {
+      query,
+      variables
+    });
+  });
+  return result?.data;
+}
+
+// src/mint/subgraph-queries.ts
+var NFT_SALE_STRATEGY_FRAGMENT = `
+fragment SaleStrategy on SalesStrategyConfig {
+  type
+  fixedPrice {
+    address
+    pricePerToken
+    saleEnd
+    saleStart
+    maxTokensPerAddress
+  }
+  erc20Minter {
+    address
+    pricePerToken
+    currency
+    saleEnd
+    saleStart
+    maxTokensPerAddress
+  }
+}`;
+var TOKEN_FRAGMENT = `
+fragment Token on ZoraCreateToken {
+    creator
+    tokenId
+    uri
+    totalMinted
+    maxSupply
+    tokenStandard
+    salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
+      ...SaleStrategy
+    }
+    contract {
+      address
+      mintFeePerQuantity
+      contractVersion
+      contractURI
+      name
+      salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
+        ...SaleStrategy
+      }
+    }
+}`;
+var FRAGMENTS = `
+${NFT_SALE_STRATEGY_FRAGMENT}
+${TOKEN_FRAGMENT}
+`;
+function buildNftTokenSalesQuery({
+  tokenId,
+  tokenAddress
+}) {
+  return {
+    query: `
+${FRAGMENTS}
+query ($id: ID!) {
+  zoraCreateToken(id: $id) {
+    ...Token 
+  }
+}
+`,
+    variables: {
+      id: tokenId !== void 0 ? (
+        // Generic Token ID types all stringify down to the base numeric equivalent.
+        `${tokenAddress.toLowerCase()}-${tokenId}`
+      ) : `${tokenAddress.toLowerCase()}-0`
+    },
+    parseResponseData: (responseData) => responseData?.zoraCreateToken
+  };
+}
+function buildContractTokensQuery({
+  tokenAddress
+}) {
+  return {
+    query: `
+${FRAGMENTS}
+query ($contract: Bytes!) {
+  zoraCreateTokens(
+     where: {address: $contract}
+  ) {
+     ...Token
+  }
+}
+`,
+    variables: {
+      contract: tokenAddress.toLowerCase()
+    },
+    parseResponseData: (responseData) => responseData?.zoraCreateTokens
+  };
+}
+function buildPremintsOfContractQuery({
+  tokenAddress
+}) {
+  return {
+    query: `
+      query ($contractAddress: Bytes!) {
+        premints(where:{contractAddress:$contractAddress}) {
+          uid
+          tokenId
+        }
+      }
+    `,
+    variables: {
+      contractAddress: tokenAddress.toLowerCase()
+    },
+    parseResponseData: (responseData) => responseData?.premints
+  };
+}
+
 // src/mint/subgraph-mint-getter.ts
 var getApiNetworkConfigForChain = (chainId) => {
   if (!networkConfigByChain[chainId]) {
@@ -653,92 +768,171 @@ var getApiNetworkConfigForChain = (chainId) => {
   }
   return networkConfigByChain[chainId];
 };
+function parseSalesConfig(targetStrategy) {
+  if (targetStrategy.type === "FIXED_PRICE")
+    return {
+      saleType: "fixedPrice",
+      ...targetStrategy.fixedPrice,
+      maxTokensPerAddress: BigInt(
+        targetStrategy.fixedPrice.maxTokensPerAddress
+      ),
+      pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken)
+    };
+  if (targetStrategy.type === "ERC_20_MINTER") {
+    return {
+      saleType: "erc20",
+      ...targetStrategy.erc20Minter,
+      maxTokensPerAddress: BigInt(
+        targetStrategy.erc20Minter.maxTokensPerAddress
+      ),
+      pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken)
+    };
+  }
+  throw new Error("Unknown saleType");
+}
+function getSaleEnd(a) {
+  return BigInt(
+    a.type === "ERC_20_MINTER" ? a.erc20Minter.saleEnd : a.fixedPrice.saleEnd
+  );
+}
+function getTargetStrategy({
+  tokenId,
+  preferredSaleType,
+  token
+}) {
+  const allStrategies = (typeof tokenId !== "undefined" ? token.salesStrategies : token.contract.salesStrategies) || [];
+  const saleStrategies = allStrategies.sort(
+    (a, b) => getSaleEnd(a) > getSaleEnd(b) ? 1 : -1
+  );
+  let targetStrategy;
+  if (!preferredSaleType) {
+    targetStrategy = saleStrategies[0];
+    if (!targetStrategy) {
+      throw new Error("Cannot find sale strategy");
+    }
+  } else {
+    const mappedSaleType = preferredSaleType === "erc20" ? "ERC_20_MINTER" : "FIXED_PRICE";
+    targetStrategy = saleStrategies.find(
+      (strategy) => strategy.type === mappedSaleType
+    );
+    if (!targetStrategy) {
+      const targetStrategy2 = saleStrategies.find(
+        (strategy) => strategy.type === "FIXED_PRICE" || strategy.type === "ERC_20_MINTER"
+      );
+      if (!targetStrategy2)
+        throw new Error("Cannot find valid sale strategy");
+      return targetStrategy2;
+    }
+  }
+  return targetStrategy;
+}
 var SubgraphMintGetter = class {
   constructor(chainId, httpClient2) {
+    this.getMintable = async ({
+      tokenAddress,
+      tokenId,
+      preferredSaleType: saleType
+    }) => {
+      const token = await this.querySubgraphWithRetries(
+        buildNftTokenSalesQuery({
+          tokenId,
+          tokenAddress
+        })
+      );
+      if (!token) {
+        throw new Error("Cannot find token");
+      }
+      return parseTokenQueryResult({
+        token,
+        tokenId,
+        preferredSaleType: saleType
+      });
+    };
     this.httpClient = httpClient2 || httpClient;
     this.networkConfig = getApiNetworkConfigForChain(chainId);
   }
-  async getSalesConfigAndTokenInfo({
-    tokenAddress,
-    tokenId,
-    saleType
+  async querySubgraphWithRetries({
+    query,
+    variables,
+    parseResponseData
   }) {
-    const { retries: retries2, post: post2 } = this.httpClient;
-    return retries2(async () => {
-      const response = await post2(this.networkConfig.subgraphUrl, {
-        query: NFT_SALE_QUERY,
-        variables: {
-          id: tokenId !== void 0 ? (
-            // Generic Token ID types all stringify down to the base numeric equivalent.
-            `${tokenAddress.toLowerCase()}-${tokenId}`
-          ) : `${tokenAddress.toLowerCase()}-0`
-        }
-      });
-      const token = response.data?.zoraCreateToken;
-      if (!token) {
-        throw new Error("Cannot find a token to mint");
-      }
-      const allStrategies = (typeof tokenId !== "undefined" ? token.salesStrategies : token.contract.salesStrategies) || [];
-      const saleStrategies = allStrategies.sort(
-        (a, b) => BigInt(
-          a.type === "ERC_20_MINTER" ? a.erc20Minter.saleEnd : a.fixedPrice.saleEnd
-        ) > BigInt(
-          b.type === "FIXED_PRICE" ? b.fixedPrice.saleEnd : b.erc20Minter.saleEnd
-        ) ? 1 : -1
-      );
-      let targetStrategy;
-      if (!saleType) {
-        targetStrategy = saleStrategies[0];
-        if (!targetStrategy) {
-          throw new Error("Cannot find sale strategy");
-        }
-      } else {
-        const mappedSaleType = saleType === "erc20" ? "ERC_20_MINTER" : "FIXED_PRICE";
-        targetStrategy = saleStrategies.find(
-          (strategy) => strategy.type === mappedSaleType
-        );
-        if (!targetStrategy) {
-          throw new Error(`Cannot find sale strategy for ${mappedSaleType}`);
-        }
-      }
-      if (targetStrategy.type === "FIXED_PRICE") {
-        return {
-          salesConfig: {
-            saleType: "fixedPrice",
-            ...targetStrategy.fixedPrice,
-            maxTokensPerAddress: BigInt(
-              targetStrategy.fixedPrice.maxTokensPerAddress
-            ),
-            pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken)
-          },
-          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
-        };
-      }
-      if (targetStrategy.type === "ERC_20_MINTER") {
-        return {
-          salesConfig: {
-            saleType: "erc20",
-            ...targetStrategy.erc20Minter,
-            maxTokensPerAddress: BigInt(
-              targetStrategy.erc20Minter.maxTokensPerAddress
-            ),
-            pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken)
-          },
-          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
-        };
-      }
-      throw new Error("Invalid saleType");
+    const responseData = await querySubgraphWithRetries({
+      httpClient: this.httpClient,
+      subgraphUrl: this.networkConfig.subgraphUrl,
+      query,
+      variables
     });
+    return parseResponseData(responseData);
+  }
+  async getContractMintable({
+    tokenAddress,
+    preferredSaleType
+  }) {
+    const tokens = await this.querySubgraphWithRetries(
+      buildContractTokensQuery({
+        tokenAddress
+      })
+    );
+    if (!tokens)
+      return [];
+    return tokens.filter((x) => x.tokenId !== "0").map(
+      (token) => parseTokenQueryResult({
+        token,
+        tokenId: token.tokenId,
+        preferredSaleType
+      })
+    );
+  }
+  async getContractPremintTokenIds({
+    tokenAddress
+  }) {
+    const premints = await this.querySubgraphWithRetries(
+      buildPremintsOfContractQuery({
+        tokenAddress
+      })
+    );
+    return premints?.map((premint) => ({
+      tokenId: BigInt(premint.tokenId),
+      uid: +premint.uid
+    })) || [];
   }
 };
-
-// src/utils.ts
-var makeContractParameters = (args) => args;
-function mintRecipientOrAccount({
-  mintRecipient,
-  minterAccount
+function parseTokenQueryResult({
+  token,
+  tokenId,
+  preferredSaleType
 }) {
-  return mintRecipient || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
+  const targetStrategy = getTargetStrategy({
+    tokenId,
+    preferredSaleType,
+    token
+  });
+  const tokenInfo = parseTokenInfo(token);
+  const salesConfig = parseSalesConfig(targetStrategy);
+  if (isErc20SaleStrategy(salesConfig)) {
+    tokenInfo.mintFeePerQuantity = 0n;
+  }
+  return {
+    ...tokenInfo,
+    salesConfig
+  };
+}
+function parseTokenInfo(token) {
+  return {
+    contract: {
+      address: token.contract.address,
+      name: token.contract.name,
+      URI: token.contract.contractURI
+    },
+    tokenURI: token.uri,
+    tokenId: token.tokenId ? BigInt(token.tokenId) : void 0,
+    mintType: token.tokenStandard === "ERC721" ? "721" : "1155",
+    creator: token.creator,
+    totalMinted: BigInt(token.totalMinted),
+    maxSupply: BigInt(token.maxSupply),
+    mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity),
+    contractVersion: token.contract.contractVersion
+  };
 }
 
 // src/premint/premint-client.ts
@@ -896,7 +1090,7 @@ var PremintClient = class {
    * @returns PremintSignatureGetResponse of premint data from the API
    */
   async getPremint({ address, uid }) {
-    return await this.apiClient.getSignature({
+    return await this.apiClient.get({
       collectionAddress: address,
       uid
     });
@@ -1025,13 +1219,19 @@ function makePremintReturn({
       premintConfigVersion
     });
   };
+  const urls = makeUrls({
+    chainId,
+    address: collectionAddress,
+    uid: premintConfig.uid
+  });
   return {
     premintConfig,
     premintConfigVersion,
     typedDataDefinition,
     collectionAddress,
     signAndSubmit,
-    submit
+    submit,
+    urls
   };
 }
 async function signPremint({
@@ -1131,10 +1331,9 @@ async function updatePremint({
   chainId
 }) {
   const {
-    premintConfig,
-    collection: collectionCreationConfig,
-    premintConfigVersion
-  } = await apiClient.getSignature({
+    premint: { premintConfig, premintConfigVersion },
+    collection: collectionCreationConfig
+  } = await apiClient.get({
     collectionAddress: collection,
     uid
   });
@@ -1162,11 +1361,10 @@ async function deletePremint({
   chainId
 }) {
   const {
-    premintConfig,
-    premintConfigVersion,
+    premint: { premintConfig, premintConfigVersion },
     collection: collectionCreationConfig,
     collectionAddress
-  } = await apiClient.getSignature({
+  } = await apiClient.get({
     collectionAddress: collection,
     uid
   });
@@ -1200,26 +1398,39 @@ async function collectPremint({
   if (typeof quantityToMint !== "undefined" && quantityToMint < 1) {
     throw new Error("Quantity to mint cannot be below 1");
   }
-  const {
-    premintConfig,
-    premintConfigVersion,
-    collection,
-    collectionAddress,
-    signature
-  } = await premintGetter.getSignature({
+  const premint = await premintGetter.get({
     collectionAddress: tokenContract,
     uid
   });
-  const numberToMint = BigInt(quantityToMint || 1);
-  if (premintConfigVersion === PremintConfigVersion2.V3) {
-    throw new Error("PremintV3 not supported in premint SDK");
-  }
-  const value = (await getPremintMintCosts({
+  const mintFee = await getPremintMintFee({
     tokenContract,
-    quantityToMint: numberToMint,
-    publicClient,
-    tokenPrice: premintConfig.tokenConfig.pricePerToken
-  })).totalCostEth;
+    publicClient
+  });
+  return buildPremintMintCall({
+    mintArguments: {
+      minterAccount,
+      quantityToMint,
+      firstMinter,
+      mintComment,
+      mintRecipient,
+      mintReferral
+    },
+    mintFee,
+    premint
+  });
+}
+var buildPremintMintCall = ({
+  mintArguments: {
+    minterAccount,
+    mintComment = "",
+    mintRecipient,
+    mintReferral,
+    firstMinter,
+    quantityToMint
+  },
+  premint: { collection, collectionAddress, premint, signature },
+  mintFee
+}) => {
   const mintArgumentsContract = {
     mintComment,
     mintRecipient: mintRecipientOrAccount({
@@ -1233,6 +1444,10 @@ async function collectPremint({
   const collectionOrEmpty = collection ? defaultAdditionalAdmins(collection) : emptyContractCreationConfig();
   const collectionAddressToSubmit = collection ? zeroAddress2 : collectionAddress;
   const firstMinterToSubmit = firstMinter || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
+  if (premint.premintConfigVersion === PremintConfigVersion2.V3) {
+    throw new Error("PremintV3 not supported in premint SDK");
+  }
+  const value = (mintFee + premint.premintConfig.tokenConfig.pricePerToken) * BigInt(quantityToMint);
   return makeContractParameters({
     account: minterAccount,
     abi: zoraCreator1155PremintExecutorImplABI2,
@@ -1242,18 +1457,15 @@ async function collectPremint({
     args: [
       collectionOrEmpty,
       collectionAddressToSubmit,
-      encodePremintConfig({
-        premintConfig,
-        premintConfigVersion
-      }),
+      encodePremintConfig(premint),
       signature,
-      numberToMint,
+      BigInt(quantityToMint),
       mintArgumentsContract,
       firstMinterToSubmit,
       zeroAddress2
     ]
   });
-}
+};
 function makeUrls({
   uid,
   address,
@@ -1314,6 +1526,19 @@ var getSignature = async ({
   );
   return convertGetPremintApiResponse(result);
 };
+var getOfCollection = async ({
+  collectionAddress,
+  chainId,
+  httpClient: { retries: retries2, get: get2 } = httpClient
+}) => {
+  const chainName = getApiNetworkConfigForChain(chainId).zoraBackendChainName;
+  const result = await retries2(
+    () => get2(
+      `${ZORA_API_BASE}premint/signature/${chainName}/${collectionAddress.toLowerCase()}`
+    )
+  );
+  return convertGetPremintOfCollectionApiResponse(result);
+};
 var PremintAPIClient = class {
   constructor(chainId, httpClient2) {
     this.postSignature = ({
@@ -1335,10 +1560,7 @@ var PremintAPIClient = class {
       chainId: this.chainId,
       httpClient: this.httpClient
     })).next_uid;
-    this.getSignature = async ({
-      collectionAddress,
-      uid
-    }) => {
+    this.get = async ({ collectionAddress, uid }) => {
       return getSignature({
         collectionAddress,
         uid,
@@ -1346,180 +1568,109 @@ var PremintAPIClient = class {
         httpClient: this.httpClient
       });
     };
+    this.getOfCollection = async ({
+      collectionAddress
+    }) => {
+      return getOfCollection({
+        collectionAddress,
+        chainId: this.chainId,
+        httpClient: this.httpClient
+      });
+    };
     this.chainId = chainId;
     this.httpClient = httpClient2 || httpClient;
   }
 };
 
-// src/mint/mint-client.ts
+// src/mint/mint-transactions.ts
 import {
   encodeAbiParameters,
   parseAbiParameters,
-  zeroAddress as zeroAddress3,
-  erc20Abi
+  zeroAddress as zeroAddress3
 } from "viem";
 import {
   erc20MinterABI,
-  erc20MinterAddress,
-  zoraCreator1155ImplABI as zoraCreator1155ImplABI2,
-  zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress2
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI2
 } from "@zoralabs/protocol-deployments";
 
-// src/mint/types.ts
-var isOnChainMint = (mint2) => mint2.mintType !== "premint";
-var is1155Mint = (mint2) => mint2.mintType === "1155";
-function isErc20SaleStrategy(salesConfig) {
-  return salesConfig.saleType === "erc20";
-}
-
-// src/mint/mint-client.ts
-var MintError = class extends Error {
-};
-var MintInactiveError = class extends Error {
-};
-var Errors = {
-  MintError,
-  MintInactiveError
+// 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");
 };
-var MintClient = class {
-  constructor({
-    chainId,
-    publicClient,
-    premintGetter,
-    mintGetter
-  }) {
-    this.chainId = chainId;
-    this.publicClient = publicClient;
-    this.mintGetter = mintGetter;
-    this.premintGetter = premintGetter;
-  }
-  /**
-   * Returns the parameters needed to prepare a transaction mint a token.
-   * Works with premint, onchain 1155, and onchain 721.
-   *
-   * @param parameters - Parameters for collecting the token {@link MakeMintParametersArguments}
-   * @returns Parameters for simulating/executing the mint transaction
-   */
-  async mint(parameters) {
-    return mint({
-      parameters,
-      chainId: this.chainId,
-      publicClient: this.publicClient,
-      mintGetter: this.mintGetter,
-      premintGetter: this.premintGetter
-    });
-  }
-  /**
-   * Gets the costs to mint the quantity of tokens specified for a mint.
-   * @param parameters - Parameters for the mint {@link GetMintCostsParameters}
-   * @returns Costs to mint the quantity of tokens specified
-   */
-  async getMintCosts(parameters) {
-    return getMintCosts({
-      ...parameters,
-      mintGetter: this.mintGetter,
-      premintGetter: this.premintGetter,
-      publicClient: this.publicClient
-    });
-  }
-};
-function isPremintCollect(parameters) {
-  return parameters.mintType === "premint";
-}
-function is721Collect(parameters) {
-  return parameters.mintType === "721";
-}
-async function mint({
-  parameters,
-  chainId,
-  publicClient,
-  mintGetter,
-  premintGetter
+
+// src/mint/mint-transactions.ts
+function makeOnchainMintCall({
+  token,
+  mintParams
 }) {
-  if (isPremintCollect(parameters)) {
-    return {
-      parameters: await collectPremint({
-        ...parameters,
-        premintGetter,
-        publicClient
-      })
-    };
+  if (token.mintType === "721") {
+    return makePrepareMint721TokenParams({
+      salesConfigAndTokenInfo: token,
+      tokenContract: token.contract.address,
+      ...mintParams
+    });
   }
-  return {
-    parameters: await collectOnchain({
-      ...parameters,
-      mintGetter,
-      chainId
-    })
-  };
-}
-function requestErc20ApprovalForMint({
-  account,
-  tokenAddress,
-  quantityErc20,
-  erc20MinterAddress: erc20MinterAddress2
-}) {
-  return makeContractParameters({
-    abi: erc20Abi,
-    address: tokenAddress,
-    account,
-    functionName: "approve",
-    args: [erc20MinterAddress2, quantityErc20]
+  return makePrepareMint1155TokenParams({
+    salesConfigAndTokenInfo: token,
+    tokenContract: token.contract.address,
+    tokenId: token.tokenId,
+    ...mintParams
   });
 }
-async function getNecessaryErc20Approval({
-  chainId,
-  account,
-  tokenAddress,
-  quantityErc20,
-  publicClient
+function makePrepareMint1155TokenParams({
+  tokenContract,
+  tokenId,
+  salesConfigAndTokenInfo,
+  minterAccount,
+  mintComment,
+  mintReferral,
+  mintRecipient,
+  quantityToMint
 }) {
-  const destination = erc20MinterAddress[chainId];
-  const allowance = await publicClient.readContract({
-    abi: erc20Abi,
-    address: tokenAddress,
-    functionName: "allowance",
-    account,
-    args: [
-      destination,
-      erc20MinterAddress[chainId]
-    ]
-  });
-  if (allowance < quantityErc20) {
-    return requestErc20ApprovalForMint({
-      erc20MinterAddress: destination,
-      account,
-      tokenAddress,
-      quantityErc20: quantityErc20 - allowance
+  const mintQuantity = BigInt(quantityToMint || 1);
+  const mintTo = mintRecipientOrAccount({ mintRecipient, minterAccount });
+  const saleType = salesConfigAndTokenInfo.salesConfig.saleType;
+  if (saleType === "fixedPrice") {
+    return makeEthMintCall({
+      mintComment,
+      minterAccount,
+      mintQuantity,
+      mintReferral,
+      mintTo,
+      salesConfigAndTokenInfo,
+      tokenContract,
+      tokenId
     });
   }
-  return void 0;
-}
-async function collectOnchain({
-  chainId,
-  mintGetter,
-  ...parameters
-}) {
-  const { tokenContract, saleType } = parameters;
-  const tokenId = is1155Mint(parameters) ? parameters.tokenId : void 0;
-  const salesConfigAndTokenInfo = await mintGetter.getSalesConfigAndTokenInfo({
-    tokenId,
-    tokenAddress: tokenContract,
-    saleType
-  });
-  if (is721Collect(parameters)) {
-    return makePrepareMint721TokenParams({
-      salesConfigAndTokenInfo,
-      ...parameters
+  if (saleType === "erc20") {
+    return makeContractParameters({
+      abi: erc20MinterABI,
+      functionName: "mint",
+      account: minterAccount,
+      address: salesConfigAndTokenInfo.salesConfig.address,
+      /* args: mintTo, quantity, tokenAddress, tokenId, totalValue, currency, mintReferral, comment */
+      args: [
+        mintTo,
+        mintQuantity,
+        tokenContract,
+        BigInt(tokenId),
+        salesConfigAndTokenInfo.salesConfig.pricePerToken * mintQuantity,
+        salesConfigAndTokenInfo.salesConfig.currency,
+        mintReferral || zeroAddress3,
+        mintComment || ""
+      ]
     });
   }
-  return makePrepareMint1155TokenParams({
-    salesConfigAndTokenInfo,
-    chainId,
-    ...parameters
-  });
+  throw new Error("Unsupported sale type");
 }
-async function makePrepareMint721TokenParams({
+function makePrepareMint721TokenParams({
   salesConfigAndTokenInfo,
   minterAccount,
   tokenContract,
@@ -1530,7 +1681,8 @@ async function makePrepareMint721TokenParams({
 }) {
   const actualQuantityToMint = BigInt(quantityToMint || 1);
   const mintValue = parseMintCosts({
-    salesConfigAndTokenInfo,
+    mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
+    salesConfig: salesConfigAndTokenInfo.salesConfig,
     quantityToMint: actualQuantityToMint
   }).totalCostEth;
   return makeContractParameters({
@@ -1547,15 +1699,65 @@ async function makePrepareMint721TokenParams({
     ]
   });
 }
-function parseMintCosts({
+function makeEthMintCall({
+  tokenContract,
+  tokenId,
   salesConfigAndTokenInfo,
+  minterAccount,
+  mintComment,
+  mintReferral,
+  mintQuantity,
+  mintTo
+}) {
+  const mintValue = parseMintCosts({
+    mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
+    salesConfig: salesConfigAndTokenInfo.salesConfig,
+    quantityToMint: mintQuantity
+  }).totalCostEth;
+  const minterArguments = encodeAbiParameters(
+    parseAbiParameters("address, string"),
+    [mintTo, mintComment || ""]
+  );
+  if (contractSupportsNewMintFunction(salesConfigAndTokenInfo.contractVersion)) {
+    return makeContractParameters({
+      abi: zoraCreator1155ImplABI2,
+      functionName: "mint",
+      account: minterAccount,
+      value: mintValue,
+      address: tokenContract,
+      args: [
+        salesConfigAndTokenInfo.salesConfig.address,
+        BigInt(tokenId),
+        mintQuantity,
+        mintReferral ? [mintReferral] : [],
+        minterArguments
+      ]
+    });
+  }
+  return makeContractParameters({
+    abi: zoraCreator1155ImplABI2,
+    functionName: "mintWithRewards",
+    account: minterAccount,
+    value: mintValue,
+    address: tokenContract,
+    /* args: minter, tokenId, quantity, minterArguments, mintReferral */
+    args: [
+      salesConfigAndTokenInfo.salesConfig.address,
+      BigInt(tokenId),
+      mintQuantity,
+      minterArguments,
+      mintReferral || zeroAddress3
+    ]
+  });
+}
+function parseMintCosts({
+  salesConfig,
+  mintFeePerQuantity,
   quantityToMint
 }) {
-  const mintFeeForTokens = salesConfigAndTokenInfo.mintFeePerQuantity * quantityToMint;
-  const tokenPurchaseCost = BigInt(salesConfigAndTokenInfo.salesConfig.pricePerToken) * quantityToMint;
-  const totalPurchaseCostCurrency = isErc20SaleStrategy(
-    salesConfigAndTokenInfo.salesConfig
-  ) ? salesConfigAndTokenInfo.salesConfig.currency : void 0;
+  const mintFeeForTokens = mintFeePerQuantity * quantityToMint;
+  const tokenPurchaseCost = BigInt(salesConfig.pricePerToken) * quantityToMint;
+  const totalPurchaseCostCurrency = isErc20SaleStrategy(salesConfig) ? salesConfig.currency : void 0;
   const totalPurchaseCostEth = totalPurchaseCostCurrency ? 0n : tokenPurchaseCost;
   return {
     mintFee: mintFeeForTokens,
@@ -1564,93 +1766,337 @@ function parseMintCosts({
     totalCostEth: mintFeeForTokens + totalPurchaseCostEth
   };
 }
-async function getMintCosts(params) {
-  const { quantityMinted: quantityToMint, collection, publicClient } = params;
+
+// src/mint/mint-queries.ts
+import { zeroAddress as zeroAddress4 } from "viem";
+async function getMint({
+  params,
+  mintGetter,
+  premintGetter,
+  publicClient
+}) {
+  const { tokenContract } = params;
+  if (isOnChainMint(params)) {
+    const tokenId = is1155Mint(params) ? params.tokenId : void 0;
+    const result = await mintGetter.getMintable({
+      tokenId,
+      tokenAddress: tokenContract,
+      preferredSaleType: params.preferredSaleType
+    });
+    return toMintableReturn(result);
+  }
+  const premint = await premintGetter.get({
+    collectionAddress: tokenContract,
+    uid: params.uid
+  });
+  const mintFee = await getPremintMintFee({
+    publicClient,
+    tokenContract
+  });
+  return toPremintMintReturn({ premint, mintFee });
+}
+async function getPremintsOfCollectionWithTokenIds({
+  premintGetter,
+  mintGetter,
+  tokenContract
+}) {
+  const { collection, premints } = await premintGetter.getOfCollection({
+    collectionAddress: tokenContract
+  });
+  const premintUidsAndTokenIds = await mintGetter.getContractPremintTokenIds({
+    tokenAddress: tokenContract
+  });
+  const premintsWithTokenId = premints.map((premint) => ({
+    ...premint,
+    tokenId: premintUidsAndTokenIds.find(
+      ({ uid }) => uid === premint.premint.premintConfig.uid
+    )?.tokenId
+  }));
+  return {
+    collection,
+    premints: premintsWithTokenId
+  };
+}
+async function getMintsOfContract({
+  params,
+  mintGetter,
+  premintGetter,
+  publicClient
+}) {
+  const onchainMints = (await mintGetter.getContractMintable({
+    tokenAddress: params.tokenContract
+  })).map(toMintableReturn);
+  const offchainMints = await getPremintsOfContractMintable({
+    mintGetter,
+    premintGetter,
+    publicClient,
+    params: {
+      tokenContract: params.tokenContract
+    }
+  });
+  const tokens = [...onchainMints, ...offchainMints];
+  return {
+    tokens,
+    contract: tokens[0]?.token.contract
+  };
+}
+async function getMintCosts({
+  params,
+  mintGetter,
+  premintGetter,
+  publicClient
+}) {
+  const { quantityMinted: quantityToMint, collection } = params;
   if (isOnChainMint(params)) {
     const tokenId = is1155Mint(params) ? params.tokenId : void 0;
-    const salesConfigAndTokenInfo = await params.mintGetter.getSalesConfigAndTokenInfo({
+    const salesConfigAndTokenInfo = await mintGetter.getMintable({
       tokenId,
       tokenAddress: collection
     });
     return parseMintCosts({
-      salesConfigAndTokenInfo,
+      mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
+      salesConfig: salesConfigAndTokenInfo.salesConfig,
       quantityToMint: BigInt(quantityToMint)
     });
   }
   return getPremintMintCostsWithUnknownTokenPrice({
-    premintGetter: params.premintGetter,
+    premintGetter,
     publicClient,
     quantityToMint: BigInt(quantityToMint),
     uid: params.uid,
     tokenContract: collection
   });
 }
-function makePrepareMint1155TokenParams({
-  tokenContract,
-  tokenId,
-  salesConfigAndTokenInfo,
-  minterAccount,
-  mintComment,
-  mintReferral,
-  mintRecipient,
-  quantityToMint,
-  chainId
+async function getPremintsOfContractMintable({
+  mintGetter,
+  premintGetter,
+  publicClient,
+  params
 }) {
-  const mintQuantity = BigInt(quantityToMint || 1);
-  const mintTo = mintRecipientOrAccount({ mintRecipient, minterAccount });
-  const saleType = salesConfigAndTokenInfo.salesConfig.saleType;
-  if (saleType === "fixedPrice") {
-    const mintValue = parseMintCosts({
-      salesConfigAndTokenInfo,
-      quantityToMint: mintQuantity
-    }).totalCostEth;
-    return makeContractParameters({
-      abi: zoraCreator1155ImplABI2,
-      functionName: "mintWithRewards",
-      account: minterAccount,
-      value: mintValue,
-      address: tokenContract,
-      /* args: minter, tokenId, quantity, minterArguments, mintReferral */
-      args: [
-        salesConfigAndTokenInfo.salesConfig.address || zoraCreatorFixedPriceSaleStrategyAddress2[chainId],
-        BigInt(tokenId),
-        mintQuantity,
-        encodeAbiParameters(parseAbiParameters("address, string"), [
-          mintTo,
-          mintComment || ""
-        ]),
-        mintReferral || zeroAddress3
-      ]
-    });
-  }
-  if (saleType === "erc20") {
-    return makeContractParameters({
-      abi: erc20MinterABI,
-      functionName: "mint",
-      account: minterAccount,
-      address: salesConfigAndTokenInfo?.salesConfig.address || erc20MinterAddress[chainId],
-      /* args: mintTo, quantity, tokenAddress, tokenId, totalValue, currency, mintReferral, comment */
-      args: [
-        mintTo,
-        mintQuantity,
-        tokenContract,
-        BigInt(tokenId),
-        salesConfigAndTokenInfo.salesConfig.pricePerToken * mintQuantity,
-        salesConfigAndTokenInfo.salesConfig.currency,
-        mintReferral || zeroAddress3,
-        mintComment || ""
-      ]
+  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 MintError("Unsupported sale type");
+  throw new Error("Invalid premint config version");
 }
-
-// src/create/1155-create-helper.ts
-import {
-  zoraCreator1155FactoryImplABI as zoraCreator1155FactoryImplABI2,
-  zoraCreator1155FactoryImplAddress as zoraCreator1155FactoryImplAddress2,
-  zoraCreator1155ImplABI as zoraCreator1155ImplABI5
-} from "@zoralabs/protocol-deployments";
+var makeOnchainPrepareMint = (result) => (params) => ({
+  parameters: makeOnchainMintCall({ token: result, mintParams: params }),
+  erc20Approval: getRequiredErc20Approvals(params, result),
+  costs: parseMintCosts({
+    salesConfig: result.salesConfig,
+    quantityToMint: BigInt(params.quantityToMint),
+    mintFeePerQuantity: result.mintFeePerQuantity
+  })
+});
+function toMintableReturn(result) {
+  return { token: result, prepareMint: makeOnchainPrepareMint(result) };
+}
+var makePremintPrepareMint = (mintable, mintFee, premint) => (params) => ({
+  parameters: buildPremintMintCall({
+    mintArguments: params,
+    mintFee,
+    premint
+  }),
+  costs: parseMintCosts({
+    mintFeePerQuantity: mintFee,
+    quantityToMint: BigInt(params.quantityToMint),
+    salesConfig: mintable.salesConfig
+  })
+});
+function toPremintMintReturn({
+  premint,
+  mintFee
+}) {
+  const mintable = parsePremint({ premint, mintFee });
+  return {
+    token: mintable,
+    prepareMint: makePremintPrepareMint(mintable, mintFee, premint)
+  };
+}
+function getRequiredErc20Approvals(params, result) {
+  if (result.salesConfig.saleType !== "erc20")
+    return void 0;
+  return {
+    quantity: result.salesConfig.pricePerToken * BigInt(params.quantityToMint),
+    approveTo: result.salesConfig.address,
+    erc20: result.salesConfig.currency
+  };
+}
+
+// src/mint/mint-client.ts
+var MintError = class extends Error {
+};
+var MintInactiveError = class extends Error {
+};
+var Errors = {
+  MintError,
+  MintInactiveError
+};
+var MintClient = class {
+  constructor({
+    publicClient,
+    premintGetter,
+    mintGetter
+  }) {
+    this.publicClient = publicClient;
+    this.mintGetter = mintGetter;
+    this.premintGetter = premintGetter;
+  }
+  /**
+   * Returns the parameters needed to prepare a transaction mint a token.
+   * Works with premint, onchain 1155, and onchain 721.
+   *
+   * @param parameters - Parameters for collecting the token {@link MakeMintParametersArguments}
+   * @returns Parameters for simulating/executing the mint transaction, any necessary erc20 approval, and costs to mint
+   */
+  async mint(parameters) {
+    return mint({
+      parameters,
+      publicClient: this.publicClient,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter
+    });
+  }
+  /**
+   * Gets an 1155, 721, or premint, and returns both information about it, and a function
+   * that can be used to build a mint transaction for a quantity of items to mint.
+   * @param parameters - Token to get {@link GetMintParameters}
+   * @Returns Information about the mint and a function to build a mint transaction {@link MintableReturn}
+   */
+  async get(parameters) {
+    return getMint({
+      params: parameters,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter,
+      publicClient: this.publicClient
+    });
+  }
+  /**
+   * Gets onchain and premint tokens of an 1155 contract.  For each token returns both information about it, and a function
+   * that can be used to build a mint transaction for a quantity of items to mint.
+   * @param parameters - Contract address to get tokens for {@link GetMintsOfContractParameters}
+   * @Returns Array of tokens, each containing information about the token and a function to build a mint transaction.
+   */
+  async getOfContract(params) {
+    return getMintsOfContract({
+      params,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter,
+      publicClient: this.publicClient
+    });
+  }
+  /**
+   * Gets the costs to mint the quantity of tokens specified for a mint.
+   * @param parameters - Parameters for the mint {@link GetMintCostsParameters}
+   * @returns Costs to mint the quantity of tokens specified
+   */
+  async getMintCosts(parameters) {
+    return getMintCosts({
+      params: parameters,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter,
+      publicClient: this.publicClient
+    });
+  }
+};
+async function mint({
+  parameters,
+  publicClient,
+  mintGetter,
+  premintGetter
+}) {
+  const { prepareMint } = await getMint({
+    params: parameters,
+    mintGetter,
+    premintGetter,
+    publicClient
+  });
+  return prepareMint({
+    minterAccount: parameters.minterAccount,
+    quantityToMint: parameters.quantityToMint,
+    firstMinter: parameters.firstMinter,
+    mintComment: parameters.mintComment,
+    mintRecipient: parameters.mintRecipient,
+    mintReferral: parameters.mintReferral
+  });
+}
+async function collectOnchain({
+  chainId,
+  mintGetter,
+  ...parameters
+}) {
+  const { tokenContract, preferredSaleType: saleType } = parameters;
+  const tokenId = is1155Mint(parameters) ? parameters.tokenId : void 0;
+  const salesConfigAndTokenInfo = await mintGetter.getMintable({
+    tokenId,
+    tokenAddress: tokenContract,
+    preferredSaleType: saleType
+  });
+  return makeOnchainMintCall({
+    mintParams: parameters,
+    token: salesConfigAndTokenInfo
+  });
+}
+
+// src/create/1155-create-helper.ts
+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
@@ -1717,17 +2163,17 @@ import {
   erc20MinterAddress as erc20MinterAddresses,
   zoraCreator1155ImplABI as zoraCreator1155ImplABI4,
   zoraCreatorFixedPriceSaleStrategyABI,
-  zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress3
+  zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress2
 } from "@zoralabs/protocol-deployments";
-import { encodeFunctionData, zeroAddress as zeroAddress4 } from "viem";
-import * as semver from "semver";
+import { encodeFunctionData, zeroAddress as zeroAddress5 } from "viem";
+import * as semver2 from "semver";
 var PERMISSION_BITS = {
   MINTER: 2n ** 2n
 };
 var saleSettingsOrDefault = (saleSettings) => {
   const SALE_END_FOREVER = 18446744073709551615n;
   const DEFAULT_SALE_SETTINGS = {
-    currency: zeroAddress4,
+    currency: zeroAddress5,
     // Free Mint
     pricePerToken: 0n,
     // Sale start time – defaults to beginning of unix time
@@ -1744,10 +2190,10 @@ var saleSettingsOrDefault = (saleSettings) => {
 };
 function applyNew1155Defaults(props, ownerAddress) {
   const { payoutRecipient: fundsRecipient } = props;
-  const fundsRecipientOrOwner = fundsRecipient && fundsRecipient !== zeroAddress4 ? fundsRecipient : ownerAddress;
+  const fundsRecipientOrOwner = fundsRecipient && fundsRecipient !== zeroAddress5 ? fundsRecipient : ownerAddress;
   return {
     payoutRecipient: fundsRecipientOrOwner,
-    createReferral: props.createReferral || zeroAddress4,
+    createReferral: props.createReferral || zeroAddress5,
     maxSupply: typeof props.maxSupply === "undefined" ? OPEN_EDITION_MINT_SIZE : BigInt(props.maxSupply),
     royaltyBPS: props.royaltyBPS || 1e3,
     salesConfig: saleSettingsOrDefault(props.salesConfig),
@@ -1764,13 +2210,13 @@ function setupErc20Minter({
   maxTokensPerAddress: mintLimit,
   fundsRecipient
 }) {
-  const erc20MinterAddress2 = erc20MinterAddresses[chainId];
-  if (!erc20MinterAddress2)
+  const erc20MinterAddress = erc20MinterAddresses[chainId];
+  if (!erc20MinterAddress)
     throw new Error(`ERC20Minter not deployed on chainId ${chainId}`);
   const erc20MinterApproval = encodeFunctionData({
     abi: zoraCreator1155ImplABI4,
     functionName: "addPermission",
-    args: [BigInt(nextTokenId), erc20MinterAddress2, PERMISSION_BITS.MINTER]
+    args: [BigInt(nextTokenId), erc20MinterAddress, PERMISSION_BITS.MINTER]
   });
   const saleData = encodeFunctionData({
     abi: erc20MinterABI2,
@@ -1790,10 +2236,10 @@ function setupErc20Minter({
   const callSale = encodeFunctionData({
     abi: zoraCreator1155ImplABI4,
     functionName: "callSale",
-    args: [BigInt(nextTokenId), erc20MinterAddress2, saleData]
+    args: [BigInt(nextTokenId), erc20MinterAddress, saleData]
   });
   return {
-    minter: erc20MinterAddress2,
+    minter: erc20MinterAddress,
     setupActions: [erc20MinterApproval, callSale]
   };
 }
@@ -1806,7 +2252,7 @@ function setupFixedPriceMinter({
   maxTokensPerAddress: mintLimit,
   fundsRecipient
 }) {
-  const fixedPriceStrategyAddress = zoraCreatorFixedPriceSaleStrategyAddress3[chainId];
+  const fixedPriceStrategyAddress = zoraCreatorFixedPriceSaleStrategyAddress2[chainId];
   const fixedPriceApproval = encodeFunctionData({
     abi: zoraCreator1155ImplABI4,
     functionName: "addPermission",
@@ -1844,7 +2290,7 @@ function setupMinters({ salesConfig, ...rest }) {
   if (!salesConfig)
     throw new Error("No sales config for token");
   const { currency: currencyAddress } = salesConfig;
-  if (currencyAddress === zeroAddress4) {
+  if (currencyAddress === zeroAddress5) {
     return setupFixedPriceMinter({
       ...salesConfig,
       ...rest
@@ -1859,7 +2305,7 @@ function setupMinters({ salesConfig, ...rest }) {
 function buildSetupNewToken({
   tokenURI,
   maxSupply = OPEN_EDITION_MINT_SIZE,
-  createReferral = zeroAddress4,
+  createReferral = zeroAddress5,
   contractVersion
 }) {
   if (contractSupportsMintRewards(contractVersion, "ERC1155")) {
@@ -1869,7 +2315,7 @@ function buildSetupNewToken({
       args: [tokenURI, BigInt(maxSupply), createReferral]
     });
   }
-  if (createReferral !== zeroAddress4) {
+  if (createReferral !== zeroAddress5) {
     throw new Error(
       "Contract does not support create referral, but one was provided"
     );
@@ -1885,7 +2331,7 @@ function setupRoyaltyConfig({
   royaltyRecipient,
   nextTokenId
 }) {
-  if (royaltyBPS > 0 && royaltyRecipient != zeroAddress4) {
+  if (royaltyBPS > 0 && royaltyRecipient != zeroAddress5) {
     return encodeFunctionData({
       abi: zoraCreator1155ImplABI4,
       functionName: "updateRoyaltiesForToken",
@@ -1912,7 +2358,7 @@ function makeAdminMintCall({
   return encodeFunctionData({
     abi: zoraCreator1155ImplABI4,
     functionName: "adminMint",
-    args: [ownerAddress, nextTokenId, BigInt(mintQuantity), zeroAddress4]
+    args: [ownerAddress, nextTokenId, BigInt(mintQuantity), zeroAddress5]
   });
 }
 function constructCreate1155TokenCalls(props) {
@@ -1971,13 +2417,13 @@ var contractSupportsMintRewards = (contractVersion, contractStandard) => {
   if (!contractStandard || !contractVersion) {
     return false;
   }
-  const semVerContractVersion = semver.coerce(contractVersion)?.raw;
+  const semVerContractVersion = semver2.coerce(contractVersion)?.raw;
   if (!semVerContractVersion)
     return false;
   if (contractStandard === "ERC1155") {
-    return semver.gte(semVerContractVersion, "1.3.5");
+    return semver2.gte(semVerContractVersion, "1.3.5");
   } else {
-    return semver.gte(semVerContractVersion, "14.0.0");
+    return semver2.gte(semVerContractVersion, "14.0.0");
   }
 };
 
@@ -2178,7 +2624,7 @@ import {
 import {
   decodeErrorResult,
   encodeFunctionData as encodeFunctionData2,
-  zeroAddress as zeroAddress5
+  zeroAddress as zeroAddress6
 } from "viem";
 var addressOrAccountAddress = (address) => typeof address === "string" ? address : address.address;
 var mintWithEthParams = ({
@@ -2334,7 +2780,7 @@ var encodePremintOnManager = ({
   premintConfig,
   premintSignature,
   mintArguments,
-  signerContract = zeroAddress5
+  signerContract = zeroAddress6
 }) => encodeFunctionData2({
   abi: zoraMintsManagerImplConfig.abi,
   functionName: "collectPremintV2",
@@ -2427,13 +2873,13 @@ var unwrapAndForwardEthPermitAndTypedDataDefinition = ({
   chainId,
   tokenIds,
   quantities,
-  from,
+  from: from2,
   callWithEth,
   safeTransferData,
   deadline,
   nonce
 }) => makePermitTransferBatchAndTypeData({
-  mintsOwner: from,
+  mintsOwner: from2,
   chainId,
   deadline,
   tokenIds,
@@ -2465,21 +2911,1164 @@ function createCollectorClient(params) {
   const premintGetterToUse = params.premintGetter || new PremintAPIClient(params.chainId);
   const mintGetterToUse = params.mintGetter || new SubgraphMintGetter(params.chainId);
   const mintClient = new MintClient({
-    chainId: params.chainId,
     publicClient: params.publicClient,
     premintGetter: premintGetterToUse,
     mintGetter: mintGetterToUse
   });
   return {
-    getPremint: (p) => premintGetterToUse.getSignature({
+    getPremint: (p) => premintGetterToUse.get({
       collectionAddress: p.address,
       uid: p.uid
     }),
     getCollectDataFromPremintReceipt: (p) => getDataFromPremintReceipt(p, params.chainId),
+    getToken: (p) => mintClient.get(p),
+    getTokensOfContract: (p) => mintClient.getOfContract(p),
     mint: (p) => mintClient.mint(p),
     getMintCosts: (p) => mintClient.getMintCosts(p)
   };
 }
+
+// src/ipfs/arweave.ts
+function isArweaveURL(url) {
+  return url && typeof url === "string" ? url.startsWith("ar://") : false;
+}
+
+// ../../node_modules/multiformats/esm/vendor/varint.js
+var encode_1 = encode;
+var MSB = 128;
+var REST = 127;
+var MSBALL = ~REST;
+var INT = Math.pow(2, 31);
+function encode(num, out, offset) {
+  out = out || [];
+  offset = offset || 0;
+  var oldOffset = offset;
+  while (num >= INT) {
+    out[offset++] = num & 255 | MSB;
+    num /= 128;
+  }
+  while (num & MSBALL) {
+    out[offset++] = num & 255 | MSB;
+    num >>>= 7;
+  }
+  out[offset] = num | 0;
+  encode.bytes = offset - oldOffset + 1;
+  return out;
+}
+var decode = read;
+var MSB$1 = 128;
+var REST$1 = 127;
+function read(buf, offset) {
+  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+  do {
+    if (counter >= l) {
+      read.bytes = 0;
+      throw new RangeError("Could not decode varint");
+    }
+    b = buf[counter++];
+    res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
+    shift += 7;
+  } while (b >= MSB$1);
+  read.bytes = counter - offset;
+  return res;
+}
+var N1 = Math.pow(2, 7);
+var N2 = Math.pow(2, 14);
+var N3 = Math.pow(2, 21);
+var N4 = Math.pow(2, 28);
+var N5 = Math.pow(2, 35);
+var N6 = Math.pow(2, 42);
+var N7 = Math.pow(2, 49);
+var N8 = Math.pow(2, 56);
+var N9 = Math.pow(2, 63);
+var length = function(value) {
+  return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
+};
+var varint = {
+  encode: encode_1,
+  decode,
+  encodingLength: length
+};
+var _brrp_varint = varint;
+var varint_default = _brrp_varint;
+
+// ../../node_modules/multiformats/esm/src/varint.js
+var decode2 = (data, offset = 0) => {
+  const code = varint_default.decode(data, offset);
+  return [
+    code,
+    varint_default.decode.bytes
+  ];
+};
+var encodeTo = (int, target, offset = 0) => {
+  varint_default.encode(int, target, offset);
+  return target;
+};
+var encodingLength = (int) => {
+  return varint_default.encodingLength(int);
+};
+
+// ../../node_modules/multiformats/esm/src/bytes.js
+var empty = new Uint8Array(0);
+var equals = (aa, bb) => {
+  if (aa === bb)
+    return true;
+  if (aa.byteLength !== bb.byteLength) {
+    return false;
+  }
+  for (let ii = 0; ii < aa.byteLength; ii++) {
+    if (aa[ii] !== bb[ii]) {
+      return false;
+    }
+  }
+  return true;
+};
+var coerce3 = (o) => {
+  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array")
+    return o;
+  if (o instanceof ArrayBuffer)
+    return new Uint8Array(o);
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+  }
+  throw new Error("Unknown type, must be binary type");
+};
+
+// ../../node_modules/multiformats/esm/src/hashes/digest.js
+var create = (code, digest) => {
+  const size = digest.byteLength;
+  const sizeOffset = encodingLength(code);
+  const digestOffset = sizeOffset + encodingLength(size);
+  const bytes = new Uint8Array(digestOffset + size);
+  encodeTo(code, bytes, 0);
+  encodeTo(size, bytes, sizeOffset);
+  bytes.set(digest, digestOffset);
+  return new Digest(code, size, digest, bytes);
+};
+var decode3 = (multihash) => {
+  const bytes = coerce3(multihash);
+  const [code, sizeOffset] = decode2(bytes);
+  const [size, digestOffset] = decode2(bytes.subarray(sizeOffset));
+  const digest = bytes.subarray(sizeOffset + digestOffset);
+  if (digest.byteLength !== size) {
+    throw new Error("Incorrect length");
+  }
+  return new Digest(code, size, digest, bytes);
+};
+var equals2 = (a, b) => {
+  if (a === b) {
+    return true;
+  } else {
+    return a.code === b.code && a.size === b.size && equals(a.bytes, b.bytes);
+  }
+};
+var Digest = class {
+  constructor(code, size, digest, bytes) {
+    this.code = code;
+    this.size = size;
+    this.digest = digest;
+    this.bytes = bytes;
+  }
+};
+
+// ../../node_modules/multiformats/esm/vendor/base-x.js
+function base2(ALPHABET, name) {
+  if (ALPHABET.length >= 255) {
+    throw new TypeError("Alphabet too long");
+  }
+  var BASE_MAP = new Uint8Array(256);
+  for (var j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (var i = 0; i < ALPHABET.length; i++) {
+    var x = ALPHABET.charAt(i);
+    var xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) {
+      throw new TypeError(x + " is ambiguous");
+    }
+    BASE_MAP[xc] = i;
+  }
+  var BASE = ALPHABET.length;
+  var LEADER = ALPHABET.charAt(0);
+  var FACTOR = Math.log(BASE) / Math.log(256);
+  var iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode3(source) {
+    if (source instanceof Uint8Array)
+      ;
+    else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) {
+      throw new TypeError("Expected Uint8Array");
+    }
+    if (source.length === 0) {
+      return "";
+    }
+    var zeroes = 0;
+    var length2 = 0;
+    var pbegin = 0;
+    var pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    var b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      var carry = source[pbegin];
+      var i2 = 0;
+      for (var it1 = size - 1; (carry !== 0 || i2 < length2) && it1 !== -1; it1--, i2++) {
+        carry += 256 * b58[it1] >>> 0;
+        b58[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length2 = i2;
+      pbegin++;
+    }
+    var it2 = size - length2;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    var str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) {
+      str += ALPHABET.charAt(b58[it2]);
+    }
+    return str;
+  }
+  function decodeUnsafe(source) {
+    if (typeof source !== "string") {
+      throw new TypeError("Expected String");
+    }
+    if (source.length === 0) {
+      return new Uint8Array();
+    }
+    var psz = 0;
+    if (source[psz] === " ") {
+      return;
+    }
+    var zeroes = 0;
+    var length2 = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    var size = (source.length - psz) * FACTOR + 1 >>> 0;
+    var b256 = new Uint8Array(size);
+    while (source[psz]) {
+      var carry = BASE_MAP[source.charCodeAt(psz)];
+      if (carry === 255) {
+        return;
+      }
+      var i2 = 0;
+      for (var it3 = size - 1; (carry !== 0 || i2 < length2) && it3 !== -1; it3--, i2++) {
+        carry += BASE * b256[it3] >>> 0;
+        b256[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length2 = i2;
+      psz++;
+    }
+    if (source[psz] === " ") {
+      return;
+    }
+    var it4 = size - length2;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    var vch = new Uint8Array(zeroes + (size - it4));
+    var j2 = zeroes;
+    while (it4 !== size) {
+      vch[j2++] = b256[it4++];
+    }
+    return vch;
+  }
+  function decode5(string) {
+    var buffer = decodeUnsafe(string);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error(`Non-${name} character`);
+  }
+  return {
+    encode: encode3,
+    decodeUnsafe,
+    decode: decode5
+  };
+}
+var src = base2;
+var _brrp__multiformats_scope_baseX = src;
+var base_x_default = _brrp__multiformats_scope_baseX;
+
+// ../../node_modules/multiformats/esm/src/bases/base.js
+var Encoder = class {
+  constructor(name, prefix, baseEncode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+  }
+  encode(bytes) {
+    if (bytes instanceof Uint8Array) {
+      return `${this.prefix}${this.baseEncode(bytes)}`;
+    } else {
+      throw Error("Unknown type, must be binary type");
+    }
+  }
+};
+var Decoder = class {
+  constructor(name, prefix, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    if (prefix.codePointAt(0) === void 0) {
+      throw new Error("Invalid prefix character");
+    }
+    this.prefixCodePoint = prefix.codePointAt(0);
+    this.baseDecode = baseDecode;
+  }
+  decode(text) {
+    if (typeof text === "string") {
+      if (text.codePointAt(0) !== this.prefixCodePoint) {
+        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+      }
+      return this.baseDecode(text.slice(this.prefix.length));
+    } else {
+      throw Error("Can only multibase decode strings");
+    }
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+};
+var ComposedDecoder = class {
+  constructor(decoders) {
+    this.decoders = decoders;
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+  decode(input) {
+    const prefix = input[0];
+    const decoder = this.decoders[prefix];
+    if (decoder) {
+      return decoder.decode(input);
+    } else {
+      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+    }
+  }
+};
+var or = (left, right) => new ComposedDecoder({
+  ...left.decoders || { [left.prefix]: left },
+  ...right.decoders || { [right.prefix]: right }
+});
+var Codec = class {
+  constructor(name, prefix, baseEncode, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+    this.baseDecode = baseDecode;
+    this.encoder = new Encoder(name, prefix, baseEncode);
+    this.decoder = new Decoder(name, prefix, baseDecode);
+  }
+  encode(input) {
+    return this.encoder.encode(input);
+  }
+  decode(input) {
+    return this.decoder.decode(input);
+  }
+};
+var from = ({ name, prefix, encode: encode3, decode: decode5 }) => new Codec(name, prefix, encode3, decode5);
+var baseX = ({ prefix, name, alphabet }) => {
+  const { encode: encode3, decode: decode5 } = base_x_default(alphabet, name);
+  return from({
+    prefix,
+    name,
+    encode: encode3,
+    decode: (text) => coerce3(decode5(text))
+  });
+};
+var decode4 = (string, alphabet, bitsPerChar, name) => {
+  const codes = {};
+  for (let i = 0; i < alphabet.length; ++i) {
+    codes[alphabet[i]] = i;
+  }
+  let end = string.length;
+  while (string[end - 1] === "=") {
+    --end;
+  }
+  const out = new Uint8Array(end * bitsPerChar / 8 | 0);
+  let bits = 0;
+  let buffer = 0;
+  let written = 0;
+  for (let i = 0; i < end; ++i) {
+    const value = codes[string[i]];
+    if (value === void 0) {
+      throw new SyntaxError(`Non-${name} character`);
+    }
+    buffer = buffer << bitsPerChar | value;
+    bits += bitsPerChar;
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 255 & buffer >> bits;
+    }
+  }
+  if (bits >= bitsPerChar || 255 & buffer << 8 - bits) {
+    throw new SyntaxError("Unexpected end of data");
+  }
+  return out;
+};
+var encode2 = (data, alphabet, bitsPerChar) => {
+  const pad = alphabet[alphabet.length - 1] === "=";
+  const mask = (1 << bitsPerChar) - 1;
+  let out = "";
+  let bits = 0;
+  let buffer = 0;
+  for (let i = 0; i < data.length; ++i) {
+    buffer = buffer << 8 | data[i];
+    bits += 8;
+    while (bits > bitsPerChar) {
+      bits -= bitsPerChar;
+      out += alphabet[mask & buffer >> bits];
+    }
+  }
+  if (bits) {
+    out += alphabet[mask & buffer << bitsPerChar - bits];
+  }
+  if (pad) {
+    while (out.length * bitsPerChar & 7) {
+      out += "=";
+    }
+  }
+  return out;
+};
+var rfc4648 = ({ name, prefix, bitsPerChar, alphabet }) => {
+  return from({
+    prefix,
+    name,
+    encode(input) {
+      return encode2(input, alphabet, bitsPerChar);
+    },
+    decode(input) {
+      return decode4(input, alphabet, bitsPerChar, name);
+    }
+  });
+};
+
+// ../../node_modules/multiformats/esm/src/bases/base58.js
+var base58btc = baseX({
+  name: "base58btc",
+  prefix: "z",
+  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+});
+var base58flickr = baseX({
+  name: "base58flickr",
+  prefix: "Z",
+  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base32.js
+var base32 = rfc4648({
+  prefix: "b",
+  name: "base32",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567",
+  bitsPerChar: 5
+});
+var base32upper = rfc4648({
+  prefix: "B",
+  name: "base32upper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+  bitsPerChar: 5
+});
+var base32pad = rfc4648({
+  prefix: "c",
+  name: "base32pad",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
+  bitsPerChar: 5
+});
+var base32padupper = rfc4648({
+  prefix: "C",
+  name: "base32padupper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
+  bitsPerChar: 5
+});
+var base32hex = rfc4648({
+  prefix: "v",
+  name: "base32hex",
+  alphabet: "0123456789abcdefghijklmnopqrstuv",
+  bitsPerChar: 5
+});
+var base32hexupper = rfc4648({
+  prefix: "V",
+  name: "base32hexupper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
+  bitsPerChar: 5
+});
+var base32hexpad = rfc4648({
+  prefix: "t",
+  name: "base32hexpad",
+  alphabet: "0123456789abcdefghijklmnopqrstuv=",
+  bitsPerChar: 5
+});
+var base32hexpadupper = rfc4648({
+  prefix: "T",
+  name: "base32hexpadupper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
+  bitsPerChar: 5
+});
+var base32z = rfc4648({
+  prefix: "h",
+  name: "base32z",
+  alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
+  bitsPerChar: 5
+});
+
+// ../../node_modules/multiformats/esm/src/cid.js
+var CID = class _CID {
+  constructor(version2, code, multihash, bytes) {
+    this.code = code;
+    this.version = version2;
+    this.multihash = multihash;
+    this.bytes = bytes;
+    this.byteOffset = bytes.byteOffset;
+    this.byteLength = bytes.byteLength;
+    this.asCID = this;
+    this._baseCache = /* @__PURE__ */ new Map();
+    Object.defineProperties(this, {
+      byteOffset: hidden,
+      byteLength: hidden,
+      code: readonly,
+      version: readonly,
+      multihash: readonly,
+      bytes: readonly,
+      _baseCache: hidden,
+      asCID: hidden
+    });
+  }
+  toV0() {
+    switch (this.version) {
+      case 0: {
+        return this;
+      }
+      default: {
+        const { code, multihash } = this;
+        if (code !== DAG_PB_CODE) {
+          throw new Error("Cannot convert a non dag-pb CID to CIDv0");
+        }
+        if (multihash.code !== SHA_256_CODE) {
+          throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
+        }
+        return _CID.createV0(multihash);
+      }
+    }
+  }
+  toV1() {
+    switch (this.version) {
+      case 0: {
+        const { code, digest } = this.multihash;
+        const multihash = create(code, digest);
+        return _CID.createV1(this.code, multihash);
+      }
+      case 1: {
+        return this;
+      }
+      default: {
+        throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
+      }
+    }
+  }
+  equals(other) {
+    return other && this.code === other.code && this.version === other.version && equals2(this.multihash, other.multihash);
+  }
+  toString(base3) {
+    const { bytes, version: version2, _baseCache } = this;
+    switch (version2) {
+      case 0:
+        return toStringV0(bytes, _baseCache, base3 || base58btc.encoder);
+      default:
+        return toStringV1(bytes, _baseCache, base3 || base32.encoder);
+    }
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      version: this.version,
+      hash: this.multihash.bytes
+    };
+  }
+  get [Symbol.toStringTag]() {
+    return "CID";
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return "CID(" + this.toString() + ")";
+  }
+  static isCID(value) {
+    deprecate(/^0\.0/, IS_CID_DEPRECATION);
+    return !!(value && (value[cidSymbol] || value.asCID === value));
+  }
+  get toBaseEncodedString() {
+    throw new Error("Deprecated, use .toString()");
+  }
+  get codec() {
+    throw new Error('"codec" property is deprecated, use integer "code" property instead');
+  }
+  get buffer() {
+    throw new Error("Deprecated .buffer property, use .bytes to get Uint8Array instead");
+  }
+  get multibaseName() {
+    throw new Error('"multibaseName" property is deprecated');
+  }
+  get prefix() {
+    throw new Error('"prefix" property is deprecated');
+  }
+  static asCID(value) {
+    if (value instanceof _CID) {
+      return value;
+    } else if (value != null && value.asCID === value) {
+      const { version: version2, code, multihash, bytes } = value;
+      return new _CID(version2, code, multihash, bytes || encodeCID(version2, code, multihash.bytes));
+    } else if (value != null && value[cidSymbol] === true) {
+      const { version: version2, multihash, code } = value;
+      const digest = decode3(multihash);
+      return _CID.create(version2, code, digest);
+    } else {
+      return null;
+    }
+  }
+  static create(version2, code, digest) {
+    if (typeof code !== "number") {
+      throw new Error("String codecs are no longer supported");
+    }
+    switch (version2) {
+      case 0: {
+        if (code !== DAG_PB_CODE) {
+          throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`);
+        } else {
+          return new _CID(version2, code, digest, digest.bytes);
+        }
+      }
+      case 1: {
+        const bytes = encodeCID(version2, code, digest.bytes);
+        return new _CID(version2, code, digest, bytes);
+      }
+      default: {
+        throw new Error("Invalid version");
+      }
+    }
+  }
+  static createV0(digest) {
+    return _CID.create(0, DAG_PB_CODE, digest);
+  }
+  static createV1(code, digest) {
+    return _CID.create(1, code, digest);
+  }
+  static decode(bytes) {
+    const [cid, remainder] = _CID.decodeFirst(bytes);
+    if (remainder.length) {
+      throw new Error("Incorrect length");
+    }
+    return cid;
+  }
+  static decodeFirst(bytes) {
+    const specs = _CID.inspectBytes(bytes);
+    const prefixSize = specs.size - specs.multihashSize;
+    const multihashBytes = coerce3(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
+    if (multihashBytes.byteLength !== specs.multihashSize) {
+      throw new Error("Incorrect length");
+    }
+    const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
+    const digest = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
+    const cid = specs.version === 0 ? _CID.createV0(digest) : _CID.createV1(specs.codec, digest);
+    return [
+      cid,
+      bytes.subarray(specs.size)
+    ];
+  }
+  static inspectBytes(initialBytes) {
+    let offset = 0;
+    const next = () => {
+      const [i, length2] = decode2(initialBytes.subarray(offset));
+      offset += length2;
+      return i;
+    };
+    let version2 = next();
+    let codec = DAG_PB_CODE;
+    if (version2 === 18) {
+      version2 = 0;
+      offset = 0;
+    } else if (version2 === 1) {
+      codec = next();
+    }
+    if (version2 !== 0 && version2 !== 1) {
+      throw new RangeError(`Invalid CID version ${version2}`);
+    }
+    const prefixSize = offset;
+    const multihashCode = next();
+    const digestSize = next();
+    const size = offset + digestSize;
+    const multihashSize = size - prefixSize;
+    return {
+      version: version2,
+      codec,
+      multihashCode,
+      digestSize,
+      multihashSize,
+      size
+    };
+  }
+  static parse(source, base3) {
+    const [prefix, bytes] = parseCIDtoBytes(source, base3);
+    const cid = _CID.decode(bytes);
+    cid._baseCache.set(prefix, source);
+    return cid;
+  }
+};
+var parseCIDtoBytes = (source, base3) => {
+  switch (source[0]) {
+    case "Q": {
+      const decoder = base3 || base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(`${base58btc.prefix}${source}`)
+      ];
+    }
+    case base58btc.prefix: {
+      const decoder = base3 || base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(source)
+      ];
+    }
+    case base32.prefix: {
+      const decoder = base3 || base32;
+      return [
+        base32.prefix,
+        decoder.decode(source)
+      ];
+    }
+    default: {
+      if (base3 == null) {
+        throw Error("To parse non base32 or base58btc encoded CID multibase decoder must be provided");
+      }
+      return [
+        source[0],
+        base3.decode(source)
+      ];
+    }
+  }
+};
+var toStringV0 = (bytes, cache, base3) => {
+  const { prefix } = base3;
+  if (prefix !== base58btc.prefix) {
+    throw Error(`Cannot string encode V0 in ${base3.name} encoding`);
+  }
+  const cid = cache.get(prefix);
+  if (cid == null) {
+    const cid2 = base3.encode(bytes).slice(1);
+    cache.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+};
+var toStringV1 = (bytes, cache, base3) => {
+  const { prefix } = base3;
+  const cid = cache.get(prefix);
+  if (cid == null) {
+    const cid2 = base3.encode(bytes);
+    cache.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+};
+var DAG_PB_CODE = 112;
+var SHA_256_CODE = 18;
+var encodeCID = (version2, code, multihash) => {
+  const codeOffset = encodingLength(version2);
+  const hashOffset = codeOffset + encodingLength(code);
+  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+  encodeTo(version2, bytes, 0);
+  encodeTo(code, bytes, codeOffset);
+  bytes.set(multihash, hashOffset);
+  return bytes;
+};
+var cidSymbol = Symbol.for("@ipld/js-cid/CID");
+var readonly = {
+  writable: false,
+  configurable: false,
+  enumerable: true
+};
+var hidden = {
+  writable: false,
+  enumerable: false,
+  configurable: false
+};
+var version = "0.0.0-dev";
+var deprecate = (range, message) => {
+  if (range.test(version)) {
+    console.warn(message);
+  } else {
+    throw new Error(message);
+  }
+};
+var IS_CID_DEPRECATION = `CID.isCID(v) is deprecated and will be removed in the next major release.
+Following code pattern:
+
+if (CID.isCID(value)) {
+  doSomethingWithCID(value)
+}
+
+Is replaced with:
+
+const cid = CID.asCID(value)
+if (cid) {
+  // Make sure to use cid instead of value
+  doSomethingWithCID(cid)
+}
+`;
+
+// src/ipfs/ipfs.ts
+function isCID(str) {
+  if (!str)
+    return false;
+  try {
+    CID.parse(str);
+    return true;
+  } catch (e) {
+    if (/^(bafy|Qm)/.test(str))
+      return true;
+    return false;
+  }
+}
+function normalizeIPFSUrl(url) {
+  if (!url || typeof url !== "string")
+    return null;
+  url = url.replace(/"/g, "");
+  if (isNormalizedIPFSURL(url))
+    return url;
+  if (isCID(url))
+    return `ipfs://${url}`;
+  if (!isIPFSUrl(url))
+    return null;
+  if (isGatewayIPFSUrl(url)) {
+    const parsed = new URL(url.replace(/^\/\//, "http://"));
+    parsed.pathname = parsed.pathname.replace(/^\/ipfs\//, "");
+    const cid = parsed.toString().replace(`${parsed.protocol}//${parsed.host}/`, "");
+    return `ipfs://${cid}`;
+  }
+  return null;
+}
+function isNormalizedIPFSURL(url) {
+  return url && typeof url === "string" ? url.startsWith("ipfs://") : false;
+}
+function isGatewayIPFSUrl(url) {
+  if (url && typeof url === "string") {
+    try {
+      const parsed = new URL(url.replace(/^"|'(.*)"|'$/, "$1"));
+      return !isNormalizedIPFSURL(url) && parsed && parsed.pathname.startsWith("/ipfs/");
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function isIPFSUrl(url) {
+  return url ? isNormalizedIPFSURL(url) || isGatewayIPFSUrl(url) : false;
+}
+function isNormalizeableIPFSUrl(url) {
+  return url ? isIPFSUrl(url) || isCID(url) : false;
+}
+
+// src/ipfs/gateway.ts
+var IPFS_GATEWAY = "https://magic.decentralized-content.com";
+var ARWEAVE_GATEWAY = "https://arweave.net";
+function arweaveGatewayUrl(normalizedArweaveUrl) {
+  if (!normalizedArweaveUrl || typeof normalizedArweaveUrl !== "string")
+    return null;
+  return normalizedArweaveUrl.replace("ar://", `${ARWEAVE_GATEWAY}/`);
+}
+function ipfsGatewayUrl(url) {
+  if (!url || typeof url !== "string")
+    return null;
+  const normalizedIPFSUrl = normalizeIPFSUrl(url);
+  if (normalizedIPFSUrl) {
+    return normalizedIPFSUrl.replace("ipfs://", `${IPFS_GATEWAY}/ipfs/`);
+  }
+  return null;
+}
+function getFetchableUrl(uri) {
+  if (!uri || typeof uri !== "string")
+    return null;
+  if (uri.startsWith("http://"))
+    return null;
+  if (isNormalizeableIPFSUrl(uri)) {
+    return ipfsGatewayUrl(uri);
+  }
+  if (isArweaveURL(uri)) {
+    return arweaveGatewayUrl(uri);
+  }
+  if (/^(https|data|blob):/.test(uri)) {
+    return uri;
+  }
+  return null;
+}
+
+// src/ipfs/mimeTypes.ts
+var HTML = "text/html";
+var MARKDOWN = "text/markdown";
+var MARKDOWN_UTF8 = "text/markdown; charset=utf-8";
+var TEXT_PLAIN_UTF8 = "text/plain; charset=utf-8";
+var TEXT_PLAIN = "text/plain";
+var CSV = "text/csv";
+var NUMBERS = ".numbers";
+var EXCEL = ".xlsx";
+var PDF = "application/pdf";
+var JPG = "image/jpg";
+var JPEG = "image/jpeg";
+var PNG = "image/png";
+var WEBP = "image/webp";
+var SVG = "image/svg+xml";
+var TIFF = "image/tiff";
+var GIF = "image/gif";
+var isImage = (mimeType) => {
+  if (!mimeType)
+    return false;
+  return [JPG, JPEG, PNG, WEBP, SVG, TIFF, GIF].includes(mimeType);
+};
+var DEFAULT_THUMBNAIL_CID_HASHES = {
+  ["AUDIO" /* AUDIO */]: "bafkreidir5laqi26ta6ivnpe2zpekgrfcyi4tb5x6vhwmwnledmzxshfb4",
+  ["VIDEO" /* VIDEO */]: "bafkreifm4edadl3j5luoyvw4p6elxeqd77la7bulee6vhq5gq4chfk32mu",
+  ["HTML" /* HTML */]: "bafkreifgvi6xfwqy2l6g45csyokejpaib52ee7zrw6etrxl2tas4xkkclq",
+  ["ZIP" /* ZIP */]: "bafkreihe5rr5jbkwzegisjlhxbb7jw22xw5oilfmgd2re6tz6buo4pasdq",
+  // assuming all zip files are html directories
+  ["TEXT" /* TEXT */]: "bafkreiaez25nfgggzrnza2loxf6xueb2esm44pnyjyulwoslnipowrf56q",
+  default: "bafkreihcoahllisbpb4eeypdwtm7go5uh275wxd7wf2tantpxlpjhviok4"
+};
+var MP4 = "video/mp4";
+var QUICKTIME = "video/quicktime";
+var M4V = "video/x-m4v";
+var WEBM = "video/webm";
+var M4A = "audio/x-m4a";
+var MPEG = "audio/mpeg";
+var MP3 = "audio/mp3";
+var WAV = "audio/wav";
+var VND_WAV = "audio/vnd.wav";
+var VND_WAVE = "audio/vnd.wave";
+var WAVE = "audio/wave";
+var X_WAV = "audio/x-wav";
+var AIFF = "audio/aiff";
+var GLTF = "model/gltf+json";
+var GLB = "model/gltf-binary";
+var GLTF_EXT = ".gltf";
+var GLB_EXT = ".glb";
+var JSON_MIME_TYPE = "application/json";
+var ZIP = "application/zip";
+var mimeToMediaType = {
+  [HTML]: "HTML" /* HTML */,
+  [JPG]: "IMAGE" /* IMAGE */,
+  [JPEG]: "IMAGE" /* IMAGE */,
+  [PNG]: "IMAGE" /* IMAGE */,
+  [WEBP]: "IMAGE" /* IMAGE */,
+  [SVG]: "IMAGE" /* IMAGE */,
+  [TIFF]: "TIFF" /* TIFF */,
+  [GIF]: "IMAGE" /* IMAGE */,
+  [MP4]: "VIDEO" /* VIDEO */,
+  [WEBM]: "VIDEO" /* VIDEO */,
+  [QUICKTIME]: "VIDEO" /* VIDEO */,
+  [M4V]: "VIDEO" /* VIDEO */,
+  [MPEG]: "AUDIO" /* AUDIO */,
+  [MP3]: "AUDIO" /* AUDIO */,
+  [M4A]: "AUDIO" /* AUDIO */,
+  [VND_WAV]: "AUDIO" /* AUDIO */,
+  [VND_WAVE]: "AUDIO" /* AUDIO */,
+  [WAV]: "AUDIO" /* AUDIO */,
+  [WAVE]: "AUDIO" /* AUDIO */,
+  [X_WAV]: "AUDIO" /* AUDIO */,
+  [AIFF]: "AUDIO" /* AUDIO */,
+  [TEXT_PLAIN]: "TEXT" /* TEXT */,
+  [TEXT_PLAIN_UTF8]: "TEXT" /* TEXT */,
+  [MARKDOWN]: "TEXT" /* TEXT */,
+  [MARKDOWN_UTF8]: "TEXT" /* TEXT */,
+  [CSV]: "CSV" /* CSV */,
+  [NUMBERS]: "NUMBERS" /* NUMBERS */,
+  [EXCEL]: "EXCEL" /* EXCEL */,
+  [PDF]: "PDF" /* PDF */,
+  [ZIP]: "ZIP" /* ZIP */,
+  [GLTF]: "MODEL" /* MODEL */,
+  [GLTF_EXT]: "MODEL" /* MODEL */,
+  [GLB]: "MODEL" /* MODEL */,
+  // GLTF returns 'application/json' as the mimetype,
+  // and as the only JSON-encoded media we currently support,
+  // we assume that if the mimetype is JSON, it's a GLTF
+  [JSON_MIME_TYPE]: "MODEL" /* MODEL */,
+  [GLB_EXT]: "MODEL" /* MODEL */
+};
+function mimeTypeToMedia(mimeType) {
+  if (!mimeType)
+    return "UNKNOWN" /* UNKNOWN */;
+  return mimeToMediaType[mimeType] || "UNKNOWN" /* UNKNOWN */;
+}
+async function getMimeType(uri) {
+  if (!uri)
+    return uri;
+  const res = await fetch(uri, { method: "HEAD" });
+  let mimeType = res.headers.get("content-type");
+  return mimeType;
+}
+
+// src/ipfs/token-metadata.ts
+var makeTextTokenMetadata = (parameters) => {
+  const { name, textFileUrl, thumbnailUrl, attributes = [] } = parameters;
+  const content = textFileUrl ? {
+    mime: TEXT_PLAIN,
+    uri: textFileUrl
+  } : null;
+  const image = thumbnailUrl;
+  const animation_url = textFileUrl;
+  return {
+    name,
+    image,
+    animation_url,
+    content,
+    attributes
+  };
+};
+var makeMediaTokenMetadata = async ({
+  name,
+  description,
+  attributes = [],
+  mediaUrl,
+  thumbnailUrl
+}) => {
+  const contentUrl = mediaUrl;
+  const fetchableContentUrl = getFetchableUrl(contentUrl);
+  if (!fetchableContentUrl)
+    throw new Error(`Content url (${contentUrl}) is not fetchable`);
+  const mimeType = await getMimeType(fetchableContentUrl);
+  const mediaType = mimeTypeToMedia(mimeType);
+  let image = void 0;
+  let animation_url = null;
+  if (isImage(mimeType)) {
+    image = contentUrl;
+  } else {
+    image = thumbnailUrl;
+    animation_url = mediaUrl;
+  }
+  if (!image)
+    image = `ipfs://${DEFAULT_THUMBNAIL_CID_HASHES[mediaType] || DEFAULT_THUMBNAIL_CID_HASHES.default}`;
+  const content = contentUrl ? {
+    mime: mimeType || "application/octet-stream",
+    uri: contentUrl
+  } : null;
+  return {
+    name,
+    description,
+    image,
+    animation_url,
+    content,
+    attributes
+  };
+};
+
+// src/ipfs/text-metadata.ts
+var CHAR_LIMIT = 1111;
+var wrapText = ({
+  ctx,
+  text,
+  x,
+  y,
+  maxWidth,
+  lineHeight
+}) => {
+  let words = text.replaceAll("\n", " \n ").split(/ +/);
+  let line = "";
+  let testLine = "";
+  let lineArray = [];
+  for (var n = 0; n < words.length; n++) {
+    testLine += `${words[n]} `;
+    let metrics = ctx.measureText(testLine);
+    let testWidth = metrics.width;
+    if (words[n]?.includes("\n") || testWidth > maxWidth && n > 0) {
+      lineArray.push({ text: line, x, y });
+      y += lineHeight;
+      if (words[n]?.includes("\n")) {
+        line = ``;
+        testLine = ``;
+      } else {
+        line = `${words[n]} `;
+        testLine = `${words[n]} `;
+      }
+    } else {
+      line += `${words[n]} `;
+    }
+    if (n === words.length - 1) {
+      lineArray.push({ text: line, x, y });
+    }
+  }
+  return lineArray;
+};
+async function generateTextPreview(text) {
+  const trimmedText = text.trim().slice(0, CHAR_LIMIT);
+  const [width, height] = [500, 500];
+  const padding = 20;
+  const dpr = 2;
+  const fontFamily = "Inter";
+  const [fontSize, lineHeight] = [16, 24];
+  const [textColor, backgroundColor] = ["black", "white"];
+  return new Promise((resolve, reject) => {
+    const canvas = document.createElement("canvas");
+    canvas.width = width * dpr;
+    canvas.height = height * dpr;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      return reject(new Error("Could not create canvas context"));
+    }
+    ctx.fillStyle = backgroundColor;
+    ctx.fillRect(0, 0, width * dpr, width * dpr);
+    ctx.fillStyle = textColor;
+    ctx.font = `${fontSize * dpr}px ${fontFamily}`;
+    const wrapped = wrapText({
+      ctx,
+      text: trimmedText,
+      x: padding * dpr,
+      y: fontSize * dpr + padding * dpr,
+      maxWidth: width * dpr - padding * 2 * dpr,
+      lineHeight: lineHeight * dpr
+    });
+    wrapped.forEach((line) => ctx.fillText(line.text, line.x, line.y));
+    canvas.toBlob((blob) => {
+      if (!blob) {
+        return reject(new Error("Could not create blob"));
+      }
+      resolve(new File([blob], "thumbnail.png", { type: "image/png" }));
+    });
+  });
+}
+function generateTextTitle(text) {
+  const firstLine = text.split("\n")[0];
+  const firstSentence = firstLine?.split(". ")[0];
+  if (firstSentence.length > 50) {
+    return firstSentence.slice(0, 50) + "...";
+  }
+  return firstSentence;
+}
+var toTextFile = (text) => new File([text], "Untitled.txt", { type: "text/plain" });
+async function generateTextNftMetadataFiles(text) {
+  const name = generateTextTitle(text);
+  const textFile = toTextFile(text);
+  const thumbnailFile = await generateTextPreview(text);
+  return {
+    name,
+    mediaUrlFile: textFile,
+    thumbnailFile
+  };
+}
 export {
   Create1155Client,
   Errors,
@@ -2490,12 +4079,14 @@ export {
   SubgraphMintGetter,
   ZORA_API_BASE,
   applyUpdateToPremint,
+  buildPremintMintCall,
   collectOnchain,
   collectPremint,
   collectPremintV2WithMintsParams,
   collectWithMintsParams,
   convertCollectionFromApi,
   convertGetPremintApiResponse,
+  convertGetPremintOfCollectionApiResponse,
   convertPremintFromApi,
   createCollectorClient,
   createCreatorClient,
@@ -2507,13 +4098,12 @@ export {
   encodeCollectOnManager,
   encodePostSignatureInput,
   encodePremintForAPI,
+  generateTextNftMetadataFiles,
   getApiNetworkConfigForChain,
   getDataFromPremintReceipt,
   getDefaultFixedPriceMinterAddress,
-  getMintCosts,
   getMintsAccountBalanceWithPriceQuery,
   getMintsEthPrice,
-  getNecessaryErc20Approval,
   getPremintCollectionAddress,
   getPremintExecutorAddress,
   getPremintMintCosts,
@@ -2528,20 +4118,19 @@ export {
   isPremintConfigV2,
   isValidSignature,
   makeCallWithEthSafeTransferData,
+  makeMediaTokenMetadata,
   makeMintRewardsRecipient,
   makeNewPremint,
   makePermitToCollectPremintOrNonPremint,
   makePermitTransferBatchAndTypeData,
   makePermitTransferTypeData,
-  makePrepareMint1155TokenParams,
+  makeTextTokenMetadata,
   makeUrls,
   migratePremintConfigToV2,
   mintWithEthParams,
   mintsBalanceOfAccountParams,
-  parseMintCosts,
   recoverCreatorFromCreatorAttribution,
   recoverPremintSigner,
-  requestErc20ApprovalForMint,
   selectMintsToCollectWithFromQueryResult,
   sumBalances,
   supportedPremintVersions,