@zoralabs/protocol-sdk 0.7.6 → 0.9.0

package/dist/index.js

@@ -710,8 +710,8 @@ var require_gte = __commonJS({
   "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/gte.js"(exports, module) {
     "use strict";
     var compare = require_compare();
-    var gte4 = (a, b, loose) => compare(a, b, loose) >= 0;
-    module.exports = gte4;
+    var gte3 = (a, b, loose) => compare(a, b, loose) >= 0;
+    module.exports = gte3;
   }
 });
 
@@ -732,7 +732,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) => {
@@ -762,7 +762,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 "<=":
@@ -782,7 +782,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;
       }
@@ -817,7 +817,7 @@ var require_coerce = __commonJS({
       const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
       return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options);
     };
-    module.exports = coerce5;
+    module.exports = coerce4;
   }
 });
 
@@ -1518,7 +1518,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);
@@ -1533,7 +1533,7 @@ var require_outside = __commonJS({
           break;
         case "<":
           gtfn = lt;
-          ltefn = gte4;
+          ltefn = gte3;
           ltfn = gt;
           comp = "<";
           ecomp = "<=";
@@ -1849,10 +1849,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();
@@ -1887,10 +1887,10 @@ var require_semver2 = __commonJS({
       lt,
       eq,
       neq,
-      gte: gte4,
+      gte: gte3,
       lte,
       cmp,
-      coerce: coerce5,
+      coerce: coerce4,
       Comparator,
       Range,
       satisfies,
@@ -2534,14 +2534,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 {
@@ -2577,36 +2583,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 = `
@@ -2627,6 +2623,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 {
@@ -2636,7 +2649,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 {
@@ -2645,7 +2658,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
       }
     }
@@ -2676,19 +2689,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
 }) {
@@ -2729,14 +2729,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",
@@ -2744,7 +2743,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 {
@@ -2753,31 +2753,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(
@@ -2795,11 +2836,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({
@@ -2815,29 +2857,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
@@ -2846,7 +2881,8 @@ var SubgraphMintGetter = class {
   }
   async getContractMintable({
     tokenAddress,
-    preferredSaleType
+    preferredSaleType,
+    blockTime
   }) {
     const tokens = await this.querySubgraphWithRetries(
       buildContractTokensQuery({
@@ -2861,7 +2897,8 @@ var SubgraphMintGetter = class {
         token,
         tokenId: token.tokenId,
         preferredSaleType,
-        defaultMintFee
+        defaultMintFee,
+        blockTime
       })
     );
   }
@@ -2879,34 +2916,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,
@@ -2919,11 +2971,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,
@@ -3571,6 +3631,16 @@ 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
+import { zeroAddress as zeroAddress4 } from "viem";
+
 // src/mint/mint-transactions.ts
 import {
   encodeAbiParameters,
@@ -3579,19 +3649,20 @@ import {
 } from "viem";
 import {
   erc20MinterABI,
-  zoraCreator1155ImplABI as zoraCreator1155ImplABI2
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI2,
+  zoraTimedSaleStrategyABI
 } from "@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
@@ -3621,12 +3692,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,
@@ -3635,7 +3707,26 @@ function makePrepareMint1155TokenParams({
       mintTo,
       salesConfigAndTokenInfo,
       tokenContract,
-      tokenId
+      tokenId,
+      allowListEntry
+    });
+  }
+  if (saleType === "timed") {
+    return makeContractParameters({
+      abi: 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 || zeroAddress3,
+        mintComment || ""
+      ]
     });
   }
   if (saleType === "erc20") {
@@ -3670,9 +3761,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,
@@ -3688,6 +3779,29 @@ function makePrepareMint721TokenParams({
     ]
   });
 }
+function makeFixedPriceMinterArguments({
+  mintTo,
+  mintComment
+}) {
+  return encodeAbiParameters(parseAbiParameters("address, string"), [
+    mintTo,
+    mintComment || ""
+  ]);
+}
+function makeAllowListMinterArguments({
+  mintTo,
+  allowListEntry
+}) {
+  return encodeAbiParameters(
+    parseAbiParameters("address, uint256, uint256, bytes32[]"),
+    [
+      mintTo,
+      BigInt(allowListEntry.maxCanMint),
+      allowListEntry.price,
+      allowListEntry.proof
+    ]
+  );
+}
 function makeEthMintCall({
   tokenContract,
   tokenId,
@@ -3696,17 +3810,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 = encodeAbiParameters(
-    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: zoraCreator1155ImplABI2,
@@ -3739,13 +3861,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 {
@@ -3757,7 +3887,6 @@ function parseMintCosts({
 }
 
 // src/mint/mint-queries.ts
-import { zeroAddress as zeroAddress4 } from "viem";
 async function getMint({
   params,
   mintGetter,
@@ -3767,10 +3896,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);
   }
@@ -3831,6 +3962,7 @@ async function getMintsOfContract({
 }
 async function getMintCosts({
   params,
+  allowListEntry,
   mintGetter,
   premintGetter,
   publicClient
@@ -3838,14 +3970,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({
@@ -3901,7 +4038,6 @@ function parsePremint({
     return {
       creator: premint.signer,
       maxSupply: premint.premint.premintConfig.tokenConfig.maxSupply,
-      mintFeePerQuantity: mintFee,
       mintType: "premint",
       uid: premint.premint.premintConfig.uid,
       contract: {
@@ -3915,21 +4051,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) };
 }
@@ -3940,9 +4085,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({
@@ -3956,7 +4101,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),
@@ -4062,29 +4207,12 @@ 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
 import {
   zoraCreator1155FactoryImplABI as zoraCreator1155FactoryImplABI2,
   zoraCreator1155FactoryImplAddress as zoraCreator1155FactoryImplAddress2,
-  zoraCreator1155ImplABI as zoraCreator1155ImplABI5
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI6
 } from "@zoralabs/protocol-deployments";
 import { decodeEventLog as decodeEventLog2 } from "viem";
 
@@ -4102,1125 +4230,399 @@ function new1155ContractVersion(chainId) {
   }
   return address.CONTRACT_1155_IMPL_VERSION;
 }
-async function getContractInfo({
+async function getContractInfoExistingContract({
   publicClient,
-  chainId,
-  contract,
-  account
+  contractAddress
 }) {
-  const contractAddress = typeof contract === "string" ? contract : await publicClient.readContract({
-    abi: zoraCreator1155FactoryImplABI,
-    // Since this address is deterministic we can hardcode a chain id safely here.
-    address: zoraCreator1155FactoryImplAddress[chainId],
-    functionName: "deterministicContractAddress",
-    args: [
-      account,
-      contract.uri,
-      contract.name,
-      contract.defaultAdmin || account
-    ]
-  });
   let contractVersion;
-  let contractExists;
   try {
     contractVersion = await publicClient.readContract({
       abi: zoraCreator1155ImplABI3,
       address: contractAddress,
       functionName: "contractVersion"
     });
-    contractExists = true;
   } catch (e) {
-    contractVersion = new1155ContractVersion(chainId);
-    contractExists = false;
+    throw new Error(`Contract does not exist at ${contractAddress}`);
   }
-  const nextTokenId = contractExists ? await publicClient.readContract({
+  const nextTokenId = await publicClient.readContract({
     address: contractAddress,
     abi: zoraCreator1155ImplABI3,
     functionName: "nextTokenId"
-  }) : 1n;
+  });
+  const contractName = await publicClient.readContract({
+    address: contractAddress,
+    abi: zoraCreator1155ImplABI3,
+    functionName: "name"
+  });
   return {
-    contractExists,
-    contractAddress,
     contractVersion,
+    contractName,
     nextTokenId
   };
 }
-
-// src/create/token-setup.ts
-var semver3 = __toESM(require_semver2(), 1);
-import {
-  erc20MinterABI as erc20MinterABI2,
-  erc20MinterAddress as erc20MinterAddresses,
-  zoraCreator1155ImplABI as zoraCreator1155ImplABI4,
-  zoraCreatorFixedPriceSaleStrategyABI,
-  zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress2
-} from "@zoralabs/protocol-deployments";
-import { encodeFunctionData, zeroAddress as zeroAddress5 } from "viem";
-var PERMISSION_BITS = {
-  MINTER: 2n ** 2n
-};
-var saleSettingsOrDefault = (saleSettings) => {
-  const SALE_END_FOREVER = 18446744073709551615n;
-  const DEFAULT_SALE_SETTINGS = {
-    currency: zeroAddress5,
-    // Free Mint
-    pricePerToken: 0n,
-    // Sale start time – defaults to beginning of unix time
-    saleStart: 0n,
-    // This is the end of uint64, plenty of time
-    saleEnd: SALE_END_FOREVER,
-    // 0 Here means no limit
-    maxTokensPerAddress: 0n
-  };
-  return {
-    ...DEFAULT_SALE_SETTINGS,
-    ...saleSettings
-  };
-};
-function applyNew1155Defaults(props, ownerAddress) {
-  const { payoutRecipient: fundsRecipient } = props;
-  const fundsRecipientOrOwner = fundsRecipient && fundsRecipient !== zeroAddress5 ? fundsRecipient : ownerAddress;
-  return {
-    payoutRecipient: fundsRecipientOrOwner,
-    createReferral: props.createReferral || zeroAddress5,
-    maxSupply: typeof props.maxSupply === "undefined" ? OPEN_EDITION_MINT_SIZE : BigInt(props.maxSupply),
-    royaltyBPS: props.royaltyBPS || 1e3,
-    salesConfig: saleSettingsOrDefault(props.salesConfig),
-    tokenMetadataURI: props.tokenMetadataURI
-  };
-}
-function setupErc20Minter({
-  pricePerToken,
-  chainId,
-  tokenId: nextTokenId,
-  currency,
-  saleStart,
-  saleEnd,
-  maxTokensPerAddress: mintLimit,
-  fundsRecipient
+async function getDeterministicContractAddress({
+  publicClient,
+  account,
+  setupActions,
+  contract,
+  chainId
 }) {
-  const erc20MinterAddress = erc20MinterAddresses[chainId];
-  if (!erc20MinterAddress)
-    throw new Error(`ERC20Minter not deployed on chainId ${chainId}`);
-  const erc20MinterApproval = encodeFunctionData({
-    abi: zoraCreator1155ImplABI4,
-    functionName: "addPermission",
-    args: [BigInt(nextTokenId), erc20MinterAddress, PERMISSION_BITS.MINTER]
-  });
-  const saleData = encodeFunctionData({
-    abi: erc20MinterABI2,
-    functionName: "setSale",
+  const contractAddress = await publicClient.readContract({
+    abi: zoraCreator1155FactoryImplABI,
+    address: zoraCreator1155FactoryImplAddress[chainId],
+    functionName: "deterministicContractAddressWithSetupActions",
     args: [
-      BigInt(nextTokenId),
-      {
-        saleStart: saleStart || BigInt(0),
-        saleEnd: saleEnd || BigInt(0),
-        maxTokensPerAddress: BigInt(mintLimit || 0),
-        pricePerToken,
-        fundsRecipient,
-        currency
-      }
+      account,
+      contract.uri,
+      contract.name,
+      contract.defaultAdmin || account,
+      setupActions
     ]
   });
-  const callSale = encodeFunctionData({
-    abi: zoraCreator1155ImplABI4,
-    functionName: "callSale",
-    args: [BigInt(nextTokenId), erc20MinterAddress, saleData]
-  });
-  return {
-    minter: erc20MinterAddress,
-    setupActions: [erc20MinterApproval, callSale]
-  };
+  return contractAddress;
 }
-function setupFixedPriceMinter({
-  pricePerToken: price,
-  tokenId: nextTokenId,
-  chainId,
-  saleStart,
-  saleEnd,
-  maxTokensPerAddress: mintLimit,
-  fundsRecipient
-}) {
-  const fixedPriceStrategyAddress = zoraCreatorFixedPriceSaleStrategyAddress2[chainId];
-  const fixedPriceApproval = encodeFunctionData({
-    abi: zoraCreator1155ImplABI4,
-    functionName: "addPermission",
-    args: [
-      BigInt(nextTokenId),
-      fixedPriceStrategyAddress,
-      PERMISSION_BITS.MINTER
-    ]
-  });
-  const saleData = encodeFunctionData({
-    abi: zoraCreatorFixedPriceSaleStrategyABI,
-    functionName: "setSale",
-    args: [
-      BigInt(nextTokenId),
-      {
-        pricePerToken: price,
-        saleStart: saleStart || BigInt(0),
-        saleEnd: saleEnd || BigInt(0),
-        maxTokensPerAddress: BigInt(mintLimit || 0),
-        fundsRecipient
-      }
-    ]
-  });
-  const callSale = encodeFunctionData({
-    abi: zoraCreator1155ImplABI4,
-    functionName: "callSale",
-    args: [BigInt(nextTokenId), fixedPriceStrategyAddress, saleData]
-  });
-  return {
-    minter: fixedPriceStrategyAddress,
-    setupActions: [fixedPriceApproval, callSale]
-  };
-}
-function setupMinters({ salesConfig, ...rest }) {
-  if (!salesConfig)
-    throw new Error("No sales config for token");
-  const { currency: currencyAddress } = salesConfig;
-  if (currencyAddress === zeroAddress5) {
-    return setupFixedPriceMinter({
-      ...salesConfig,
-      ...rest
-    });
-  } else {
-    return setupErc20Minter({
-      ...salesConfig,
-      ...rest
-    });
-  }
+
+// src/create/token-setup.ts
+var semver2 = __toESM(require_semver2(), 1);
+import { zoraCreator1155ImplABI as zoraCreator1155ImplABI5 } from "@zoralabs/protocol-deployments";
+import { encodeFunctionData as encodeFunctionData2, zeroAddress as zeroAddress5 } from "viem";
+
+// src/ipfs/arweave.ts
+function isArweaveURL(url) {
+  return url && typeof url === "string" ? url.startsWith("ar://") : false;
 }
-function buildSetupNewToken({
-  tokenURI,
-  maxSupply = OPEN_EDITION_MINT_SIZE,
-  createReferral = zeroAddress5,
-  contractVersion
-}) {
-  if (contractSupportsMintRewards(contractVersion, "ERC1155")) {
-    return encodeFunctionData({
-      abi: zoraCreator1155ImplABI4,
-      functionName: "setupNewTokenWithCreateReferral",
-      args: [tokenURI, BigInt(maxSupply), createReferral]
-    });
+
+// ../../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;
   }
-  if (createReferral !== zeroAddress5) {
-    throw new Error(
-      "Contract does not support create referral, but one was provided"
-    );
+  for (let ii = 0; ii < aa.byteLength; ii++) {
+    if (aa[ii] !== bb[ii]) {
+      return false;
+    }
   }
-  return encodeFunctionData({
-    abi: zoraCreator1155ImplABI4,
-    functionName: "setupNewToken",
-    args: [tokenURI, BigInt(maxSupply)]
-  });
+  return true;
 }
-function setupRoyaltyConfig({
-  royaltyBPS,
-  royaltyRecipient,
-  nextTokenId
-}) {
-  if (royaltyBPS > 0 && royaltyRecipient != zeroAddress5) {
-    return encodeFunctionData({
-      abi: zoraCreator1155ImplABI4,
-      functionName: "updateRoyaltiesForToken",
-      args: [
-        nextTokenId,
-        {
-          royaltyBPS,
-          royaltyRecipient,
-          royaltyMintSchedule: 0
-        }
-      ]
-    });
+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 null;
+  throw new Error("Unknown type, must be binary type");
 }
-function makeAdminMintCall({
-  ownerAddress,
-  mintQuantity,
-  nextTokenId
-}) {
-  if (!mintQuantity || mintQuantity <= 0 || !ownerAddress) {
-    return null;
+
+// ../../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");
   }
-  return encodeFunctionData({
-    abi: zoraCreator1155ImplABI4,
-    functionName: "adminMint",
-    args: [ownerAddress, nextTokenId, BigInt(mintQuantity), zeroAddress5]
-  });
-}
-function constructCreate1155TokenCalls(props) {
-  const {
-    chainId,
-    nextTokenId,
-    mintToCreatorCount,
-    ownerAddress,
-    contractVersion
-  } = props;
-  const new1155TokenPropsWithDefaults = applyNew1155Defaults(
-    props,
-    ownerAddress
-  );
-  const verifyTokenIdExpected = encodeFunctionData({
-    abi: zoraCreator1155ImplABI4,
-    functionName: "assumeLastTokenIdMatches",
-    args: [nextTokenId - 1n]
-  });
-  const setupNewToken = buildSetupNewToken({
-    tokenURI: new1155TokenPropsWithDefaults.tokenMetadataURI,
-    maxSupply: new1155TokenPropsWithDefaults.maxSupply,
-    createReferral: new1155TokenPropsWithDefaults.createReferral,
-    contractVersion
-  });
-  const royaltyConfig = setupRoyaltyConfig({
-    royaltyBPS: new1155TokenPropsWithDefaults.royaltyBPS,
-    royaltyRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
-    nextTokenId
-  });
-  const { minter, setupActions: mintersSetup } = setupMinters({
-    tokenId: nextTokenId,
-    chainId,
-    fundsRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
-    salesConfig: new1155TokenPropsWithDefaults.salesConfig
-  });
-  const adminMintCall = makeAdminMintCall({
-    ownerAddress,
-    mintQuantity: mintToCreatorCount,
-    nextTokenId
-  });
-  const setupActions = [
-    verifyTokenIdExpected,
-    setupNewToken,
-    ...mintersSetup,
-    royaltyConfig,
-    adminMintCall
-  ].filter((item) => item !== null);
-  return {
-    setupActions,
-    minter,
-    newToken: new1155TokenPropsWithDefaults
-  };
-}
-var contractSupportsMintRewards = (contractVersion, contractStandard) => {
-  if (!contractStandard || !contractVersion) {
-    return false;
+  var BASE_MAP = new Uint8Array(256);
+  for (var j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
   }
-  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");
+  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;
   }
-};
-
-// src/create/1155-create-helper.ts
-var ROYALTY_BPS_DEFAULT = 1e3;
-var getTokenIdFromCreateReceipt = (receipt) => {
-  for (const data of receipt.logs) {
-    try {
-      const decodedLog = decodeEventLog2({
-        abi: zoraCreator1155ImplABI5,
-        eventName: "SetupNewToken",
-        ...data
-      });
-      if (decodedLog && decodedLog.eventName === "SetupNewToken") {
-        return decodedLog.args.tokenId;
+  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;
   }
-};
-function makeCreateContractAndTokenCall({
-  contractExists,
-  contractAddress,
-  contract,
-  account,
-  royaltyBPS,
-  tokenSetupActions,
-  fundsRecipient
-}) {
-  if (!contractAddress && typeof contract === "string") {
-    throw new Error("Invariant: contract cannot be missing and an address");
-  }
-  if (!contractExists) {
-    if (typeof contract === "string") {
-      throw new Error("Invariant: expected contract object");
+  function decodeUnsafe(source) {
+    if (typeof source !== "string") {
+      throw new TypeError("Expected String");
     }
-    const accountAddress = typeof account === "string" ? account : account.address;
-    return makeContractParameters({
-      abi: zoraCreator1155FactoryImplABI2,
-      functionName: "createContractDeterministic",
-      account,
-      address: zoraCreator1155FactoryImplAddress2[999],
-      args: [
-        contract.uri,
-        contract.name,
-        {
-          // deprecated
-          royaltyMintSchedule: 0,
-          royaltyBPS: royaltyBPS || ROYALTY_BPS_DEFAULT,
-          royaltyRecipient: fundsRecipient || accountAddress
-        },
-        contract.defaultAdmin || accountAddress,
-        tokenSetupActions
-      ]
-    });
-  }
-  return makeContractParameters({
-    abi: zoraCreator1155ImplABI5,
-    functionName: "multicall",
-    account,
-    address: contractAddress,
-    args: [tokenSetupActions]
-  });
-}
-var Create1155Client = class {
-  constructor({
-    chainId,
-    publicClient
-  }) {
-    this.chainId = chainId;
-    this.publicClient = publicClient;
+    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;
   }
-  async createNew1155Token(props) {
-    return createNew1155Token({
-      ...props,
-      publicClient: this.publicClient,
-      chainId: this.chainId
-    });
+  function decode5(string) {
+    var buffer = decodeUnsafe(string);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error(`Non-${name} character`);
   }
-};
-async function createNew1155Token({
-  contract,
-  account,
-  getAdditionalSetupActions,
-  token: tokenConfig,
-  publicClient,
-  chainId
-}) {
-  const { contractExists, contractAddress, nextTokenId, contractVersion } = await getContractInfo({
-    publicClient,
-    chainId,
-    contract,
-    account
-  });
-  const {
-    minter,
-    newToken,
-    setupActions: tokenSetupActions
-  } = constructCreate1155TokenCalls({
-    chainId,
-    ownerAddress: account,
-    contractVersion,
-    nextTokenId,
-    ...tokenConfig
-  });
-  const setupActions = getAdditionalSetupActions ? [
-    ...getAdditionalSetupActions({
-      tokenId: nextTokenId,
-      contractAddress
-    }),
-    ...tokenSetupActions
-  ] : tokenSetupActions;
-  const request = makeCreateContractAndTokenCall({
-    contractExists,
-    contractAddress,
-    contract,
-    account,
-    tokenSetupActions: setupActions,
-    royaltyBPS: tokenConfig.royaltyBPS,
-    fundsRecipient: tokenConfig.payoutRecipient
-  });
   return {
-    parameters: request,
-    tokenSetupActions,
-    collectionAddress: contractAddress,
-    contractExists,
-    newTokenId: nextTokenId,
-    newToken,
-    minter
+    encode: encode3,
+    decodeUnsafe,
+    decode: decode5
   };
 }
+var src = base2;
+var _brrp__multiformats_scope_baseX = src;
+var base_x_default = _brrp__multiformats_scope_baseX;
 
-// src/sparks/mints-queries.ts
-var getMintsAccountBalanceWithPriceQuery = (account) => {
-  const query = `
-    query GetMintAccountBalances($account: String!) {
-      mintAccountBalances(where: { account: $account }) {
-        balance
-        mintToken {
-          id
-          pricePerToken
-        }
-      }
+// ../../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");
     }
-  `;
-  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;
+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");
     }
-    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");
+    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");
     }
-    const quantityToUse = remainingQuantity > next.quantity ? next.quantity : remainingQuantity;
-    tokenIds.push(next.tokenId);
-    quantities.push(quantityToUse);
-    remainingQuantity -= quantityToUse;
   }
-  return {
-    tokenIds,
-    quantities
-  };
+  or(decoder) {
+    return or(this, decoder);
+  }
 };
-var sumBalances = (mintAccountBalances) => {
-  return mintAccountBalances.reduce((acc, curr) => {
-    return acc + BigInt(curr.balance);
-  }, BigInt(0));
+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`);
+    }
+  }
 };
-
-// src/sparks/sparks-contracts.ts
-import {
-  mintsSafeTransferBatchTypedDataDefinition,
-  mintsSafeTransferTypedDataDefinition,
-  zoraMints1155Config,
-  zoraMintsManagerImplABI,
-  zoraMintsManagerImplAddress,
-  zoraMintsManagerImplConfig,
-  zoraSparksManagerImplABI,
-  zoraSparksManagerImplAddress
-} from "@zoralabs/protocol-deployments";
-import {
-  decodeErrorResult,
-  encodeFunctionData as encodeFunctionData2,
-  zeroAddress as zeroAddress6
-} from "viem";
-var addressOrAccountAddress = (address) => typeof address === "string" ? address : address.address;
-var mintWithEthParams = ({
-  tokenId,
-  quantity,
-  recipient,
-  chainId,
-  pricePerMint,
-  account
-}) => makeContractParameters({
-  abi: zoraSparksManagerImplABI,
-  address: 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;
-};
-var mintsBalanceOfAccountParams = ({
-  account,
-  chainId
-}) => ({
-  abi: zoraMints1155Config.abi,
-  address: zoraMints1155Config.address[chainId],
-  functionName: "balanceOfAccount",
-  args: [account]
-});
-var encodeCollectOnManager = ({
-  zoraCreator1155Contract,
-  minter,
-  zoraCreator1155TokenId,
-  mintArguments
-}) => encodeFunctionData2({
-  abi: 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: zoraMints1155Config.abi,
-    address: 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 or(left, right) {
+  return new ComposedDecoder({
+    ...left.decoders ?? { [left.prefix]: left },
+    ...right.decoders ?? { [right.prefix]: right }
   });
 }
-function getMintsEthPrice({
-  publicClient
-}) {
-  const chainId = publicClient.chain?.id;
-  if (!chainId || !zoraMintsManagerImplAddress[chainId]) {
-    throw new Error(`Chain id ${chainId} not supported`);
+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);
   }
-  return publicClient.readContract({
-    abi: zoraMintsManagerImplABI,
-    address: 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 = {
-    ...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 = {
-    ...mintsSafeTransferTypedDataDefinition({
-      chainId,
-      message: permit
-    }),
-    account: mintsOwner
-  };
-  return {
-    permit,
-    typedData
-  };
-}
-var encodePremintOnManager = ({
-  contractCreationConfig,
-  premintConfig,
-  premintSignature,
-  mintArguments,
-  signerContract = zeroAddress6
-}) => encodeFunctionData2({
-  abi: 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
-}) => {
-  let safeTransferData;
-  if (premint) {
-    safeTransferData = encodePremintOnManager(premint);
-  } else if (collect) {
-    safeTransferData = encodeCollectOnManager(collect);
-  } else {
-    throw new Error("Invalid operation");
+  encode(input) {
+    return this.encoder.encode(input);
+  }
+  decode(input) {
+    return this.decoder.decode(input);
   }
-  return makePermitTransferBatchAndTypeData({
-    tokenIds,
-    quantities,
-    chainId,
-    mintsOwner,
-    nonce,
-    deadline,
-    safeTransferData,
-    to: zoraMintsManagerImplConfig.address[chainId]
-  });
 };
-function collectPremintV2WithMintsParams({
-  tokenIds,
-  quantities,
-  paidMintPricePerToken,
-  account,
-  chainId,
-  ...rest
-}) {
-  const call = encodePremintOnManager({
-    ...rest
-  });
-  return makeContractParameters({
-    abi: zoraMints1155Config.abi,
-    address: zoraMints1155Config.address[chainId],
-    functionName: "transferBatchToManagerAndCall",
-    args: [tokenIds, quantities, call],
-    value: getPaidMintValue(quantities, paidMintPricePerToken),
-    account
-  });
+function from({ name, prefix, encode: encode3, decode: decode5 }) {
+  return new Codec(name, prefix, encode3, decode5);
 }
-function decodeCallFailedError(error) {
-  if (error.data?.errorName !== "CallFailed")
-    throw new Error("Not a CallFailed error");
-  const internalErrorData = error.data?.args?.[0];
-  return decodeErrorResult({
-    abi: zoraMintsManagerImplABI,
-    data: internalErrorData
+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))
   });
 }
-
-// src/sdk.ts
-function createCreatorClient(clientConfig) {
-  const premintClient = new PremintClient({
-    chainId: clientConfig.chainId,
-    publicClient: clientConfig.publicClient,
-    premintApi: clientConfig.premintApi || new PremintAPIClient(clientConfig.chainId)
-  });
-  const create1155CreatorClient = new Create1155Client({
-    chainId: clientConfig.chainId,
-    publicClient: clientConfig.publicClient
-  });
-  return {
-    createPremint: (p) => premintClient.createPremint(p),
-    updatePremint: (p) => premintClient.updatePremint(p),
-    deletePremint: (p) => premintClient.deletePremint(p),
-    create1155: (p) => create1155CreatorClient.createNew1155Token(p)
-  };
-}
-function createCollectorClient(params) {
-  const premintGetterToUse = params.premintGetter || new PremintAPIClient(params.chainId);
-  const mintGetterToUse = params.mintGetter || new SubgraphMintGetter(params.chainId);
-  const mintClient = new MintClient({
-    publicClient: params.publicClient,
-    premintGetter: premintGetterToUse,
-    mintGetter: mintGetterToUse
-  });
-  return {
-    getPremint: (p) => premintGetterToUse.get({
-      collectionAddress: p.address,
-      uid: p.uid
-    }),
-    getCollectDataFromPremintReceipt: (p) => getDataFromPremintReceipt(p, params.chainId),
-    getToken: (p) => mintClient.get(p),
-    getTokensOfContract: (p) => mintClient.getOfContract(p),
-    mint: (p) => mintClient.mint(p),
-    getMintCosts: (p) => mintClient.getMintCosts(p)
-  };
-}
-
-// src/ipfs/arweave.ts
-function isArweaveURL(url) {
-  return url && typeof url === "string" ? url.startsWith("ar://") : false;
-}
-
-// ../../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;
+function decode(string, alphabet, bitsPerChar, name) {
+  const codes = {};
+  for (let i = 0; i < alphabet.length; ++i) {
+    codes[alphabet[i]] = i;
   }
-  for (let ii = 0; ii < aa.byteLength; ii++) {
-    if (aa[ii] !== bb[ii]) {
-      return false;
+  let end = string.length;
+  while (string[end - 1] === "=") {
+    --end;
+  }
+  const out = new Uint8Array(end * bitsPerChar / 8 | 0);
+  let bits = 0;
+  let buffer = 0;
+  let written = 0;
+  for (let i = 0; i < end; ++i) {
+    const value = codes[string[i]];
+    if (value === void 0) {
+      throw new SyntaxError(`Non-${name} character`);
+    }
+    buffer = buffer << bitsPerChar | value;
+    bits += bitsPerChar;
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 255 & buffer >> bits;
     }
   }
-  return true;
-}
-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);
+  if (bits >= bitsPerChar || (255 & buffer << 8 - bits) !== 0) {
+    throw new SyntaxError("Unexpected end of data");
   }
-  throw new Error("Unknown type, must be binary type");
+  return out;
 }
-
-// ../../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;
-  }
-  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");
+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];
     }
-    BASE_MAP[xc] = i;
   }
-  var BASE = ALPHABET.length;
-  var LEADER = ALPHABET.charAt(0);
-  var FACTOR = Math.log(BASE) / Math.log(256);
-  var iFACTOR = Math.log(256) / Math.log(BASE);
-  function encode3(source) {
-    if (source instanceof Uint8Array)
-      ;
-    else if (ArrayBuffer.isView(source)) {
-      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-    } else if (Array.isArray(source)) {
-      source = Uint8Array.from(source);
-    }
-    if (!(source instanceof Uint8Array)) {
-      throw new TypeError("Expected Uint8Array");
-    }
-    if (source.length === 0) {
-      return "";
-    }
-    var zeroes = 0;
-    var length2 = 0;
-    var pbegin = 0;
-    var pend = source.length;
-    while (pbegin !== pend && source[pbegin] === 0) {
-      pbegin++;
-      zeroes++;
-    }
-    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
-    var b58 = new Uint8Array(size);
-    while (pbegin !== pend) {
-      var carry = source[pbegin];
-      var i2 = 0;
-      for (var it1 = size - 1; (carry !== 0 || i2 < length2) && it1 !== -1; it1--, i2++) {
-        carry += 256 * b58[it1] >>> 0;
-        b58[it1] = carry % BASE >>> 0;
-        carry = carry / BASE >>> 0;
-      }
-      if (carry !== 0) {
-        throw new Error("Non-zero carry");
-      }
-      length2 = i2;
-      pbegin++;
-    }
-    var it2 = size - length2;
-    while (it2 !== size && b58[it2] === 0) {
-      it2++;
-    }
-    var str = LEADER.repeat(zeroes);
-    for (; it2 < size; ++it2) {
-      str += ALPHABET.charAt(b58[it2]);
-    }
-    return str;
+  if (bits !== 0) {
+    out += alphabet[mask & buffer << bitsPerChar - bits];
   }
-  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++];
+  if (pad) {
+    while ((out.length * bitsPerChar & 7) !== 0) {
+      out += "=";
     }
-    return vch;
   }
-  function decode5(string) {
-    var buffer = decodeUnsafe(string);
-    if (buffer) {
-      return buffer;
+  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);
     }
-    throw new Error(`Non-${name} character`);
-  }
-  return {
-    encode: encode3,
-    decodeUnsafe,
-    decode: decode5
-  };
-}
-var src = base2;
-var _brrp__multiformats_scope_baseX = src;
-var base_x_default = _brrp__multiformats_scope_baseX;
-
-// ../../node_modules/.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 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);
-  }
-  encode(input) {
-    return this.encoder.encode(input);
-  }
-  decode(input) {
-    return this.decoder.decode(input);
-  }
-};
-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;
-  }
-  let end = string.length;
-  while (string[end - 1] === "=") {
-    --end;
-  }
-  const out = new Uint8Array(end * bitsPerChar / 8 | 0);
-  let bits = 0;
-  let buffer = 0;
-  let written = 0;
-  for (let i = 0; i < end; ++i) {
-    const value = codes[string[i]];
-    if (value === void 0) {
-      throw new SyntaxError(`Non-${name} character`);
-    }
-    buffer = buffer << bitsPerChar | value;
-    bits += bitsPerChar;
-    if (bits >= 8) {
-      bits -= 8;
-      out[written++] = 255 & buffer >> bits;
-    }
-  }
-  if (bits >= bitsPerChar || (255 & buffer << 8 - bits) !== 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];
-    }
-  }
-  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);
-    }
-  });
+  });
 }
 
 // ../../node_modules/.pnpm/multiformats@13.2.1/node_modules/multiformats/dist/src/bases/base32.js
