@zoralabs/protocol-sdk 0.5.17 → 0.6.0

package/dist/index.js

@@ -20,8 +20,266 @@ 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({
   contractAdmin = zeroAddress,
@@ -164,8 +422,8 @@ var supportsPremintVersion = async ({
 };
 async function getPremintCollectionAddress({
   publicClient,
-  collection,
-  collectionAddress
+  contract: collection,
+  contractAddress: collectionAddress
 }) {
   if (typeof collection !== "undefined") {
     return publicClient.readContract({
@@ -224,7 +482,7 @@ async function getPremintMintFee({
     });
   } catch (e) {
     console.error(e);
-    return parseEther("0.000777");
+    return parseEther2("0.000777");
   }
 }
 async function getPremintMintCosts({
@@ -234,14 +492,44 @@ 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
   };
 }
-function makeMintRewardsRecipient({
-  mintReferral = zeroAddress,
+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
 }) {
   return [mintReferral, platformReferral];
@@ -267,12 +555,12 @@ var toContractCreationConfigOrAddress = ({
 }) => {
   if (typeof collection !== "undefined") {
     return {
-      collection
+      contract: collection
     };
   }
   if (typeof collectionAddress !== "undefined") {
     return {
-      collectionAddress
+      contractAddress: collectionAddress
     };
   }
   throw new Error("Must provide either a collection or a collection address");
@@ -348,433 +636,109 @@ var retries = async (tryFn, maxTries = 3, atTry = 1, linearBackoffMS = 200) => {
           return await retries(tryFn, maxTries, atTry + 1);
         }
       }
-    }
-    throw err;
-  }
-};
-var httpClient = {
-  get,
-  post,
-  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
-var getApiNetworkConfigForChain = (chainId) => {
-  if (!networkConfigByChain[chainId]) {
-    throw new Error(`chain id ${chainId} network not configured `);
-  }
-  return networkConfigByChain[chainId];
-};
-var MintAPIClient = class {
-  constructor(chainId, httpClient2) {
-    this.httpClient = httpClient2 || httpClient;
-    this.networkConfig = getApiNetworkConfigForChain(chainId);
-  }
-  async getSalesConfigAndTokenInfo({
-    tokenAddress,
-    tokenId,
-    saleType
-  }) {
-    const { retries: retries2, post: post2 } = this.httpClient;
-    return retries2(async () => {
-      const response = await post2(this.networkConfig.subgraphUrl, {
-        query: NFT_SALE_QUERY,
-        variables: {
-          id: tokenId !== void 0 ? (
-            // Generic Token ID types all stringify down to the base numeric equivalent.
-            `${tokenAddress.toLowerCase()}-${tokenId}`
-          ) : `${tokenAddress.toLowerCase()}-0`
-        }
-      });
-      const token = response.data?.zoraCreateToken;
-      if (!token) {
-        throw new Error("Cannot find a token to mint");
-      }
-      const allStrategies = (typeof tokenId !== "undefined" ? token.salesStrategies : token.contract.salesStrategies) || [];
-      const saleStrategies = allStrategies.sort(
-        (a, b) => BigInt(
-          a.type === "ERC_20_MINTER" ? a.erc20Minter.saleEnd : a.fixedPrice.saleEnd
-        ) > BigInt(
-          b.type === "FIXED_PRICE" ? b.fixedPrice.saleEnd : b.erc20Minter.saleEnd
-        ) ? 1 : -1
-      );
-      let targetStrategy;
-      if (!saleType) {
-        targetStrategy = saleStrategies[0];
-        if (!targetStrategy) {
-          throw new Error("Cannot find sale strategy");
-        }
-      } else {
-        const mappedSaleType = saleType === "erc20" ? "ERC_20_MINTER" : "FIXED_PRICE";
-        targetStrategy = saleStrategies.find(
-          (strategy) => strategy.type === mappedSaleType
-        );
-        if (!targetStrategy) {
-          throw new Error(`Cannot find sale strategy for ${mappedSaleType}`);
-        }
-      }
-      if (targetStrategy.type === "FIXED_PRICE") {
-        return {
-          salesConfig: {
-            saleType: "fixedPrice",
-            ...targetStrategy.fixedPrice,
-            maxTokensPerAddress: BigInt(
-              targetStrategy.fixedPrice.maxTokensPerAddress
-            ),
-            pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken)
-          },
-          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
-        };
-      }
-      if (targetStrategy.type === "ERC_20_MINTER") {
-        return {
-          salesConfig: {
-            saleType: "erc20",
-            ...targetStrategy.erc20Minter,
-            maxTokensPerAddress: BigInt(
-              targetStrategy.erc20Minter.maxTokensPerAddress
-            ),
-            pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken)
-          },
-          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
-        };
-      }
-      throw new Error("Invalid saleType");
-    });
-  }
-};
-
-// src/premint/conversions.ts
-import {
-  PremintConfigVersion
-} from "@zoralabs/protocol-deployments";
-var convertCollectionFromApi = (collection) => {
-  if (!collection)
-    return void 0;
-  return {
-    additionalAdmins: collection.additionalAdmins || [],
-    contractAdmin: collection.contractAdmin,
-    contractName: collection.contractName,
-    contractURI: collection.contractURI
-  };
-};
-var convertPremintFromApi = (premint) => {
-  if (premint.config_version === PremintConfigVersion.V1 || !premint.config_version) {
-    const tokenConfig = premint.tokenConfig;
-    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 = ({
-  collection,
-  collectionAddress,
-  premintConfigVersion,
-  premintConfig,
-  signature,
-  chainId
-}) => ({
-  premint: encodePremintForAPI({
-    premintConfig,
-    premintConfigVersion
-  }),
-  signature,
-  collection,
-  collection_address: collectionAddress,
-  chain_name: networkConfigByChain[chainId].zoraBackendChainName
-});
+    }
+    throw err;
+  }
+};
+var httpClient = {
+  get,
+  post,
+  retries
+};
 
-// 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;
+// 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 PremintAPIClient = class {
+var SubgraphMintGetter = class {
   constructor(chainId, httpClient2) {
-    this.postSignature = async ({
-      signature,
-      ...rest
-    }) => {
-      const data = encodePostSignatureInput({
-        ...rest,
-        chainId: this.networkConfig.chainId,
-        signature
-      });
-      return postSignature({
-        ...data,
-        httpClient: this.httpClient
-      });
-    };
-    this.getNextUID = async (collectionAddress) => (await getNextUID({
-      collection_address: collectionAddress.toLowerCase(),
-      chain_name: this.networkConfig.zoraBackendChainName,
-      httpClient: this.httpClient
-    })).next_uid;
-    this.getSignature = async ({
-      collectionAddress,
-      uid
-    }) => {
-      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);
   }
+  async getSalesConfigAndTokenInfo({
+    tokenAddress,
+    tokenId,
+    saleType
+  }) {
+    const { retries: retries2, post: post2 } = this.httpClient;
+    return retries2(async () => {
+      const response = await post2(this.networkConfig.subgraphUrl, {
+        query: NFT_SALE_QUERY,
+        variables: {
+          id: tokenId !== void 0 ? (
+            // Generic Token ID types all stringify down to the base numeric equivalent.
+            `${tokenAddress.toLowerCase()}-${tokenId}`
+          ) : `${tokenAddress.toLowerCase()}-0`
+        }
+      });
+      const token = response.data?.zoraCreateToken;
+      if (!token) {
+        throw new Error("Cannot find a token to mint");
+      }
+      const allStrategies = (typeof tokenId !== "undefined" ? token.salesStrategies : token.contract.salesStrategies) || [];
+      const saleStrategies = allStrategies.sort(
+        (a, b) => BigInt(
+          a.type === "ERC_20_MINTER" ? a.erc20Minter.saleEnd : a.fixedPrice.saleEnd
+        ) > BigInt(
+          b.type === "FIXED_PRICE" ? b.fixedPrice.saleEnd : b.erc20Minter.saleEnd
+        ) ? 1 : -1
+      );
+      let targetStrategy;
+      if (!saleType) {
+        targetStrategy = saleStrategies[0];
+        if (!targetStrategy) {
+          throw new Error("Cannot find sale strategy");
+        }
+      } else {
+        const mappedSaleType = saleType === "erc20" ? "ERC_20_MINTER" : "FIXED_PRICE";
+        targetStrategy = saleStrategies.find(
+          (strategy) => strategy.type === mappedSaleType
+        );
+        if (!targetStrategy) {
+          throw new Error(`Cannot find sale strategy for ${mappedSaleType}`);
+        }
+      }
+      if (targetStrategy.type === "FIXED_PRICE") {
+        return {
+          salesConfig: {
+            saleType: "fixedPrice",
+            ...targetStrategy.fixedPrice,
+            maxTokensPerAddress: BigInt(
+              targetStrategy.fixedPrice.maxTokensPerAddress
+            ),
+            pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken)
+          },
+          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
+        };
+      }
+      if (targetStrategy.type === "ERC_20_MINTER") {
+        return {
+          salesConfig: {
+            saleType: "erc20",
+            ...targetStrategy.erc20Minter,
+            maxTokensPerAddress: BigInt(
+              targetStrategy.erc20Minter.maxTokensPerAddress
+            ),
+            pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken)
+          },
+          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
+        };
+      }
+      throw new Error("Invalid saleType");
+    });
+  }
 };
 
 // src/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
