@zoralabs/protocol-sdk 0.5.16 → 0.6.0

package/dist/index.js

@@ -1,6 +1,9 @@
 // src/premint/premint-client.ts
 import { decodeEventLog, zeroAddress as zeroAddress2 } from "viem";
-import { zoraCreator1155PremintExecutorImplABI as zoraCreator1155PremintExecutorImplABI2 } from "@zoralabs/protocol-deployments";
+import {
+  encodePremintConfig,
+  zoraCreator1155PremintExecutorImplABI as zoraCreator1155PremintExecutorImplABI2
+} from "@zoralabs/protocol-deployments";
 
 // src/premint/preminter.ts
 import {
@@ -17,26 +20,283 @@ import {
   keccak256,
   concat,
   recoverAddress,
-  parseEther
+  parseEther as parseEther2
 } from "viem";
+
+// src/apis/chain-constants.ts
+import {
+  arbitrum,
+  base,
+  baseSepolia,
+  foundry,
+  mainnet,
+  optimism,
+  sepolia,
+  zora,
+  zoraSepolia
+} from "viem/chains";
+import { parseEther } from "viem";
+
+// src/constants.ts
+import { parseAbi } from "viem";
+var ZORA_API_BASE = "https://api.zora.co/";
+var OPEN_EDITION_MINT_SIZE = BigInt("18446744073709551615");
+var SUBGRAPH_CONFIG_BASE = "https://api.goldsky.com/api/public/project_clhk16b61ay9t49vm6ntn4mkz/subgraphs";
+function getSubgraph(name, version) {
+  return `${SUBGRAPH_CONFIG_BASE}/${name}/${version}/gn`;
+}
+var zora721Abi = parseAbi([
+  "function mintWithRewards(address recipient, uint256 quantity, string calldata comment, address mintReferral) external payable",
+  "function zoraFeeForAmount(uint256 amount) public view returns (address, uint256)"
+]);
+var NFT_SALE_QUERY = `
+fragment SaleStrategy on SalesStrategyConfig {
+  type
+  fixedPrice {
+    address
+    pricePerToken
+    saleEnd
+    saleStart
+    maxTokensPerAddress
+  }
+  erc20Minter {
+    address
+    pricePerToken
+    currency
+    saleEnd
+    saleStart
+    maxTokensPerAddress
+  }
+}
+
+query ($id: ID!) {
+  zoraCreateToken(id: $id) {
+    id
+    contract {
+      mintFeePerQuantity
+      salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
+        ...SaleStrategy
+      }
+    }
+    salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
+      ...SaleStrategy
+    }
+  }
+}
+`;
+
+// src/apis/chain-constants.ts
+var REWARD_PER_TOKEN = parseEther("0.000777");
+var networkConfigByChain = {
+  [mainnet.id]: {
+    chainId: mainnet.id,
+    isTestnet: false,
+    zoraCollectPathChainName: "eth",
+    zoraBackendChainName: "ETHEREUM-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-mainnet", "stable")
+  },
+  [sepolia.id]: {
+    chainId: sepolia.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "sep",
+    zoraBackendChainName: "ETHEREUM-SEPOLIA",
+    subgraphUrl: getSubgraph("zora-create-sepolia", "stable")
+  },
+  [zora.id]: {
+    chainId: zora.id,
+    isTestnet: false,
+    zoraCollectPathChainName: "zora",
+    zoraBackendChainName: "ZORA-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-zora-mainnet", "stable")
+  },
+  [zoraSepolia.id]: {
+    chainId: zoraSepolia.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "zsep",
+    zoraBackendChainName: "ZORA-SEPOLIA",
+    subgraphUrl: getSubgraph("zora-create-zora-sepolia", "stable")
+  },
+  [optimism.id]: {
+    chainId: optimism.id,
+    isTestnet: false,
+    zoraCollectPathChainName: "oeth",
+    zoraBackendChainName: "OPTIMISM-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-optimism", "stable")
+  },
+  [arbitrum.id]: {
+    chainId: arbitrum.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "arb",
+    zoraBackendChainName: "ARBITRUM-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-arbitrum-one", "stable")
+  },
+  [base.id]: {
+    chainId: base.id,
+    isTestnet: false,
+    zoraCollectPathChainName: "base",
+    zoraBackendChainName: "BASE-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-base-mainnet", "stable")
+  },
+  [baseSepolia.id]: {
+    chainId: baseSepolia.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "bsep",
+    zoraBackendChainName: "BASE-SEPOLIA",
+    subgraphUrl: getSubgraph("zora-create-base-sepolia", "stable")
+  },
+  [foundry.id]: {
+    chainId: foundry.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "zgor",
+    zoraBackendChainName: "ZORA-GOERLI",
+    subgraphUrl: getSubgraph("zora-create-zora-testnet", "stable")
+  }
+};
+
+// src/premint/conversions.ts
+import {
+  PremintConfigVersion
+} from "@zoralabs/protocol-deployments";
+var convertCollectionFromApi = (collection) => {
+  if (!collection)
+    return void 0;
+  return {
+    additionalAdmins: collection.additionalAdmins || [],
+    contractAdmin: collection.contractAdmin,
+    contractName: collection.contractName,
+    contractURI: collection.contractURI
+  };
+};
+var convertPremintFromApi = (premint) => {
+  if (premint.config_version === PremintConfigVersion.V1 || !premint.config_version) {
+    const tokenConfig = premint.tokenConfig;
+    return {
+      premintConfigVersion: PremintConfigVersion.V1,
+      premintConfig: {
+        deleted: premint.deleted,
+        uid: premint.uid,
+        version: premint.version,
+        tokenConfig: {
+          ...tokenConfig,
+          fixedPriceMinter: tokenConfig.fixedPriceMinter,
+          royaltyRecipient: tokenConfig.royaltyRecipient,
+          maxSupply: BigInt(tokenConfig.maxSupply),
+          pricePerToken: BigInt(tokenConfig.pricePerToken),
+          mintStart: BigInt(tokenConfig.mintStart),
+          mintDuration: BigInt(tokenConfig.mintDuration),
+          maxTokensPerAddress: BigInt(tokenConfig.maxTokensPerAddress)
+        }
+      }
+    };
+  } else {
+    const tokenConfig = premint.tokenConfig;
+    return {
+      premintConfigVersion: PremintConfigVersion.V2,
+      premintConfig: {
+        deleted: premint.deleted,
+        uid: premint.uid,
+        version: premint.version,
+        tokenConfig: {
+          ...tokenConfig,
+          fixedPriceMinter: tokenConfig.fixedPriceMinter,
+          payoutRecipient: tokenConfig.payoutRecipient,
+          createReferral: tokenConfig.createReferral,
+          maxSupply: BigInt(tokenConfig.maxSupply),
+          pricePerToken: BigInt(tokenConfig.pricePerToken),
+          mintStart: BigInt(tokenConfig.mintStart),
+          mintDuration: BigInt(tokenConfig.mintDuration),
+          maxTokensPerAddress: BigInt(tokenConfig.maxTokensPerAddress)
+        }
+      }
+    };
+  }
+};
+var convertGetPremintApiResponse = (response) => ({
+  ...convertPremintFromApi(response.premint),
+  collection: convertCollectionFromApi(response.collection),
+  collectionAddress: response.collection_address,
+  signature: response.signature
+});
+var encodePremintV1ForAPI = ({
+  tokenConfig,
+  ...premint
+}) => ({
+  ...premint,
+  config_version: "1",
+  tokenConfig: {
+    ...tokenConfig,
+    maxSupply: tokenConfig.maxSupply.toString(),
+    pricePerToken: tokenConfig.pricePerToken.toString(),
+    mintStart: tokenConfig.mintStart.toString(),
+    mintDuration: tokenConfig.mintDuration.toString(),
+    maxTokensPerAddress: tokenConfig.maxTokensPerAddress.toString()
+  }
+});
+var encodePremintV2ForAPI = ({
+  tokenConfig,
+  ...premint
+}) => ({
+  ...premint,
+  config_version: "2",
+  tokenConfig: {
+    ...tokenConfig,
+    maxSupply: tokenConfig.maxSupply.toString(),
+    pricePerToken: tokenConfig.pricePerToken.toString(),
+    mintStart: tokenConfig.mintStart.toString(),
+    mintDuration: tokenConfig.mintDuration.toString(),
+    maxTokensPerAddress: tokenConfig.maxTokensPerAddress.toString()
+  }
+});
+var encodePremintForAPI = ({
+  premintConfig,
+  premintConfigVersion
+}) => {
+  if (premintConfigVersion === PremintConfigVersion.V1) {
+    return encodePremintV1ForAPI(premintConfig);
+  }
+  if (premintConfigVersion === PremintConfigVersion.V2) {
+    return encodePremintV2ForAPI(premintConfig);
+  }
+  throw new Error(`Invalid premint config version ${premintConfigVersion}`);
+};
+var encodePostSignatureInput = ({
+  contract: collection,
+  contractAddress: collectionAddress,
+  premintConfigVersion,
+  premintConfig,
+  signature,
+  chainId
+}) => ({
+  premint: encodePremintForAPI({
+    premintConfig,
+    premintConfigVersion
+  }),
+  signature,
+  collection,
+  collection_address: collectionAddress,
+  chain_name: networkConfigByChain[chainId].zoraBackendChainName
+});
+var isPremintConfigV1 = (premintConfigAndVersion) => premintConfigAndVersion.premintConfigVersion === PremintConfigVersion.V1;
+var isPremintConfigV2 = (premintConfigAndVersion) => premintConfigAndVersion.premintConfigVersion === PremintConfigVersion.V2;
+
+// src/premint/preminter.ts
 var getPremintExecutorAddress = () => zoraCreator1155PremintExecutorImplAddress[999];
 async function isAuthorizedToCreatePremint({
-  collection,
+  contractAdmin = zeroAddress,
+  additionalAdmins = [],
   collectionAddress,
   publicClient,
   signer
 }) {
-  if (collection.additionalAdmins.length > 0)
-    throw new Error("additionalAdmins not supported yet.");
   return await publicClient.readContract({
     abi: preminterAbi,
     address: getPremintExecutorAddress(),
     functionName: "isAuthorizedToCreatePremintWithAdditionalAdmins",
     args: [
-      signer,
-      collection.contractAdmin,
+      typeof signer === "string" ? signer : signer.address,
+      contractAdmin,
       collectionAddress,
-      collection.additionalAdmins
+      additionalAdmins
     ]
   });
 }