@@ -5375,7 +4777,7 @@ function create(code, digest) {
   return new Digest(code, size, digest, bytes);
 }
 function decode4(multihash) {
-  const bytes = coerce4(multihash);
+  const bytes = coerce2(multihash);
   const [code, sizeOffset] = decode3(bytes);
   const [size, digestOffset] = decode3(bytes.subarray(sizeOffset));
   const digest = bytes.subarray(sizeOffset + digestOffset);
@@ -5618,7 +5020,7 @@ var CID = class _CID {
   static decodeFirst(bytes) {
     const specs = _CID.inspectBytes(bytes);
     const prefixSize = specs.size - specs.multihashSize;
-    const multihashBytes = coerce4(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
+    const multihashBytes = coerce2(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
     if (multihashBytes.byteLength !== specs.multihashSize) {
       throw new Error("Incorrect length");
     }
@@ -5921,67 +5323,1060 @@ function mimeTypeToMedia(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;
+async function getMimeType(uri) {
+  if (!uri)
+    return uri;
+  const res = await fetch(uri, { method: "HEAD" });
+  let mimeType = res.headers.get("content-type");
+  return mimeType;
+}
+
+// src/ipfs/token-metadata.ts
+var makeTextTokenMetadata = (parameters) => {
+  const { name, textFileUrl, thumbnailUrl, attributes = [] } = parameters;
+  const content = textFileUrl ? {
+    mime: TEXT_PLAIN,
+    uri: textFileUrl
+  } : null;
+  const image = thumbnailUrl;
+  const animation_url = textFileUrl;
+  return {
+    name,
+    image,
+    animation_url,
+    content,
+    attributes
+  };
+};
+var makeMediaTokenMetadata = async ({
+  name,
+  description,
+  attributes = [],
+  mediaUrl,
+  thumbnailUrl
+}) => {
+  const contentUrl = mediaUrl;
+  const fetchableContentUrl = getFetchableUrl(contentUrl);
+  if (!fetchableContentUrl)
+    throw new Error(`Content url (${contentUrl}) is not fetchable`);
+  const mimeType = await getMimeType(fetchableContentUrl);
+  const mediaType = mimeTypeToMedia(mimeType);
+  let image = void 0;
+  let animation_url = null;
+  if (isImage(mimeType)) {
+    image = contentUrl;
+  } else {
+    image = thumbnailUrl;
+    animation_url = mediaUrl;
+  }
+  if (!image)
+    image = `ipfs://${DEFAULT_THUMBNAIL_CID_HASHES[mediaType] || DEFAULT_THUMBNAIL_CID_HASHES.default}`;
+  const content = contentUrl ? {
+    mime: mimeType || "application/octet-stream",
+    uri: contentUrl
+  } : null;
+  return {
+    name,
+    description,
+    image,
+    animation_url,
+    content,
+    attributes
+  };
+};
+async function fetchTokenMetadata(tokenMetadataURI) {
+  const fetchableUrl = getFetchableUrl(tokenMetadataURI);
+  if (!fetchableUrl) {
+    throw new Error(`Invalid token metadata URI: ${tokenMetadataURI}`);
+  }
+  const json = await (await fetch(fetchableUrl)).json();
+  if (!json) {
+    throw new Error(`Failed to fetch metadata from ${fetchableUrl}`);
+  }
+  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");
+  }
+  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");
+  }
+  return result;
+};
+async function fetchTokenNameFromMetadata(tokenMetadataURI) {
+  const tokenMetadata = await fetchTokenMetadata(tokenMetadataURI);
+  if (!tokenMetadata.name) {
+    throw new Error("No name found in token metadata");
+  }
+  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);
+  }
+  if (isErc20(salesConfig)) {
+    return erc20SaleSettingsWithDefaults(salesConfig);
+  }
+  if (isFixedPrice(salesConfig)) {
+    return fixedPriceSettingsWithDefaults(salesConfig);
+  }
+  return timedSaleSettingsWithDefaults(salesConfig, tokenMetadataURI);
+};
+
+// src/create/minter-setup.ts
+import {
+  erc20MinterABI as erc20MinterABI2,
+  erc20MinterAddress as erc20MinterAddresses,
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI4,
+  zoraCreatorFixedPriceSaleStrategyABI,
+  zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress2,
+  zoraCreatorMerkleMinterStrategyABI,
+  zoraCreatorMerkleMinterStrategyAddress,
+  zoraTimedSaleStrategyABI as zoraTimedSaleStrategyABI2,
+  zoraTimedSaleStrategyAddress
+} from "@zoralabs/protocol-deployments";
+import { encodeFunctionData } from "viem";
+var PERMISSION_BITS = {
+  MINTER: 2n ** 2n
+};
+function setupErc20Minter({
+  pricePerToken,
+  chainId,
+  tokenId: nextTokenId,
+  currency,
+  saleStart,
+  saleEnd,
+  maxTokensPerAddress: mintLimit,
+  fundsRecipient
+}) {
+  const erc20MinterAddress = erc20MinterAddresses[chainId];
+  if (!erc20MinterAddress)
+    throw new Error(`ERC20Minter not deployed on chainId ${chainId}`);
+  const erc20MinterApproval = encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    functionName: "addPermission",
+    args: [BigInt(nextTokenId), erc20MinterAddress, PERMISSION_BITS.MINTER]
+  });
+  const saleData = encodeFunctionData({
+    abi: erc20MinterABI2,
+    functionName: "setSale",
+    args: [
+      BigInt(nextTokenId),
+      {
+        saleStart: saleStart || BigInt(0),
+        saleEnd: saleEnd || BigInt(0),
+        maxTokensPerAddress: BigInt(mintLimit || 0),
+        pricePerToken,
+        fundsRecipient,
+        currency
+      }
+    ]
+  });
+  const callSale = encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    functionName: "callSale",
+    args: [BigInt(nextTokenId), erc20MinterAddress, saleData]
+  });
+  return {
+    minter: erc20MinterAddress,
+    setupActions: [erc20MinterApproval, callSale]
+  };
+}
+function setupFixedPriceMinter({
+  pricePerToken: price,
+  tokenId: nextTokenId,
+  chainId,
+  saleStart,
+  saleEnd,
+  maxTokensPerAddress: mintLimit,
+  fundsRecipient
+}) {
+  const fixedPriceStrategyAddress = zoraCreatorFixedPriceSaleStrategyAddress2[chainId];
+  const fixedPriceApproval = encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    functionName: "addPermission",
+    args: [
+      BigInt(nextTokenId),
+      fixedPriceStrategyAddress,
+      PERMISSION_BITS.MINTER
+    ]
+  });
+  const saleData = encodeFunctionData({
+    abi: zoraCreatorFixedPriceSaleStrategyABI,
+    functionName: "setSale",
+    args: [
+      BigInt(nextTokenId),
+      {
+        pricePerToken: price,
+        saleStart: saleStart || BigInt(0),
+        saleEnd: saleEnd || BigInt(0),
+        maxTokensPerAddress: BigInt(mintLimit || 0),
+        fundsRecipient
+      }
+    ]
+  });
+  const callSale = encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    functionName: "callSale",
+    args: [BigInt(nextTokenId), fixedPriceStrategyAddress, saleData]
+  });
+  return {
+    minter: fixedPriceStrategyAddress,
+    setupActions: [fixedPriceApproval, callSale]
+  };
+}
+function setupTimedSaleMinter({
+  chainId,
+  tokenId,
+  erc20Name: erc20zName,
+  erc20Symbol: erc20zSymbol,
+  saleStart,
+  saleEnd
+}) {
+  const minterAddress = zoraTimedSaleStrategyAddress[chainId];
+  const fixedPriceApproval = encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    functionName: "addPermission",
+    args: [BigInt(tokenId), minterAddress, PERMISSION_BITS.MINTER]
+  });
+  const saleData = encodeFunctionData({
+    abi: zoraTimedSaleStrategyABI2,
+    functionName: "setSale",
+    args: [
+      BigInt(tokenId),
+      {
+        saleStart,
+        saleEnd,
+        name: erc20zName,
+        symbol: erc20zSymbol
+      }
+    ]
+  });
+  const callSale = encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    functionName: "callSale",
+    args: [BigInt(tokenId), minterAddress, saleData]
+  });
+  return {
+    minter: minterAddress,
+    setupActions: [fixedPriceApproval, callSale]
+  };
+}
+function setupAllowListMinter({
+  chainId,
+  tokenId: nextTokenId,
+  allowlist,
+  fundsRecipient
+}) {
+  const merkleSaleStrategyAddress = zoraCreatorMerkleMinterStrategyAddress[chainId];
+  const merkleApproval = encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    functionName: "addPermission",
+    args: [nextTokenId, merkleSaleStrategyAddress, PERMISSION_BITS.MINTER]
+  });
+  const merkleRoot = allowlist.presaleMerkleRoot.startsWith("0x") ? allowlist.presaleMerkleRoot : `0x${allowlist.presaleMerkleRoot}`;
+  const saleData = encodeFunctionData({
+    abi: zoraCreatorMerkleMinterStrategyABI,
+    functionName: "setSale",
+    args: [
+      BigInt(nextTokenId),
+      {
+        presaleStart: allowlist.saleStart,
+        presaleEnd: allowlist.saleEnd,
+        merkleRoot,
+        fundsRecipient
+      }
+    ]
+  });
+  const callSaleMerkle = encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    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
+    });
+  }
+  if (isAllowList2(salesConfig)) {
+    return setupAllowListMinter({
+      allowlist: salesConfig,
+      ...rest
+    });
+  }
+  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 !== zeroAddress5 ? fundsRecipient : ownerAddress;
+  return {
+    payoutRecipient: fundsRecipientOrOwner,
+    createReferral: props.createReferral || zeroAddress5,
+    maxSupply: typeof props.maxSupply === "undefined" ? OPEN_EDITION_MINT_SIZE : BigInt(props.maxSupply),
+    royaltyBPS: props.royaltyBPS || 1e3,
+    tokenMetadataURI: props.tokenMetadataURI,
+    salesConfig: await getSalesConfigWithDefaults(
+      props.salesConfig,
+      props.tokenMetadataURI
+    )
+  };
+}
+function buildSetupNewToken({
+  tokenURI,
+  maxSupply = OPEN_EDITION_MINT_SIZE,
+  createReferral = zeroAddress5,
+  contractVersion
+}) {
+  if (contractSupportsMintRewards(contractVersion, "ERC1155")) {
+    return encodeFunctionData2({
+      abi: zoraCreator1155ImplABI5,
+      functionName: "setupNewTokenWithCreateReferral",
+      args: [tokenURI, BigInt(maxSupply), createReferral]
+    });
+  }
+  if (createReferral !== zeroAddress5) {
+    throw new Error(
+      "Contract does not support create referral, but one was provided"
+    );
+  }
+  return encodeFunctionData2({
+    abi: zoraCreator1155ImplABI5,
+    functionName: "setupNewToken",
+    args: [tokenURI, BigInt(maxSupply)]
+  });
+}
+function setupRoyaltyConfig({
+  royaltyBPS,
+  royaltyRecipient,
+  nextTokenId
+}) {
+  if (royaltyBPS > 0 && royaltyRecipient != zeroAddress5) {
+    return encodeFunctionData2({
+      abi: zoraCreator1155ImplABI5,
+      functionName: "updateRoyaltiesForToken",
+      args: [
+        nextTokenId,
+        {
+          royaltyBPS,
+          royaltyRecipient,
+          royaltyMintSchedule: 0
+        }
+      ]
+    });
+  }
+  return null;
+}
+function makeAdminMintCall({
+  ownerAddress,
+  mintQuantity,
+  nextTokenId
+}) {
+  if (!mintQuantity || mintQuantity <= 0 || !ownerAddress) {
+    return null;
+  }
+  return encodeFunctionData2({
+    abi: zoraCreator1155ImplABI5,
+    functionName: "adminMint",
+    args: [ownerAddress, nextTokenId, BigInt(mintQuantity), zeroAddress5]
+  });
+}
+async function constructCreate1155TokenCalls(props) {
+  const {
+    chainId,
+    nextTokenId,
+    mintToCreatorCount,
+    ownerAddress,
+    contractVersion
+  } = props;
+  const new1155TokenPropsWithDefaults = await applyNew1155Defaults(
+    props,
+    ownerAddress
+  );
+  const verifyTokenIdExpected = encodeFunctionData2({
+    abi: zoraCreator1155ImplABI5,
+    functionName: "assumeLastTokenIdMatches",
+    args: [nextTokenId - 1n]
+  });
+  const setupNewToken = buildSetupNewToken({
+    tokenURI: new1155TokenPropsWithDefaults.tokenMetadataURI,
+    maxSupply: new1155TokenPropsWithDefaults.maxSupply,
+    createReferral: new1155TokenPropsWithDefaults.createReferral,
+    contractVersion
+  });
+  const royaltyConfig = setupRoyaltyConfig({
+    royaltyBPS: new1155TokenPropsWithDefaults.royaltyBPS,
+    royaltyRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
+    nextTokenId
+  });
+  const { minter, setupActions: mintersSetup } = setupMinters({
+    tokenId: nextTokenId,
+    chainId,
+    fundsRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
+    salesConfig: new1155TokenPropsWithDefaults.salesConfig
+  });
+  const adminMintCall = makeAdminMintCall({
+    ownerAddress,
+    mintQuantity: mintToCreatorCount,
+    nextTokenId
+  });
+  const setupActions = [
+    verifyTokenIdExpected,
+    setupNewToken,
+    ...mintersSetup,
+    royaltyConfig,
+    adminMintCall
+  ].filter((item) => item !== null);
+  return {
+    setupActions,
+    minter,
+    newToken: new1155TokenPropsWithDefaults
+  };
+}
+var contractSupportsMintRewards = (contractVersion, contractStandard) => {
+  if (!contractStandard || !contractVersion) {
+    return false;
+  }
+  const semVerContractVersion = semver2.coerce(contractVersion)?.raw;
+  if (!semVerContractVersion)
+    return false;
+  if (contractStandard === "ERC1155") {
+    return semver2.gte(semVerContractVersion, "1.3.5");
+  } else {
+    return semver2.gte(semVerContractVersion, "14.0.0");
+  }
+};
+
+// src/create/1155-create-helper.ts
+var ROYALTY_BPS_DEFAULT = 1e3;
+var getTokenIdFromCreateReceipt = (receipt) => {
+  for (const data of receipt.logs) {
+    try {
+      const decodedLog = decodeEventLog2({
+        abi: zoraCreator1155ImplABI6,
+        eventName: "SetupNewToken",
+        ...data
+      });
+      if (decodedLog && decodedLog.eventName === "SetupNewToken") {
+        return decodedLog.args.tokenId;
+      }
+    } catch (err) {
+    }
+  }
+  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 = decodeEventLog2({
+        abi: zoraCreator1155FactoryImplABI2,
+        eventName: "SetupNewContract",
+        ...data
+      });
+      if (decodedLog && decodedLog.eventName === "SetupNewContract") {
+        return decodedLog.args.newContract;
+      }
+    } 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: zoraCreator1155FactoryImplABI2,
+    functionName: "createContractDeterministic",
+    account,
+    address: zoraCreator1155FactoryImplAddress2[chainId],
+    args: [
+      contract.uri,
+      contract.name,
+      {
+        // deprecated
+        royaltyMintSchedule: 0,
+        royaltyBPS: royaltyBPS || ROYALTY_BPS_DEFAULT,
+        royaltyRecipient: fundsRecipient || accountAddress
+      },
+      contract.defaultAdmin || accountAddress,
+      tokenSetupActions
+    ]
+  });
+}
+function makeCreateTokenCall({
+  contractAddress,
+  account,
+  tokenSetupActions
+}) {
+  return makeContractParameters({
+    abi: zoraCreator1155ImplABI6,
+    functionName: "multicall",
+    account,
+    address: contractAddress,
+    args: [tokenSetupActions]
+  });
+}
+var Create1155Client = class {
+  constructor({
+    chainId,
+    publicClient
+  }) {
+    this.chainId = chainId;
+    this.publicClient = publicClient;
+  }
+  async createNew1155(props) {
+    return createNew1155ContractAndToken({
+      ...props,
+      publicClient: this.publicClient,
+      chainId: this.chainId
+    });
+  }
+  async createNew1155OnExistingContract({
+    contractAddress: contract,
+    account,
+    token,
+    getAdditionalSetupActions
+  }) {
+    return createNew1155Token({
+      contractAddress: contract,
+      account,
+      token,
+      getAdditionalSetupActions,
+      publicClient: this.publicClient,
+      chainId: this.chainId
+    });
+  }
+};
+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
+  };
+}
+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
+  };
+}
+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/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 {
+    tokenIds,
+    quantities
+  };
+};
+var sumBalances = (mintAccountBalances) => {
+  return mintAccountBalances.reduce((acc, curr) => {
+    return acc + BigInt(curr.balance);
+  }, BigInt(0));
+};
+
+// src/sparks/sparks-contracts.ts
+import {
+  mintsSafeTransferBatchTypedDataDefinition,
+  mintsSafeTransferTypedDataDefinition,
+  zoraMints1155Config,
+  zoraMintsManagerImplABI,
+  zoraMintsManagerImplAddress,
+  zoraMintsManagerImplConfig,
+  zoraSparksManagerImplABI,
+  zoraSparksManagerImplAddress
+} from "@zoralabs/protocol-deployments";
+import {
+  decodeErrorResult,
+  encodeFunctionData as encodeFunctionData3,
+  zeroAddress as zeroAddress6
+} from "viem";
+var addressOrAccountAddress = (address) => typeof address === "string" ? address : address.address;
+var mintWithEthParams = ({
+  tokenId,
+  quantity,
+  recipient,
+  chainId,
+  pricePerMint,
+  account
+}) => makeContractParameters({
+  abi: zoraSparksManagerImplABI,
+  address: 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;
+};
+var mintsBalanceOfAccountParams = ({
+  account,
+  chainId
+}) => ({
+  abi: zoraMints1155Config.abi,
+  address: zoraMints1155Config.address[chainId],
+  functionName: "balanceOfAccount",
+  args: [account]
+});
+var encodeCollectOnManager = ({
+  zoraCreator1155Contract,
+  minter,
+  zoraCreator1155TokenId,
+  mintArguments
+}) => encodeFunctionData3({
+  abi: 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: zoraMints1155Config.abi,
+    address: 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 || !zoraMintsManagerImplAddress[chainId]) {
+    throw new Error(`Chain id ${chainId} not supported`);
+  }
+  return publicClient.readContract({
+    abi: zoraMintsManagerImplABI,
+    address: 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 = {
+    ...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 = {
+    ...mintsSafeTransferTypedDataDefinition({
+      chainId,
+      message: permit
+    }),
+    account: mintsOwner
+  };
+  return {
+    permit,
+    typedData
+  };
+}
+var encodePremintOnManager = ({
+  contractCreationConfig,
+  premintConfig,
+  premintSignature,
+  mintArguments,
+  signerContract = zeroAddress6
+}) => encodeFunctionData3({
+  abi: 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: zoraMintsManagerImplConfig.address[chainId]
+  });
+};
+function collectPremintV2WithMintsParams({
+  tokenIds,
+  quantities,
+  paidMintPricePerToken,
+  account,
+  chainId,
+  ...rest
+}) {
+  const call = encodePremintOnManager({
+    ...rest
+  });
+  return makeContractParameters({
+    abi: zoraMints1155Config.abi,
+    address: 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 decodeErrorResult({
+    abi: 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;
@@ -6076,6 +6471,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;
+};
 export {
   Create1155Client,
   Errors,
@@ -6087,7 +6502,6 @@ export {
   ZORA_API_BASE,
   applyUpdateToPremint,
   buildPremintMintCall,
-  collectOnchain,
   collectPremint,
   collectPremintV2WithMintsParams,
   collectWithMintsParams,
@@ -6095,6 +6509,7 @@ export {
   convertGetPremintApiResponse,
   convertGetPremintOfCollectionApiResponse,
   convertPremintFromApi,
+  createAllowList,
   createCollectorClient,
   createCreatorClient,
   decodeCallFailedError,
@@ -6107,6 +6522,7 @@ export {
   encodePremintForAPI,
   generateTextNftMetadataFiles,
   getApiNetworkConfigForChain,
+  getContractAddressFromReceipt,
   getDataFromPremintReceipt,
   getDefaultFixedPriceMinterAddress,
   getMintsAccountBalanceWithPriceQuery,
@@ -6124,6 +6540,7 @@ export {
   isPremintConfigV1,
   isPremintConfigV2,
   isValidSignature,
+  makeCreateContractAndTokenCall,
   makeMediaTokenMetadata,
   makeMintRewardsRecipient,
   makeNewPremint,