@@ -782,8 +746,7 @@ var defaultTokenConfigV1MintArguments = () => ({
   maxSupply: OPEN_EDITION_MINT_SIZE,
   maxTokensPerAddress: 0n,
   pricePerToken: 0n,
-  mintDuration: BigInt(60 * 60 * 24 * 7),
-  // 1 week
+  mintDuration: 0n,
   mintStart: 0n,
   royaltyMintSchedule: 0,
   royaltyBPS: 1e3
@@ -824,8 +787,7 @@ var defaultTokenConfigV2MintArguments = () => ({
   maxSupply: OPEN_EDITION_MINT_SIZE,
   maxTokensPerAddress: 0n,
   pricePerToken: 0n,
-  mintDuration: BigInt(60 * 60 * 24 * 7),
-  // 1 week
+  mintDuration: 0n,
   mintStart: 0n,
   royaltyBPS: 1e3
   // 10%,
@@ -872,20 +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
@@ -898,7 +857,7 @@ var PremintClient = class {
       ...args,
       apiClient: this.apiClient,
       publicClient: this.publicClient,
-      chainId: this.chain.id
+      chainId: this.chainId
     });
   }
   /**
@@ -912,7 +871,7 @@ var PremintClient = class {
       ...params,
       apiClient: this.apiClient,
       publicClient: this.publicClient,
-      chainId: this.chain.id
+      chainId: this.chainId
     });
   }
   /**
@@ -926,7 +885,7 @@ var PremintClient = class {
       ...parameters,
       publicClient: this.publicClient,
       apiClient: this.apiClient,
-      chainId: this.chain.id
+      chainId: this.chainId
     });
   }
   /**
@@ -936,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
@@ -952,48 +908,9 @@ var PremintClient = class {
    */
   async getCollectionAddress(collection) {
     return await getPremintCollectionAddress({
-      collection,
-      publicClient: this.publicClient
-    });
-  }
-  /**
-   * Check user signature for v1
-   *
-   * @param data Signature data from the API
-   * @returns isValid = signature is valid or not, recoveredSigner = signer from contract
-   */
-  async isValidSignature({
-    signature,
-    premintConfig,
-    premintConfigVersion,
-    ...collectionAndOrAddress
-  }) {
-    const collectionAddressToUse = await getPremintCollectionAddress({
-      ...collectionAndOrAddress,
+      contract: collection,
       publicClient: this.publicClient
     });
-    const { isAuthorized, recoveredAddress } = await isValidSignature({
-      chainId: this.chain.id,
-      signature,
-      publicClient: this.publicClient,
-      premintConfig,
-      premintConfigVersion: premintConfigVersion || PremintConfigVersion2.V1,
-      collectionAddress: collectionAddressToUse,
-      collection: collectionAndOrAddress.collection
-    });
-    return { isValid: isAuthorized, recoveredSigner: recoveredAddress };
-  }
-  makeUrls({
-    uid,
-    address,
-    tokenId
-  }) {
-    return makeUrls({
-      uid,
-      address,
-      tokenId,
-      chain: this.chain
-    });
   }
   async getMintCosts({
     tokenContract,
@@ -1014,17 +931,40 @@ var PremintClient = class {
    * @param parameters - Parameters for collecting the Premint {@link MakeMintParametersArguments}
    * @returns receipt, log, zoraURL
    */
-  async makeMintParameters(parameters) {
-    return await makeMintParameters({
-      ...parameters,
-      apiClient: this.apiClient,
+  async makeMintParameters({
+    minterAccount,
+    tokenContract,
+    uid,
+    mintArguments,
+    firstMinter
+  }) {
+    return await collectPremint({
+      uid,
+      tokenContract,
+      minterAccount,
+      quantityToMint: mintArguments?.quantityToMint || 1n,
+      mintComment: mintArguments?.mintComment,
+      mintReferral: mintArguments?.mintReferral,
+      mintRecipient: mintArguments?.mintRecipient,
+      firstMinter,
+      premintGetter: this.apiClient,
       publicClient: this.publicClient
     });
   }
 };
-function createPremintClient(clientConfig) {
-  const { chain, httpClient: httpClient2, publicClient } = setupClient(clientConfig);
-  return new PremintClient(chain, publicClient, httpClient2);
+function getDataFromPremintReceipt(receipt, chainId, blockExplorerUrl) {
+  const premintedLog = getPremintedLogFromReceipt(receipt);
+  return {
+    tokenId: premintedLog?.tokenId,
+    collectionAddres: premintedLog?.contractAddress,
+    premintedLog,
+    urls: makeUrls({
+      address: premintedLog?.contractAddress,
+      tokenId: premintedLog?.tokenId,
+      chainId,
+      blockExplorerUrl
+    })
+  };
 }
 function makePremintReturn({
   premintConfig,
@@ -1054,7 +994,7 @@ function makePremintReturn({
     await submit({
       signature,
       checkSignature,
-      signerAccount
+      account: signerAccount
     });
     return {
       signature,
@@ -1064,7 +1004,7 @@ function makePremintReturn({
   const submit = async ({
     signature,
     checkSignature,
-    signerAccount
+    account
   }) => {
     if (checkSignature) {
       const isAuthorized = await isAuthorizedToCreatePremint({
@@ -1072,7 +1012,7 @@ function makePremintReturn({
         additionalAdmins: collection?.additionalAdmins,
         contractAdmin: collection?.contractAdmin,
         publicClient,
-        signer: signerAccount
+        signer: account
       });
       if (!isAuthorized) {
         throw new Error("Not authorized to create premint");
@@ -1115,7 +1055,7 @@ async function signPremint({
   };
 }
 async function createPremint({
-  tokenCreationConfig,
+  token: tokenCreationConfig,
   uid,
   publicClient,
   apiClient,
@@ -1138,7 +1078,7 @@ async function createPremint({
     premintConfig,
     premintConfigVersion,
     collectionAddress: collectionAddressToUse,
-    collection: collectionOrAddress.collection,
+    collection: collectionOrAddress.contract,
     publicClient,
     apiClient,
     chainId
@@ -1245,32 +1185,32 @@ async function deletePremint({
     chainId
   });
 }
-async function makeMintParameters({
+async function collectPremint({
   uid,
   tokenContract,
   minterAccount,
-  mintArguments,
+  quantityToMint,
+  mintComment = "",
+  mintReferral,
+  mintRecipient,
   firstMinter,
-  apiClient,
+  premintGetter,
   publicClient
 }) {
-  if (mintArguments && mintArguments?.quantityToMint < 1) {
+  if (typeof quantityToMint !== "undefined" && quantityToMint < 1) {
     throw new Error("Quantity to mint cannot be below 1");
   }
-  if (!minterAccount) {
-    throw new Error("Wallet not passed in");
-  }
   const {
     premintConfig,
     premintConfigVersion,
     collection,
     collectionAddress,
     signature
-  } = await apiClient.getSignature({
+  } = 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");
   }
@@ -1279,18 +1219,21 @@ 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
     })
   };
   const collectionOrEmpty = collection ? defaultAdditionalAdmins(collection) : emptyContractCreationConfig();
   const collectionAddressToSubmit = collection ? zeroAddress2 : collectionAddress;
   const firstMinterToSubmit = firstMinter || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
-  return makeSimulateContractParamaters({
+  return makeContractParameters({
     account: minterAccount,
     abi: zoraCreator1155PremintExecutorImplABI2,
     functionName: "premint",
@@ -1315,15 +1258,16 @@ function makeUrls({
   uid,
   address,
   tokenId,
-  chain
+  chainId,
+  blockExplorerUrl
 }) {
   if ((!uid || !tokenId) && !address) {
     return { explorer: null, zoraCollect: null, zoraManage: null };
   }
   const zoraTokenPath = uid ? `premint-${uid}` : tokenId;
-  const network = getApiNetworkConfigForChain(chain.id);
+  const network = getApiNetworkConfigForChain(chainId);
   return {
-    explorer: tokenId ? `https://${chain.blockExplorers?.default.url}/token/${address}/instance/${tokenId}` : null,
+    explorer: tokenId ? `https://${blockExplorerUrl}/token/${address}/instance/${tokenId}` : null,
     zoraCollect: `https://${network.isTestnet ? "testnet." : ""}zora.co/collect/${network.zoraCollectPathChainName}:${address}/${zoraTokenPath}`,
     zoraManage: `https://${network.isTestnet ? "testnet." : ""}zora.co/collect/${network.zoraCollectPathChainName}:${address}/${zoraTokenPath}`
   };
@@ -1340,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,
@@ -1352,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 {
@@ -1361,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,
-      apiClient: this.apiClient,
+      mintGetter: this.mintGetter,
+      premintGetter: this.premintGetter,
       publicClient: this.publicClient
     });
   }
 };
-function createMintClient(clientConfig) {
-  const { chain, publicClient, httpClient: httpClient2 } = setupClient(clientConfig);
-  return new MintClient(chain, publicClient, httpClient2);
+function isPremintCollect(parameters) {
+  return parameters.mintType === "premint";
+}
+function is721Collect(parameters) {
+  return parameters.mintType === "721";
 }
-async function makePrepareMintTokenParams({
+async function mint({
+  parameters,
+  chainId,
   publicClient,
-  apiClient,
-  tokenId,
+  mintGetter,
+  premintGetter
+}) {
+  if (isPremintCollect(parameters)) {
+    return {
+      parameters: await collectPremint({
+        ...parameters,
+        premintGetter,
+        publicClient
+      })
+    };
+  }
+  return {
+    parameters: await collectOnchain({
+      ...parameters,
+      mintGetter,
+      chainId
+    })
+  };
+}
+function requestErc20ApprovalForMint({
+  account,
   tokenAddress,
-  mintArguments,
-  ...rest
+  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
+    });
+  }
+  return void 0;
+}
+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
       });
@@ -1630,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
@@ -1835,7 +2187,7 @@ var mintWithEthParams = ({
   chainId,
   pricePerMint,
   account
-}) => makeSimulateContractParamaters({
+}) => makeContractParameters({
   abi: zoraMintsManagerImplConfig.abi,
   address: zoraMintsManagerImplConfig.address[chainId],
   functionName: "mintWithEth",
@@ -1891,7 +2243,7 @@ function collectWithMintsParams({
     minter,
     mintArguments
   });
-  return makeSimulateContractParamaters({
+  return makeContractParameters({
     abi: zoraMints1155Config.abi,
     address: zoraMints1155Config.address[chainId],
     functionName: "transferBatchToManagerAndCall",
@@ -2037,7 +2389,7 @@ function collectPremintV2WithMintsParams({
   const call = encodePremintOnManager({
     ...rest
   });
-  return makeSimulateContractParamaters({
+  return makeContractParameters({
     abi: zoraMints1155Config.abi,
     address: zoraMints1155Config.address[chainId],
     functionName: "transferBatchToManagerAndCall",
@@ -2090,23 +2442,63 @@ 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,
@@ -2116,17 +2508,24 @@ export {
   encodePostSignatureInput,
   encodePremintForAPI,
   getApiNetworkConfigForChain,
+  getDataFromPremintReceipt,
   getDefaultFixedPriceMinterAddress,
   getMintCosts,
   getMintsAccountBalanceWithPriceQuery,
   getMintsEthPrice,
+  getNecessaryErc20Approval,
   getPremintCollectionAddress,
   getPremintExecutorAddress,
   getPremintMintCosts,
+  getPremintMintCostsWithUnknownTokenPrice,
   getPremintMintFee,
+  getPremintPricePerToken,
   getPremintedLogFromReceipt,
+  getSignature,
   getTokenIdFromCreateReceipt,
   isAuthorizedToCreatePremint,
+  isPremintConfigV1,
+  isPremintConfigV2,
   isValidSignature,
   makeCallWithEthSafeTransferData,
   makeMintRewardsRecipient,
@@ -2134,12 +2533,15 @@ export {
   makePermitToCollectPremintOrNonPremint,
   makePermitTransferBatchAndTypeData,
   makePermitTransferTypeData,
+  makePrepareMint1155TokenParams,
   makeUrls,
   migratePremintConfigToV2,
   mintWithEthParams,
   mintsBalanceOfAccountParams,
+  parseMintCosts,
   recoverCreatorFromCreatorAttribution,
   recoverPremintSigner,
+  requestErc20ApprovalForMint,
   selectMintsToCollectWithFromQueryResult,
   sumBalances,
   supportedPremintVersions,