@zoralabs/protocol-sdk 0.8.0 → 0.9.0

package/dist/index.cjs

@@ -716,8 +716,8 @@ var require_gte = __commonJS({
   "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/gte.js"(exports2, module2) {
     "use strict";
     var compare = require_compare();
-    var gte4 = (a, b, loose) => compare(a, b, loose) >= 0;
-    module2.exports = gte4;
+    var gte3 = (a, b, loose) => compare(a, b, loose) >= 0;
+    module2.exports = gte3;
   }
 });
 
@@ -738,7 +738,7 @@ var require_cmp = __commonJS({
     var eq = require_eq();
     var neq = require_neq();
     var gt = require_gt();
-    var gte4 = require_gte();
+    var gte3 = require_gte();
     var lt = require_lt();
     var lte = require_lte();
     var cmp = (a, op, b, loose) => {
@@ -768,7 +768,7 @@ var require_cmp = __commonJS({
         case ">":
           return gt(a, b, loose);
         case ">=":
-          return gte4(a, b, loose);
+          return gte3(a, b, loose);
         case "<":
           return lt(a, b, loose);
         case "<=":
@@ -788,7 +788,7 @@ var require_coerce = __commonJS({
     var SemVer = require_semver();
     var parse = require_parse();
     var { safeRe: re, t } = require_re();
-    var coerce5 = (version, options) => {
+    var coerce4 = (version, options) => {
       if (version instanceof SemVer) {
         return version;
       }
@@ -823,7 +823,7 @@ var require_coerce = __commonJS({
       const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
       return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options);
     };
-    module2.exports = coerce5;
+    module2.exports = coerce4;
   }
 });
 
@@ -1524,7 +1524,7 @@ var require_outside = __commonJS({
     var gt = require_gt();
     var lt = require_lt();
     var lte = require_lte();
-    var gte4 = require_gte();
+    var gte3 = require_gte();
     var outside = (version, range, hilo, options) => {
       version = new SemVer(version, options);
       range = new Range(range, options);
@@ -1539,7 +1539,7 @@ var require_outside = __commonJS({
           break;
         case "<":
           gtfn = lt;
-          ltefn = gte4;
+          ltefn = gte3;
           ltfn = gt;
           comp = "<";
           ecomp = "<=";
@@ -1855,10 +1855,10 @@ var require_semver2 = __commonJS({
     var lt = require_lt();
     var eq = require_eq();
     var neq = require_neq();
-    var gte4 = require_gte();
+    var gte3 = require_gte();
     var lte = require_lte();
     var cmp = require_cmp();
-    var coerce5 = require_coerce();
+    var coerce4 = require_coerce();
     var Comparator = require_comparator();
     var Range = require_range();
     var satisfies = require_satisfies();
@@ -1893,10 +1893,10 @@ var require_semver2 = __commonJS({
       lt,
       eq,
       neq,
-      gte: gte4,
+      gte: gte3,
       lte,
       cmp,
-      coerce: coerce5,
+      coerce: coerce4,
       Comparator,
       Range,
       satisfies,
@@ -1936,7 +1936,6 @@ __export(src_exports, {
   ZORA_API_BASE: () => ZORA_API_BASE,
   applyUpdateToPremint: () => applyUpdateToPremint,
   buildPremintMintCall: () => buildPremintMintCall,
-  collectOnchain: () => collectOnchain,
   collectPremint: () => collectPremint,
   collectPremintV2WithMintsParams: () => collectPremintV2WithMintsParams,
   collectWithMintsParams: () => collectWithMintsParams,
@@ -1944,6 +1943,7 @@ __export(src_exports, {
   convertGetPremintApiResponse: () => convertGetPremintApiResponse,
   convertGetPremintOfCollectionApiResponse: () => convertGetPremintOfCollectionApiResponse,
   convertPremintFromApi: () => convertPremintFromApi,
+  createAllowList: () => createAllowList,
   createCollectorClient: () => createCollectorClient,
   createCreatorClient: () => createCreatorClient,
   decodeCallFailedError: () => decodeCallFailedError,
@@ -2582,14 +2582,20 @@ var get = async (url) => {
   return await response.json();
 };
 var post = async (url, data) => {
+  const controller = new AbortController();
+  const { signal } = controller;
+  const timeout = 30 * 60 * 1e3;
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
   const response = await fetch(url, {
     method: "POST",
     headers: {
       "content-type": "application/json",
       accept: "application/json"
     },
-    body: JSON.stringify(data)
+    body: JSON.stringify(data),
+    signal
   });
+  clearTimeout(timeoutId);
   if (response.status !== 200) {
     let json;
     try {
@@ -2625,36 +2631,26 @@ 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
+// src/apis/subgraph-querier.ts
+var SubgraphQuerier = class {
+  constructor(httpClient2) {
+    this.httpClient = httpClient2;
+  }
+  async query({
+    subgraphUrl,
+    query,
+    variables
+  }) {
+    const { retries: retries2, post: post2 } = this.httpClient;
+    const result = await retries2(async () => {
+      return await post2(subgraphUrl, {
+        query,
+        variables
+      });
     });
-  });
-  return result?.data;
-}
+    return result?.data;
+  }
+};
 
 // src/mint/subgraph-queries.ts
 var NFT_SALE_STRATEGY_FRAGMENT = `
@@ -2675,6 +2671,23 @@ fragment SaleStrategy on SalesStrategyConfig {
     saleStart
     maxTokensPerAddress
   }
+  presale {
+    address
+    presaleStart
+    presaleEnd
+    merkleRoot
+  }
+  zoraTimedMinter {
+    address
+    mintFee
+    saleStart
+    saleEnd
+    erc20Z {
+      id 
+      pool
+    }
+    secondaryActivated
+  }
 }`;
 var TOKEN_FRAGMENT = `
 fragment Token on ZoraCreateToken {
@@ -2684,7 +2697,7 @@ fragment Token on ZoraCreateToken {
     totalMinted
     maxSupply
     tokenStandard
-    salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
+    salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER", "PRESALE", "ZORA_TIMED"]}) {
       ...SaleStrategy
     }
     contract {
@@ -2693,7 +2706,7 @@ fragment Token on ZoraCreateToken {
       contractVersion
       contractURI
       name
-      salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
+      salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER", "PRESALE", "ZORA_TIMED"]}) {
         ...SaleStrategy
       }
     }
@@ -2724,19 +2737,6 @@ query ($id: ID!) {
     parseResponseData: (responseData) => responseData?.zoraCreateToken
   };
 }
-function buildGetDefaultMintPriceQuery({}) {
-  return {
-    query: `
-{
-  defaultMintPrice(id: "0x0000000000000000000000000000000000000000") {
-    pricePerToken
-  }
-}
-`,
-    variables: {},
-    parseResponseData: (responseData) => responseData?.defaultMintPrice?.pricePerToken ? BigInt(responseData?.defaultMintPrice?.pricePerToken) : void 0
-  };
-}
 function buildContractTokensQuery({
   tokenAddress
 }) {
@@ -2777,14 +2777,13 @@ function buildPremintsOfContractQuery({
 }
 
 // src/mint/subgraph-mint-getter.ts
-var semver = __toESM(require_semver2(), 1);
 var getApiNetworkConfigForChain = (chainId) => {
   if (!networkConfigByChain[chainId]) {
     throw new Error(`chain id ${chainId} network not configured `);
   }
   return networkConfigByChain[chainId];
 };
-function parseSalesConfig(targetStrategy) {
+function parseSalesConfig(targetStrategy, contractMintFee) {
   if (targetStrategy.type === "FIXED_PRICE")
     return {
       saleType: "fixedPrice",
@@ -2792,7 +2791,8 @@ function parseSalesConfig(targetStrategy) {
       maxTokensPerAddress: BigInt(
         targetStrategy.fixedPrice.maxTokensPerAddress
       ),
-      pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken)
+      pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken),
+      mintFeePerQuantity: contractMintFee
     };
   if (targetStrategy.type === "ERC_20_MINTER") {
     return {
@@ -2801,31 +2801,72 @@ function parseSalesConfig(targetStrategy) {
       maxTokensPerAddress: BigInt(
         targetStrategy.erc20Minter.maxTokensPerAddress
       ),
-      pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken)
+      pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken),
+      mintFeePerQuantity: 0n
+    };
+  }
+  if (targetStrategy.type === "PRESALE") {
+    return {
+      saleType: "allowlist",
+      address: targetStrategy.presale.address,
+      merkleRoot: targetStrategy.presale.merkleRoot,
+      saleStart: targetStrategy.presale.presaleStart,
+      saleEnd: targetStrategy.presale.presaleEnd,
+      mintFeePerQuantity: contractMintFee
+    };
+  }
+  if (targetStrategy.type === "ZORA_TIMED") {
+    return {
+      saleType: "timed",
+      address: targetStrategy.zoraTimedMinter.address,
+      mintFee: BigInt(targetStrategy.zoraTimedMinter.mintFee),
+      saleStart: targetStrategy.zoraTimedMinter.saleStart,
+      saleEnd: targetStrategy.zoraTimedMinter.saleEnd,
+      erc20Z: targetStrategy.zoraTimedMinter.erc20Z.id,
+      pool: targetStrategy.zoraTimedMinter.erc20Z.pool,
+      secondaryActivated: targetStrategy.zoraTimedMinter.secondaryActivated,
+      mintFeePerQuantity: BigInt(targetStrategy.zoraTimedMinter.mintFee)
     };
   }
   throw new Error("Unknown saleType");
 }
 function getSaleEnd(a) {
-  return BigInt(
-    a.type === "ERC_20_MINTER" ? a.erc20Minter.saleEnd : a.fixedPrice.saleEnd
-  );
+  if (a.type === "FIXED_PRICE")
+    return BigInt(a.fixedPrice.saleEnd);
+  if (a.type === "ERC_20_MINTER")
+    return BigInt(a.erc20Minter.saleEnd);
+  if (a.type === "ZORA_TIMED")
+    return BigInt(a.zoraTimedMinter.saleEnd);
+  return BigInt(a.presale.presaleEnd);
+}
+function strategyIsStillValid(strategy, blockTime) {
+  if (strategy.type === "FIXED_PRICE") {
+    return BigInt(strategy.fixedPrice.saleEnd) > blockTime;
+  }
+  if (strategy.type === "ERC_20_MINTER") {
+    return BigInt(strategy.erc20Minter.saleEnd) > blockTime;
+  }
+  if (strategy.type === "ZORA_TIMED") {
+    return BigInt(strategy.zoraTimedMinter.saleEnd) > blockTime;
+  }
+  return BigInt(strategy.presale.presaleEnd) > blockTime;
 }
 function getTargetStrategy({
   tokenId,
   preferredSaleType,
-  token
+  token,
+  blockTime
 }) {
   const allStrategies = (typeof tokenId !== "undefined" ? token.salesStrategies : token.contract.salesStrategies) || [];
-  const saleStrategies = allStrategies.sort(
+  const stillValidSalesStrategies = allStrategies.filter(
+    (strategy) => strategyIsStillValid(strategy, blockTime)
+  );
+  const saleStrategies = stillValidSalesStrategies.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");
-    }
+    return saleStrategies[0];
   } else {
     const mappedSaleType = preferredSaleType === "erc20" ? "ERC_20_MINTER" : "FIXED_PRICE";
     targetStrategy = saleStrategies.find(
@@ -2843,11 +2884,12 @@ function getTargetStrategy({
   return targetStrategy;
 }
 var SubgraphMintGetter = class {
-  constructor(chainId, httpClient2) {
+  constructor(chainId, subgraphQuerier) {
     this.getMintable = async ({
       tokenAddress,
       tokenId,
-      preferredSaleType: saleType
+      preferredSaleType: saleType,
+      blockTime
     }) => {
       const token = await this.querySubgraphWithRetries(
         buildNftTokenSalesQuery({
@@ -2863,29 +2905,22 @@ var SubgraphMintGetter = class {
         token,
         defaultMintFee,
         tokenId,
-        preferredSaleType: saleType
+        preferredSaleType: saleType,
+        blockTime
       });
     };
-    this.httpClient = httpClient2 || httpClient;
+    this.subgraphQuerier = subgraphQuerier || new SubgraphQuerier(httpClient);
     this.networkConfig = getApiNetworkConfigForChain(chainId);
   }
   async getContractMintFee(contract) {
-    const storedMintFee = BigInt(contract.mintFeePerQuantity);
-    if (!contractUsesMintCardsForMintFee(contract.contractVersion)) {
-      return storedMintFee;
-    }
-    const defaultMintFee = await this.querySubgraphWithRetries(
-      buildGetDefaultMintPriceQuery({})
-    );
-    return defaultMintFee || storedMintFee;
+    return BigInt(contract.mintFeePerQuantity);
   }
   async querySubgraphWithRetries({
     query,
     variables,
     parseResponseData
   }) {
-    const responseData = await querySubgraphWithRetries({
-      httpClient: this.httpClient,
+    const responseData = await this.subgraphQuerier.query({
       subgraphUrl: this.networkConfig.subgraphUrl,
       query,
       variables
@@ -2894,7 +2929,8 @@ var SubgraphMintGetter = class {
   }
   async getContractMintable({
     tokenAddress,
-    preferredSaleType
+    preferredSaleType,
+    blockTime
   }) {
     const tokens = await this.querySubgraphWithRetries(
       buildContractTokensQuery({
@@ -2909,7 +2945,8 @@ var SubgraphMintGetter = class {
         token,
         tokenId: token.tokenId,
         preferredSaleType,
-        defaultMintFee
+        defaultMintFee,
+        blockTime
       })
     );
   }
@@ -2927,34 +2964,49 @@ var SubgraphMintGetter = class {
     })) || [];
   }
 };
-function parseTokenQueryResult({
+function getTargetStrategyAndMintFee({
   token,
   tokenId,
   preferredSaleType,
-  defaultMintFee
+  defaultMintFee,
+  blockTime
 }) {
   const targetStrategy = getTargetStrategy({
     tokenId,
     preferredSaleType,
+    token,
+    blockTime
+  });
+  if (!targetStrategy)
+    return void 0;
+  const salesConfig = parseSalesConfig(targetStrategy, defaultMintFee);
+  return salesConfig;
+}
+function parseTokenQueryResult({
+  token,
+  tokenId,
+  preferredSaleType,
+  defaultMintFee,
+  blockTime
+}) {
+  const salesConfig = getTargetStrategyAndMintFee({
+    token,
+    tokenId,
+    preferredSaleType,
+    defaultMintFee,
+    blockTime
+  });
+  const tokenInfo = parseTokenInfo({
     token
   });
-  const tokenInfo = parseTokenInfo(token, defaultMintFee);
-  const salesConfig = parseSalesConfig(targetStrategy);
-  if (isErc20SaleStrategy(salesConfig)) {
-    tokenInfo.mintFeePerQuantity = 0n;
-  }
   return {
     ...tokenInfo,
     salesConfig
   };
 }
-var contractUsesMintCardsForMintFee = (contractVersion) => {
-  const semVerContractVersion = semver.coerce(contractVersion)?.raw;
-  if (!semVerContractVersion)
-    return false;
-  return semver.gte(semVerContractVersion, "2.9.0");
-};
-function parseTokenInfo(token, defaultMintFee) {
+function parseTokenInfo({
+  token
+}) {
   return {
     contract: {
       address: token.contract.address,
@@ -2967,11 +3019,19 @@ function parseTokenInfo(token, defaultMintFee) {
     creator: token.creator,
     totalMinted: BigInt(token.totalMinted),
     maxSupply: BigInt(token.maxSupply),
-    mintFeePerQuantity: defaultMintFee,
     contractVersion: token.contract.contractVersion
   };
 }
 
+// src/utils.ts
+var makeContractParameters = (args) => args;
+function mintRecipientOrAccount({
+  mintRecipient,
+  minterAccount
+}) {
+  return mintRecipient || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
+}
+
 // src/premint/premint-client.ts
 var defaultTokenConfigV1MintArguments = () => ({
   maxSupply: OPEN_EDITION_MINT_SIZE,
@@ -3617,20 +3677,30 @@ var PremintAPIClient = class {
   }
 };
 
+// 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-queries.ts
+var import_viem6 = require("viem");
+
 // src/mint/mint-transactions.ts
 var import_viem5 = require("viem");
 var import_protocol_deployments6 = require("@zoralabs/protocol-deployments");
 
 // src/mint/utils.ts
-var semver2 = __toESM(require_semver2(), 1);
+var semver = __toESM(require_semver2(), 1);
 var contractSupportsNewMintFunction = (contractVersion) => {
   if (!contractVersion) {
     return false;
   }
-  const semVerContractVersion = semver2.coerce(contractVersion)?.raw;
+  const semVerContractVersion = semver.coerce(contractVersion)?.raw;
   if (!semVerContractVersion)
     return false;
-  return semver2.gte(semVerContractVersion, "2.9.0");
+  return semver.gte(semVerContractVersion, "2.9.0");
 };
 
 // src/mint/mint-transactions.ts
@@ -3660,12 +3730,13 @@ function makePrepareMint1155TokenParams({
   mintComment,
   mintReferral,
   mintRecipient,
-  quantityToMint
+  quantityToMint,
+  allowListEntry
 }) {
   const mintQuantity = BigInt(quantityToMint || 1);
   const mintTo = mintRecipientOrAccount({ mintRecipient, minterAccount });
   const saleType = salesConfigAndTokenInfo.salesConfig.saleType;
-  if (saleType === "fixedPrice") {
+  if (saleType === "fixedPrice" || saleType === "allowlist") {
     return makeEthMintCall({
       mintComment,
       minterAccount,
@@ -3674,7 +3745,26 @@ function makePrepareMint1155TokenParams({
       mintTo,
       salesConfigAndTokenInfo,
       tokenContract,
-      tokenId
+      tokenId,
+      allowListEntry
+    });
+  }
+  if (saleType === "timed") {
+    return makeContractParameters({
+      abi: import_protocol_deployments6.zoraTimedSaleStrategyABI,
+      functionName: "mint",
+      account: minterAccount,
+      address: salesConfigAndTokenInfo.salesConfig.address,
+      value: salesConfigAndTokenInfo.salesConfig.mintFeePerQuantity * mintQuantity,
+      /* args: mintTo, quantity, collection, tokenId, mintReferral, comment */
+      args: [
+        mintTo,
+        mintQuantity,
+        tokenContract,
+        BigInt(tokenId),
+        mintReferral || import_viem5.zeroAddress,
+        mintComment || ""
+      ]
     });
   }
   if (saleType === "erc20") {
@@ -3709,9 +3799,9 @@ function makePrepareMint721TokenParams({
 }) {
   const actualQuantityToMint = BigInt(quantityToMint || 1);
   const mintValue = parseMintCosts({
-    mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
     salesConfig: salesConfigAndTokenInfo.salesConfig,
-    quantityToMint: actualQuantityToMint
+    quantityToMint: actualQuantityToMint,
+    allowListEntry: void 0
   }).totalCostEth;
   return makeContractParameters({
     abi: zora721Abi,
@@ -3727,6 +3817,29 @@ function makePrepareMint721TokenParams({
     ]
   });
 }
+function makeFixedPriceMinterArguments({
+  mintTo,
+  mintComment
+}) {
+  return (0, import_viem5.encodeAbiParameters)((0, import_viem5.parseAbiParameters)("address, string"), [
+    mintTo,
+    mintComment || ""
+  ]);
+}
+function makeAllowListMinterArguments({
+  mintTo,
+  allowListEntry
+}) {
+  return (0, import_viem5.encodeAbiParameters)(
+    (0, import_viem5.parseAbiParameters)("address, uint256, uint256, bytes32[]"),
+    [
+      mintTo,
+      BigInt(allowListEntry.maxCanMint),
+      allowListEntry.price,
+      allowListEntry.proof
+    ]
+  );
+}
 function makeEthMintCall({
   tokenContract,
   tokenId,
@@ -3735,17 +3848,25 @@ function makeEthMintCall({
   mintComment,
   mintReferral,
   mintQuantity,
-  mintTo
+  mintTo,
+  allowListEntry
 }) {
   const mintValue = parseMintCosts({
-    mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
     salesConfig: salesConfigAndTokenInfo.salesConfig,
-    quantityToMint: mintQuantity
+    quantityToMint: mintQuantity,
+    allowListEntry
   }).totalCostEth;
-  const minterArguments = (0, import_viem5.encodeAbiParameters)(
-    (0, import_viem5.parseAbiParameters)("address, string"),
-    [mintTo, mintComment || ""]
-  );
+  const saleType = salesConfigAndTokenInfo.salesConfig.saleType;
+  let minterArguments;
+  if (saleType === "fixedPrice") {
+    minterArguments = makeFixedPriceMinterArguments({ mintTo, mintComment });
+  } else if (saleType === "allowlist") {
+    if (!allowListEntry)
+      throw new Error("Missing allowListEntry");
+    minterArguments = makeAllowListMinterArguments({ mintTo, allowListEntry });
+  } else {
+    throw new Error("Unsupported sale type");
+  }
   if (contractSupportsNewMintFunction(salesConfigAndTokenInfo.contractVersion)) {
     return makeContractParameters({
       abi: import_protocol_deployments6.zoraCreator1155ImplABI,
@@ -3778,13 +3899,21 @@ function makeEthMintCall({
     ]
   });
 }
+function paidMintCost(salesConfig, allowListEntry) {
+  if (salesConfig.saleType === "erc20" || salesConfig.saleType === "fixedPrice") {
+    return salesConfig.pricePerToken;
+  }
+  if (allowListEntry)
+    return allowListEntry.price;
+  return 0n;
+}
 function parseMintCosts({
   salesConfig,
-  mintFeePerQuantity,
-  quantityToMint
+  quantityToMint,
+  allowListEntry
 }) {
-  const mintFeeForTokens = mintFeePerQuantity * quantityToMint;
-  const tokenPurchaseCost = BigInt(salesConfig.pricePerToken) * quantityToMint;
+  const mintFeeForTokens = salesConfig.mintFeePerQuantity * quantityToMint;
+  const tokenPurchaseCost = paidMintCost(salesConfig, allowListEntry) * quantityToMint;
   const totalPurchaseCostCurrency = isErc20SaleStrategy(salesConfig) ? salesConfig.currency : void 0;
   const totalPurchaseCostEth = totalPurchaseCostCurrency ? 0n : tokenPurchaseCost;
   return {
@@ -3796,7 +3925,6 @@ function parseMintCosts({
 }
 
 // src/mint/mint-queries.ts
-var import_viem6 = require("viem");
 async function getMint({
   params,
   mintGetter,
@@ -3806,10 +3934,12 @@ async function getMint({
   const { tokenContract } = params;
   if (isOnChainMint(params)) {
     const tokenId = is1155Mint(params) ? params.tokenId : void 0;
+    const blockTime = (await publicClient.getBlock()).timestamp;
     const result = await mintGetter.getMintable({
       tokenId,
       tokenAddress: tokenContract,
-      preferredSaleType: params.preferredSaleType
+      preferredSaleType: params.preferredSaleType,
+      blockTime
     });
     return toMintableReturn(result);
   }
@@ -3870,6 +4000,7 @@ async function getMintsOfContract({
 }
 async function getMintCosts({
   params,
+  allowListEntry,
   mintGetter,
   premintGetter,
   publicClient
@@ -3877,14 +4008,19 @@ async function getMintCosts({
   const { quantityMinted: quantityToMint, collection } = params;
   if (isOnChainMint(params)) {
     const tokenId = is1155Mint(params) ? params.tokenId : void 0;
+    const blockTime = (await publicClient.getBlock()).timestamp;
     const salesConfigAndTokenInfo = await mintGetter.getMintable({
       tokenId,
-      tokenAddress: collection
+      tokenAddress: collection,
+      blockTime
     });
+    if (!salesConfigAndTokenInfo.salesConfig) {
+      throw new Error("No valid sales config found for token");
+    }
     return parseMintCosts({
-      mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
       salesConfig: salesConfigAndTokenInfo.salesConfig,
-      quantityToMint: BigInt(quantityToMint)
+      quantityToMint: BigInt(quantityToMint),
+      allowListEntry
     });
   }
   return getPremintMintCostsWithUnknownTokenPrice({
@@ -3940,7 +4076,6 @@ function parsePremint({
     return {
       creator: premint.signer,
       maxSupply: premint.premint.premintConfig.tokenConfig.maxSupply,
-      mintFeePerQuantity: mintFee,
       mintType: "premint",
       uid: premint.premint.premintConfig.uid,
       contract: {
@@ -3954,21 +4089,30 @@ function parsePremint({
         duration: premint.premint.premintConfig.tokenConfig.mintDuration,
         maxTokensPerAddress: premint.premint.premintConfig.tokenConfig.maxTokensPerAddress,
         pricePerToken: premint.premint.premintConfig.tokenConfig.pricePerToken,
-        saleType: "premint"
+        saleType: "premint",
+        mintFeePerQuantity: mintFee
       }
     };
   }
   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
-  })
-});
+var makeOnchainPrepareMint = (result) => (params) => {
+  if (!result.salesConfig) {
+    throw new Error("No valid sales config found for token");
+  }
+  return {
+    parameters: makeOnchainMintCall({
+      token: result,
+      mintParams: params
+    }),
+    erc20Approval: getRequiredErc20Approvals(params, result),
+    costs: parseMintCosts({
+      salesConfig: result.salesConfig,
+      quantityToMint: BigInt(params.quantityToMint),
+      allowListEntry: params.allowListEntry
+    })
+  };
+};
 function toMintableReturn(result) {
   return { token: result, prepareMint: makeOnchainPrepareMint(result) };
 }
@@ -3979,9 +4123,9 @@ var makePremintPrepareMint = (mintable, mintFee, premint) => (params) => ({
     premint
   }),
   costs: parseMintCosts({
-    mintFeePerQuantity: mintFee,
     quantityToMint: BigInt(params.quantityToMint),
-    salesConfig: mintable.salesConfig
+    salesConfig: mintable.salesConfig,
+    allowListEntry: params.allowListEntry
   })
 });
 function toPremintMintReturn({
@@ -3995,7 +4139,7 @@ function toPremintMintReturn({
   };
 }
 function getRequiredErc20Approvals(params, result) {
-  if (result.salesConfig.saleType !== "erc20")
+  if (result.salesConfig?.saleType !== "erc20")
     return void 0;
   return {
     quantity: result.salesConfig.pricePerToken * BigInt(params.quantityToMint),
@@ -4101,27 +4245,10 @@ async function mint({
     mintReferral: parameters.mintReferral
   });
 }
-async function collectOnchain({
-  chainId,
-  mintGetter,
-  ...parameters
-}) {
-  const { tokenContract, preferredSaleType: saleType } = parameters;
-  const tokenId = is1155Mint(parameters) ? parameters.tokenId : void 0;
-  const salesConfigAndTokenInfo = await mintGetter.getMintable({
-    tokenId,
-    tokenAddress: tokenContract,
-    preferredSaleType: saleType
-  });
-  return makeOnchainMintCall({
-    mintParams: parameters,
-    token: salesConfigAndTokenInfo
-  });
-}
 
 // src/create/1155-create-helper.ts
-var import_protocol_deployments9 = require("@zoralabs/protocol-deployments");
-var import_viem8 = require("viem");
+var import_protocol_deployments10 = require("@zoralabs/protocol-deployments");
+var import_viem9 = require("viem");
 
 // src/create/contract-setup.ts
 var import_protocol_deployments7 = require("@zoralabs/protocol-deployments");
@@ -4151,8 +4278,14 @@ async function getContractInfoExistingContract({
     abi: import_protocol_deployments7.zoraCreator1155ImplABI,
     functionName: "nextTokenId"
   });
+  const contractName = await publicClient.readContract({
+    address: contractAddress,
+    abi: import_protocol_deployments7.zoraCreator1155ImplABI,
+    functionName: "name"
+  });
   return {
     contractVersion,
+    contractName,
     nextTokenId
   };
 }
@@ -4179,1917 +4312,2077 @@ async function getDeterministicContractAddress({
 }
 
 // src/create/token-setup.ts
-var import_protocol_deployments8 = require("@zoralabs/protocol-deployments");
-var import_viem7 = require("viem");
-var semver3 = __toESM(require_semver2(), 1);
-var PERMISSION_BITS = {
-  MINTER: 2n ** 2n
-};
-var saleSettingsOrDefault = (saleSettings) => {
-  const SALE_END_FOREVER = 18446744073709551615n;
-  const DEFAULT_SALE_SETTINGS = {
-    currency: import_viem7.zeroAddress,
-    // Free Mint
-    pricePerToken: 0n,
-    // Sale start time – defaults to beginning of unix time
-    saleStart: 0n,
-    // This is the end of uint64, plenty of time
-    saleEnd: SALE_END_FOREVER,
-    // 0 Here means no limit
-    maxTokensPerAddress: 0n
-  };
-  return {
-    ...DEFAULT_SALE_SETTINGS,
-    ...saleSettings
-  };
-};
-function applyNew1155Defaults(props, ownerAddress) {
-  const { payoutRecipient: fundsRecipient } = props;
-  const fundsRecipientOrOwner = fundsRecipient && fundsRecipient !== import_viem7.zeroAddress ? fundsRecipient : ownerAddress;
-  return {
-    payoutRecipient: fundsRecipientOrOwner,
-    createReferral: props.createReferral || import_viem7.zeroAddress,
-    maxSupply: typeof props.maxSupply === "undefined" ? OPEN_EDITION_MINT_SIZE : BigInt(props.maxSupply),
-    royaltyBPS: props.royaltyBPS || 1e3,
-    salesConfig: saleSettingsOrDefault(props.salesConfig),
-    tokenMetadataURI: props.tokenMetadataURI
-  };
+var import_protocol_deployments9 = require("@zoralabs/protocol-deployments");
+var import_viem8 = require("viem");
+var semver2 = __toESM(require_semver2(), 1);
+
+// src/ipfs/arweave.ts
+function isArweaveURL(url) {
+  return url && typeof url === "string" ? url.startsWith("ar://") : false;
 }
-function setupErc20Minter({
-  pricePerToken,
-  chainId,
-  tokenId: nextTokenId,
-  currency,
-  saleStart,
-  saleEnd,
-  maxTokensPerAddress: mintLimit,
-  fundsRecipient
-}) {
-  const erc20MinterAddress = import_protocol_deployments8.erc20MinterAddress[chainId];
-  if (!erc20MinterAddress)
-    throw new Error(`ERC20Minter not deployed on chainId ${chainId}`);
-  const erc20MinterApproval = (0, import_viem7.encodeFunctionData)({
-    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
-    functionName: "addPermission",
-    args: [BigInt(nextTokenId), erc20MinterAddress, PERMISSION_BITS.MINTER]
-  });
-  const saleData = (0, import_viem7.encodeFunctionData)({
-    abi: import_protocol_deployments8.erc20MinterABI,
-    functionName: "setSale",
-    args: [
-      BigInt(nextTokenId),
-      {
-        saleStart: saleStart || BigInt(0),
-        saleEnd: saleEnd || BigInt(0),
-        maxTokensPerAddress: BigInt(mintLimit || 0),
-        pricePerToken,
-        fundsRecipient,
-        currency
-      }
-    ]
-  });
-  const callSale = (0, import_viem7.encodeFunctionData)({
-    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
-    functionName: "callSale",
-    args: [BigInt(nextTokenId), erc20MinterAddress, saleData]
-  });
-  return {
-    minter: erc20MinterAddress,
-    setupActions: [erc20MinterApproval, callSale]
-  };
+
+// ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/bytes.js
+var empty = new Uint8Array(0);
+function 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;
 }
-function setupFixedPriceMinter({
-  pricePerToken: price,
-  tokenId: nextTokenId,
-  chainId,
-  saleStart,
-  saleEnd,
-  maxTokensPerAddress: mintLimit,
-  fundsRecipient
-}) {
-  const fixedPriceStrategyAddress = import_protocol_deployments8.zoraCreatorFixedPriceSaleStrategyAddress[chainId];
-  const fixedPriceApproval = (0, import_viem7.encodeFunctionData)({
-    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
-    functionName: "addPermission",
-    args: [
-      BigInt(nextTokenId),
-      fixedPriceStrategyAddress,
-      PERMISSION_BITS.MINTER
-    ]
-  });
-  const saleData = (0, import_viem7.encodeFunctionData)({
-    abi: import_protocol_deployments8.zoraCreatorFixedPriceSaleStrategyABI,
-    functionName: "setSale",
-    args: [
-      BigInt(nextTokenId),
-      {
-        pricePerToken: price,
-        saleStart: saleStart || BigInt(0),
-        saleEnd: saleEnd || BigInt(0),
-        maxTokensPerAddress: BigInt(mintLimit || 0),
-        fundsRecipient
-      }
-    ]
-  });
-  const callSale = (0, import_viem7.encodeFunctionData)({
-    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
-    functionName: "callSale",
-    args: [BigInt(nextTokenId), fixedPriceStrategyAddress, saleData]
-  });
-  return {
-    minter: fixedPriceStrategyAddress,
-    setupActions: [fixedPriceApproval, callSale]
-  };
-}
-function setupMinters({ salesConfig, ...rest }) {
-  if (!salesConfig)
-    throw new Error("No sales config for token");
-  const { currency: currencyAddress } = salesConfig;
-  if (currencyAddress === import_viem7.zeroAddress) {
-    return setupFixedPriceMinter({
-      ...salesConfig,
-      ...rest
-    });
-  } else {
-    return setupErc20Minter({
-      ...salesConfig,
-      ...rest
-    });
-  }
-}
-function buildSetupNewToken({
-  tokenURI,
-  maxSupply = OPEN_EDITION_MINT_SIZE,
-  createReferral = import_viem7.zeroAddress,
-  contractVersion
-}) {
-  if (contractSupportsMintRewards(contractVersion, "ERC1155")) {
-    return (0, import_viem7.encodeFunctionData)({
-      abi: import_protocol_deployments8.zoraCreator1155ImplABI,
-      functionName: "setupNewTokenWithCreateReferral",
-      args: [tokenURI, BigInt(maxSupply), createReferral]
-    });
-  }
-  if (createReferral !== import_viem7.zeroAddress) {
-    throw new Error(
-      "Contract does not support create referral, but one was provided"
-    );
-  }
-  return (0, import_viem7.encodeFunctionData)({
-    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
-    functionName: "setupNewToken",
-    args: [tokenURI, BigInt(maxSupply)]
-  });
-}
-function setupRoyaltyConfig({
-  royaltyBPS,
-  royaltyRecipient,
-  nextTokenId
-}) {
-  if (royaltyBPS > 0 && royaltyRecipient != import_viem7.zeroAddress) {
-    return (0, import_viem7.encodeFunctionData)({
-      abi: import_protocol_deployments8.zoraCreator1155ImplABI,
-      functionName: "updateRoyaltiesForToken",
-      args: [
-        nextTokenId,
-        {
-          royaltyBPS,
-          royaltyRecipient,
-          royaltyMintSchedule: 0
-        }
-      ]
-    });
-  }
-  return null;
-}
-function makeAdminMintCall({
-  ownerAddress,
-  mintQuantity,
-  nextTokenId
-}) {
-  if (!mintQuantity || mintQuantity <= 0 || !ownerAddress) {
-    return null;
+function coerce2(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);
   }
-  return (0, import_viem7.encodeFunctionData)({
-    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
-    functionName: "adminMint",
-    args: [ownerAddress, nextTokenId, BigInt(mintQuantity), import_viem7.zeroAddress]
-  });
-}
-function constructCreate1155TokenCalls(props) {
-  const {
-    chainId,
-    nextTokenId,
-    mintToCreatorCount,
-    ownerAddress,
-    contractVersion
-  } = props;
-  const new1155TokenPropsWithDefaults = applyNew1155Defaults(
-    props,
-    ownerAddress
-  );
-  const verifyTokenIdExpected = (0, import_viem7.encodeFunctionData)({
-    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
-    functionName: "assumeLastTokenIdMatches",
-    args: [nextTokenId - 1n]
-  });
-  const setupNewToken = buildSetupNewToken({
-    tokenURI: new1155TokenPropsWithDefaults.tokenMetadataURI,
-    maxSupply: new1155TokenPropsWithDefaults.maxSupply,
-    createReferral: new1155TokenPropsWithDefaults.createReferral,
-    contractVersion
-  });
-  const royaltyConfig = setupRoyaltyConfig({
-    royaltyBPS: new1155TokenPropsWithDefaults.royaltyBPS,
-    royaltyRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
-    nextTokenId
-  });
-  const { minter, setupActions: mintersSetup } = setupMinters({
-    tokenId: nextTokenId,
-    chainId,
-    fundsRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
-    salesConfig: new1155TokenPropsWithDefaults.salesConfig
-  });
-  const adminMintCall = makeAdminMintCall({
-    ownerAddress,
-    mintQuantity: mintToCreatorCount,
-    nextTokenId
-  });
-  const setupActions = [
-    verifyTokenIdExpected,
-    setupNewToken,
-    ...mintersSetup,
-    royaltyConfig,
-    adminMintCall
-  ].filter((item) => item !== null);
-  return {
-    setupActions,
-    minter,
-    newToken: new1155TokenPropsWithDefaults
-  };
+  throw new Error("Unknown type, must be binary type");
 }
-var contractSupportsMintRewards = (contractVersion, contractStandard) => {
-  if (!contractStandard || !contractVersion) {
-    return false;
+
+// ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/vendor/base-x.js
+function base2(ALPHABET, name) {
+  if (ALPHABET.length >= 255) {
+    throw new TypeError("Alphabet too long");
   }
-  const semVerContractVersion = semver3.coerce(contractVersion)?.raw;
-  if (!semVerContractVersion)
-    return false;
-  if (contractStandard === "ERC1155") {
-    return semver3.gte(semVerContractVersion, "1.3.5");
-  } else {
-    return semver3.gte(semVerContractVersion, "14.0.0");
+  var BASE_MAP = new Uint8Array(256);
+  for (var j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
   }
-};
-
-// src/create/1155-create-helper.ts
-var ROYALTY_BPS_DEFAULT = 1e3;
-var getTokenIdFromCreateReceipt = (receipt) => {
-  for (const data of receipt.logs) {
-    try {
-      const decodedLog = (0, import_viem8.decodeEventLog)({
-        abi: import_protocol_deployments9.zoraCreator1155ImplABI,
-        eventName: "SetupNewToken",
-        ...data
-      });
-      if (decodedLog && decodedLog.eventName === "SetupNewToken") {
-        return decodedLog.args.tokenId;
-      }
-    } catch (err) {
+  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;
   }
-  throw new Error(
-    "No event found in receipt that could be used to get tokenId"
-  );
-};
-var getContractAddressFromReceipt = (receipt) => {
-  for (const data of receipt.logs) {
-    try {
-      const decodedLog = (0, import_viem8.decodeEventLog)({
-        abi: import_protocol_deployments9.zoraCreator1155FactoryImplABI,
-        eventName: "SetupNewContract",
-        ...data
-      });
-      if (decodedLog && decodedLog.eventName === "SetupNewContract") {
-        return decodedLog.args.newContract;
+  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;
       }
-    } catch (err) {
+      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;
   }
-  throw new Error(
-    "No event found in receipt that could be used to get contract address"
-  );
-};
-function makeCreateContractAndTokenCall({
-  account,
-  contract,
-  royaltyBPS,
-  fundsRecipient,
-  tokenSetupActions,
-  chainId
-}) {
-  const accountAddress = typeof account === "string" ? account : account.address;
-  return makeContractParameters({
-    abi: import_protocol_deployments9.zoraCreator1155FactoryImplABI,
-    functionName: "createContractDeterministic",
-    account,
-    address: import_protocol_deployments9.zoraCreator1155FactoryImplAddress[chainId],
-    args: [
-      contract.uri,
-      contract.name,
-      {
-        // deprecated
-        royaltyMintSchedule: 0,
-        royaltyBPS: royaltyBPS || ROYALTY_BPS_DEFAULT,
-        royaltyRecipient: fundsRecipient || accountAddress
-      },
-      contract.defaultAdmin || accountAddress,
-      tokenSetupActions
-    ]
-  });
+  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
+  };
 }
-function makeCreateTokenCall({
-  contractAddress,
-  account,
-  tokenSetupActions
-}) {
-  return makeContractParameters({
-    abi: import_protocol_deployments9.zoraCreator1155ImplABI,
-    functionName: "multicall",
-    account,
-    address: contractAddress,
-    args: [tokenSetupActions]
+var src = base2;
+var _brrp__multiformats_scope_baseX = src;
+var base_x_default = _brrp__multiformats_scope_baseX;
+
+// ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/bases/base.js
+var Encoder = class {
+  constructor(name, prefix, baseEncode) {
+    __publicField(this, "name");
+    __publicField(this, "prefix");
+    __publicField(this, "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) {
+    __publicField(this, "name");
+    __publicField(this, "prefix");
+    __publicField(this, "baseDecode");
+    __publicField(this, "prefixCodePoint");
+    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) {
+    __publicField(this, "decoders");
+    this.decoders = decoders;
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+  decode(input) {
+    const prefix = input[0];
+    const decoder = this.decoders[prefix];
+    if (decoder != null) {
+      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`);
+    }
+  }
+};
+function or(left, right) {
+  return new ComposedDecoder({
+    ...left.decoders ?? { [left.prefix]: left },
+    ...right.decoders ?? { [right.prefix]: right }
   });
 }
-var Create1155Client = class {
-  constructor({
-    chainId,
-    publicClient
-  }) {
-    this.chainId = chainId;
-    this.publicClient = publicClient;
+var Codec = class {
+  constructor(name, prefix, baseEncode, baseDecode) {
+    __publicField(this, "name");
+    __publicField(this, "prefix");
+    __publicField(this, "baseEncode");
+    __publicField(this, "baseDecode");
+    __publicField(this, "encoder");
+    __publicField(this, "decoder");
+    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);
   }
-  async createNew1155(props) {
-    return createNew1155ContractAndToken({
-      ...props,
-      publicClient: this.publicClient,
-      chainId: this.chainId
-    });
+  encode(input) {
+    return this.encoder.encode(input);
   }
-  async createNew1155OnExistingContract({
-    contractAddress: contract,
-    account,
-    token,
-    getAdditionalSetupActions
-  }) {
-    return createNew1155Token({
-      contractAddress: contract,
-      account,
-      token,
-      getAdditionalSetupActions,
-      publicClient: this.publicClient,
-      chainId: this.chainId
-    });
+  decode(input) {
+    return this.decoder.decode(input);
   }
 };
-async function createNew1155ContractAndToken({
-  contract,
-  account,
-  chainId,
-  token,
-  publicClient,
-  getAdditionalSetupActions
-}) {
-  const nextTokenId = 1n;
-  const contractVersion = new1155ContractVersion(chainId);
-  const {
-    minter,
-    newToken,
-    setupActions: tokenSetupActions
-  } = prepareSetupActions({
-    chainId,
-    account,
-    contractVersion,
-    nextTokenId,
-    token,
-    getAdditionalSetupActions
-  });
-  const request = makeCreateContractAndTokenCall({
-    contract,
-    account,
-    chainId,
-    tokenSetupActions,
-    fundsRecipient: token.payoutRecipient,
-    royaltyBPS: token.royaltyBPS
-  });
-  const contractAddress = await getDeterministicContractAddress({
-    account,
-    publicClient,
-    setupActions: tokenSetupActions,
-    chainId,
-    contract
+function from({ name, prefix, encode: encode3, decode: decode5 }) {
+  return new Codec(name, prefix, encode3, decode5);
+}
+function baseX({ name, prefix, alphabet }) {
+  const { encode: encode3, decode: decode5 } = base_x_default(alphabet, name);
+  return from({
+    prefix,
+    name,
+    encode: encode3,
+    decode: (text) => coerce2(decode5(text))
   });
-  return {
-    parameters: request,
-    tokenSetupActions,
-    newTokenId: nextTokenId,
-    newToken,
-    contractAddress,
-    contractVersion,
-    minter
-  };
-}
-async function createNew1155Token({
-  contractAddress,
-  account,
-  getAdditionalSetupActions,
-  token,
-  publicClient,
-  chainId
-}) {
-  const { nextTokenId, contractVersion } = await getContractInfoExistingContract({
-    publicClient,
-    contractAddress
-  });
-  const {
-    minter,
-    newToken,
-    setupActions: tokenSetupActions
-  } = prepareSetupActions({
-    chainId,
-    account,
-    contractVersion,
-    nextTokenId,
-    token,
-    getAdditionalSetupActions
-  });
-  const request = makeCreateTokenCall({
-    contractAddress,
-    account,
-    tokenSetupActions
-  });
-  return {
-    parameters: request,
-    tokenSetupActions,
-    newTokenId: nextTokenId,
-    newToken,
-    contractVersion,
-    minter
-  };
-}
-function prepareSetupActions({
-  chainId,
-  account,
-  contractVersion,
-  nextTokenId,
-  token,
-  getAdditionalSetupActions
-}) {
-  const {
-    minter,
-    newToken,
-    setupActions: tokenSetupActions
-  } = constructCreate1155TokenCalls({
-    chainId,
-    ownerAddress: account,
-    contractVersion,
-    nextTokenId,
-    ...token
-  });
-  const setupActions = getAdditionalSetupActions ? [
-    ...getAdditionalSetupActions({
-      tokenId: nextTokenId
-    }),
-    ...tokenSetupActions
-  ] : tokenSetupActions;
-  return { minter, newToken, setupActions };
 }
-
-// src/sparks/mints-queries.ts
-var getMintsAccountBalanceWithPriceQuery = (account) => {
-  const query = `
-    query GetMintAccountBalances($account: String!) {
-      mintAccountBalances(where: { account: $account }) {
-        balance
-        mintToken {
-          id
-          pricePerToken
-        }
-      }
+function decode(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`);
     }
-  `;
-  return {
-    query,
-    variables: { account }
-  };
-};
-var selectMintsToCollectWithFromQueryResult = (mintAccountBalances, quantityToCollect) => {
-  const parsed = mintAccountBalances.map((r) => {
-    return {
-      tokenId: BigInt(r.mintToken.id),
-      quantity: BigInt(r.balance),
-      pricePerToken: BigInt(r.mintToken.pricePerToken)
-    };
-  });
-  const sorted = parsed.sort((a, b) => {
-    if (a.pricePerToken < b.pricePerToken) {
-      return -1;
+    buffer = buffer << bitsPerChar | value;
+    bits += bitsPerChar;
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 255 & buffer >> bits;
     }
-    return 1;
-  });
-  let remainingQuantity = quantityToCollect;
-  const tokenIds = [];
-  const quantities = [];
-  while (remainingQuantity > 0) {
-    const next = sorted.shift();
-    if (!next) {
-      throw new Error("Not enough MINTs to collect with");
+  }
+  if (bits >= bitsPerChar || (255 & buffer << 8 - bits) !== 0) {
+    throw new SyntaxError("Unexpected end of data");
+  }
+  return out;
+}
+function encode(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];
     }
-    const quantityToUse = remainingQuantity > next.quantity ? next.quantity : remainingQuantity;
-    tokenIds.push(next.tokenId);
-    quantities.push(quantityToUse);
-    remainingQuantity -= quantityToUse;
   }
-  return {
-    tokenIds,
-    quantities
-  };
-};
-var sumBalances = (mintAccountBalances) => {
-  return mintAccountBalances.reduce((acc, curr) => {
-    return acc + BigInt(curr.balance);
-  }, BigInt(0));
-};
+  if (bits !== 0) {
+    out += alphabet[mask & buffer << bitsPerChar - bits];
+  }
+  if (pad) {
+    while ((out.length * bitsPerChar & 7) !== 0) {
+      out += "=";
+    }
+  }
+  return out;
+}
+function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
+  return from({
+    prefix,
+    name,
+    encode(input) {
+      return encode(input, alphabet, bitsPerChar);
+    },
+    decode(input) {
+      return decode(input, alphabet, bitsPerChar, name);
+    }
+  });
+}
 
-// src/sparks/sparks-contracts.ts
-var import_protocol_deployments10 = require("@zoralabs/protocol-deployments");
-var import_viem9 = require("viem");
-var addressOrAccountAddress = (address) => typeof address === "string" ? address : address.address;
-var mintWithEthParams = ({
-  tokenId,
-  quantity,
-  recipient,
-  chainId,
-  pricePerMint,
-  account
-}) => makeContractParameters({
-  abi: import_protocol_deployments10.zoraSparksManagerImplABI,
-  address: import_protocol_deployments10.zoraSparksManagerImplAddress[chainId],
-  functionName: "mintWithEth",
-  args: [tokenId, quantity, recipient || addressOrAccountAddress(account)],
-  value: pricePerMint * quantity,
-  account
+// ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/bases/base32.js
+var base32 = rfc4648({
+  prefix: "b",
+  name: "base32",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567",
+  bitsPerChar: 5
 });
-var getPaidMintValue = (quantities, pricePerMint) => {
-  if (!pricePerMint || pricePerMint === 0n)
-    return;
-  return quantities.reduce((a, b) => a + b, 0n) * pricePerMint;
-};
-var mintsBalanceOfAccountParams = ({
-  account,
-  chainId
-}) => ({
-  abi: import_protocol_deployments10.zoraMints1155Config.abi,
-  address: import_protocol_deployments10.zoraMints1155Config.address[chainId],
-  functionName: "balanceOfAccount",
-  args: [account]
+var base32upper = rfc4648({
+  prefix: "B",
+  name: "base32upper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+  bitsPerChar: 5
 });
-var encodeCollectOnManager = ({
-  zoraCreator1155Contract,
-  minter,
-  zoraCreator1155TokenId,
-  mintArguments
-}) => (0, import_viem9.encodeFunctionData)({
-  abi: import_protocol_deployments10.zoraMintsManagerImplConfig.abi,
-  functionName: "collect",
-  args: [
-    zoraCreator1155Contract,
-    minter,
-    zoraCreator1155TokenId,
-    mintArguments
-  ]
+var base32pad = rfc4648({
+  prefix: "c",
+  name: "base32pad",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
+  bitsPerChar: 5
 });
-function collectWithMintsParams({
-  tokenIds,
-  quantities,
-  chainId,
-  paidMintPricePerToken,
-  account,
-  mintArguments,
-  minter,
-  zoraCreator1155Contract,
-  zoraCreator1155TokenId
-}) {
-  const call = encodeCollectOnManager({
-    tokenIds,
-    quantities,
-    zoraCreator1155Contract,
-    zoraCreator1155TokenId,
-    minter,
-    mintArguments
-  });
-  return makeContractParameters({
-    abi: import_protocol_deployments10.zoraMints1155Config.abi,
-    address: import_protocol_deployments10.zoraMints1155Config.address[chainId],
-    functionName: "transferBatchToManagerAndCall",
-    args: [tokenIds, quantities, call],
-    // if it is a paid mint, the aadditional value will be sent to the manager contract and forwarded to the creator 1155 contract
-    // for the paid mint cost.
-    value: getPaidMintValue(quantities, paidMintPricePerToken),
-    account
-  });
-}
-function getMintsEthPrice({
-  publicClient
-}) {
-  const chainId = publicClient.chain?.id;
-  if (!chainId || !import_protocol_deployments10.zoraMintsManagerImplAddress[chainId]) {
-    throw new Error(`Chain id ${chainId} not supported`);
-  }
-  return publicClient.readContract({
-    abi: import_protocol_deployments10.zoraMintsManagerImplABI,
-    address: import_protocol_deployments10.zoraMintsManagerImplAddress[chainId],
-    functionName: "getEthPrice"
-  });
-}
-function makePermitTransferBatchAndTypeData({
-  tokenIds,
-  quantities,
-  chainId,
-  mintsOwner,
-  to,
-  nonce,
-  deadline,
-  safeTransferData
-}) {
-  const permit = {
-    owner: typeof mintsOwner === "string" ? mintsOwner : mintsOwner.address,
-    to,
-    tokenIds,
-    quantities,
-    deadline,
-    nonce,
-    safeTransferData
-  };
-  const typedData = {
-    ...(0, import_protocol_deployments10.mintsSafeTransferBatchTypedDataDefinition)({
-      chainId,
-      message: permit
-    }),
-    account: mintsOwner
-  };
-  return {
-    permit,
-    typedData
-  };
-}
-function makePermitTransferTypeData({
-  tokenId,
-  quantity,
-  chainId,
-  mintsOwner,
-  to,
-  nonce,
-  deadline,
-  safeTransferData
-}) {
-  const permit = {
-    owner: typeof mintsOwner === "string" ? mintsOwner : mintsOwner.address,
-    to,
-    tokenId,
-    quantity,
-    deadline,
-    nonce,
-    safeTransferData
-  };
-  const typedData = {
-    ...(0, import_protocol_deployments10.mintsSafeTransferTypedDataDefinition)({
-      chainId,
-      message: permit
-    }),
-    account: mintsOwner
-  };
-  return {
-    permit,
-    typedData
-  };
-}
-var encodePremintOnManager = ({
-  contractCreationConfig,
-  premintConfig,
-  premintSignature,
-  mintArguments,
-  signerContract = import_viem9.zeroAddress
-}) => (0, import_viem9.encodeFunctionData)({
-  abi: import_protocol_deployments10.zoraMintsManagerImplConfig.abi,
-  functionName: "collectPremintV2",
-  args: [
-    contractCreationConfig,
-    premintConfig,
-    premintSignature,
-    mintArguments,
-    signerContract
-  ]
+var base32padupper = rfc4648({
+  prefix: "C",
+  name: "base32padupper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
+  bitsPerChar: 5
 });
-var makePermitToCollectPremintOrNonPremint = ({
-  mintsOwner,
-  chainId,
-  deadline,
-  tokenIds,
-  // this quantity of MINTs will be used to collect premint
-  // and will be burned.  This same quantity is the quantity of
-  // premint to collect.
-  quantities,
-  nonce,
-  premint,
-  collect
-}) => {
-  let safeTransferData;
-  if (premint) {
-    safeTransferData = encodePremintOnManager(premint);
-  } else if (collect) {
-    safeTransferData = encodeCollectOnManager(collect);
-  } else {
-    throw new Error("Invalid operation");
+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/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/bases/base58.js
+var base58btc = baseX({
+  name: "base58btc",
+  prefix: "z",
+  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+});
+var base58flickr = baseX({
+  name: "base58flickr",
+  prefix: "Z",
+  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+});
+
+// ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/vendor/varint.js
+var encode_1 = encode2;
+var MSB = 128;
+var REST = 127;
+var MSBALL = ~REST;
+var INT = Math.pow(2, 31);
+function encode2(num, out, offset) {
+  out = out || [];
+  offset = offset || 0;
+  var oldOffset = offset;
+  while (num >= INT) {
+    out[offset++] = num & 255 | MSB;
+    num /= 128;
   }
-  return makePermitTransferBatchAndTypeData({
-    tokenIds,
-    quantities,
-    chainId,
-    mintsOwner,
-    nonce,
-    deadline,
-    safeTransferData,
-    to: import_protocol_deployments10.zoraMintsManagerImplConfig.address[chainId]
-  });
-};
-function collectPremintV2WithMintsParams({
-  tokenIds,
-  quantities,
-  paidMintPricePerToken,
-  account,
-  chainId,
-  ...rest
-}) {
-  const call = encodePremintOnManager({
-    ...rest
-  });
-  return makeContractParameters({
-    abi: import_protocol_deployments10.zoraMints1155Config.abi,
-    address: import_protocol_deployments10.zoraMints1155Config.address[chainId],
-    functionName: "transferBatchToManagerAndCall",
-    args: [tokenIds, quantities, call],
-    value: getPaidMintValue(quantities, paidMintPricePerToken),
-    account
-  });
+  while (num & MSBALL) {
+    out[offset++] = num & 255 | MSB;
+    num >>>= 7;
+  }
+  out[offset] = num | 0;
+  encode2.bytes = offset - oldOffset + 1;
+  return out;
 }
-function decodeCallFailedError(error) {
-  if (error.data?.errorName !== "CallFailed")
-    throw new Error("Not a CallFailed error");
-  const internalErrorData = error.data?.args?.[0];
-  return (0, import_viem9.decodeErrorResult)({
-    abi: import_protocol_deployments10.zoraMintsManagerImplABI,
-    data: internalErrorData
-  });
+var decode2 = 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: decode2,
+  encodingLength: length
+};
+var _brrp_varint = varint;
+var varint_default = _brrp_varint;
 
-// 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.createNew1155(p),
-    create1155OnExistingContract: (p) => create1155CreatorClient.createNew1155OnExistingContract(p)
-  };
+// ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/varint.js
+function decode3(data, offset = 0) {
+  const code = varint_default.decode(data, offset);
+  return [code, varint_default.decode.bytes];
 }
-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)
-  };
+function encodeTo(int, target, offset = 0) {
+  varint_default.encode(int, target, offset);
+  return target;
 }
-
-// src/ipfs/arweave.ts
-function isArweaveURL(url) {
-  return url && typeof url === "string" ? url.startsWith("ar://") : false;
+function encodingLength(int) {
+  return varint_default.encodingLength(int);
 }
 
-// ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/bytes.js
-var empty = new Uint8Array(0);
-function 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;
-    }
+// ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/hashes/digest.js
+function 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);
+}
+function decode4(multihash) {
+  const bytes = coerce2(multihash);
+  const [code, sizeOffset] = decode3(bytes);
+  const [size, digestOffset] = decode3(bytes.subarray(sizeOffset));
+  const digest = bytes.subarray(sizeOffset + digestOffset);
+  if (digest.byteLength !== size) {
+    throw new Error("Incorrect length");
   }
-  return true;
+  return new Digest(code, size, digest, bytes);
 }
-function coerce4(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);
+function equals2(a, b) {
+  if (a === b) {
+    return true;
+  } else {
+    const data = b;
+    return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals(a.bytes, data.bytes);
   }
-  throw new Error("Unknown type, must be binary type");
 }
-
-// ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/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;
+var Digest = class {
+  /**
+   * Creates a multihash digest.
+   */
+  constructor(code, size, digest, bytes) {
+    __publicField(this, "code");
+    __publicField(this, "size");
+    __publicField(this, "digest");
+    __publicField(this, "bytes");
+    this.code = code;
+    this.size = size;
+    this.digest = digest;
+    this.bytes = bytes;
   }
-  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;
+};
+
+// ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/cid.js
+function format(link, base3) {
+  const { bytes, version } = link;
+  switch (version) {
+    case 0:
+      return toStringV0(bytes, baseCache(link), base3 ?? base58btc.encoder);
+    default:
+      return toStringV1(bytes, baseCache(link), base3 ?? base32.encoder);
   }
-  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;
+}
+var cache = /* @__PURE__ */ new WeakMap();
+function baseCache(cid) {
+  const baseCache2 = cache.get(cid);
+  if (baseCache2 == null) {
+    const baseCache3 = /* @__PURE__ */ new Map();
+    cache.set(cid, baseCache3);
+    return baseCache3;
   }
-  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;
+  return baseCache2;
+}
+var _a;
+var CID = class _CID {
+  /**
+   * @param version - Version of the CID
+   * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+   * @param multihash - (Multi)hash of the of the content.
+   */
+  constructor(version, code, multihash, bytes) {
+    __publicField(this, "code");
+    __publicField(this, "version");
+    __publicField(this, "multihash");
+    __publicField(this, "bytes");
+    __publicField(this, "/");
+    __publicField(this, _a, "CID");
+    this.code = code;
+    this.version = version;
+    this.multihash = multihash;
+    this.bytes = bytes;
+    this["/"] = bytes;
   }
-  function decode5(string) {
-    var buffer = decodeUnsafe(string);
-    if (buffer) {
-      return buffer;
-    }
-    throw new Error(`Non-${name} character`);
+  /**
+   * Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`
+   * please either use `CID.asCID(cid)` or switch to new signalling mechanism
+   *
+   * @deprecated
+   */
+  get asCID() {
+    return this;
   }
-  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/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/bases/base.js
-var Encoder = class {
-  constructor(name, prefix, baseEncode) {
-    __publicField(this, "name");
-    __publicField(this, "prefix");
-    __publicField(this, "baseEncode");
-    this.name = name;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
+  // ArrayBufferView
+  get byteOffset() {
+    return this.bytes.byteOffset;
   }
-  encode(bytes) {
-    if (bytes instanceof Uint8Array) {
-      return `${this.prefix}${this.baseEncode(bytes)}`;
-    } else {
-      throw Error("Unknown type, must be binary type");
-    }
+  // ArrayBufferView
+  get byteLength() {
+    return this.bytes.byteLength;
   }
-};
-var Decoder = class {
-  constructor(name, prefix, baseDecode) {
-    __publicField(this, "name");
-    __publicField(this, "prefix");
-    __publicField(this, "baseDecode");
-    __publicField(this, "prefixCodePoint");
-    this.name = name;
-    this.prefix = prefix;
-    if (prefix.codePointAt(0) === void 0) {
-      throw new Error("Invalid prefix character");
+  toV0() {
+    switch (this.version) {
+      case 0: {
+        return this;
+      }
+      case 1: {
+        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);
+      }
+      default: {
+        throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
+      }
     }
-    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}`);
+  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 1. This is a bug please report`);
       }
-      return this.baseDecode(text.slice(this.prefix.length));
-    } else {
-      throw Error("Can only multibase decode strings");
     }
   }
-  or(decoder) {
-    return or(this, decoder);
+  equals(other) {
+    return _CID.equals(this, other);
   }
-};
-var ComposedDecoder = class {
-  constructor(decoders) {
-    __publicField(this, "decoders");
-    this.decoders = decoders;
+  static equals(self, other) {
+    const unknown = other;
+    return unknown != null && self.code === unknown.code && self.version === unknown.version && equals2(self.multihash, unknown.multihash);
   }
-  or(decoder) {
-    return or(this, decoder);
+  toString(base3) {
+    return format(this, base3);
   }
-  decode(input) {
-    const prefix = input[0];
-    const decoder = this.decoders[prefix];
-    if (decoder != null) {
-      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`);
-    }
+  toJSON() {
+    return { "/": format(this) };
   }
-};
-function or(left, right) {
-  return new ComposedDecoder({
-    ...left.decoders ?? { [left.prefix]: left },
-    ...right.decoders ?? { [right.prefix]: right }
-  });
-}
-var Codec = class {
-  constructor(name, prefix, baseEncode, baseDecode) {
-    __publicField(this, "name");
-    __publicField(this, "prefix");
-    __publicField(this, "baseEncode");
-    __publicField(this, "baseDecode");
-    __publicField(this, "encoder");
-    __publicField(this, "decoder");
-    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);
+  link() {
+    return this;
   }
-  encode(input) {
-    return this.encoder.encode(input);
+  // Legacy
+  [(_a = Symbol.toStringTag, Symbol.for("nodejs.util.inspect.custom"))]() {
+    return `CID(${this.toString()})`;
   }
-  decode(input) {
-    return this.decoder.decode(input);
+  /**
+   * Takes any input `value` and returns a `CID` instance if it was
+   * a `CID` otherwise returns `null`. If `value` is instanceof `CID`
+   * it will return value back. If `value` is not instance of this CID
+   * class, but is compatible CID it will return new instance of this
+   * `CID` class. Otherwise returns null.
+   *
+   * This allows two different incompatible versions of CID library to
+   * co-exist and interop as long as binary interface is compatible.
+   */
+  static asCID(input) {
+    if (input == null) {
+      return null;
+    }
+    const value = input;
+    if (value instanceof _CID) {
+      return value;
+    } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
+      const { version, code, multihash, bytes } = value;
+      return new _CID(version, code, multihash, bytes ?? encodeCID(version, code, multihash.bytes));
+    } else if (value[cidSymbol] === true) {
+      const { version, multihash, code } = value;
+      const digest = decode4(multihash);
+      return _CID.create(version, code, digest);
+    } else {
+      return null;
+    }
   }
-};
-function from({ name, prefix, encode: encode3, decode: decode5 }) {
-  return new Codec(name, prefix, encode3, decode5);
-}
-function baseX({ name, prefix, alphabet }) {
-  const { encode: encode3, decode: decode5 } = base_x_default(alphabet, name);
-  return from({
-    prefix,
-    name,
-    encode: encode3,
-    decode: (text) => coerce4(decode5(text))
-  });
-}
-function decode(string, alphabet, bitsPerChar, name) {
-  const codes = {};
-  for (let i = 0; i < alphabet.length; ++i) {
-    codes[alphabet[i]] = i;
+  /**
+   * @param version - Version of the CID
+   * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+   * @param digest - (Multi)hash of the of the content.
+   */
+  static create(version, code, digest) {
+    if (typeof code !== "number") {
+      throw new Error("String codecs are no longer supported");
+    }
+    if (!(digest.bytes instanceof Uint8Array)) {
+      throw new Error("Invalid digest");
+    }
+    switch (version) {
+      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(version, code, digest, digest.bytes);
+        }
+      }
+      case 1: {
+        const bytes = encodeCID(version, code, digest.bytes);
+        return new _CID(version, code, digest, bytes);
+      }
+      default: {
+        throw new Error("Invalid version");
+      }
+    }
   }
-  let end = string.length;
-  while (string[end - 1] === "=") {
-    --end;
+  /**
+   * Simplified version of `create` for CIDv0.
+   */
+  static createV0(digest) {
+    return _CID.create(0, DAG_PB_CODE, digest);
   }
-  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;
+  /**
+   * Simplified version of `create` for CIDv1.
+   *
+   * @param code - Content encoding format code.
+   * @param digest - Multihash of the content.
+   */
+  static createV1(code, digest) {
+    return _CID.create(1, code, digest);
+  }
+  /**
+   * Decoded a CID from its binary representation. The byte array must contain
+   * only the CID with no additional bytes.
+   *
+   * An error will be thrown if the bytes provided do not contain a valid
+   * binary representation of a CID.
+   */
+  static decode(bytes) {
+    const [cid, remainder] = _CID.decodeFirst(bytes);
+    if (remainder.length !== 0) {
+      throw new Error("Incorrect length");
     }
+    return cid;
   }
-  if (bits >= bitsPerChar || (255 & buffer << 8 - bits) !== 0) {
-    throw new SyntaxError("Unexpected end of data");
+  /**
+   * Decoded a CID from its binary representation at the beginning of a byte
+   * array.
+   *
+   * Returns an array with the first element containing the CID and the second
+   * element containing the remainder of the original byte array. The remainder
+   * will be a zero-length byte array if the provided bytes only contained a
+   * binary CID representation.
+   */
+  static decodeFirst(bytes) {
+    const specs = _CID.inspectBytes(bytes);
+    const prefixSize = specs.size - specs.multihashSize;
+    const multihashBytes = coerce2(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)];
   }
-  return out;
-}
-function encode(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];
+  /**
+   * Inspect the initial bytes of a CID to determine its properties.
+   *
+   * Involves decoding up to 4 varints. Typically this will require only 4 to 6
+   * bytes but for larger multicodec code values and larger multihash digest
+   * lengths these varints can be quite large. It is recommended that at least
+   * 10 bytes be made available in the `initialBytes` argument for a complete
+   * inspection.
+   */
+  static inspectBytes(initialBytes) {
+    let offset = 0;
+    const next = () => {
+      const [i, length2] = decode3(initialBytes.subarray(offset));
+      offset += length2;
+      return i;
+    };
+    let version = next();
+    let codec = DAG_PB_CODE;
+    if (version === 18) {
+      version = 0;
+      offset = 0;
+    } else {
+      codec = next();
+    }
+    if (version !== 0 && version !== 1) {
+      throw new RangeError(`Invalid CID version ${version}`);
     }
+    const prefixSize = offset;
+    const multihashCode = next();
+    const digestSize = next();
+    const size = offset + digestSize;
+    const multihashSize = size - prefixSize;
+    return { version, codec, multihashCode, digestSize, multihashSize, size };
   }
-  if (bits !== 0) {
-    out += alphabet[mask & buffer << bitsPerChar - bits];
-  }
-  if (pad) {
-    while ((out.length * bitsPerChar & 7) !== 0) {
-      out += "=";
+  /**
+   * Takes cid in a string representation and creates an instance. If `base`
+   * decoder is not provided will use a default from the configuration. It will
+   * throw an error if encoding of the CID is not compatible with supplied (or
+   * a default decoder).
+   */
+  static parse(source, base3) {
+    const [prefix, bytes] = parseCIDtoBytes(source, base3);
+    const cid = _CID.decode(bytes);
+    if (cid.version === 0 && source[0] !== "Q") {
+      throw Error("Version 0 CID string must not include multibase prefix");
     }
+    baseCache(cid).set(prefix, source);
+    return cid;
   }
-  return out;
-}
-function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
-  return from({
-    prefix,
-    name,
-    encode(input) {
-      return encode(input, alphabet, bitsPerChar);
-    },
-    decode(input) {
-      return decode(input, alphabet, bitsPerChar, name);
+};
+function 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)];
+    }
+  }
 }
-
-// ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/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/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/bases/base58.js
-var base58btc = baseX({
-  name: "base58btc",
-  prefix: "z",
-  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-});
-var base58flickr = baseX({
-  name: "base58flickr",
-  prefix: "Z",
-  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
-});
-
-// ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/vendor/varint.js
-var encode_1 = encode2;
-var MSB = 128;
-var REST = 127;
-var MSBALL = ~REST;
-var INT = Math.pow(2, 31);
-function encode2(num, out, offset) {
-  out = out || [];
-  offset = offset || 0;
-  var oldOffset = offset;
-  while (num >= INT) {
-    out[offset++] = num & 255 | MSB;
-    num /= 128;
+function toStringV0(bytes, cache2, base3) {
+  const { prefix } = base3;
+  if (prefix !== base58btc.prefix) {
+    throw Error(`Cannot string encode V0 in ${base3.name} encoding`);
   }
-  while (num & MSBALL) {
-    out[offset++] = num & 255 | MSB;
-    num >>>= 7;
+  const cid = cache2.get(prefix);
+  if (cid == null) {
+    const cid2 = base3.encode(bytes).slice(1);
+    cache2.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
   }
-  out[offset] = num | 0;
-  encode2.bytes = offset - oldOffset + 1;
-  return out;
-}
-var decode2 = 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: decode2,
-  encodingLength: length
-};
-var _brrp_varint = varint;
-var varint_default = _brrp_varint;
-
-// ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/varint.js
-function decode3(data, offset = 0) {
-  const code = varint_default.decode(data, offset);
-  return [code, varint_default.decode.bytes];
 }
-function encodeTo(int, target, offset = 0) {
-  varint_default.encode(int, target, offset);
-  return target;
+function toStringV1(bytes, cache2, base3) {
+  const { prefix } = base3;
+  const cid = cache2.get(prefix);
+  if (cid == null) {
+    const cid2 = base3.encode(bytes);
+    cache2.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
 }
-function encodingLength(int) {
-  return varint_default.encodingLength(int);
+var DAG_PB_CODE = 112;
+var SHA_256_CODE = 18;
+function encodeCID(version, code, multihash) {
+  const codeOffset = encodingLength(version);
+  const hashOffset = codeOffset + encodingLength(code);
+  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+  encodeTo(version, bytes, 0);
+  encodeTo(code, bytes, codeOffset);
+  bytes.set(multihash, hashOffset);
+  return bytes;
 }
+var cidSymbol = Symbol.for("@ipld/js-cid/CID");
 
-// ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/hashes/digest.js
-function 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);
-}
-function decode4(multihash) {
-  const bytes = coerce4(multihash);
-  const [code, sizeOffset] = decode3(bytes);
-  const [size, digestOffset] = decode3(bytes.subarray(sizeOffset));
-  const digest = bytes.subarray(sizeOffset + digestOffset);
-  if (digest.byteLength !== size) {
-    throw new Error("Incorrect length");
+// 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;
   }
-  return new Digest(code, size, digest, bytes);
 }
-function equals2(a, b) {
-  if (a === b) {
-    return true;
-  } else {
-    const data = b;
-    return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals(a.bytes, data.bytes);
+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;
 }
-var Digest = class {
-  /**
-   * Creates a multihash digest.
-   */
-  constructor(code, size, digest, bytes) {
-    __publicField(this, "code");
-    __publicField(this, "size");
-    __publicField(this, "digest");
-    __publicField(this, "bytes");
-    this.code = code;
-    this.size = size;
-    this.digest = digest;
-    this.bytes = bytes;
+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;
+}
 
-// ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/cid.js
-function format(link, base3) {
-  const { bytes, version } = link;
-  switch (version) {
-    case 0:
-      return toStringV0(bytes, baseCache(link), base3 ?? base58btc.encoder);
-    default:
-      return toStringV1(bytes, baseCache(link), base3 ?? base32.encoder);
-  }
+// 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}/`);
 }
-var cache = /* @__PURE__ */ new WeakMap();
-function baseCache(cid) {
-  const baseCache2 = cache.get(cid);
-  if (baseCache2 == null) {
-    const baseCache3 = /* @__PURE__ */ new Map();
-    cache.set(cid, baseCache3);
-    return baseCache3;
+function ipfsGatewayUrl(url) {
+  if (!url || typeof url !== "string")
+    return null;
+  const normalizedIPFSUrl = normalizeIPFSUrl(url);
+  if (normalizedIPFSUrl) {
+    return normalizedIPFSUrl.replace("ipfs://", `${IPFS_GATEWAY}/ipfs/`);
   }
-  return baseCache2;
+  return null;
 }
-var _a;
-var CID = class _CID {
-  /**
-   * @param version - Version of the CID
-   * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
-   * @param multihash - (Multi)hash of the of the content.
-   */
-  constructor(version, code, multihash, bytes) {
-    __publicField(this, "code");
-    __publicField(this, "version");
-    __publicField(this, "multihash");
-    __publicField(this, "bytes");
-    __publicField(this, "/");
-    __publicField(this, _a, "CID");
-    this.code = code;
-    this.version = version;
-    this.multihash = multihash;
-    this.bytes = bytes;
-    this["/"] = bytes;
-  }
-  /**
-   * Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`
-   * please either use `CID.asCID(cid)` or switch to new signalling mechanism
-   *
-   * @deprecated
-   */
-  get asCID() {
-    return this;
+function getFetchableUrl(uri) {
+  if (!uri || typeof uri !== "string")
+    return null;
+  if (uri.startsWith("http://"))
+    return null;
+  if (isNormalizeableIPFSUrl(uri)) {
+    return ipfsGatewayUrl(uri);
   }
-  // ArrayBufferView
-  get byteOffset() {
-    return this.bytes.byteOffset;
+  if (isArweaveURL(uri)) {
+    return arweaveGatewayUrl(uri);
   }
-  // ArrayBufferView
-  get byteLength() {
-    return this.bytes.byteLength;
+  if (/^(https|data|blob):/.test(uri)) {
+    return uri;
   }
-  toV0() {
-    switch (this.version) {
-      case 0: {
-        return this;
-      }
-      case 1: {
-        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);
-      }
-      default: {
-        throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
-      }
-    }
+  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;
   }
-  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 1. This is a bug please report`);
-      }
-    }
+  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
+  };
+};
+async function fetchTokenMetadata(tokenMetadataURI) {
+  const fetchableUrl = getFetchableUrl(tokenMetadataURI);
+  if (!fetchableUrl) {
+    throw new Error(`Invalid token metadata URI: ${tokenMetadataURI}`);
   }
-  equals(other) {
-    return _CID.equals(this, other);
+  const json = await (await fetch(fetchableUrl)).json();
+  if (!json) {
+    throw new Error(`Failed to fetch metadata from ${fetchableUrl}`);
   }
-  static equals(self, other) {
-    const unknown = other;
-    return unknown != null && self.code === unknown.code && self.version === unknown.version && equals2(self.multihash, unknown.multihash);
+  return json;
+}
+
+// src/create/minter-defaults.ts
+var SALE_END_FOREVER = 18446744073709551615n;
+var DEFAULT_SALE_START_AND_END = {
+  // Sale start time – defaults to beginning of unix time
+  saleStart: 0n,
+  // This is the end of uint64, plenty of time
+  saleEnd: SALE_END_FOREVER
+};
+var DEFAULT_MAX_TOKENS_PER_ADDRESS = {
+  maxTokensPerAddress: 0n
+};
+var erc20SaleSettingsWithDefaults = (params) => ({
+  ...DEFAULT_SALE_START_AND_END,
+  ...DEFAULT_MAX_TOKENS_PER_ADDRESS,
+  ...params
+});
+var allowListWithDefaults = (allowlist) => {
+  return {
+    ...DEFAULT_SALE_START_AND_END,
+    ...allowlist
+  };
+};
+var fixedPriceSettingsWithDefaults = (params) => ({
+  ...DEFAULT_SALE_START_AND_END,
+  ...DEFAULT_MAX_TOKENS_PER_ADDRESS,
+  type: "fixedPrice",
+  ...params
+});
+var parseNameIntoSymbol = (name) => {
+  if (name === "") {
+    throw new Error("Name must be provided to generate a symbol");
   }
-  toString(base3) {
-    return format(this, base3);
+  const result = "$" + name.replace(/[^a-zA-Z0-9]/g, "").replace(/^\$+/, "").toUpperCase().replace(/[AEIOU\s]/g, "").slice(0, 4);
+  if (result === "$") {
+    throw new Error("Not enough valid characters to generate a symbol");
   }
-  toJSON() {
-    return { "/": format(this) };
+  return result;
+};
+async function fetchTokenNameFromMetadata(tokenMetadataURI) {
+  const tokenMetadata = await fetchTokenMetadata(tokenMetadataURI);
+  if (!tokenMetadata.name) {
+    throw new Error("No name found in token metadata");
   }
-  link() {
-    return this;
+  return tokenMetadata.name;
+}
+var timedSaleSettingsWithDefaults = async (params, tokenMetadataURI) => {
+  const erc20Name = params.erc20Name || await fetchTokenNameFromMetadata(tokenMetadataURI);
+  const symbol = params.erc20Symbol || parseNameIntoSymbol(erc20Name);
+  return {
+    type: "timed",
+    ...DEFAULT_SALE_START_AND_END,
+    erc20Name,
+    erc20Symbol: symbol
+  };
+};
+var isAllowList = (salesConfig) => salesConfig.type === "allowlistMint";
+var isErc20 = (salesConfig) => salesConfig.type === "erc20Mint";
+var isFixedPrice = (salesConfig) => {
+  return salesConfig.pricePerToken > 0n;
+};
+var getSalesConfigWithDefaults = async (salesConfig, tokenMetadataURI) => {
+  if (!salesConfig)
+    return timedSaleSettingsWithDefaults({}, tokenMetadataURI);
+  if (isAllowList(salesConfig)) {
+    return allowListWithDefaults(salesConfig);
   }
-  // Legacy
-  [(_a = Symbol.toStringTag, Symbol.for("nodejs.util.inspect.custom"))]() {
-    return `CID(${this.toString()})`;
+  if (isErc20(salesConfig)) {
+    return erc20SaleSettingsWithDefaults(salesConfig);
   }
-  /**
-   * Takes any input `value` and returns a `CID` instance if it was
-   * a `CID` otherwise returns `null`. If `value` is instanceof `CID`
-   * it will return value back. If `value` is not instance of this CID
-   * class, but is compatible CID it will return new instance of this
-   * `CID` class. Otherwise returns null.
-   *
-   * This allows two different incompatible versions of CID library to
-   * co-exist and interop as long as binary interface is compatible.
-   */
-  static asCID(input) {
-    if (input == null) {
-      return null;
-    }
-    const value = input;
-    if (value instanceof _CID) {
-      return value;
-    } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
-      const { version, code, multihash, bytes } = value;
-      return new _CID(version, code, multihash, bytes ?? encodeCID(version, code, multihash.bytes));
-    } else if (value[cidSymbol] === true) {
-      const { version, multihash, code } = value;
-      const digest = decode4(multihash);
-      return _CID.create(version, code, digest);
-    } else {
-      return null;
-    }
+  if (isFixedPrice(salesConfig)) {
+    return fixedPriceSettingsWithDefaults(salesConfig);
   }
-  /**
-   * @param version - Version of the CID
-   * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
-   * @param digest - (Multi)hash of the of the content.
-   */
-  static create(version, code, digest) {
-    if (typeof code !== "number") {
-      throw new Error("String codecs are no longer supported");
-    }
-    if (!(digest.bytes instanceof Uint8Array)) {
-      throw new Error("Invalid digest");
-    }
-    switch (version) {
-      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(version, code, digest, digest.bytes);
-        }
+  return timedSaleSettingsWithDefaults(salesConfig, tokenMetadataURI);
+};
+
+// src/create/minter-setup.ts
+var import_protocol_deployments8 = require("@zoralabs/protocol-deployments");
+var import_viem7 = require("viem");
+var PERMISSION_BITS = {
+  MINTER: 2n ** 2n
+};
+function setupErc20Minter({
+  pricePerToken,
+  chainId,
+  tokenId: nextTokenId,
+  currency,
+  saleStart,
+  saleEnd,
+  maxTokensPerAddress: mintLimit,
+  fundsRecipient
+}) {
+  const erc20MinterAddress = import_protocol_deployments8.erc20MinterAddress[chainId];
+  if (!erc20MinterAddress)
+    throw new Error(`ERC20Minter not deployed on chainId ${chainId}`);
+  const erc20MinterApproval = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
+    functionName: "addPermission",
+    args: [BigInt(nextTokenId), erc20MinterAddress, PERMISSION_BITS.MINTER]
+  });
+  const saleData = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.erc20MinterABI,
+    functionName: "setSale",
+    args: [
+      BigInt(nextTokenId),
+      {
+        saleStart: saleStart || BigInt(0),
+        saleEnd: saleEnd || BigInt(0),
+        maxTokensPerAddress: BigInt(mintLimit || 0),
+        pricePerToken,
+        fundsRecipient,
+        currency
       }
-      case 1: {
-        const bytes = encodeCID(version, code, digest.bytes);
-        return new _CID(version, code, digest, bytes);
+    ]
+  });
+  const callSale = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
+    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 = import_protocol_deployments8.zoraCreatorFixedPriceSaleStrategyAddress[chainId];
+  const fixedPriceApproval = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
+    functionName: "addPermission",
+    args: [
+      BigInt(nextTokenId),
+      fixedPriceStrategyAddress,
+      PERMISSION_BITS.MINTER
+    ]
+  });
+  const saleData = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreatorFixedPriceSaleStrategyABI,
+    functionName: "setSale",
+    args: [
+      BigInt(nextTokenId),
+      {
+        pricePerToken: price,
+        saleStart: saleStart || BigInt(0),
+        saleEnd: saleEnd || BigInt(0),
+        maxTokensPerAddress: BigInt(mintLimit || 0),
+        fundsRecipient
       }
-      default: {
-        throw new Error("Invalid version");
+    ]
+  });
+  const callSale = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
+    functionName: "callSale",
+    args: [BigInt(nextTokenId), fixedPriceStrategyAddress, saleData]
+  });
+  return {
+    minter: fixedPriceStrategyAddress,
+    setupActions: [fixedPriceApproval, callSale]
+  };
+}
+function setupTimedSaleMinter({
+  chainId,
+  tokenId,
+  erc20Name: erc20zName,
+  erc20Symbol: erc20zSymbol,
+  saleStart,
+  saleEnd
+}) {
+  const minterAddress = import_protocol_deployments8.zoraTimedSaleStrategyAddress[chainId];
+  const fixedPriceApproval = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
+    functionName: "addPermission",
+    args: [BigInt(tokenId), minterAddress, PERMISSION_BITS.MINTER]
+  });
+  const saleData = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraTimedSaleStrategyABI,
+    functionName: "setSale",
+    args: [
+      BigInt(tokenId),
+      {
+        saleStart,
+        saleEnd,
+        name: erc20zName,
+        symbol: erc20zSymbol
+      }
+    ]
+  });
+  const callSale = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
+    functionName: "callSale",
+    args: [BigInt(tokenId), minterAddress, saleData]
+  });
+  return {
+    minter: minterAddress,
+    setupActions: [fixedPriceApproval, callSale]
+  };
+}
+function setupAllowListMinter({
+  chainId,
+  tokenId: nextTokenId,
+  allowlist,
+  fundsRecipient
+}) {
+  const merkleSaleStrategyAddress = import_protocol_deployments8.zoraCreatorMerkleMinterStrategyAddress[chainId];
+  const merkleApproval = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
+    functionName: "addPermission",
+    args: [nextTokenId, merkleSaleStrategyAddress, PERMISSION_BITS.MINTER]
+  });
+  const merkleRoot = allowlist.presaleMerkleRoot.startsWith("0x") ? allowlist.presaleMerkleRoot : `0x${allowlist.presaleMerkleRoot}`;
+  const saleData = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreatorMerkleMinterStrategyABI,
+    functionName: "setSale",
+    args: [
+      BigInt(nextTokenId),
+      {
+        presaleStart: allowlist.saleStart,
+        presaleEnd: allowlist.saleEnd,
+        merkleRoot,
+        fundsRecipient
       }
-    }
+    ]
+  });
+  const callSaleMerkle = (0, import_viem7.encodeFunctionData)({
+    abi: import_protocol_deployments8.zoraCreator1155ImplABI,
+    functionName: "callSale",
+    args: [BigInt(nextTokenId), merkleSaleStrategyAddress, saleData]
+  });
+  return {
+    minter: merkleSaleStrategyAddress,
+    setupActions: [merkleApproval, callSaleMerkle]
+  };
+}
+var isAllowList2 = (salesConfig) => salesConfig.type === "allowlistMint";
+var isErc202 = (salesConfig) => salesConfig.type === "erc20Mint";
+var isFixedPrice2 = (salesConfig) => salesConfig.type === "fixedPrice" || salesConfig.pricePerToken > BigInt(0);
+function setupMinters({ salesConfig, ...rest }) {
+  if (isErc202(salesConfig)) {
+    return setupErc20Minter({
+      ...salesConfig,
+      ...rest
+    });
   }
-  /**
-   * Simplified version of `create` for CIDv0.
-   */
-  static createV0(digest) {
-    return _CID.create(0, DAG_PB_CODE, digest);
+  if (isAllowList2(salesConfig)) {
+    return setupAllowListMinter({
+      allowlist: salesConfig,
+      ...rest
+    });
   }
-  /**
-   * Simplified version of `create` for CIDv1.
-   *
-   * @param code - Content encoding format code.
-   * @param digest - Multihash of the content.
-   */
-  static createV1(code, digest) {
-    return _CID.create(1, code, digest);
+  if (isFixedPrice2(salesConfig))
+    return setupFixedPriceMinter({
+      ...salesConfig,
+      ...rest
+    });
+  return setupTimedSaleMinter({
+    ...salesConfig,
+    ...rest
+  });
+}
+
+// src/create/token-setup.ts
+async function applyNew1155Defaults(props, ownerAddress) {
+  const { payoutRecipient: fundsRecipient } = props;
+  const fundsRecipientOrOwner = fundsRecipient && fundsRecipient !== import_viem8.zeroAddress ? fundsRecipient : ownerAddress;
+  return {
+    payoutRecipient: fundsRecipientOrOwner,
+    createReferral: props.createReferral || import_viem8.zeroAddress,
+    maxSupply: typeof props.maxSupply === "undefined" ? OPEN_EDITION_MINT_SIZE : BigInt(props.maxSupply),
+    royaltyBPS: props.royaltyBPS || 1e3,
+    tokenMetadataURI: props.tokenMetadataURI,
+    salesConfig: await getSalesConfigWithDefaults(
+      props.salesConfig,
+      props.tokenMetadataURI
+    )
+  };
+}
+function buildSetupNewToken({
+  tokenURI,
+  maxSupply = OPEN_EDITION_MINT_SIZE,
+  createReferral = import_viem8.zeroAddress,
+  contractVersion
+}) {
+  if (contractSupportsMintRewards(contractVersion, "ERC1155")) {
+    return (0, import_viem8.encodeFunctionData)({
+      abi: import_protocol_deployments9.zoraCreator1155ImplABI,
+      functionName: "setupNewTokenWithCreateReferral",
+      args: [tokenURI, BigInt(maxSupply), createReferral]
+    });
   }
-  /**
-   * Decoded a CID from its binary representation. The byte array must contain
-   * only the CID with no additional bytes.
-   *
-   * An error will be thrown if the bytes provided do not contain a valid
-   * binary representation of a CID.
-   */
-  static decode(bytes) {
-    const [cid, remainder] = _CID.decodeFirst(bytes);
-    if (remainder.length !== 0) {
-      throw new Error("Incorrect length");
-    }
-    return cid;
+  if (createReferral !== import_viem8.zeroAddress) {
+    throw new Error(
+      "Contract does not support create referral, but one was provided"
+    );
   }
-  /**
-   * Decoded a CID from its binary representation at the beginning of a byte
-   * array.
-   *
-   * Returns an array with the first element containing the CID and the second
-   * element containing the remainder of the original byte array. The remainder
-   * will be a zero-length byte array if the provided bytes only contained a
-   * binary CID representation.
-   */
-  static decodeFirst(bytes) {
-    const specs = _CID.inspectBytes(bytes);
-    const prefixSize = specs.size - specs.multihashSize;
-    const multihashBytes = coerce4(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)];
+  return (0, import_viem8.encodeFunctionData)({
+    abi: import_protocol_deployments9.zoraCreator1155ImplABI,
+    functionName: "setupNewToken",
+    args: [tokenURI, BigInt(maxSupply)]
+  });
+}
+function setupRoyaltyConfig({
+  royaltyBPS,
+  royaltyRecipient,
+  nextTokenId
+}) {
+  if (royaltyBPS > 0 && royaltyRecipient != import_viem8.zeroAddress) {
+    return (0, import_viem8.encodeFunctionData)({
+      abi: import_protocol_deployments9.zoraCreator1155ImplABI,
+      functionName: "updateRoyaltiesForToken",
+      args: [
+        nextTokenId,
+        {
+          royaltyBPS,
+          royaltyRecipient,
+          royaltyMintSchedule: 0
+        }
+      ]
+    });
   }
-  /**
-   * Inspect the initial bytes of a CID to determine its properties.
-   *
-   * Involves decoding up to 4 varints. Typically this will require only 4 to 6
-   * bytes but for larger multicodec code values and larger multihash digest
-   * lengths these varints can be quite large. It is recommended that at least
-   * 10 bytes be made available in the `initialBytes` argument for a complete
-   * inspection.
-   */
-  static inspectBytes(initialBytes) {
-    let offset = 0;
-    const next = () => {
-      const [i, length2] = decode3(initialBytes.subarray(offset));
-      offset += length2;
-      return i;
-    };
-    let version = next();
-    let codec = DAG_PB_CODE;
-    if (version === 18) {
-      version = 0;
-      offset = 0;
-    } else {
-      codec = next();
-    }
-    if (version !== 0 && version !== 1) {
-      throw new RangeError(`Invalid CID version ${version}`);
-    }
-    const prefixSize = offset;
-    const multihashCode = next();
-    const digestSize = next();
-    const size = offset + digestSize;
-    const multihashSize = size - prefixSize;
-    return { version, codec, multihashCode, digestSize, multihashSize, size };
+  return null;
+}
+function makeAdminMintCall({
+  ownerAddress,
+  mintQuantity,
+  nextTokenId
+}) {
+  if (!mintQuantity || mintQuantity <= 0 || !ownerAddress) {
+    return null;
   }
-  /**
-   * Takes cid in a string representation and creates an instance. If `base`
-   * decoder is not provided will use a default from the configuration. It will
-   * throw an error if encoding of the CID is not compatible with supplied (or
-   * a default decoder).
-   */
-  static parse(source, base3) {
-    const [prefix, bytes] = parseCIDtoBytes(source, base3);
-    const cid = _CID.decode(bytes);
-    if (cid.version === 0 && source[0] !== "Q") {
-      throw Error("Version 0 CID string must not include multibase prefix");
+  return (0, import_viem8.encodeFunctionData)({
+    abi: import_protocol_deployments9.zoraCreator1155ImplABI,
+    functionName: "adminMint",
+    args: [ownerAddress, nextTokenId, BigInt(mintQuantity), import_viem8.zeroAddress]
+  });
+}
+async function constructCreate1155TokenCalls(props) {
+  const {
+    chainId,
+    nextTokenId,
+    mintToCreatorCount,
+    ownerAddress,
+    contractVersion
+  } = props;
+  const new1155TokenPropsWithDefaults = await applyNew1155Defaults(
+    props,
+    ownerAddress
+  );
+  const verifyTokenIdExpected = (0, import_viem8.encodeFunctionData)({
+    abi: import_protocol_deployments9.zoraCreator1155ImplABI,
+    functionName: "assumeLastTokenIdMatches",
+    args: [nextTokenId - 1n]
+  });
+  const setupNewToken = buildSetupNewToken({
+    tokenURI: new1155TokenPropsWithDefaults.tokenMetadataURI,
+    maxSupply: new1155TokenPropsWithDefaults.maxSupply,
+    createReferral: new1155TokenPropsWithDefaults.createReferral,
+    contractVersion
+  });
+  const royaltyConfig = setupRoyaltyConfig({
+    royaltyBPS: new1155TokenPropsWithDefaults.royaltyBPS,
+    royaltyRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
+    nextTokenId
+  });
+  const { minter, setupActions: mintersSetup } = setupMinters({
+    tokenId: nextTokenId,
+    chainId,
+    fundsRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
+    salesConfig: new1155TokenPropsWithDefaults.salesConfig
+  });
+  const adminMintCall = makeAdminMintCall({
+    ownerAddress,
+    mintQuantity: mintToCreatorCount,
+    nextTokenId
+  });
+  const setupActions = [
+    verifyTokenIdExpected,
+    setupNewToken,
+    ...mintersSetup,
+    royaltyConfig,
+    adminMintCall
+  ].filter((item) => item !== null);
+  return {
+    setupActions,
+    minter,
+    newToken: new1155TokenPropsWithDefaults
+  };
+}
+var contractSupportsMintRewards = (contractVersion, contractStandard) => {
+  if (!contractStandard || !contractVersion) {
+    return false;
+  }
+  const semVerContractVersion = semver2.coerce(contractVersion)?.raw;
+  if (!semVerContractVersion)
+    return false;
+  if (contractStandard === "ERC1155") {
+    return semver2.gte(semVerContractVersion, "1.3.5");
+  } else {
+    return semver2.gte(semVerContractVersion, "14.0.0");
+  }
+};
+
+// src/create/1155-create-helper.ts
+var ROYALTY_BPS_DEFAULT = 1e3;
+var getTokenIdFromCreateReceipt = (receipt) => {
+  for (const data of receipt.logs) {
+    try {
+      const decodedLog = (0, import_viem9.decodeEventLog)({
+        abi: import_protocol_deployments10.zoraCreator1155ImplABI,
+        eventName: "SetupNewToken",
+        ...data
+      });
+      if (decodedLog && decodedLog.eventName === "SetupNewToken") {
+        return decodedLog.args.tokenId;
+      }
+    } catch (err) {
     }
-    baseCache(cid).set(prefix, source);
-    return cid;
   }
+  throw new Error(
+    "No event found in receipt that could be used to get tokenId"
+  );
 };
-function 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");
+var getContractAddressFromReceipt = (receipt) => {
+  for (const data of receipt.logs) {
+    try {
+      const decodedLog = (0, import_viem9.decodeEventLog)({
+        abi: import_protocol_deployments10.zoraCreator1155FactoryImplABI,
+        eventName: "SetupNewContract",
+        ...data
+      });
+      if (decodedLog && decodedLog.eventName === "SetupNewContract") {
+        return decodedLog.args.newContract;
       }
-      return [source[0], base3.decode(source)];
+    } catch (err) {
     }
   }
+  throw new Error(
+    "No event found in receipt that could be used to get contract address"
+  );
+};
+function makeCreateContractAndTokenCall({
+  account,
+  contract,
+  royaltyBPS,
+  fundsRecipient,
+  tokenSetupActions,
+  chainId
+}) {
+  const accountAddress = typeof account === "string" ? account : account.address;
+  return makeContractParameters({
+    abi: import_protocol_deployments10.zoraCreator1155FactoryImplABI,
+    functionName: "createContractDeterministic",
+    account,
+    address: import_protocol_deployments10.zoraCreator1155FactoryImplAddress[chainId],
+    args: [
+      contract.uri,
+      contract.name,
+      {
+        // deprecated
+        royaltyMintSchedule: 0,
+        royaltyBPS: royaltyBPS || ROYALTY_BPS_DEFAULT,
+        royaltyRecipient: fundsRecipient || accountAddress
+      },
+      contract.defaultAdmin || accountAddress,
+      tokenSetupActions
+    ]
+  });
 }
-function toStringV0(bytes, cache2, base3) {
-  const { prefix } = base3;
-  if (prefix !== base58btc.prefix) {
-    throw Error(`Cannot string encode V0 in ${base3.name} encoding`);
-  }
-  const cid = cache2.get(prefix);
-  if (cid == null) {
-    const cid2 = base3.encode(bytes).slice(1);
-    cache2.set(prefix, cid2);
-    return cid2;
-  } else {
-    return cid;
-  }
-}
-function toStringV1(bytes, cache2, base3) {
-  const { prefix } = base3;
-  const cid = cache2.get(prefix);
-  if (cid == null) {
-    const cid2 = base3.encode(bytes);
-    cache2.set(prefix, cid2);
-    return cid2;
-  } else {
-    return cid;
-  }
-}
-var DAG_PB_CODE = 112;
-var SHA_256_CODE = 18;
-function encodeCID(version, code, multihash) {
-  const codeOffset = encodingLength(version);
-  const hashOffset = codeOffset + encodingLength(code);
-  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
-  encodeTo(version, bytes, 0);
-  encodeTo(code, bytes, codeOffset);
-  bytes.set(multihash, hashOffset);
-  return bytes;
+function makeCreateTokenCall({
+  contractAddress,
+  account,
+  tokenSetupActions
+}) {
+  return makeContractParameters({
+    abi: import_protocol_deployments10.zoraCreator1155ImplABI,
+    functionName: "multicall",
+    account,
+    address: contractAddress,
+    args: [tokenSetupActions]
+  });
 }
-var cidSymbol = Symbol.for("@ipld/js-cid/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;
+var Create1155Client = class {
+  constructor({
+    chainId,
+    publicClient
+  }) {
+    this.chainId = chainId;
+    this.publicClient = publicClient;
   }
-}
-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}`;
+  async createNew1155(props) {
+    return createNew1155ContractAndToken({
+      ...props,
+      publicClient: this.publicClient,
+      chainId: this.chainId
+    });
   }
-  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;
-    }
+  async createNew1155OnExistingContract({
+    contractAddress: contract,
+    account,
+    token,
+    getAdditionalSetupActions
+  }) {
+    return createNew1155Token({
+      contractAddress: contract,
+      account,
+      token,
+      getAdditionalSetupActions,
+      publicClient: this.publicClient,
+      chainId: this.chainId
+    });
   }
-  return false;
+};
+async function createNew1155ContractAndToken({
+  contract,
+  account,
+  chainId,
+  token,
+  publicClient,
+  getAdditionalSetupActions
+}) {
+  const nextTokenId = 1n;
+  const contractVersion = new1155ContractVersion(chainId);
+  const {
+    minter,
+    newToken,
+    setupActions: tokenSetupActions
+  } = await prepareSetupActions({
+    chainId,
+    account,
+    contractVersion,
+    nextTokenId,
+    token,
+    getAdditionalSetupActions
+  });
+  const request = makeCreateContractAndTokenCall({
+    contract,
+    account,
+    chainId,
+    tokenSetupActions,
+    fundsRecipient: token.payoutRecipient,
+    royaltyBPS: token.royaltyBPS
+  });
+  const contractAddress = await getDeterministicContractAddress({
+    account,
+    publicClient,
+    setupActions: tokenSetupActions,
+    chainId,
+    contract
+  });
+  return {
+    parameters: request,
+    tokenSetupActions,
+    newTokenId: nextTokenId,
+    newToken,
+    contractAddress,
+    contractVersion,
+    minter
+  };
 }
-function isIPFSUrl(url) {
-  return url ? isNormalizedIPFSURL(url) || isGatewayIPFSUrl(url) : false;
+async function createNew1155Token({
+  contractAddress,
+  account,
+  getAdditionalSetupActions,
+  token,
+  publicClient,
+  chainId
+}) {
+  const { nextTokenId, contractVersion } = await getContractInfoExistingContract({
+    publicClient,
+    contractAddress
+  });
+  const {
+    minter,
+    newToken,
+    setupActions: tokenSetupActions
+  } = await prepareSetupActions({
+    chainId,
+    account,
+    contractVersion,
+    nextTokenId,
+    token,
+    getAdditionalSetupActions
+  });
+  const request = makeCreateTokenCall({
+    contractAddress,
+    account,
+    tokenSetupActions
+  });
+  return {
+    parameters: request,
+    tokenSetupActions,
+    newTokenId: nextTokenId,
+    newToken,
+    contractVersion,
+    minter
+  };
 }
-function isNormalizeableIPFSUrl(url) {
-  return url ? isIPFSUrl(url) || isCID(url) : false;
+async function prepareSetupActions({
+  chainId,
+  account,
+  contractVersion,
+  nextTokenId,
+  token,
+  getAdditionalSetupActions
+}) {
+  const {
+    minter,
+    newToken,
+    setupActions: tokenSetupActions
+  } = await constructCreate1155TokenCalls({
+    chainId,
+    ownerAddress: account,
+    contractVersion,
+    nextTokenId,
+    ...token
+  });
+  const setupActions = getAdditionalSetupActions ? [
+    ...getAdditionalSetupActions({
+      tokenId: nextTokenId
+    }),
+    ...tokenSetupActions
+  ] : tokenSetupActions;
+  return { minter, newToken, setupActions };
 }
 
-// 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;
+// src/sparks/mints-queries.ts
+var getMintsAccountBalanceWithPriceQuery = (account) => {
+  const query = `
+    query GetMintAccountBalances($account: String!) {
+      mintAccountBalances(where: { account: $account }) {
+        balance
+        mintToken {
+          id
+          pricePerToken
+        }
+      }
+    }
+  `;
+  return {
+    query,
+    variables: { account }
+  };
+};
+var selectMintsToCollectWithFromQueryResult = (mintAccountBalances, quantityToCollect) => {
+  const parsed = mintAccountBalances.map((r) => {
+    return {
+      tokenId: BigInt(r.mintToken.id),
+      quantity: BigInt(r.balance),
+      pricePerToken: BigInt(r.mintToken.pricePerToken)
+    };
+  });
+  const sorted = parsed.sort((a, b) => {
+    if (a.pricePerToken < b.pricePerToken) {
+      return -1;
+    }
+    return 1;
+  });
+  let remainingQuantity = quantityToCollect;
+  const tokenIds = [];
+  const quantities = [];
+  while (remainingQuantity > 0) {
+    const next = sorted.shift();
+    if (!next) {
+      throw new Error("Not enough MINTs to collect with");
+    }
+    const quantityToUse = remainingQuantity > next.quantity ? next.quantity : remainingQuantity;
+    tokenIds.push(next.tokenId);
+    quantities.push(quantityToUse);
+    remainingQuantity -= quantityToUse;
   }
-  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);
+  return {
+    tokenIds,
+    quantities
+  };
 };
-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 sumBalances = (mintAccountBalances) => {
+  return mintAccountBalances.reduce((acc, curr) => {
+    return acc + BigInt(curr.balance);
+  }, BigInt(0));
 };
-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 */
+
+// src/sparks/sparks-contracts.ts
+var import_protocol_deployments11 = require("@zoralabs/protocol-deployments");
+var import_viem10 = require("viem");
+var addressOrAccountAddress = (address) => typeof address === "string" ? address : address.address;
+var mintWithEthParams = ({
+  tokenId,
+  quantity,
+  recipient,
+  chainId,
+  pricePerMint,
+  account
+}) => makeContractParameters({
+  abi: import_protocol_deployments11.zoraSparksManagerImplABI,
+  address: import_protocol_deployments11.zoraSparksManagerImplAddress[chainId],
+  functionName: "mintWithEth",
+  args: [tokenId, quantity, recipient || addressOrAccountAddress(account)],
+  value: pricePerMint * quantity,
+  account
+});
+var getPaidMintValue = (quantities, pricePerMint) => {
+  if (!pricePerMint || pricePerMint === 0n)
+    return;
+  return quantities.reduce((a, b) => a + b, 0n) * pricePerMint;
 };
-function mimeTypeToMedia(mimeType) {
-  if (!mimeType)
-    return "UNKNOWN" /* UNKNOWN */;
-  return mimeToMediaType[mimeType] || "UNKNOWN" /* UNKNOWN */;
+var mintsBalanceOfAccountParams = ({
+  account,
+  chainId
+}) => ({
+  abi: import_protocol_deployments11.zoraMints1155Config.abi,
+  address: import_protocol_deployments11.zoraMints1155Config.address[chainId],
+  functionName: "balanceOfAccount",
+  args: [account]
+});
+var encodeCollectOnManager = ({
+  zoraCreator1155Contract,
+  minter,
+  zoraCreator1155TokenId,
+  mintArguments
+}) => (0, import_viem10.encodeFunctionData)({
+  abi: import_protocol_deployments11.zoraMintsManagerImplConfig.abi,
+  functionName: "collect",
+  args: [
+    zoraCreator1155Contract,
+    minter,
+    zoraCreator1155TokenId,
+    mintArguments
+  ]
+});
+function collectWithMintsParams({
+  tokenIds,
+  quantities,
+  chainId,
+  paidMintPricePerToken,
+  account,
+  mintArguments,
+  minter,
+  zoraCreator1155Contract,
+  zoraCreator1155TokenId
+}) {
+  const call = encodeCollectOnManager({
+    tokenIds,
+    quantities,
+    zoraCreator1155Contract,
+    zoraCreator1155TokenId,
+    minter,
+    mintArguments
+  });
+  return makeContractParameters({
+    abi: import_protocol_deployments11.zoraMints1155Config.abi,
+    address: import_protocol_deployments11.zoraMints1155Config.address[chainId],
+    functionName: "transferBatchToManagerAndCall",
+    args: [tokenIds, quantities, call],
+    // if it is a paid mint, the aadditional value will be sent to the manager contract and forwarded to the creator 1155 contract
+    // for the paid mint cost.
+    value: getPaidMintValue(quantities, paidMintPricePerToken),
+    account
+  });
 }
-async function getMimeType(uri) {
-  if (!uri)
-    return uri;
-  const res = await fetch(uri, { method: "HEAD" });
-  let mimeType = res.headers.get("content-type");
-  return mimeType;
+function getMintsEthPrice({
+  publicClient
+}) {
+  const chainId = publicClient.chain?.id;
+  if (!chainId || !import_protocol_deployments11.zoraMintsManagerImplAddress[chainId]) {
+    throw new Error(`Chain id ${chainId} not supported`);
+  }
+  return publicClient.readContract({
+    abi: import_protocol_deployments11.zoraMintsManagerImplABI,
+    address: import_protocol_deployments11.zoraMintsManagerImplAddress[chainId],
+    functionName: "getEthPrice"
+  });
 }
-
-// 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;
+function makePermitTransferBatchAndTypeData({
+  tokenIds,
+  quantities,
+  chainId,
+  mintsOwner,
+  to,
+  nonce,
+  deadline,
+  safeTransferData
+}) {
+  const permit = {
+    owner: typeof mintsOwner === "string" ? mintsOwner : mintsOwner.address,
+    to,
+    tokenIds,
+    quantities,
+    deadline,
+    nonce,
+    safeTransferData
+  };
+  const typedData = {
+    ...(0, import_protocol_deployments11.mintsSafeTransferBatchTypedDataDefinition)({
+      chainId,
+      message: permit
+    }),
+    account: mintsOwner
+  };
   return {
-    name,
-    image,
-    animation_url,
-    content,
-    attributes
+    permit,
+    typedData
   };
-};
-var makeMediaTokenMetadata = async ({
-  name,
-  description,
-  attributes = [],
-  mediaUrl,
-  thumbnailUrl
+}
+function makePermitTransferTypeData({
+  tokenId,
+  quantity,
+  chainId,
+  mintsOwner,
+  to,
+  nonce,
+  deadline,
+  safeTransferData
+}) {
+  const permit = {
+    owner: typeof mintsOwner === "string" ? mintsOwner : mintsOwner.address,
+    to,
+    tokenId,
+    quantity,
+    deadline,
+    nonce,
+    safeTransferData
+  };
+  const typedData = {
+    ...(0, import_protocol_deployments11.mintsSafeTransferTypedDataDefinition)({
+      chainId,
+      message: permit
+    }),
+    account: mintsOwner
+  };
+  return {
+    permit,
+    typedData
+  };
+}
+var encodePremintOnManager = ({
+  contractCreationConfig,
+  premintConfig,
+  premintSignature,
+  mintArguments,
+  signerContract = import_viem10.zeroAddress
+}) => (0, import_viem10.encodeFunctionData)({
+  abi: import_protocol_deployments11.zoraMintsManagerImplConfig.abi,
+  functionName: "collectPremintV2",
+  args: [
+    contractCreationConfig,
+    premintConfig,
+    premintSignature,
+    mintArguments,
+    signerContract
+  ]
+});
+var makePermitToCollectPremintOrNonPremint = ({
+  mintsOwner,
+  chainId,
+  deadline,
+  tokenIds,
+  // this quantity of MINTs will be used to collect premint
+  // and will be burned.  This same quantity is the quantity of
+  // premint to collect.
+  quantities,
+  nonce,
+  premint,
+  collect
 }) => {
-  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;
+  let safeTransferData;
+  if (premint) {
+    safeTransferData = encodePremintOnManager(premint);
+  } else if (collect) {
+    safeTransferData = encodeCollectOnManager(collect);
   } else {
-    image = thumbnailUrl;
-    animation_url = mediaUrl;
+    throw new Error("Invalid operation");
   }
-  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 makePermitTransferBatchAndTypeData({
+    tokenIds,
+    quantities,
+    chainId,
+    mintsOwner,
+    nonce,
+    deadline,
+    safeTransferData,
+    to: import_protocol_deployments11.zoraMintsManagerImplConfig.address[chainId]
+  });
+};
+function collectPremintV2WithMintsParams({
+  tokenIds,
+  quantities,
+  paidMintPricePerToken,
+  account,
+  chainId,
+  ...rest
+}) {
+  const call = encodePremintOnManager({
+    ...rest
+  });
+  return makeContractParameters({
+    abi: import_protocol_deployments11.zoraMints1155Config.abi,
+    address: import_protocol_deployments11.zoraMints1155Config.address[chainId],
+    functionName: "transferBatchToManagerAndCall",
+    args: [tokenIds, quantities, call],
+    value: getPaidMintValue(quantities, paidMintPricePerToken),
+    account
+  });
+}
+function decodeCallFailedError(error) {
+  if (error.data?.errorName !== "CallFailed")
+    throw new Error("Not a CallFailed error");
+  const internalErrorData = error.data?.args?.[0];
+  return (0, import_viem10.decodeErrorResult)({
+    abi: import_protocol_deployments11.zoraMintsManagerImplABI,
+    data: internalErrorData
+  });
+}
+
+// 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 {
-    name,
-    description,
-    image,
-    animation_url,
-    content,
-    attributes
+    createPremint: (p) => premintClient.createPremint(p),
+    updatePremint: (p) => premintClient.updatePremint(p),
+    deletePremint: (p) => premintClient.deletePremint(p),
+    create1155: (p) => create1155CreatorClient.createNew1155(p),
+    create1155OnExistingContract: (p) => create1155CreatorClient.createNew1155OnExistingContract(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)
+  };
+}
 
 // src/ipfs/text-metadata.ts
 var CHAR_LIMIT = 1111;
@@ -6184,6 +6477,26 @@ async function generateTextNftMetadataFiles(text) {
     thumbnailFile
   };
 }
+
+// src/allow-list/allow-list-client.ts
+var ALLOW_LIST_API_BASE = "http://allowlist.zora.co/";
+var createAllowList = async ({
+  allowList,
+  httpClient: httpClient2 = httpClient,
+  baseUrl = ALLOW_LIST_API_BASE
+}) => {
+  const { post: post2, retries: retries2 } = httpClient2;
+  const data = {
+    entries: allowList.entries.map((entry) => ({
+      user: entry.user,
+      maxCanMint: entry.maxCanMint,
+      price: entry.price.toString()
+    }))
+  };
+  return (await retries2(
+    () => post2(`${baseUrl}allowlist`, data)
+  )).root;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Create1155Client,
@@ -6196,7 +6509,6 @@ async function generateTextNftMetadataFiles(text) {
   ZORA_API_BASE,
   applyUpdateToPremint,
   buildPremintMintCall,
-  collectOnchain,
   collectPremint,
   collectPremintV2WithMintsParams,
   collectWithMintsParams,
@@ -6204,6 +6516,7 @@ async function generateTextNftMetadataFiles(text) {
   convertGetPremintApiResponse,
   convertGetPremintOfCollectionApiResponse,
   convertPremintFromApi,
+  createAllowList,
   createCollectorClient,
   createCreatorClient,
   decodeCallFailedError,