@@ -61,17 +321,14 @@ async function isValidSignature({
   signature,
   publicClient,
   collection,
+  collectionAddress,
   chainId,
   ...premintConfigAndVersion
 }) {
-  const tokenContract = await getPremintCollectionAddress({
-    collection,
-    publicClient
-  });
   const recoveredAddress = await tryRecoverPremintSigner({
     ...premintConfigAndVersion,
     signature,
-    verifyingContract: tokenContract,
+    verifyingContract: collectionAddress,
     chainId
   });
   if (!recoverAddress) {
@@ -81,8 +338,9 @@ async function isValidSignature({
   }
   const isAuthorized = await isAuthorizedToCreatePremint({
     signer: recoveredAddress,
-    collection,
-    collectionAddress: tokenContract,
+    additionalAdmins: collection?.additionalAdmins,
+    contractAdmin: collection?.contractAdmin,
+    collectionAddress,
     publicClient
   });
   return {
@@ -163,15 +421,24 @@ var supportsPremintVersion = async ({
   return (await supportedPremintVersions({ tokenContract, publicClient })).includes(version);
 };
 async function getPremintCollectionAddress({
-  collection,
-  publicClient
+  publicClient,
+  contract: collection,
+  contractAddress: collectionAddress
 }) {
-  return publicClient.readContract({
-    address: getPremintExecutorAddress(),
-    abi: zoraCreator1155PremintExecutorImplABI,
-    functionName: "getContractAddress",
-    args: [collection]
-  });
+  if (typeof collection !== "undefined") {
+    return publicClient.readContract({
+      address: getPremintExecutorAddress(),
+      abi: zoraCreator1155PremintExecutorImplABI,
+      functionName: "getContractWithAdditionalAdminsAddress",
+      args: [
+        {
+          ...collection,
+          additionalAdmins: collection.additionalAdmins || []
+        }
+      ]
+    });
+  }
+  return collectionAddress;
 }
 function applyUpdateToPremint({
   uid,
@@ -215,7 +482,7 @@ async function getPremintMintFee({
     });
   } catch (e) {
     console.error(e);
-    return parseEther("0.000777");
+    return parseEther2("0.000777");
   }
 }
 async function getPremintMintCosts({
@@ -225,12 +492,42 @@ async function getPremintMintCosts({
   quantityToMint
 }) {
   const mintFee = await getPremintMintFee({ tokenContract, publicClient });
+  const quantityToMintBigInt = BigInt(quantityToMint);
   return {
-    mintFee: mintFee * quantityToMint,
-    tokenPurchaseCost: tokenPrice * quantityToMint,
-    totalCost: (mintFee + tokenPrice) * quantityToMint
+    mintFee: mintFee * quantityToMintBigInt,
+    totalPurchaseCost: tokenPrice * quantityToMintBigInt,
+    totalCostEth: (mintFee + tokenPrice) * quantityToMintBigInt
   };
 }
+async function getPremintPricePerToken({
+  collection,
+  uid,
+  premintGetter
+}) {
+  const premintConfigWithVersion = await premintGetter.getSignature({
+    collectionAddress: collection,
+    uid
+  });
+  if (isPremintConfigV1(premintConfigWithVersion) || isPremintConfigV2(premintConfigWithVersion)) {
+    return premintConfigWithVersion.premintConfig.tokenConfig.pricePerToken;
+  }
+  throw new Error("Premint version not supported to get price");
+}
+async function getPremintMintCostsWithUnknownTokenPrice({
+  premintGetter,
+  uid,
+  ...rest
+}) {
+  const pricePerToken = await getPremintPricePerToken({
+    uid,
+    premintGetter,
+    collection: rest.tokenContract
+  });
+  return await getPremintMintCosts({
+    ...rest,
+    tokenPrice: pricePerToken
+  });
+}
 function makeMintRewardsRecipient({
   mintReferral = zeroAddress,
   platformReferral = zeroAddress
@@ -240,6 +537,34 @@ function makeMintRewardsRecipient({
 function getDefaultFixedPriceMinterAddress(chainId) {
   return zoraCreatorFixedPriceSaleStrategyAddress[chainId];
 }
+var emptyContractCreationConfig = () => ({
+  contractAdmin: zeroAddress,
+  contractURI: "",
+  contractName: "",
+  additionalAdmins: []
+});
+function defaultAdditionalAdmins(collection) {
+  return {
+    ...collection,
+    additionalAdmins: collection.additionalAdmins || []
+  };
+}
+var toContractCreationConfigOrAddress = ({
+  collection,
+  collectionAddress
+}) => {
+  if (typeof collection !== "undefined") {
+    return {
+      contract: collection
+    };
+  }
+  if (typeof collectionAddress !== "undefined") {
+    return {
+      contractAddress: collectionAddress
+    };
+  }
+  throw new Error("Must provide either a collection or a collection address");
+};
 
 // src/premint/premint-client.ts
 import {
@@ -321,142 +646,14 @@ var httpClient = {
   retries
 };
 
-// src/constants.ts
-import { parseAbi } from "viem";
-var ZORA_API_BASE = "https://api.zora.co/";
-var OPEN_EDITION_MINT_SIZE = BigInt("18446744073709551615");
-var SUBGRAPH_CONFIG_BASE = "https://api.goldsky.com/api/public/project_clhk16b61ay9t49vm6ntn4mkz/subgraphs";
-function getSubgraph(name, version) {
-  return `${SUBGRAPH_CONFIG_BASE}/${name}/${version}/gn`;
-}
-var zora721Abi = parseAbi([
-  "function mintWithRewards(address recipient, uint256 quantity, string calldata comment, address mintReferral) external payable",
-  "function zoraFeeForAmount(uint256 amount) public view returns (address, uint256)"
-]);
-var NFT_SALE_QUERY = `
-fragment SaleStrategy on SalesStrategyConfig {
-  type
-  fixedPrice {
-    address
-    pricePerToken
-    saleEnd
-    saleStart
-    maxTokensPerAddress
-  }
-  erc20Minter {
-    address
-    pricePerToken
-    currency
-    saleEnd
-    saleStart
-    maxTokensPerAddress
-  }
-}
-
-query ($id: ID!) {
-  zoraCreateToken(id: $id) {
-    id
-    contract {
-      mintFeePerQuantity
-      salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
-        ...SaleStrategy
-      }
-    }
-    salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
-      ...SaleStrategy
-    }
-  }
-}
-`;
-
-// src/apis/chain-constants.ts
-import {
-  arbitrum,
-  base,
-  baseSepolia,
-  foundry,
-  mainnet,
-  optimism,
-  sepolia,
-  zora,
-  zoraSepolia
-} from "viem/chains";
-import { parseEther as parseEther2 } from "viem";
-var REWARD_PER_TOKEN = parseEther2("0.000777");
-var networkConfigByChain = {
-  [mainnet.id]: {
-    chainId: mainnet.id,
-    isTestnet: false,
-    zoraCollectPathChainName: "eth",
-    zoraBackendChainName: "ETHEREUM-MAINNET",
-    subgraphUrl: getSubgraph("zora-create-mainnet", "stable")
-  },
-  [sepolia.id]: {
-    chainId: sepolia.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "sep",
-    zoraBackendChainName: "ETHEREUM-SEPOLIA",
-    subgraphUrl: getSubgraph("zora-create-sepolia", "stable")
-  },
-  [zora.id]: {
-    chainId: zora.id,
-    isTestnet: false,
-    zoraCollectPathChainName: "zora",
-    zoraBackendChainName: "ZORA-MAINNET",
-    subgraphUrl: getSubgraph("zora-create-zora-mainnet", "stable")
-  },
-  [zoraSepolia.id]: {
-    chainId: zoraSepolia.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "zsep",
-    zoraBackendChainName: "ZORA-SEPOLIA",
-    subgraphUrl: getSubgraph("zora-create-zora-sepolia", "stable")
-  },
-  [optimism.id]: {
-    chainId: optimism.id,
-    isTestnet: false,
-    zoraCollectPathChainName: "oeth",
-    zoraBackendChainName: "OPTIMISM-MAINNET",
-    subgraphUrl: getSubgraph("zora-create-optimism", "stable")
-  },
-  [arbitrum.id]: {
-    chainId: arbitrum.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "arb",
-    zoraBackendChainName: "ARBITRUM-MAINNET",
-    subgraphUrl: getSubgraph("zora-create-arbitrum-one", "stable")
-  },
-  [base.id]: {
-    chainId: base.id,
-    isTestnet: false,
-    zoraCollectPathChainName: "base",
-    zoraBackendChainName: "BASE-MAINNET",
-    subgraphUrl: getSubgraph("zora-create-base-mainnet", "stable")
-  },
-  [baseSepolia.id]: {
-    chainId: baseSepolia.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "bsep",
-    zoraBackendChainName: "BASE-SEPOLIA",
-    subgraphUrl: getSubgraph("zora-create-base-sepolia", "stable")
-  },
-  [foundry.id]: {
-    chainId: foundry.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "zgor",
-    zoraBackendChainName: "ZORA-GOERLI",
-    subgraphUrl: getSubgraph("zora-create-zora-testnet", "stable")
-  }
-};
-
-// src/mint/mint-api-client.ts
+// src/mint/subgraph-mint-getter.ts
 var getApiNetworkConfigForChain = (chainId) => {
   if (!networkConfigByChain[chainId]) {
     throw new Error(`chain id ${chainId} network not configured `);
   }
   return networkConfigByChain[chainId];
 };
-var MintAPIClient = class {
+var SubgraphMintGetter = class {
   constructor(chainId, httpClient2) {
     this.httpClient = httpClient2 || httpClient;
     this.networkConfig = getApiNetworkConfigForChain(chainId);
@@ -502,236 +699,46 @@ var MintAPIClient = class {
         );
         if (!targetStrategy) {
           throw new Error(`Cannot find sale strategy for ${mappedSaleType}`);
-        }
-      }
-      if (targetStrategy.type === "FIXED_PRICE") {
-        return {
-          salesConfig: {
-            saleType: "fixedPrice",
-            ...targetStrategy.fixedPrice,
-            maxTokensPerAddress: BigInt(
-              targetStrategy.fixedPrice.maxTokensPerAddress
-            ),
-            pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken)
-          },
-          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
-        };
-      }
-      if (targetStrategy.type === "ERC_20_MINTER") {
-        return {
-          salesConfig: {
-            saleType: "erc20",
-            ...targetStrategy.erc20Minter,
-            maxTokensPerAddress: BigInt(
-              targetStrategy.erc20Minter.maxTokensPerAddress
-            ),
-            pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken)
-          },
-          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
-        };
-      }
-      throw new Error("Invalid saleType");
-    });
-  }
-};
-
-// src/premint/conversions.ts
-import {
-  PremintConfigVersion
-} from "@zoralabs/protocol-deployments";
-var convertCollectionFromApi = (collection) => ({
-  ...collection,
-  contractAdmin: collection.contractAdmin,
-  additionalAdmins: []
-});
-var convertPremintFromApi = (premint) => {
-  if (premint.config_version === PremintConfigVersion.V1 || !premint.config_version) {
-    const tokenConfig = premint.tokenConfig;
-    return {
-      premintConfigVersion: PremintConfigVersion.V1,
-      premintConfig: {
-        deleted: premint.deleted,
-        uid: premint.uid,
-        version: premint.version,
-        tokenConfig: {
-          ...tokenConfig,
-          fixedPriceMinter: tokenConfig.fixedPriceMinter,
-          royaltyRecipient: tokenConfig.royaltyRecipient,
-          maxSupply: BigInt(tokenConfig.maxSupply),
-          pricePerToken: BigInt(tokenConfig.pricePerToken),
-          mintStart: BigInt(tokenConfig.mintStart),
-          mintDuration: BigInt(tokenConfig.mintDuration),
-          maxTokensPerAddress: BigInt(tokenConfig.maxTokensPerAddress)
-        }
-      }
-    };
-  } else {
-    const tokenConfig = premint.tokenConfig;
-    return {
-      premintConfigVersion: PremintConfigVersion.V2,
-      premintConfig: {
-        deleted: premint.deleted,
-        uid: premint.uid,
-        version: premint.version,
-        tokenConfig: {
-          ...tokenConfig,
-          fixedPriceMinter: tokenConfig.fixedPriceMinter,
-          payoutRecipient: tokenConfig.payoutRecipient,
-          createReferral: tokenConfig.createReferral,
-          maxSupply: BigInt(tokenConfig.maxSupply),
-          pricePerToken: BigInt(tokenConfig.pricePerToken),
-          mintStart: BigInt(tokenConfig.mintStart),
-          mintDuration: BigInt(tokenConfig.mintDuration),
-          maxTokensPerAddress: BigInt(tokenConfig.maxTokensPerAddress)
-        }
-      }
-    };
-  }
-};
-var convertGetPremintApiResponse = (response) => ({
-  ...convertPremintFromApi(response.premint),
-  collection: convertCollectionFromApi(response.collection),
-  signature: response.signature
-});
-var encodePremintV1ForAPI = ({
-  tokenConfig,
-  ...premint
-}) => ({
-  ...premint,
-  config_version: "1",
-  tokenConfig: {
-    ...tokenConfig,
-    maxSupply: tokenConfig.maxSupply.toString(),
-    pricePerToken: tokenConfig.pricePerToken.toString(),
-    mintStart: tokenConfig.mintStart.toString(),
-    mintDuration: tokenConfig.mintDuration.toString(),
-    maxTokensPerAddress: tokenConfig.maxTokensPerAddress.toString()
-  }
-});
-var encodePremintV2ForAPI = ({
-  tokenConfig,
-  ...premint
-}) => ({
-  ...premint,
-  config_version: "2",
-  tokenConfig: {
-    ...tokenConfig,
-    maxSupply: tokenConfig.maxSupply.toString(),
-    pricePerToken: tokenConfig.pricePerToken.toString(),
-    mintStart: tokenConfig.mintStart.toString(),
-    mintDuration: tokenConfig.mintDuration.toString(),
-    maxTokensPerAddress: tokenConfig.maxTokensPerAddress.toString()
-  }
-});
-var encodePremintForAPI = ({
-  premintConfig,
-  premintConfigVersion
-}) => {
-  if (premintConfigVersion === PremintConfigVersion.V1) {
-    return encodePremintV1ForAPI(premintConfig);
-  }
-  if (premintConfigVersion === PremintConfigVersion.V2) {
-    return encodePremintV2ForAPI(premintConfig);
-  }
-  throw new Error(`Invalid premint config version ${premintConfigVersion}`);
-};
-var encodePostSignatureInput = ({
-  collection,
-  premintConfigVersion,
-  premintConfig,
-  signature,
-  chainId
-}) => ({
-  premint: encodePremintForAPI({
-    premintConfig,
-    premintConfigVersion
-  }),
-  signature,
-  collection,
-  chain_name: networkConfigByChain[chainId].zoraBackendChainName
-});
-
-// src/premint/premint-api-client.ts
-var postSignature = async ({
-  httpClient: { post: post2, retries: retries2 } = httpClient,
-  ...data
-}) => retries2(
-  () => post2(`${ZORA_API_BASE}premint/signature`, data)
-);
-var getNextUID = async ({
-  chain_name,
-  collection_address,
-  httpClient: { retries: retries2, get: get2 } = httpClient
-}) => retries2(
-  () => get2(
-    `${ZORA_API_BASE}premint/signature/${chain_name}/${collection_address}/next_uid`
-  )
-);
-var getSignature = async ({
-  collection_address,
-  uid,
-  chain_name,
-  httpClient: { retries: retries2, get: get2 } = httpClient
-}) => {
-  const result = await retries2(
-    () => get2(
-      `${ZORA_API_BASE}premint/signature/${chain_name}/${collection_address}/${uid}`
-    )
-  );
-  return result;
-};
-var PremintAPIClient = class {
-  constructor(chainId, httpClient2) {
-    this.postSignature = async ({
-      collection,
-      signature,
-      ...premintConfigAndVersion
-    }) => {
-      const data = encodePostSignatureInput({
-        collection,
-        ...premintConfigAndVersion,
-        chainId: this.networkConfig.chainId,
-        signature
-      });
-      return postSignature({
-        ...data,
-        httpClient: this.httpClient
-      });
-    };
-    this.getNextUID = async (collectionAddress) => (await getNextUID({
-      collection_address: collectionAddress.toLowerCase(),
-      chain_name: this.networkConfig.zoraBackendChainName,
-      httpClient: this.httpClient
-    })).next_uid;
-    this.getSignature = async ({
-      collectionAddress,
-      uid
-    }) => {
-      const response = await getSignature({
-        collection_address: collectionAddress.toLowerCase(),
-        uid,
-        chain_name: this.networkConfig.zoraBackendChainName,
-        httpClient: this.httpClient
-      });
-      return convertGetPremintApiResponse(response);
-    };
-    this.httpClient = httpClient2 || httpClient;
-    this.networkConfig = getApiNetworkConfigForChain(chainId);
+        }
+      }
+      if (targetStrategy.type === "FIXED_PRICE") {
+        return {
+          salesConfig: {
+            saleType: "fixedPrice",
+            ...targetStrategy.fixedPrice,
+            maxTokensPerAddress: BigInt(
+              targetStrategy.fixedPrice.maxTokensPerAddress
+            ),
+            pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken)
+          },
+          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
+        };
+      }
+      if (targetStrategy.type === "ERC_20_MINTER") {
+        return {
+          salesConfig: {
+            saleType: "erc20",
+            ...targetStrategy.erc20Minter,
+            maxTokensPerAddress: BigInt(
+              targetStrategy.erc20Minter.maxTokensPerAddress
+            ),
+            pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken)
+          },
+          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
+        };
+      }
+      throw new Error("Invalid saleType");
+    });
   }
 };
 
 // src/utils.ts
-import {
-  createPublicClient,
-  http
-} from "viem";
-var makeSimulateContractParamaters = (args) => args;
-function setupClient({ chain, httpClient: httpClient2, publicClient }) {
-  return {
-    chain,
-    httpClient: httpClient2 || httpClient,
-    publicClient: publicClient || createPublicClient({ chain, transport: http() })
-  };
+var makeContractParameters = (args) => args;
+function mintRecipientOrAccount({
+  mintRecipient,
+  minterAccount
+}) {
+  return mintRecipient || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
 }
 
 // src/premint/premint-client.ts
@@ -739,51 +746,77 @@ var defaultTokenConfigV1MintArguments = () => ({
   maxSupply: OPEN_EDITION_MINT_SIZE,
   maxTokensPerAddress: 0n,
   pricePerToken: 0n,
-  mintDuration: BigInt(60 * 60 * 24 * 7),
-  // 1 week
+  mintDuration: 0n,
   mintStart: 0n,
   royaltyMintSchedule: 0,
   royaltyBPS: 1e3
   // 10%,
 });
+var pickTokenConfigV1 = (tokenConfig) => ({
+  maxSupply: tokenConfig.maxSupply,
+  maxTokensPerAddress: tokenConfig.maxTokensPerAddress,
+  pricePerToken: tokenConfig.pricePerToken,
+  mintDuration: tokenConfig.mintDuration,
+  mintStart: tokenConfig.mintStart,
+  royaltyBPS: tokenConfig.royaltyBPS,
+  tokenURI: tokenConfig.tokenURI,
+  royaltyRecipient: tokenConfig.payoutRecipient
+});
+var pickTokenConfigV2 = (tokenConfig) => ({
+  maxSupply: tokenConfig.maxSupply,
+  maxTokensPerAddress: tokenConfig.maxTokensPerAddress,
+  pricePerToken: tokenConfig.pricePerToken,
+  mintDuration: tokenConfig.mintDuration,
+  mintStart: tokenConfig.mintStart,
+  royaltyBPS: tokenConfig.royaltyBPS,
+  tokenURI: tokenConfig.tokenURI,
+  payoutRecipient: tokenConfig.payoutRecipient,
+  createReferral: tokenConfig.createReferral || zeroAddress2
+});
+var tokenConfigV1WithDefault = (tokenConfig, fixedPriceMinter) => ({
+  ...pickTokenConfigV1(tokenConfig),
+  ...defaultTokenConfigV1MintArguments(),
+  fixedPriceMinter
+});
+var tokenConfigV2WithDefault = (tokenConfig, fixedPriceMinter) => ({
+  ...pickTokenConfigV2(tokenConfig),
+  ...defaultTokenConfigV2MintArguments(),
+  fixedPriceMinter
+});
 var defaultTokenConfigV2MintArguments = () => ({
   maxSupply: OPEN_EDITION_MINT_SIZE,
   maxTokensPerAddress: 0n,
   pricePerToken: 0n,
-  mintDuration: BigInt(60 * 60 * 24 * 7),
-  // 1 week
+  mintDuration: 0n,
   mintStart: 0n,
   royaltyBPS: 1e3
   // 10%,
 });
 var makeTokenConfigWithDefaults = ({
   chainId,
-  premintConfigVersion,
   tokenCreationConfig,
-  payoutRecipient
+  supportedPremintVersions: supportedPremintVersions2
 }) => {
-  if (premintConfigVersion === PremintConfigVersion2.V3) {
-    throw new Error("PremintV3 not supported in SDK");
-  }
-  const fixedPriceMinter = tokenCreationConfig.fixedPriceMinter || getDefaultFixedPriceMinterAddress(chainId);
-  if (premintConfigVersion === PremintConfigVersion2.V1) {
-    return {
-      fixedPriceMinter,
-      ...defaultTokenConfigV1MintArguments(),
-      royaltyRecipient: payoutRecipient,
-      ...tokenCreationConfig
-    };
-  } else if (premintConfigVersion === PremintConfigVersion2.V2) {
+  const fixedPriceMinter = getDefaultFixedPriceMinterAddress(chainId);
+  if (!supportedPremintVersions2.includes(PremintConfigVersion2.V2)) {
+    if (tokenCreationConfig.createReferral) {
+      throw new Error("Contract does not support create referral");
+    }
     return {
-      fixedPriceMinter,
-      ...defaultTokenConfigV2MintArguments(),
-      payoutRecipient,
-      createReferral: zeroAddress2,
-      ...tokenCreationConfig
+      premintConfigVersion: PremintConfigVersion2.V1,
+      tokenConfig: tokenConfigV1WithDefault(
+        tokenCreationConfig,
+        fixedPriceMinter
+      )
     };
-  } else {
-    throw new Error(`Invalid premint config version ${premintConfigVersion}`);
   }
+  return {
+    premintConfigVersion: PremintConfigVersion2.V2,
+    tokenConfig: tokenConfigV2WithDefault(
+      tokenCreationConfig,
+      fixedPriceMinter
+    )
+  };
 };
 function getPremintedLogFromReceipt(receipt) {
   for (const data of receipt.logs) {
@@ -801,20 +834,17 @@ function getPremintedLogFromReceipt(receipt) {
   }
 }
 var PremintClient = class {
-  constructor(chain, publicClient, httpClient2) {
-    this.chain = chain;
-    this.apiClient = new PremintAPIClient(chain.id, httpClient2);
+  constructor({
+    chainId,
+    publicClient,
+    premintApi
+  }) {
+    this.chainId = chainId;
+    this.apiClient = premintApi;
     this.publicClient = publicClient;
   }
-  getDataFromPremintReceipt(receipt) {
-    const premintedLog = getPremintedLogFromReceipt(receipt);
-    return {
-      premintedLog,
-      urls: this.makeUrls({
-        address: premintedLog?.contractAddress,
-        tokenId: premintedLog?.tokenId
-      })
-    };
+  getDataFromPremintReceipt(receipt, blockExplorerUrl) {
+    return getDataFromPremintReceipt(receipt, this.chainId, blockExplorerUrl);
   }
   /**
    * Prepares data for updating a premint
@@ -827,7 +857,7 @@ var PremintClient = class {
       ...args,
       apiClient: this.apiClient,
       publicClient: this.publicClient,
-      chainId: this.chain.id
+      chainId: this.chainId
     });
   }
   /**
@@ -841,7 +871,7 @@ var PremintClient = class {
       ...params,
       apiClient: this.apiClient,
       publicClient: this.publicClient,
-      chainId: this.chain.id
+      chainId: this.chainId
     });
   }
   /**
@@ -855,7 +885,7 @@ var PremintClient = class {
       ...parameters,
       publicClient: this.publicClient,
       apiClient: this.apiClient,
-      chainId: this.chain.id
+      chainId: this.chainId
     });
   }
   /**
@@ -865,10 +895,7 @@ var PremintClient = class {
    * @param uid UID for the desired premint
    * @returns PremintSignatureGetResponse of premint data from the API
    */
-  async getPremintSignature({
-    address,
-    uid
-  }) {
+  async getPremint({ address, uid }) {
     return await this.apiClient.getSignature({
       collectionAddress: address,
       uid
@@ -881,44 +908,10 @@ var PremintClient = class {
    */
   async getCollectionAddress(collection) {
     return await getPremintCollectionAddress({
-      collection,
+      contract: collection,
       publicClient: this.publicClient
     });
   }
-  /**
-   * Check user signature for v1
-   *
-   * @param data Signature data from the API
-   * @returns isValid = signature is valid or not, recoveredSigner = signer from contract
-   */
-  async isValidSignature({
-    signature,
-    collection,
-    premintConfig,
-    premintConfigVersion
-  }) {
-    const { isAuthorized, recoveredAddress } = await isValidSignature({
-      chainId: this.chain.id,
-      signature,
-      collection,
-      publicClient: this.publicClient,
-      premintConfig,
-      premintConfigVersion: premintConfigVersion || PremintConfigVersion2.V1
-    });
-    return { isValid: isAuthorized, recoveredSigner: recoveredAddress };
-  }
-  makeUrls({
-    uid,
-    address,
-    tokenId
-  }) {
-    return makeUrls({
-      uid,
-      address,
-      tokenId,
-      chain: this.chain
-    });
-  }
   async getMintCosts({
     tokenContract,
     quantityToMint,
@@ -938,27 +931,50 @@ var PremintClient = class {
    * @param parameters - Parameters for collecting the Premint {@link MakeMintParametersArguments}
    * @returns receipt, log, zoraURL
    */
-  async makeMintParameters(parameters) {
-    return await makeMintParameters({
-      ...parameters,
-      apiClient: this.apiClient,
+  async makeMintParameters({
+    minterAccount,
+    tokenContract,
+    uid,
+    mintArguments,
+    firstMinter
+  }) {
+    return await collectPremint({
+      uid,
+      tokenContract,
+      minterAccount,
+      quantityToMint: mintArguments?.quantityToMint || 1n,
+      mintComment: mintArguments?.mintComment,
+      mintReferral: mintArguments?.mintReferral,
+      mintRecipient: mintArguments?.mintRecipient,
+      firstMinter,
+      premintGetter: this.apiClient,
       publicClient: this.publicClient
     });
   }
 };
-function createPremintClient(clientConfig) {
-  const { chain, httpClient: httpClient2, publicClient } = setupClient(clientConfig);
-  return new PremintClient(chain, publicClient, httpClient2);
+function getDataFromPremintReceipt(receipt, chainId, blockExplorerUrl) {
+  const premintedLog = getPremintedLogFromReceipt(receipt);
+  return {
+    tokenId: premintedLog?.tokenId,
+    collectionAddres: premintedLog?.contractAddress,
+    premintedLog,
+    urls: makeUrls({
+      address: premintedLog?.contractAddress,
+      tokenId: premintedLog?.tokenId,
+      chainId,
+      blockExplorerUrl
+    })
+  };
 }
 function makePremintReturn({
   premintConfig,
   premintConfigVersion,
-  collectionAddress,
-  collection,
   publicClient,
   apiClient,
-  chainId
+  chainId,
+  ...collectionAndAddress
 }) {
+  const { collection, collectionAddress } = collectionAndAddress;
   const typedDataDefinition = premintTypedDataDefinition2({
     verifyingContract: collectionAddress,
     premintConfig,
@@ -978,7 +994,7 @@ function makePremintReturn({
     await submit({
       signature,
       checkSignature,
-      signerAccount
+      account: signerAccount
     });
     return {
       signature,
@@ -988,23 +1004,22 @@ function makePremintReturn({
   const submit = async ({
     signature,
     checkSignature,
-    signerAccount
+    account
   }) => {
     if (checkSignature) {
-      await validateSignature({
-        collection: {
-          ...collection,
-          additionalAdmins: []
-        },
+      const isAuthorized = await isAuthorizedToCreatePremint({
+        collectionAddress,
+        additionalAdmins: collection?.additionalAdmins,
+        contractAdmin: collection?.contractAdmin,
         publicClient,
-        signerAccount
+        signer: account
       });
+      if (!isAuthorized) {
+        throw new Error("Not authorized to create premint");
+      }
     }
     await apiClient.postSignature({
-      collection: {
-        ...collection,
-        additionalAdmins: []
-      },
+      ...toContractCreationConfigOrAddress(collectionAndAddress),
       signature,
       premintConfig,
       premintConfigVersion
@@ -1039,43 +1054,21 @@ async function signPremint({
     signerAccount: account
   };
 }
-var validateSignature = async ({
-  collection,
-  publicClient,
-  signerAccount
-}) => {
-  const isAuthorized = await isAuthorizedToCreatePremint({
-    collection,
-    publicClient,
-    signer: typeof signerAccount === "string" ? signerAccount : signerAccount.address,
-    collectionAddress: await getPremintCollectionAddress({
-      collection,
-      publicClient
-    })
-  });
-  if (!isAuthorized) {
-    throw new Error("Not authorized to create premint");
-  }
-};
 async function createPremint({
-  payoutRecipient: creatorAccount,
-  collection,
-  tokenCreationConfig,
-  premintConfigVersion,
+  token: tokenCreationConfig,
   uid,
   publicClient,
   apiClient,
-  chainId
+  chainId,
+  ...collectionOrAddress
 }) {
   const {
     premintConfig,
-    premintConfigVersion: actualVersion,
-    collectionAddress
+    premintConfigVersion,
+    collectionAddress: collectionAddressToUse
   } = await prepareCreatePremintConfig({
-    payoutRecipient: creatorAccount,
-    collection,
+    ...collectionOrAddress,
     tokenCreationConfig,
-    premintConfigVersion,
     uid,
     publicClient,
     apiClient,
@@ -1083,59 +1076,49 @@ async function createPremint({
   });
   return makePremintReturn({
     premintConfig,
-    premintConfigVersion: actualVersion,
-    collectionAddress,
-    collection,
+    premintConfigVersion,
+    collectionAddress: collectionAddressToUse,
+    collection: collectionOrAddress.contract,
     publicClient,
     apiClient,
     chainId
   });
 }
 async function prepareCreatePremintConfig({
-  payoutRecipient,
-  collection,
   tokenCreationConfig,
-  premintConfigVersion,
   uid,
   publicClient,
   apiClient,
-  chainId
+  chainId,
+  ...collectionOrAddress
 }) {
-  const collectionWithAdditionalAdmins = {
-    ...collection,
-    additionalAdmins: collection.additionalAdmins || []
-  };
   const newContractAddress = await getPremintCollectionAddress({
     publicClient,
-    collection: collectionWithAdditionalAdmins
+    ...collectionOrAddress
   });
   let uidToUse = uid;
   if (typeof uidToUse !== "number") {
     uidToUse = await apiClient.getNextUID(newContractAddress);
   }
-  const actualVersion = premintConfigVersion || PremintConfigVersion2.V1;
-  if (!await supportsPremintVersion({
-    version: actualVersion,
-    publicClient,
-    tokenContract: newContractAddress
-  })) {
-    throw new Error(
-      `Premint version ${actualVersion} not supported by contract`
-    );
-  }
+  const supportedVersions = await supportedPremintVersions({
+    tokenContract: newContractAddress,
+    publicClient
+  });
+  const tokenConfigAndVersion = makeTokenConfigWithDefaults({
+    tokenCreationConfig,
+    chainId,
+    supportedPremintVersions: supportedVersions
+  });
   const premintConfig = makeNewPremint({
-    tokenConfig: makeTokenConfigWithDefaults({
-      // @ts-ignore
-      premintConfigVersion: actualVersion,
-      tokenCreationConfig,
-      payoutRecipient: typeof payoutRecipient === "string" ? payoutRecipient : payoutRecipient.address,
-      chainId
-    }),
+    ...tokenConfigAndVersion,
     uid: uidToUse
   });
-  return {
+  const premintConfigAndVersion = {
     premintConfig,
-    premintConfigVersion: actualVersion,
+    premintConfigVersion: tokenConfigAndVersion.premintConfigVersion
+  };
+  return {
+    ...premintConfigAndVersion,
     collectionAddress: newContractAddress
   };
 }
@@ -1181,7 +1164,8 @@ async function deletePremint({
   const {
     premintConfig,
     premintConfigVersion,
-    collection: collectionCreationConfig
+    collection: collectionCreationConfig,
+    collectionAddress
   } = await apiClient.getSignature({
     collectionAddress: collection,
     uid
@@ -1194,32 +1178,39 @@ async function deletePremint({
   return makePremintReturn({
     premintConfig: deletedPremint,
     premintConfigVersion,
-    collectionAddress: collection,
+    collectionAddress,
     collection: collectionCreationConfig,
     publicClient,
     apiClient,
     chainId
   });
 }
-async function makeMintParameters({
+async function collectPremint({
   uid,
   tokenContract,
   minterAccount,
-  mintArguments,
-  apiClient,
+  quantityToMint,
+  mintComment = "",
+  mintReferral,
+  mintRecipient,
+  firstMinter,
+  premintGetter,
   publicClient
 }) {
-  if (mintArguments && mintArguments?.quantityToMint < 1) {
+  if (typeof quantityToMint !== "undefined" && quantityToMint < 1) {
     throw new Error("Quantity to mint cannot be below 1");
   }
-  if (!minterAccount) {
-    throw new Error("Wallet not passed in");
-  }
-  const { premintConfig, premintConfigVersion, collection, signature } = await apiClient.getSignature({
+  const {
+    premintConfig,
+    premintConfigVersion,
+    collection,
+    collectionAddress,
+    signature
+  } = await premintGetter.getSignature({
     collectionAddress: tokenContract,
     uid
   });
-  const numberToMint = BigInt(mintArguments?.quantityToMint || 1);
+  const numberToMint = BigInt(quantityToMint || 1);
   if (premintConfigVersion === PremintConfigVersion2.V3) {
     throw new Error("PremintV3 not supported in premint SDK");
   }
@@ -1228,67 +1219,64 @@ async function makeMintParameters({
     quantityToMint: numberToMint,
     publicClient,
     tokenPrice: premintConfig.tokenConfig.pricePerToken
-  })).totalCost;
+  })).totalCostEth;
   const mintArgumentsContract = {
-    mintComment: mintArguments?.mintComment || "",
-    mintRecipient: mintArguments?.mintRecipient || (typeof minterAccount === "string" ? minterAccount : minterAccount.address),
+    mintComment,
+    mintRecipient: mintRecipientOrAccount({
+      mintRecipient,
+      minterAccount
+    }),
     mintRewardsRecipients: makeMintRewardsRecipient({
-      mintReferral: mintArguments?.mintReferral
+      mintReferral
     })
   };
-  if (premintConfigVersion === PremintConfigVersion2.V1) {
-    return makeSimulateContractParamaters({
-      account: minterAccount,
-      abi: zoraCreator1155PremintExecutorImplABI2,
-      functionName: "premintV1",
-      value,
-      address: getPremintExecutorAddress(),
-      args: [
-        collection,
-        premintConfig,
-        signature,
-        numberToMint,
-        mintArgumentsContract
-      ]
-    });
-  } else if (premintConfigVersion === PremintConfigVersion2.V2) {
-    return makeSimulateContractParamaters({
-      account: minterAccount,
-      abi: zoraCreator1155PremintExecutorImplABI2,
-      functionName: "premintV2",
-      value,
-      address: getPremintExecutorAddress(),
-      args: [
-        collection,
+  const collectionOrEmpty = collection ? defaultAdditionalAdmins(collection) : emptyContractCreationConfig();
+  const collectionAddressToSubmit = collection ? zeroAddress2 : collectionAddress;
+  const firstMinterToSubmit = firstMinter || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
+  return makeContractParameters({
+    account: minterAccount,
+    abi: zoraCreator1155PremintExecutorImplABI2,
+    functionName: "premint",
+    value,
+    address: getPremintExecutorAddress(),
+    args: [
+      collectionOrEmpty,
+      collectionAddressToSubmit,
+      encodePremintConfig({
         premintConfig,
-        signature,
-        numberToMint,
-        mintArgumentsContract
-      ]
-    });
-  }
-  throw new Error(`Invalid premint config version ${premintConfigVersion}`);
+        premintConfigVersion
+      }),
+      signature,
+      numberToMint,
+      mintArgumentsContract,
+      firstMinterToSubmit,
+      zeroAddress2
+    ]
+  });
 }
 function makeUrls({
   uid,
   address,
   tokenId,
-  chain
+  chainId,
+  blockExplorerUrl
 }) {
   if ((!uid || !tokenId) && !address) {
     return { explorer: null, zoraCollect: null, zoraManage: null };
   }
   const zoraTokenPath = uid ? `premint-${uid}` : tokenId;
-  const network = getApiNetworkConfigForChain(chain.id);
+  const network = getApiNetworkConfigForChain(chainId);
   return {
-    explorer: tokenId ? `https://${chain.blockExplorers?.default.url}/token/${address}/instance/${tokenId}` : null,
+    explorer: tokenId ? `https://${blockExplorerUrl}/token/${address}/instance/${tokenId}` : null,
     zoraCollect: `https://${network.isTestnet ? "testnet." : ""}zora.co/collect/${network.zoraCollectPathChainName}:${address}/${zoraTokenPath}`,
     zoraManage: `https://${network.isTestnet ? "testnet." : ""}zora.co/collect/${network.zoraCollectPathChainName}:${address}/${zoraTokenPath}`
   };
 }
 
 // src/premint/contract-types.ts
-import { PremintConfigVersion as PremintConfigVersionOrig } from "@zoralabs/protocol-deployments";
+import {
+  PremintConfigVersion as PremintConfigVersionOrig
+} from "@zoralabs/protocol-deployments";
 var PremintConfigVersion3 = ((PremintConfigVersion4) => {
   PremintConfigVersion4[PremintConfigVersion4["V1"] = PremintConfigVersionOrig.V1] = "V1";
   PremintConfigVersion4[PremintConfigVersion4["V2"] = PremintConfigVersionOrig.V2] = "V2";
@@ -1296,11 +1284,79 @@ var PremintConfigVersion3 = ((PremintConfigVersion4) => {
   return PremintConfigVersion4;
 })(PremintConfigVersion3 || {});
 
+// src/premint/premint-api-client.ts
+var postSignature = async ({
+  httpClient: { post: post2, retries: retries2 } = httpClient,
+  ...data
+}) => retries2(
+  () => post2(`${ZORA_API_BASE}premint/signature`, data)
+);
+var getNextUID = async ({
+  chainId,
+  collection_address,
+  httpClient: { retries: retries2, get: get2 } = httpClient
+}) => retries2(
+  () => get2(
+    `${ZORA_API_BASE}premint/signature/${getApiNetworkConfigForChain(chainId).zoraBackendChainName}/${collection_address}/next_uid`
+  )
+);
+var getSignature = async ({
+  collectionAddress,
+  uid,
+  chainId,
+  httpClient: { retries: retries2, get: get2 } = httpClient
+}) => {
+  const chainName = getApiNetworkConfigForChain(chainId).zoraBackendChainName;
+  const result = await retries2(
+    () => get2(
+      `${ZORA_API_BASE}premint/signature/${chainName}/${collectionAddress.toLowerCase()}/${uid}`
+    )
+  );
+  return convertGetPremintApiResponse(result);
+};
+var PremintAPIClient = class {
+  constructor(chainId, httpClient2) {
+    this.postSignature = ({
+      signature,
+      ...rest
+    }) => {
+      const data = encodePostSignatureInput({
+        ...rest,
+        chainId: this.chainId,
+        signature
+      });
+      return postSignature({
+        ...data,
+        httpClient: this.httpClient
+      });
+    };
+    this.getNextUID = async (collectionAddress) => (await getNextUID({
+      collection_address: collectionAddress.toLowerCase(),
+      chainId: this.chainId,
+      httpClient: this.httpClient
+    })).next_uid;
+    this.getSignature = async ({
+      collectionAddress,
+      uid
+    }) => {
+      return getSignature({
+        collectionAddress,
+        uid,
+        chainId: this.chainId,
+        httpClient: this.httpClient
+      });
+    };
+    this.chainId = chainId;
+    this.httpClient = httpClient2 || httpClient;
+  }
+};
+
 // src/mint/mint-client.ts
 import {
   encodeAbiParameters,
   parseAbiParameters,
-  zeroAddress as zeroAddress3
+  zeroAddress as zeroAddress3,
+  erc20Abi
 } from "viem";
 import {
   erc20MinterABI,
@@ -1308,6 +1364,15 @@ import {
   zoraCreator1155ImplABI as zoraCreator1155ImplABI2,
   zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress2
 } from "@zoralabs/protocol-deployments";
+
+// src/mint/types.ts
+var isOnChainMint = (mint2) => mint2.mintType !== "premint";
+var is1155Mint = (mint2) => mint2.mintType === "1155";
+function isErc20SaleStrategy(salesConfig) {
+  return salesConfig.saleType === "erc20";
+}
+
+// src/mint/mint-client.ts
 var MintError = class extends Error {
 };
 var MintInactiveError = class extends Error {
@@ -1317,265 +1382,612 @@ var Errors = {
   MintInactiveError
 };
 var MintClient = class {
-  constructor(chain, publicClient, httpClient2) {
-    this.apiClient = new MintAPIClient(chain.id, httpClient2);
+  constructor({
+    chainId,
+    publicClient,
+    premintGetter,
+    mintGetter
+  }) {
+    this.chainId = chainId;
     this.publicClient = publicClient;
+    this.mintGetter = mintGetter;
+    this.premintGetter = premintGetter;
   }
   /**
    * Returns the parameters needed to prepare a transaction mint a token.
+   * Works with premint, onchain 1155, and onchain 721.
    *
-   * @param parameters - Parameters for collecting the token {@link MintTokenParams}
+   * @param parameters - Parameters for collecting the token {@link MakeMintParametersArguments}
    * @returns Parameters for simulating/executing the mint transaction
    */
-  async makePrepareMintTokenParams(parameters) {
-    return makePrepareMintTokenParams({
+  async mint(parameters) {
+    return mint({
+      parameters,
+      chainId: this.chainId,
+      publicClient: this.publicClient,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter
+    });
+  }
+  /**
+   * Gets the costs to mint the quantity of tokens specified for a mint.
+   * @param parameters - Parameters for the mint {@link GetMintCostsParameters}
+   * @returns Costs to mint the quantity of tokens specified
+   */
+  async getMintCosts(parameters) {
+    return getMintCosts({
+      ...parameters,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter,
+      publicClient: this.publicClient
+    });
+  }
+};
+function isPremintCollect(parameters) {
+  return parameters.mintType === "premint";
+}
+function is721Collect(parameters) {
+  return parameters.mintType === "721";
+}
+async function mint({
+  parameters,
+  chainId,
+  publicClient,
+  mintGetter,
+  premintGetter
+}) {
+  if (isPremintCollect(parameters)) {
+    return {
+      parameters: await collectPremint({
+        ...parameters,
+        premintGetter,
+        publicClient
+      })
+    };
+  }
+  return {
+    parameters: await collectOnchain({
       ...parameters,
-      apiClient: this.apiClient,
-      publicClient: this.publicClient
+      mintGetter,
+      chainId
+    })
+  };
+}
+function requestErc20ApprovalForMint({
+  account,
+  tokenAddress,
+  quantityErc20,
+  erc20MinterAddress: erc20MinterAddress2
+}) {
+  return makeContractParameters({
+    abi: erc20Abi,
+    address: tokenAddress,
+    account,
+    functionName: "approve",
+    args: [erc20MinterAddress2, quantityErc20]
+  });
+}
+async function getNecessaryErc20Approval({
+  chainId,
+  account,
+  tokenAddress,
+  quantityErc20,
+  publicClient
+}) {
+  const destination = erc20MinterAddress[chainId];
+  const allowance = await publicClient.readContract({
+    abi: erc20Abi,
+    address: tokenAddress,
+    functionName: "allowance",
+    account,
+    args: [
+      destination,
+      erc20MinterAddress[chainId]
+    ]
+  });
+  if (allowance < quantityErc20) {
+    return requestErc20ApprovalForMint({
+      erc20MinterAddress: destination,
+      account,
+      tokenAddress,
+      quantityErc20: quantityErc20 - allowance
     });
   }
-};
-function createMintClient(clientConfig) {
-  const { chain, publicClient, httpClient: httpClient2 } = setupClient(clientConfig);
-  return new MintClient(chain, publicClient, httpClient2);
+  return void 0;
 }
-async function makePrepareMintTokenParams({
-  publicClient,
-  apiClient,
-  tokenId,
-  tokenAddress,
-  mintArguments,
-  ...rest
+async function collectOnchain({
+  chainId,
+  mintGetter,
+  ...parameters
 }) {
-  const salesConfigAndTokenInfo = await apiClient.getSalesConfigAndTokenInfo({
+  const { tokenContract, saleType } = parameters;
+  const tokenId = is1155Mint(parameters) ? parameters.tokenId : void 0;
+  const salesConfigAndTokenInfo = await mintGetter.getSalesConfigAndTokenInfo({
     tokenId,
-    tokenAddress,
-    saleType: mintArguments.saleType
+    tokenAddress: tokenContract,
+    saleType
   });
-  if (tokenId === void 0) {
+  if (is721Collect(parameters)) {
     return makePrepareMint721TokenParams({
       salesConfigAndTokenInfo,
-      tokenAddress,
-      mintArguments,
-      ...rest
+      ...parameters
     });
   }
   return makePrepareMint1155TokenParams({
     salesConfigAndTokenInfo,
-    tokenAddress,
-    tokenId,
-    mintArguments,
-    ...rest
+    chainId,
+    ...parameters
   });
 }
 async function makePrepareMint721TokenParams({
-  tokenAddress,
   salesConfigAndTokenInfo,
   minterAccount,
-  mintArguments
+  tokenContract,
+  mintComment,
+  mintReferral,
+  mintRecipient,
+  quantityToMint
 }) {
-  const mintValue = getMintCosts({
+  const actualQuantityToMint = BigInt(quantityToMint || 1);
+  const mintValue = parseMintCosts({
     salesConfigAndTokenInfo,
-    quantityToMint: BigInt(mintArguments.quantityToMint)
-  }).totalCost;
-  return makeSimulateContractParamaters({
+    quantityToMint: actualQuantityToMint
+  }).totalCostEth;
+  return makeContractParameters({
     abi: zora721Abi,
-    address: tokenAddress,
+    address: tokenContract,
     account: minterAccount,
     functionName: "mintWithRewards",
     value: mintValue,
     args: [
-      mintArguments.mintToAddress,
-      BigInt(mintArguments.quantityToMint),
-      mintArguments.mintComment || "",
-      mintArguments.mintReferral || zeroAddress3
+      mintRecipientOrAccount({ mintRecipient, minterAccount }),
+      actualQuantityToMint,
+      mintComment || "",
+      mintReferral || zeroAddress3
     ]
   });
 }
-function getMintCosts({
+function parseMintCosts({
   salesConfigAndTokenInfo,
   quantityToMint
 }) {
   const mintFeeForTokens = salesConfigAndTokenInfo.mintFeePerQuantity * quantityToMint;
   const tokenPurchaseCost = BigInt(salesConfigAndTokenInfo.salesConfig.pricePerToken) * quantityToMint;
+  const totalPurchaseCostCurrency = isErc20SaleStrategy(
+    salesConfigAndTokenInfo.salesConfig
+  ) ? salesConfigAndTokenInfo.salesConfig.currency : void 0;
+  const totalPurchaseCostEth = totalPurchaseCostCurrency ? 0n : tokenPurchaseCost;
   return {
     mintFee: mintFeeForTokens,
-    tokenPurchaseCost,
-    totalCost: mintFeeForTokens + tokenPurchaseCost
+    totalPurchaseCost: tokenPurchaseCost,
+    totalPurchaseCostCurrency,
+    totalCostEth: mintFeeForTokens + totalPurchaseCostEth
   };
 }
-async function makePrepareMint1155TokenParams({
+async function getMintCosts(params) {
+  const { quantityMinted: quantityToMint, collection, publicClient } = params;
+  if (isOnChainMint(params)) {
+    const tokenId = is1155Mint(params) ? params.tokenId : void 0;
+    const salesConfigAndTokenInfo = await params.mintGetter.getSalesConfigAndTokenInfo({
+      tokenId,
+      tokenAddress: collection
+    });
+    return parseMintCosts({
+      salesConfigAndTokenInfo,
+      quantityToMint: BigInt(quantityToMint)
+    });
+  }
+  return getPremintMintCostsWithUnknownTokenPrice({
+    premintGetter: params.premintGetter,
+    publicClient,
+    quantityToMint: BigInt(quantityToMint),
+    uid: params.uid,
+    tokenContract: collection
+  });
+}
+function makePrepareMint1155TokenParams({
+  tokenContract,
   tokenId,
   salesConfigAndTokenInfo,
   minterAccount,
-  tokenAddress,
-  mintArguments
+  mintComment,
+  mintReferral,
+  mintRecipient,
+  quantityToMint,
+  chainId
 }) {
-  const mintQuantity = BigInt(mintArguments.quantityToMint);
-  const mintValue = getMintCosts({
-    salesConfigAndTokenInfo,
-    quantityToMint: mintQuantity
-  }).totalCost;
-  switch (salesConfigAndTokenInfo.salesConfig.saleType) {
-    case "fixedPrice":
-      const fixedPriceArgs = mintArguments;
-      return makeSimulateContractParamaters({
-        abi: zoraCreator1155ImplABI2,
-        functionName: "mintWithRewards",
-        account: minterAccount,
-        value: mintValue,
-        address: tokenAddress,
-        /* args: minter, tokenId, quantity, minterArguments, mintReferral */
-        args: [
-          salesConfigAndTokenInfo.salesConfig.address || zoraCreatorFixedPriceSaleStrategyAddress2[999999999],
-          BigInt(tokenId),
-          mintQuantity,
-          encodeAbiParameters(parseAbiParameters("address, string"), [
-            fixedPriceArgs.mintToAddress,
-            fixedPriceArgs.mintComment || ""
-          ]),
-          fixedPriceArgs.mintReferral || zeroAddress3
-        ]
-      });
-    case "erc20":
-      const erc20Args = mintArguments;
-      return makeSimulateContractParamaters({
-        abi: erc20MinterABI,
-        functionName: "mint",
-        account: minterAccount,
-        address: salesConfigAndTokenInfo?.salesConfig.address || erc20MinterAddress[999999999],
-        /* args: mintTo, quantity, tokenAddress, tokenId, totalValue, currency, mintReferral, comment */
-        args: [
-          mintArguments.mintToAddress,
-          mintQuantity,
-          tokenAddress,
-          BigInt(tokenId),
-          salesConfigAndTokenInfo.salesConfig.pricePerToken,
-          salesConfigAndTokenInfo.salesConfig.currency,
-          erc20Args.mintReferral || zeroAddress3,
-          erc20Args.mintComment || ""
-        ]
-      });
-    default:
-      throw new MintError("Unsupported sale type");
+  const mintQuantity = BigInt(quantityToMint || 1);
+  const mintTo = mintRecipientOrAccount({ mintRecipient, minterAccount });
+  const saleType = salesConfigAndTokenInfo.salesConfig.saleType;
+  if (saleType === "fixedPrice") {
+    const mintValue = parseMintCosts({
+      salesConfigAndTokenInfo,
+      quantityToMint: mintQuantity
+    }).totalCostEth;
+    return makeContractParameters({
+      abi: zoraCreator1155ImplABI2,
+      functionName: "mintWithRewards",
+      account: minterAccount,
+      value: mintValue,
+      address: tokenContract,
+      /* args: minter, tokenId, quantity, minterArguments, mintReferral */
+      args: [
+        salesConfigAndTokenInfo.salesConfig.address || zoraCreatorFixedPriceSaleStrategyAddress2[chainId],
+        BigInt(tokenId),
+        mintQuantity,
+        encodeAbiParameters(parseAbiParameters("address, string"), [
+          mintTo,
+          mintComment || ""
+        ]),
+        mintReferral || zeroAddress3
+      ]
+    });
   }
+  if (saleType === "erc20") {
+    return makeContractParameters({
+      abi: erc20MinterABI,
+      functionName: "mint",
+      account: minterAccount,
+      address: salesConfigAndTokenInfo?.salesConfig.address || erc20MinterAddress[chainId],
+      /* args: mintTo, quantity, tokenAddress, tokenId, totalValue, currency, mintReferral, comment */
+      args: [
+        mintTo,
+        mintQuantity,
+        tokenContract,
+        BigInt(tokenId),
+        salesConfigAndTokenInfo.salesConfig.pricePerToken * mintQuantity,
+        salesConfigAndTokenInfo.salesConfig.currency,
+        mintReferral || zeroAddress3,
+        mintComment || ""
+      ]
+    });
+  }
+  throw new MintError("Unsupported sale type");
 }
 
 // src/create/1155-create-helper.ts
 import {
+  zoraCreator1155FactoryImplABI as zoraCreator1155FactoryImplABI2,
+  zoraCreator1155FactoryImplAddress as zoraCreator1155FactoryImplAddress2,
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI5
+} from "@zoralabs/protocol-deployments";
+import { decodeEventLog as decodeEventLog2 } from "viem";
+
+// src/create/contract-setup.ts
+import {
+  contracts1155,
   zoraCreator1155FactoryImplABI,
   zoraCreator1155FactoryImplAddress,
-  zoraCreator1155ImplABI as zoraCreator1155ImplABI3,
-  zoraCreatorFixedPriceSaleStrategyABI
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI3
 } from "@zoralabs/protocol-deployments";
-import { decodeEventLog as decodeEventLog2, encodeFunctionData, zeroAddress as zeroAddress4 } from "viem";
-var SALE_END_FOREVER = 18446744073709551615n;
-var ROYALTY_BPS_DEFAULT = 1e3;
-var DEFAULT_SALE_SETTINGS = {
-  fundsRecipient: zeroAddress4,
-  // Free Mint
-  pricePerToken: 0n,
-  // Sale start time – defaults to beginning of unix time
-  saleStart: 0n,
-  // This is the end of uint64, plenty of time
-  saleEnd: SALE_END_FOREVER,
-  // 0 Here means no limit
-  maxTokensPerAddress: 0n
-};
-var PERMISSION_BIT_MINTER = 4n;
-function create1155TokenSetupArgs({
-  nextTokenId,
-  // How many NFTs upon initialization to mint to the creator
-  mintToCreatorCount,
-  tokenMetadataURI,
-  // Fixed price minter address – required minter
-  fixedPriceMinterAddress,
-  // Address to use as the create referral, optional.
-  createReferral,
-  // Optional max supply of the token. Default unlimited
-  maxSupply,
-  // wallet sending the transaction
-  account,
-  salesConfig,
-  royaltySettings
+function new1155ContractVersion(chainId) {
+  const address = contracts1155.addresses[chainId];
+  if (!address) {
+    throw new Error(`No contract address for chainId ${chainId}`);
+  }
+  return address.CONTRACT_1155_IMPL_VERSION;
+}
+async function getContractInfo({
+  publicClient,
+  chainId,
+  contract,
+  account
 }) {
-  if (!maxSupply) {
-    maxSupply = OPEN_EDITION_MINT_SIZE;
+  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;
   }
-  maxSupply = BigInt(maxSupply);
-  mintToCreatorCount = BigInt(mintToCreatorCount);
-  const salesConfigWithDefaults = {
-    // Set static sales default.
+  const nextTokenId = contractExists ? await publicClient.readContract({
+    address: contractAddress,
+    abi: zoraCreator1155ImplABI3,
+    functionName: "nextTokenId"
+  }) : 1n;
+  return {
+    contractExists,
+    contractAddress,
+    contractVersion,
+    nextTokenId
+  };
+}
+
+// src/create/token-setup.ts
+import {
+  erc20MinterABI as erc20MinterABI2,
+  erc20MinterAddress as erc20MinterAddresses,
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI4,
+  zoraCreatorFixedPriceSaleStrategyABI,
+  zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress3
+} from "@zoralabs/protocol-deployments";
+import { encodeFunctionData, zeroAddress as zeroAddress4 } from "viem";
+import * as semver from "semver";
+var PERMISSION_BITS = {
+  MINTER: 2n ** 2n
+};
+var saleSettingsOrDefault = (saleSettings) => {
+  const SALE_END_FOREVER = 18446744073709551615n;
+  const DEFAULT_SALE_SETTINGS = {
+    currency: zeroAddress4,
+    // Free Mint
+    pricePerToken: 0n,
+    // Sale start time – defaults to beginning of unix time
+    saleStart: 0n,
+    // This is the end of uint64, plenty of time
+    saleEnd: SALE_END_FOREVER,
+    // 0 Here means no limit
+    maxTokensPerAddress: 0n
+  };
+  return {
     ...DEFAULT_SALE_SETTINGS,
-    // Override with user settings.
-    ...salesConfig
+    ...saleSettings
   };
-  const setupActions = [
-    encodeFunctionData({
-      abi: zoraCreator1155ImplABI3,
-      functionName: "assumeLastTokenIdMatches",
-      args: [nextTokenId - 1n]
-    }),
-    createReferral ? encodeFunctionData({
-      abi: zoraCreator1155ImplABI3,
+};
+function applyNew1155Defaults(props, ownerAddress) {
+  const { payoutRecipient: fundsRecipient } = props;
+  const fundsRecipientOrOwner = fundsRecipient && fundsRecipient !== zeroAddress4 ? fundsRecipient : ownerAddress;
+  return {
+    payoutRecipient: fundsRecipientOrOwner,
+    createReferral: props.createReferral || zeroAddress4,
+    maxSupply: typeof props.maxSupply === "undefined" ? OPEN_EDITION_MINT_SIZE : BigInt(props.maxSupply),
+    royaltyBPS: props.royaltyBPS || 1e3,
+    salesConfig: saleSettingsOrDefault(props.salesConfig),
+    tokenMetadataURI: props.tokenMetadataURI
+  };
+}
+function setupErc20Minter({
+  pricePerToken,
+  chainId,
+  tokenId: nextTokenId,
+  currency,
+  saleStart,
+  saleEnd,
+  maxTokensPerAddress: mintLimit,
+  fundsRecipient
+}) {
+  const erc20MinterAddress2 = erc20MinterAddresses[chainId];
+  if (!erc20MinterAddress2)
+    throw new Error(`ERC20Minter not deployed on chainId ${chainId}`);
+  const erc20MinterApproval = encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    functionName: "addPermission",
+    args: [BigInt(nextTokenId), erc20MinterAddress2, 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), erc20MinterAddress2, saleData]
+  });
+  return {
+    minter: erc20MinterAddress2,
+    setupActions: [erc20MinterApproval, callSale]
+  };
+}
+function setupFixedPriceMinter({
+  pricePerToken: price,
+  tokenId: nextTokenId,
+  chainId,
+  saleStart,
+  saleEnd,
+  maxTokensPerAddress: mintLimit,
+  fundsRecipient
+}) {
+  const fixedPriceStrategyAddress = zoraCreatorFixedPriceSaleStrategyAddress3[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 === zeroAddress4) {
+    return setupFixedPriceMinter({
+      ...salesConfig,
+      ...rest
+    });
+  } else {
+    return setupErc20Minter({
+      ...salesConfig,
+      ...rest
+    });
+  }
+}
+function buildSetupNewToken({
+  tokenURI,
+  maxSupply = OPEN_EDITION_MINT_SIZE,
+  createReferral = zeroAddress4,
+  contractVersion
+}) {
+  if (contractSupportsMintRewards(contractVersion, "ERC1155")) {
+    return encodeFunctionData({
+      abi: zoraCreator1155ImplABI4,
       functionName: "setupNewTokenWithCreateReferral",
-      args: [tokenMetadataURI, maxSupply, createReferral]
-    }) : encodeFunctionData({
-      abi: zoraCreator1155ImplABI3,
-      functionName: "setupNewToken",
-      args: [tokenMetadataURI, maxSupply]
-    }),
-    encodeFunctionData({
-      abi: zoraCreator1155ImplABI3,
-      functionName: "addPermission",
-      args: [0n, fixedPriceMinterAddress, PERMISSION_BIT_MINTER]
-    }),
-    encodeFunctionData({
-      abi: zoraCreator1155ImplABI3,
-      functionName: "callSale",
+      args: [tokenURI, BigInt(maxSupply), createReferral]
+    });
+  }
+  if (createReferral !== zeroAddress4) {
+    throw new Error(
+      "Contract does not support create referral, but one was provided"
+    );
+  }
+  return encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    functionName: "setupNewToken",
+    args: [tokenURI, BigInt(maxSupply)]
+  });
+}
+function setupRoyaltyConfig({
+  royaltyBPS,
+  royaltyRecipient,
+  nextTokenId
+}) {
+  if (royaltyBPS > 0 && royaltyRecipient != zeroAddress4) {
+    return encodeFunctionData({
+      abi: zoraCreator1155ImplABI4,
+      functionName: "updateRoyaltiesForToken",
       args: [
         nextTokenId,
-        fixedPriceMinterAddress,
-        encodeFunctionData({
-          abi: zoraCreatorFixedPriceSaleStrategyABI,
-          functionName: "setSale",
-          args: [nextTokenId, salesConfigWithDefaults]
-        })
+        {
+          royaltyBPS,
+          royaltyRecipient,
+          royaltyMintSchedule: 0
+        }
       ]
-    })
-  ];
-  if (mintToCreatorCount) {
-    setupActions.push(
-      encodeFunctionData({
-        abi: zoraCreator1155ImplABI3,
-        functionName: "adminMint",
-        args: [account, nextTokenId, mintToCreatorCount, "0x"]
-      })
-    );
+    });
   }
-  if (royaltySettings) {
-    setupActions.push(
-      encodeFunctionData({
-        abi: zoraCreator1155ImplABI3,
-        functionName: "updateRoyaltiesForToken",
-        args: [
-          nextTokenId,
-          {
-            royaltyMintSchedule: 0,
-            royaltyBPS: royaltySettings?.royaltyBPS || ROYALTY_BPS_DEFAULT,
-            royaltyRecipient: royaltySettings?.royaltyRecipient || account
-          }
-        ]
-      })
-    );
+  return null;
+}
+function makeAdminMintCall({
+  ownerAddress,
+  mintQuantity,
+  nextTokenId
+}) {
+  if (!mintQuantity || mintQuantity <= 0 || !ownerAddress) {
+    return null;
   }
-  return setupActions;
+  return encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    functionName: "adminMint",
+    args: [ownerAddress, nextTokenId, BigInt(mintQuantity), zeroAddress4]
+  });
+}
+function constructCreate1155TokenCalls(props) {
+  const {
+    chainId,
+    nextTokenId,
+    mintToCreatorCount,
+    ownerAddress,
+    contractVersion
+  } = props;
+  const new1155TokenPropsWithDefaults = applyNew1155Defaults(
+    props,
+    ownerAddress
+  );
+  const verifyTokenIdExpected = encodeFunctionData({
+    abi: zoraCreator1155ImplABI4,
+    functionName: "assumeLastTokenIdMatches",
+    args: [nextTokenId - 1n]
+  });
+  const setupNewToken = buildSetupNewToken({
+    tokenURI: new1155TokenPropsWithDefaults.tokenMetadataURI,
+    maxSupply: new1155TokenPropsWithDefaults.maxSupply,
+    createReferral: new1155TokenPropsWithDefaults.createReferral,
+    contractVersion
+  });
+  const royaltyConfig = setupRoyaltyConfig({
+    royaltyBPS: new1155TokenPropsWithDefaults.royaltyBPS,
+    royaltyRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
+    nextTokenId
+  });
+  const { minter, setupActions: mintersSetup } = setupMinters({
+    tokenId: nextTokenId,
+    chainId,
+    fundsRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
+    salesConfig: new1155TokenPropsWithDefaults.salesConfig
+  });
+  const adminMintCall = makeAdminMintCall({
+    ownerAddress,
+    mintQuantity: mintToCreatorCount,
+    nextTokenId
+  });
+  const setupActions = [
+    verifyTokenIdExpected,
+    setupNewToken,
+    ...mintersSetup,
+    royaltyConfig,
+    adminMintCall
+  ].filter((item) => item !== null);
+  return {
+    setupActions,
+    minter,
+    newToken: new1155TokenPropsWithDefaults
+  };
 }
+var contractSupportsMintRewards = (contractVersion, contractStandard) => {
+  if (!contractStandard || !contractVersion) {
+    return false;
+  }
+  const semVerContractVersion = semver.coerce(contractVersion)?.raw;
+  if (!semVerContractVersion)
+    return false;
+  if (contractStandard === "ERC1155") {
+    return semver.gte(semVerContractVersion, "1.3.5");
+  } else {
+    return semver.gte(semVerContractVersion, "14.0.0");
+  }
+};
+
+// src/create/1155-create-helper.ts
+var ROYALTY_BPS_DEFAULT = 1e3;
 var getTokenIdFromCreateReceipt = (receipt) => {
   for (const data of receipt.logs) {
     try {
       const decodedLog = decodeEventLog2({
-        abi: zoraCreator1155ImplABI3,
+        abi: zoraCreator1155ImplABI5,
         eventName: "SetupNewToken",
         ...data
       });
@@ -1586,132 +1998,116 @@ var getTokenIdFromCreateReceipt = (receipt) => {
     }
   }
 };
-async function getContractExists(publicClient, contract, account) {
-  let contractAddress;
-  let contractExists = false;
-  if (typeof contract !== "string") {
-    contractAddress = await publicClient.readContract({
-      abi: zoraCreator1155FactoryImplABI,
-      // Since this address is deterministic we can hardcode a chain id safely here.
-      address: zoraCreator1155FactoryImplAddress[999],
-      functionName: "deterministicContractAddress",
+function makeCreateContractAndTokenCall({
+  contractExists,
+  contractAddress,
+  contract,
+  account,
+  royaltyBPS,
+  tokenSetupActions,
+  fundsRecipient
+}) {
+  if (!contractAddress && typeof contract === "string") {
+    throw new Error("Invariant: contract cannot be missing and an address");
+  }
+  if (!contractExists) {
+    if (typeof contract === "string") {
+      throw new Error("Invariant: expected contract object");
+    }
+    const accountAddress = typeof account === "string" ? account : account.address;
+    return makeContractParameters({
+      abi: zoraCreator1155FactoryImplABI2,
+      functionName: "createContractDeterministic",
+      account,
+      address: zoraCreator1155FactoryImplAddress2[999],
       args: [
-        account,
         contract.uri,
         contract.name,
-        contract.defaultAdmin || account
+        {
+          // deprecated
+          royaltyMintSchedule: 0,
+          royaltyBPS: royaltyBPS || ROYALTY_BPS_DEFAULT,
+          royaltyRecipient: fundsRecipient || accountAddress
+        },
+        contract.defaultAdmin || accountAddress,
+        tokenSetupActions
       ]
     });
-    try {
-      await publicClient.readContract({
-        abi: zoraCreator1155ImplABI3,
-        address: contractAddress,
-        functionName: "contractVersion"
-      });
-      contractExists = true;
-    } catch (e) {
-    }
-    return { contractAddress, contractExists };
   }
-  return {
-    contractExists: true,
-    contractAddress: contract
-  };
-}
-function create1155CreatorClient(clientConfig) {
-  const { publicClient } = setupClient(clientConfig);
-  async function createNew1155Token({
-    contract,
-    tokenMetadataURI,
-    mintToCreatorCount = 1,
-    salesConfig = {},
-    maxSupply,
+  return makeContractParameters({
+    abi: zoraCreator1155ImplABI5,
+    functionName: "multicall",
     account,
-    royaltySettings,
-    createReferral,
-    getAdditionalSetupActions
+    address: contractAddress,
+    args: [tokenSetupActions]
+  });
+}
+var Create1155Client = class {
+  constructor({
+    chainId,
+    publicClient
   }) {
-    const { contractExists, contractAddress } = await getContractExists(
-      publicClient,
-      contract,
-      account
-    );
-    let nextTokenId = 1n;
-    if (contractExists) {
-      nextTokenId = await publicClient.readContract({
-        abi: zoraCreator1155ImplABI3,
-        functionName: "nextTokenId",
-        address: contractAddress
-      });
-    }
-    const fixedPriceMinterAddress = await publicClient.readContract({
-      abi: zoraCreator1155FactoryImplABI,
-      address: zoraCreator1155FactoryImplAddress[999],
-      functionName: "fixedPriceMinter"
-    });
-    let tokenSetupActions = create1155TokenSetupArgs({
-      tokenMetadataURI,
-      nextTokenId,
-      salesConfig,
-      maxSupply,
-      fixedPriceMinterAddress,
-      account,
-      mintToCreatorCount,
-      royaltySettings,
-      createReferral
+    this.chainId = chainId;
+    this.publicClient = publicClient;
+  }
+  async createNew1155Token(props) {
+    return createNew1155Token({
+      ...props,
+      publicClient: this.publicClient,
+      chainId: this.chainId
     });
-    if (getAdditionalSetupActions) {
-      tokenSetupActions = [
-        ...getAdditionalSetupActions({ tokenId: nextTokenId, contractAddress }),
-        ...tokenSetupActions
-      ];
-    }
-    if (!contractAddress && typeof contract === "string") {
-      throw new Error("Invariant: contract cannot be missing and an address");
-    }
-    if (!contractExists && typeof contract !== "string") {
-      const request = makeSimulateContractParamaters({
-        abi: zoraCreator1155FactoryImplABI,
-        functionName: "createContractDeterministic",
-        account,
-        address: zoraCreator1155FactoryImplAddress[999],
-        args: [
-          contract.uri,
-          contract.name,
-          {
-            // deprecated
-            royaltyMintSchedule: 0,
-            royaltyBPS: royaltySettings?.royaltyBPS || ROYALTY_BPS_DEFAULT,
-            royaltyRecipient: royaltySettings?.royaltyRecipient || account
-          },
-          contract.defaultAdmin || account,
-          tokenSetupActions
-        ]
-      });
-      return {
-        request,
-        tokenSetupActions,
-        contractAddress,
-        contractExists
-      };
-    } else if (contractExists) {
-      const request = makeSimulateContractParamaters({
-        abi: zoraCreator1155ImplABI3,
-        functionName: "multicall",
-        account,
-        address: contractAddress,
-        args: [tokenSetupActions]
-      });
-      return {
-        request,
-        tokenSetupActions,
-        contractAddress,
-        contractExists
-      };
-    }
-    throw new Error("Unsupported contract argument type");
   }
-  return { createNew1155Token };
+};
+async function createNew1155Token({
+  contract,
+  account,
+  getAdditionalSetupActions,
+  token: tokenConfig,
+  publicClient,
+  chainId
+}) {
+  const { contractExists, contractAddress, nextTokenId, contractVersion } = await getContractInfo({
+    publicClient,
+    chainId,
+    contract,
+    account
+  });
+  const {
+    minter,
+    newToken,
+    setupActions: tokenSetupActions
+  } = constructCreate1155TokenCalls({
+    chainId,
+    ownerAddress: account,
+    contractVersion,
+    nextTokenId,
+    ...tokenConfig
+  });
+  const setupActions = getAdditionalSetupActions ? [
+    ...getAdditionalSetupActions({
+      tokenId: nextTokenId,
+      contractAddress
+    }),
+    ...tokenSetupActions
+  ] : tokenSetupActions;
+  const request = makeCreateContractAndTokenCall({
+    contractExists,
+    contractAddress,
+    contract,
+    account,
+    tokenSetupActions: setupActions,
+    royaltyBPS: tokenConfig.royaltyBPS,
+    fundsRecipient: tokenConfig.payoutRecipient
+  });
+  return {
+    parameters: request,
+    tokenSetupActions,
+    collectionAddress: contractAddress,
+    contractExists,
+    newTokenId: nextTokenId,
+    newToken,
+    minter
+  };
 }
 
 // src/mints/mints-queries.ts
@@ -1791,7 +2187,7 @@ var mintWithEthParams = ({
   chainId,
   pricePerMint,
   account
-}) => makeSimulateContractParamaters({
+}) => makeContractParameters({
   abi: zoraMintsManagerImplConfig.abi,
   address: zoraMintsManagerImplConfig.address[chainId],
   functionName: "mintWithEth",
@@ -1847,7 +2243,7 @@ function collectWithMintsParams({
     minter,
     mintArguments
   });
-  return makeSimulateContractParamaters({
+  return makeContractParameters({
     abi: zoraMints1155Config.abi,
     address: zoraMints1155Config.address[chainId],
     functionName: "transferBatchToManagerAndCall",
@@ -1993,7 +2389,7 @@ function collectPremintV2WithMintsParams({
   const call = encodePremintOnManager({
     ...rest
   });
-  return makeSimulateContractParamaters({
+  return makeContractParameters({
     abi: zoraMints1155Config.abi,
     address: zoraMints1155Config.address[chainId],
     functionName: "transferBatchToManagerAndCall",
@@ -2046,41 +2442,90 @@ var unwrapAndForwardEthPermitAndTypedDataDefinition = ({
   to: mintsEthUnwrapperAndCallerAddress[chainId],
   nonce
 });
+
+// src/sdk.ts
+function createCreatorClient(clientConfig) {
+  const premintClient = new PremintClient({
+    chainId: clientConfig.chainId,
+    publicClient: clientConfig.publicClient,
+    premintApi: clientConfig.premintApi || new PremintAPIClient(clientConfig.chainId)
+  });
+  const create1155CreatorClient = new Create1155Client({
+    chainId: clientConfig.chainId,
+    publicClient: clientConfig.publicClient
+  });
+  return {
+    createPremint: (p) => premintClient.createPremint(p),
+    updatePremint: (p) => premintClient.updatePremint(p),
+    deletePremint: (p) => premintClient.deletePremint(p),
+    create1155: (p) => create1155CreatorClient.createNew1155Token(p)
+  };
+}
+function createCollectorClient(params) {
+  const premintGetterToUse = params.premintGetter || new PremintAPIClient(params.chainId);
+  const mintGetterToUse = params.mintGetter || new SubgraphMintGetter(params.chainId);
+  const mintClient = new MintClient({
+    chainId: params.chainId,
+    publicClient: params.publicClient,
+    premintGetter: premintGetterToUse,
+    mintGetter: mintGetterToUse
+  });
+  return {
+    getPremint: (p) => premintGetterToUse.getSignature({
+      collectionAddress: p.address,
+      uid: p.uid
+    }),
+    getCollectDataFromPremintReceipt: (p) => getDataFromPremintReceipt(p, params.chainId),
+    mint: (p) => mintClient.mint(p),
+    getMintCosts: (p) => mintClient.getMintCosts(p)
+  };
+}
 export {
-  DEFAULT_SALE_SETTINGS,
+  Create1155Client,
   Errors,
-  MintAPIClient,
+  MintClient,
   PremintAPIClient,
+  PremintClient,
   PremintConfigVersion3 as PremintConfigVersion,
+  SubgraphMintGetter,
   ZORA_API_BASE,
   applyUpdateToPremint,
+  collectOnchain,
+  collectPremint,
   collectPremintV2WithMintsParams,
   collectWithMintsParams,
   convertCollectionFromApi,
   convertGetPremintApiResponse,
   convertPremintFromApi,
-  create1155CreatorClient,
-  create1155TokenSetupArgs,
-  createMintClient,
-  createPremintClient,
+  createCollectorClient,
+  createCreatorClient,
   decodeCallFailedError,
+  defaultAdditionalAdmins,
   defaultTokenConfigV1MintArguments,
   defaultTokenConfigV2MintArguments,
+  emptyContractCreationConfig,
   encodeCollectOnManager,
   encodePostSignatureInput,
   encodePremintForAPI,
   getApiNetworkConfigForChain,
+  getDataFromPremintReceipt,
   getDefaultFixedPriceMinterAddress,
   getMintCosts,
   getMintsAccountBalanceWithPriceQuery,
   getMintsEthPrice,
+  getNecessaryErc20Approval,
   getPremintCollectionAddress,
   getPremintExecutorAddress,
   getPremintMintCosts,
+  getPremintMintCostsWithUnknownTokenPrice,
   getPremintMintFee,
+  getPremintPricePerToken,
   getPremintedLogFromReceipt,
+  getSignature,
   getTokenIdFromCreateReceipt,
   isAuthorizedToCreatePremint,
+  isPremintConfigV1,
+  isPremintConfigV2,
   isValidSignature,
   makeCallWithEthSafeTransferData,
   makeMintRewardsRecipient,
@@ -2088,16 +2533,20 @@ export {
   makePermitToCollectPremintOrNonPremint,
   makePermitTransferBatchAndTypeData,
   makePermitTransferTypeData,
+  makePrepareMint1155TokenParams,
   makeUrls,
   migratePremintConfigToV2,
   mintWithEthParams,
   mintsBalanceOfAccountParams,
+  parseMintCosts,
   recoverCreatorFromCreatorAttribution,
   recoverPremintSigner,
+  requestErc20ApprovalForMint,
   selectMintsToCollectWithFromQueryResult,
   sumBalances,
   supportedPremintVersions,
   supportsPremintVersion,
+  toContractCreationConfigOrAddress,
   tryRecoverPremintSigner,
   unwrapAndForwardEthPermitAndTypedDataDefinition
 };