@zoralabs/protocol-sdk 0.5.4-exports.0 → 0.5.4

package/dist/index.js

@@ -0,0 +1,1664 @@
+// src/premint/premint-client.ts
+import { createPublicClient, decodeEventLog, http, zeroAddress as zeroAddress2 } from "viem";
+import { zoraCreator1155PremintExecutorImplABI as zoraCreator1155PremintExecutorImplABI2 } from "@zoralabs/protocol-deployments";
+
+// src/premint/preminter.ts
+import {
+  zoraCreator1155PremintExecutorImplABI as preminterAbi,
+  zoraCreator1155PremintExecutorImplABI,
+  zoraCreator1155PremintExecutorImplAddress,
+  zoraCreatorFixedPriceSaleStrategyAddress
+} from "@zoralabs/protocol-deployments";
+import {
+  recoverTypedDataAddress,
+  zeroAddress,
+  hashDomain,
+  keccak256,
+  concat,
+  recoverAddress,
+  parseEther
+} from "viem";
+
+// src/premint/contract-types.ts
+var v1Types = {
+  CreatorAttribution: [
+    { name: "tokenConfig", type: "TokenCreationConfig" },
+    // unique id scoped to the contract and token to create.
+    // ensure that a signature can be replaced, as long as the replacement
+    // has the same uid, and a newer version.
+    { name: "uid", type: "uint32" },
+    { name: "version", type: "uint32" },
+    // if this update should result in the signature being deleted.
+    { name: "deleted", type: "bool" }
+  ],
+  TokenCreationConfig: [
+    { name: "tokenURI", type: "string" },
+    { name: "maxSupply", type: "uint256" },
+    { name: "maxTokensPerAddress", type: "uint64" },
+    { name: "pricePerToken", type: "uint96" },
+    { name: "mintStart", type: "uint64" },
+    { name: "mintDuration", type: "uint64" },
+    { name: "royaltyMintSchedule", type: "uint32" },
+    { name: "royaltyBPS", type: "uint32" },
+    { name: "royaltyRecipient", type: "address" },
+    { name: "fixedPriceMinter", type: "address" }
+  ]
+};
+var v2Types = {
+  CreatorAttribution: [
+    { name: "tokenConfig", type: "TokenCreationConfig" },
+    // unique id scoped to the contract and token to create.
+    // ensure that a signature can be replaced, as long as the replacement
+    // has the same uid, and a newer version.
+    { name: "uid", type: "uint32" },
+    { name: "version", type: "uint32" },
+    // if this update should result in the signature being deleted.
+    { name: "deleted", type: "bool" }
+  ],
+  TokenCreationConfig: [
+    { name: "tokenURI", type: "string" },
+    { name: "maxSupply", type: "uint256" },
+    { name: "maxTokensPerAddress", type: "uint64" },
+    { name: "pricePerToken", type: "uint96" },
+    { name: "mintStart", type: "uint64" },
+    { name: "mintDuration", type: "uint64" },
+    { name: "royaltyBPS", type: "uint32" },
+    { name: "payoutRecipient", type: "address" },
+    { name: "fixedPriceMinter", type: "address" },
+    { name: "createReferral", type: "address" }
+  ]
+};
+var PreminterDomain = "Preminter";
+var PremintConfigVersion = /* @__PURE__ */ ((PremintConfigVersion2) => {
+  PremintConfigVersion2["V1"] = "1";
+  PremintConfigVersion2["V2"] = "2";
+  return PremintConfigVersion2;
+})(PremintConfigVersion || {});
+
+// src/premint/preminter.ts
+var getPremintExecutorAddress = () => zoraCreator1155PremintExecutorImplAddress[999];
+var premintTypedDataDefinition = ({
+  verifyingContract,
+  chainId,
+  premintConfigVersion: version,
+  premintConfig
+}) => {
+  const domain = {
+    chainId,
+    name: PreminterDomain,
+    version,
+    verifyingContract
+  };
+  if (version === "1" /* V1 */)
+    return {
+      domain,
+      types: v1Types,
+      message: premintConfig,
+      primaryType: "CreatorAttribution"
+    };
+  if (version === "2" /* V2 */) {
+    return {
+      domain,
+      types: v2Types,
+      message: premintConfig,
+      primaryType: "CreatorAttribution"
+    };
+  }
+  throw new Error(`Invalid version ${version}`);
+};
+async function isAuthorizedToCreatePremint({
+  collection,
+  collectionAddress,
+  publicClient,
+  signer
+}) {
+  return await publicClient.readContract({
+    abi: preminterAbi,
+    address: getPremintExecutorAddress(),
+    functionName: "isAuthorizedToCreatePremint",
+    args: [signer, collection.contractAdmin, collectionAddress]
+  });
+}
+async function recoverPremintSigner({
+  signature,
+  ...rest
+}) {
+  const typedData = premintTypedDataDefinition(rest);
+  return await recoverTypedDataAddress({
+    ...typedData,
+    signature
+  });
+}
+async function tryRecoverPremintSigner(params) {
+  try {
+    return await recoverPremintSigner(params);
+  } catch (error) {
+    console.error(error);
+    return void 0;
+  }
+}
+async function isValidSignature({
+  signature,
+  publicClient,
+  collection,
+  chainId,
+  ...premintConfigAndVersion
+}) {
+  const tokenContract = await getPremintCollectionAddress({
+    collection,
+    publicClient
+  });
+  const recoveredAddress = await tryRecoverPremintSigner({
+    ...premintConfigAndVersion,
+    signature,
+    verifyingContract: tokenContract,
+    chainId
+  });
+  if (!recoverAddress) {
+    return {
+      isAuthorized: false
+    };
+  }
+  const isAuthorized = await isAuthorizedToCreatePremint({
+    signer: recoveredAddress,
+    collection,
+    collectionAddress: tokenContract,
+    publicClient
+  });
+  return {
+    isAuthorized,
+    recoveredAddress
+  };
+}
+function migratePremintConfigToV2({
+  premintConfig,
+  createReferral = zeroAddress
+}) {
+  return {
+    ...premintConfig,
+    tokenConfig: {
+      tokenURI: premintConfig.tokenConfig.tokenURI,
+      maxSupply: premintConfig.tokenConfig.maxSupply,
+      maxTokensPerAddress: premintConfig.tokenConfig.maxTokensPerAddress,
+      pricePerToken: premintConfig.tokenConfig.pricePerToken,
+      mintStart: premintConfig.tokenConfig.mintStart,
+      mintDuration: premintConfig.tokenConfig.mintDuration,
+      payoutRecipient: premintConfig.tokenConfig.royaltyRecipient,
+      royaltyBPS: premintConfig.tokenConfig.royaltyBPS,
+      fixedPriceMinter: premintConfig.tokenConfig.fixedPriceMinter,
+      createReferral
+    }
+  };
+}
+var recoverCreatorFromCreatorAttribution = async ({
+  creatorAttribution: { version, domainName, structHash, signature },
+  chainId,
+  tokenContract
+}) => {
+  const hashedDomain = hashDomain({
+    domain: {
+      chainId,
+      name: domainName,
+      verifyingContract: tokenContract,
+      version
+    },
+    types: {
+      EIP712Domain: [
+        { name: "name", type: "string" },
+        { name: "version", type: "string" },
+        {
+          name: "chainId",
+          type: "uint256"
+        },
+        {
+          name: "verifyingContract",
+          type: "address"
+        }
+      ]
+    }
+  });
+  const parts = ["0x1901", hashedDomain, structHash];
+  const hashedTypedData = keccak256(concat(parts));
+  return await recoverAddress({
+    hash: hashedTypedData,
+    signature
+  });
+};
+var supportedPremintVersions = async ({
+  tokenContract,
+  publicClient
+}) => {
+  return await publicClient.readContract({
+    abi: preminterAbi,
+    address: getPremintExecutorAddress(),
+    functionName: "supportedPremintSignatureVersions",
+    args: [tokenContract]
+  });
+};
+var supportsPremintVersion = async ({
+  version,
+  tokenContract,
+  publicClient
+}) => {
+  return (await supportedPremintVersions({ tokenContract, publicClient })).includes(version);
+};
+async function getPremintCollectionAddress({
+  collection,
+  publicClient
+}) {
+  return publicClient.readContract({
+    address: getPremintExecutorAddress(),
+    abi: zoraCreator1155PremintExecutorImplABI,
+    functionName: "getContractAddress",
+    args: [collection]
+  });
+}
+function markPremintDeleted(premintConfig) {
+  return {
+    ...premintConfig,
+    version: premintConfig.version + 1,
+    deleted: true
+  };
+}
+function applyUpdateToPremint({
+  uid,
+  version,
+  tokenConfig,
+  tokenConfigUpdates
+}) {
+  const updatedTokenConfig = {
+    ...tokenConfig,
+    ...tokenConfigUpdates
+  };
+  const result = {
+    deleted: false,
+    uid,
+    version: version + 1,
+    tokenConfig: updatedTokenConfig
+  };
+  return result;
+}
+function makeNewPremint({
+  tokenConfig,
+  uid
+}) {
+  return {
+    deleted: false,
+    uid,
+    version: 0,
+    tokenConfig
+  };
+}
+async function getPremintMintFee({
+  tokenContract,
+  publicClient
+}) {
+  try {
+    return await publicClient.readContract({
+      address: getPremintExecutorAddress(),
+      abi: zoraCreator1155PremintExecutorImplABI,
+      functionName: "mintFee",
+      args: [tokenContract]
+    });
+  } catch (e) {
+    console.error(e);
+    return parseEther("0.000777");
+  }
+}
+async function getPremintMintCosts({
+  publicClient,
+  tokenContract,
+  tokenPrice,
+  quantityToMint
+}) {
+  const mintFee = await getPremintMintFee({ tokenContract, publicClient });
+  return {
+    mintFee: mintFee * quantityToMint,
+    tokenPurchaseCost: tokenPrice * quantityToMint,
+    totalCost: (mintFee + tokenPrice) * quantityToMint
+  };
+}
+function makeMintRewardsRecipient({
+  mintReferral = zeroAddress,
+  platformReferral = zeroAddress
+}) {
+  return [mintReferral, platformReferral];
+}
+function getDefaultFixedPriceMinterAddress(chainId) {
+  return zoraCreatorFixedPriceSaleStrategyAddress[chainId];
+}
+
+// src/apis/http-api-base.ts
+var BadResponseError = class extends Error {
+  constructor(message, status, json) {
+    super(message);
+    this.name = "BadResponseError";
+    this.status = status;
+    this.json = json;
+  }
+};
+async function wait(delayMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+  });
+}
+var get = async (url) => {
+  const response = await fetch(url, { method: "GET" });
+  if (response.status !== 200) {
+    let json;
+    try {
+      json = await response.json();
+    } catch (e) {
+    }
+    throw new BadResponseError(
+      `Invalid response, status ${response.status}`,
+      response.status,
+      json
+    );
+  }
+  return await response.json();
+};
+var post = async (url, data) => {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json"
+    },
+    body: JSON.stringify(data)
+  });
+  if (response.status !== 200) {
+    let json;
+    try {
+      json = await response.json();
+    } catch (e) {
+    }
+    throw new BadResponseError(
+      `Bad response: ${response.status}`,
+      response.status,
+      json
+    );
+  }
+  return await response.json();
+};
+var retries = async (tryFn, maxTries = 3, atTry = 1, linearBackoffMS = 200) => {
+  try {
+    return await tryFn();
+  } catch (err) {
+    if (err instanceof BadResponseError) {
+      if (err.status >= 500) {
+        if (atTry <= maxTries) {
+          await wait(atTry * linearBackoffMS);
+          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)"
+]);
+
+// src/apis/chain-constants.ts
+import {
+  base,
+  baseGoerli,
+  foundry,
+  goerli,
+  mainnet,
+  optimism,
+  optimismGoerli,
+  zora,
+  zoraSepolia,
+  zoraTestnet
+} 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")
+  },
+  [goerli.id]: {
+    chainId: goerli.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "gor",
+    zoraBackendChainName: "ETHEREUM-GOERLI",
+    subgraphUrl: getSubgraph("zora-create-goerli", "stable")
+  },
+  [zora.id]: {
+    chainId: zora.id,
+    isTestnet: false,
+    zoraCollectPathChainName: "zora",
+    zoraBackendChainName: "ZORA-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-zora-mainnet", "stable")
+  },
+  [zoraTestnet.id]: {
+    chainId: zoraTestnet.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "zgor",
+    zoraBackendChainName: "ZORA-GOERLI",
+    subgraphUrl: getSubgraph("zora-create-zora-testnet", "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")
+  },
+  [optimismGoerli.id]: {
+    chainId: optimismGoerli.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "ogor",
+    zoraBackendChainName: "OPTIMISM-GOERLI",
+    subgraphUrl: getSubgraph("zora-create-optimism-goerli", "stable")
+  },
+  [base.id]: {
+    chainId: base.id,
+    isTestnet: false,
+    zoraCollectPathChainName: "base",
+    zoraBackendChainName: "BASE-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-base-mainnet", "stable")
+  },
+  [baseGoerli.id]: {
+    chainId: baseGoerli.id,
+    isTestnet: true,
+    zoraCollectPathChainName: "bgor",
+    zoraBackendChainName: "BASE-GOERLI",
+    subgraphUrl: getSubgraph("zora-create-base-goerli", "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
+  }) {
+    const { retries: retries2, post: post2 } = this.httpClient;
+    return retries2(async () => {
+      const response = await post2(this.networkConfig.subgraphUrl, {
+        query: `
+          fragment SaleStrategy on SalesStrategyConfig {
+            type
+            fixedPrice {
+              address
+              pricePerToken
+              saleEnd
+              saleStart
+              maxTokensPerAddress
+            }
+          }
+          
+          query ($id: ID!) {
+            zoraCreateToken(id: $id) {
+              id
+              contract {
+                mintFeePerQuantity
+                salesStrategies(where: {type: "FIXED_PRICE"}) {
+                  ...SaleStrategy
+                }
+              }
+              salesStrategies(where: {type: "FIXED_PRICE"}) {
+                ...SaleStrategy
+              }
+            }
+          }
+        `,
+        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 saleStrategies = tokenId !== void 0 ? token.salesStrategies : token.contract.salesStrategies;
+      const fixedPrice = saleStrategies?.sort(
+        (a, b) => BigInt(a.fixedPrice.saleEnd) > BigInt(b.fixedPrice.saleEnd) ? 1 : -1
+      )?.find(() => true)?.fixedPrice;
+      if (!fixedPrice) {
+        throw new Error("Cannot find fixed price sale strategy");
+      }
+      return {
+        fixedPrice,
+        mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
+      };
+    });
+  }
+};
+
+// src/premint/conversions.ts
+var convertCollectionFromApi = (collection) => ({
+  ...collection,
+  contractAdmin: collection.contractAdmin
+});
+var convertPremintFromApi = (premint) => {
+  if (premint.config_version === "1" /* V1 */ || !premint.config_version) {
+    const tokenConfig = premint.tokenConfig;
+    return {
+      premintConfigVersion: "1" /* 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: "2" /* 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 === "1" /* V1 */) {
+    return encodePremintV1ForAPI(premintConfig);
+  }
+  if (premintConfigVersion === "2" /* 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);
+  }
+};
+
+// src/premint/premint-client.ts
+var defaultTokenConfigV1MintArguments = () => ({
+  maxSupply: OPEN_EDITION_MINT_SIZE,
+  maxTokensPerAddress: 0n,
+  pricePerToken: 0n,
+  mintDuration: BigInt(60 * 60 * 24 * 7),
+  // 1 week
+  mintStart: 0n,
+  royaltyMintSchedule: 0,
+  royaltyBPS: 1e3
+  // 10%,
+});
+var defaultTokenConfigV2MintArguments = () => ({
+  maxSupply: OPEN_EDITION_MINT_SIZE,
+  maxTokensPerAddress: 0n,
+  pricePerToken: 0n,
+  mintDuration: BigInt(60 * 60 * 24 * 7),
+  // 1 week
+  mintStart: 0n,
+  royaltyBPS: 1e3
+  // 10%,
+});
+var makeTokenConfigWithDefaults = ({
+  chainId,
+  premintConfigVersion,
+  tokenCreationConfig,
+  creatorAccount
+}) => {
+  const fixedPriceMinter = tokenCreationConfig.fixedPriceMinter || getDefaultFixedPriceMinterAddress(chainId);
+  if (premintConfigVersion === "1" /* V1 */) {
+    return {
+      fixedPriceMinter,
+      ...defaultTokenConfigV1MintArguments(),
+      royaltyRecipient: creatorAccount,
+      ...tokenCreationConfig
+    };
+  } else if (premintConfigVersion === "2" /* V2 */) {
+    return {
+      fixedPriceMinter,
+      ...defaultTokenConfigV2MintArguments(),
+      payoutRecipient: creatorAccount,
+      createReferral: zeroAddress2,
+      ...tokenCreationConfig
+    };
+  } else {
+    throw new Error(`Invalid premint config version ${premintConfigVersion}`);
+  }
+};
+function getPremintedLogFromReceipt(receipt) {
+  for (const data of receipt.logs) {
+    try {
+      const decodedLog = decodeEventLog({
+        abi: zoraCreator1155PremintExecutorImplABI2,
+        eventName: "PremintedV2",
+        ...data
+      });
+      if (decodedLog.eventName === "PremintedV2") {
+        return decodedLog.args;
+      }
+    } catch (err) {
+    }
+  }
+}
+var PremintClient = class {
+  constructor(chain, publicClient, httpClient2) {
+    this.chain = chain;
+    this.apiClient = new PremintAPIClient(chain.id, httpClient2);
+    this.publicClient = publicClient || createPublicClient({ chain, transport: http() });
+  }
+  getDataFromPremintReceipt(receipt) {
+    const premintedLog = getPremintedLogFromReceipt(receipt);
+    return {
+      premintedLog,
+      urls: this.makeUrls({
+        address: premintedLog?.contractAddress,
+        tokenId: premintedLog?.tokenId
+      })
+    };
+  }
+  /**
+   * Update existing premint given collection address and UID of existing premint.
+   *
+   * 1. Loads existing premint token
+   * 2. Updates with settings passed into function
+   * 3. Increments the version field
+   * 4. Re-signs the premint
+   * 5. Uploads the premint to the ZORA API
+   *
+   * Updates existing premint
+   * @param settings Settings for the new premint
+   * @param settings.account Account to sign the premint update from. Taken from walletClient if none passed in.
+   * @param settings.collection Collection information for the mint
+   * @param settings.walletClient viem wallet client to use to sign
+   * @param settings.uid UID
+   * @param settings.token Mint argument settings, optional settings are overridden with sensible defaults.
+   *
+   */
+  async updatePremint({
+    walletClient,
+    uid,
+    collection,
+    account,
+    tokenConfigUpdates
+  }) {
+    const {
+      premintConfig,
+      collection: collectionCreationConfig,
+      premintConfigVersion
+    } = await this.apiClient.getSignature({
+      collectionAddress: collection,
+      uid
+    });
+    const updatedPremint = applyUpdateToPremint({
+      uid: premintConfig.uid,
+      version: premintConfig.version,
+      tokenConfig: premintConfig.tokenConfig,
+      tokenConfigUpdates
+    });
+    return await this.signAndSubmitPremint({
+      walletClient,
+      account,
+      checkSignature: true,
+      verifyingContract: collection,
+      collection: collectionCreationConfig,
+      premintConfig: updatedPremint,
+      premintConfigVersion
+    });
+  }
+  /**
+   * Delete premint.
+   *
+   * 1. Loads current premint from collection address with UID
+   * 2. Increments version and marks as deleted
+   * 3. Signs new premint version
+   * 4. Sends to ZORA Premint API
+   *
+   * Deletes existing premint
+   * @param settings.collection collection address
+   * @param settings.uid UID
+   * @param settings.walletClient viem wallet client to use to sign
+   *
+   */
+  async deletePremint({
+    walletClient,
+    uid,
+    account,
+    collection
+  }) {
+    const {
+      premintConfig,
+      premintConfigVersion,
+      collection: collectionCreationConfig
+    } = await this.apiClient.getSignature({
+      collectionAddress: collection,
+      uid
+    });
+    const deletedPremint = markPremintDeleted(premintConfig);
+    return await this.signAndSubmitPremint({
+      walletClient,
+      account,
+      checkSignature: false,
+      verifyingContract: collection,
+      collection: collectionCreationConfig,
+      premintConfig: deletedPremint,
+      premintConfigVersion
+    });
+  }
+  /**
+   * Internal function to sign and submit a premint request.
+   *
+   * @param premintArguments Arguments to premint
+   * @returns
+   */
+  async signAndSubmitPremint(params) {
+    const { verifyingContract } = await signAndSubmitPremint({
+      ...params,
+      chainId: this.chain.id,
+      apiClient: this.apiClient,
+      publicClient: this.publicClient
+    });
+    const uid = params.premintConfig.uid;
+    return {
+      urls: this.makeUrls({ address: verifyingContract, uid }),
+      uid,
+      verifyingContract
+    };
+  }
+  /**
+   * Create premint
+   *
+   * @param settings Settings for the new premint
+   * @param settings.account Account to sign the premint with. Taken from walletClient if none passed in.
+   * @param settings.collection Collection information for the mint
+   * @param settings.tokenCreationConfig Mint argument settings, optional settings are overridden with sensible defaults.
+   * @param setings.premintConfigVersion Premint config version to use, defaults to V2
+   * @param settings.uid the UID to use – optional and retrieved as a fresh UID from ZORA by default.
+   * @param settings.checkSignature if the signature should have a pre-flight check. Not required but helpful for debugging.
+   * @returns premint url, uid, newContractAddress, and premint object
+   */
+  async createPremint({
+    creatorAccount,
+    collection,
+    tokenCreationConfig,
+    premintConfigVersion,
+    walletClient,
+    uid,
+    checkSignature = false
+  }) {
+    const newContractAddress = await getPremintCollectionAddress({
+      publicClient: this.publicClient,
+      collection
+    });
+    let uidToUse = uid;
+    if (typeof uidToUse !== "number") {
+      uidToUse = await this.apiClient.getNextUID(newContractAddress);
+    }
+    const actualVersion = premintConfigVersion || "1" /* V1 */;
+    if (!await supportsPremintVersion({
+      version: actualVersion,
+      publicClient: this.publicClient,
+      tokenContract: newContractAddress
+    })) {
+      throw new Error(
+        `Premint version ${actualVersion} not supported by contract`
+      );
+    }
+    const premintConfig = makeNewPremint({
+      tokenConfig: makeTokenConfigWithDefaults({
+        premintConfigVersion: actualVersion,
+        tokenCreationConfig,
+        creatorAccount: typeof creatorAccount === "string" ? creatorAccount : creatorAccount.address,
+        chainId: this.chain.id
+      }),
+      uid: uidToUse
+    });
+    return await this.signAndSubmitPremint({
+      verifyingContract: newContractAddress,
+      premintConfig,
+      premintConfigVersion: actualVersion,
+      checkSignature,
+      account: creatorAccount,
+      walletClient,
+      collection
+    });
+  }
+  /**
+   * Fetches given premint data from the ZORA API.
+   *
+   * @param address Address for the premint contract
+   * @param uid UID for the desired premint
+   * @returns PremintSignatureGetResponse of premint data from the API
+   */
+  async getPremintSignature({
+    address,
+    uid
+  }) {
+    return await this.apiClient.getSignature({
+      collectionAddress: address,
+      uid
+    });
+  }
+  /**
+   * Gets the deterministic contract address for a premint collection
+   * @param collection Collection to get the address for
+   * @returns deterministic contract address
+   */
+  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,
+    collection,
+    premintConfig,
+    premintConfigVersion
+  }) {
+    const { isAuthorized, recoveredAddress } = await isValidSignature({
+      chainId: this.chain.id,
+      signature,
+      collection,
+      publicClient: this.publicClient,
+      premintConfig,
+      premintConfigVersion: premintConfigVersion || "1" /* V1 */
+    });
+    return { isValid: isAuthorized, recoveredSigner: recoveredAddress };
+  }
+  makeUrls({
+    uid,
+    address,
+    tokenId
+  }) {
+    return makeUrls({
+      uid,
+      address,
+      tokenId,
+      chain: this.chain
+    });
+  }
+  async getMintCosts({
+    tokenContract,
+    quantityToMint,
+    pricePerToken
+  }) {
+    return await getPremintMintCosts({
+      publicClient: this.publicClient,
+      quantityToMint,
+      tokenContract,
+      tokenPrice: pricePerToken
+    });
+  }
+  /**
+   * Execute premint on-chain
+   *
+   * @param settings.data Data from the API for the mint
+   * @param settings.account Optional account (if omitted taken from wallet client) for the account executing the premint.
+   * @param settings.walletClient WalletClient to send execution from.
+   * @param settings.mintArguments User minting arguments.
+   * @param settings.mintArguments.quantityToMint Quantity to mint, optional, defaults to 1.
+   * @param settings.mintArguments.mintComment Optional mint comment, optional, omits when not included.
+   * @param settings.publicClient Optional public client for preflight checks.
+   * @returns receipt, log, zoraURL
+   */
+  async makeMintParameters({
+    uid,
+    tokenContract,
+    minterAccount,
+    mintArguments
+  }) {
+    if (mintArguments && mintArguments?.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 this.getPremintSignature({
+      address: tokenContract,
+      uid
+    });
+    const numberToMint = BigInt(mintArguments?.quantityToMint || 1);
+    const value = (await getPremintMintCosts({
+      tokenContract,
+      quantityToMint: numberToMint,
+      publicClient: this.publicClient,
+      tokenPrice: premintConfig.tokenConfig.pricePerToken
+    })).totalCost;
+    const mintArgumentsContract = {
+      mintComment: mintArguments?.mintComment || "",
+      mintRecipient: mintArguments?.mintRecipient || (typeof minterAccount === "string" ? minterAccount : minterAccount.address),
+      mintRewardsRecipients: makeMintRewardsRecipient({
+        mintReferral: mintArguments?.mintReferral,
+        platformReferral: mintArguments?.platformReferral
+      })
+    };
+    if (premintConfigVersion === "1" /* V1 */) {
+      return {
+        account: minterAccount,
+        abi: zoraCreator1155PremintExecutorImplABI2,
+        functionName: "premintV1",
+        value,
+        address: getPremintExecutorAddress(),
+        args: [
+          collection,
+          premintConfig,
+          signature,
+          numberToMint,
+          mintArgumentsContract
+        ]
+      };
+    } else if (premintConfigVersion === "2" /* V2 */) {
+      return {
+        account: minterAccount,
+        abi: zoraCreator1155PremintExecutorImplABI2,
+        functionName: "premintV2",
+        value,
+        address: getPremintExecutorAddress(),
+        args: [
+          collection,
+          premintConfig,
+          signature,
+          numberToMint,
+          mintArgumentsContract
+        ]
+      };
+    }
+    throw new Error(`Invalid premint config version ${premintConfigVersion}`);
+  }
+};
+function createPremintClient({
+  chain,
+  httpClient: httpClient2,
+  publicClient
+}) {
+  return new PremintClient(chain, publicClient, httpClient2);
+}
+function makeUrls({
+  uid,
+  address,
+  tokenId,
+  chain
+}) {
+  if ((!uid || !tokenId) && !address) {
+    return { explorer: null, zoraCollect: null, zoraManage: null };
+  }
+  const zoraTokenPath = uid ? `premint-${uid}` : tokenId;
+  const network = getApiNetworkConfigForChain(chain.id);
+  return {
+    explorer: tokenId ? `https://${chain.blockExplorers?.default.url}/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}`
+  };
+}
+async function signAndSubmitPremint({
+  walletClient,
+  verifyingContract,
+  account,
+  checkSignature,
+  collection,
+  chainId,
+  publicClient,
+  apiClient,
+  ...premintConfigAndVersion
+}) {
+  if (!account) {
+    account = walletClient.account;
+  }
+  if (!account) {
+    throw new Error("No account provided");
+  }
+  const signature = await walletClient.signTypedData({
+    account,
+    ...premintTypedDataDefinition({
+      verifyingContract,
+      ...premintConfigAndVersion,
+      chainId
+    })
+  });
+  if (checkSignature) {
+    const isAuthorized = await isAuthorizedToCreatePremint({
+      collection,
+      publicClient,
+      signer: typeof account === "string" ? account : account.address,
+      collectionAddress: await getPremintCollectionAddress({
+        collection,
+        publicClient
+      })
+    });
+    if (!isAuthorized) {
+      throw new Error("Not authorized to create premint");
+    }
+  }
+  const premint = await apiClient.postSignature({
+    collection,
+    signature,
+    ...premintConfigAndVersion
+  });
+  return { premint, verifyingContract };
+}
+
+// src/mint/mint-client.ts
+import {
+  createPublicClient as createPublicClient2,
+  encodeAbiParameters,
+  parseAbiParameters,
+  zeroAddress as zeroAddress3,
+  http as http2
+} from "viem";
+import {
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI2,
+  zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress2
+} from "@zoralabs/protocol-deployments";
+var MintError = class extends Error {
+};
+var MintInactiveError = class extends Error {
+};
+var Errors = {
+  MintError,
+  MintInactiveError
+};
+var MintClient = class {
+  constructor(chain, publicClient, httpClient2) {
+    this.apiClient = new MintAPIClient(chain.id, httpClient2);
+    this.publicClient = publicClient || createPublicClient2({ chain, transport: http2() });
+  }
+  /**
+   * Returns the parameters needed to prepare a transaction mint a token.
+   * @param param0.minterAccount The account that will mint the token.
+   * @param param0.mintable The mintable token to mint.
+   * @param param0.mintArguments The arguments for the mint (mint recipient, comment, mint referral, quantity to mint)
+   * @returns
+   */
+  async makePrepareMintTokenParams({
+    ...rest
+  }) {
+    return makePrepareMintTokenParams({
+      ...rest,
+      apiClient: this.apiClient,
+      publicClient: this.publicClient
+    });
+  }
+};
+function createMintClient({
+  chain,
+  publicClient,
+  httpClient: httpClient2
+}) {
+  return new MintClient(chain, publicClient, httpClient2);
+}
+async function makePrepareMintTokenParams({
+  publicClient,
+  apiClient,
+  tokenId,
+  tokenAddress,
+  ...rest
+}) {
+  const salesConfigAndTokenInfo = await apiClient.getSalesConfigAndTokenInfo({
+    tokenId,
+    tokenAddress
+  });
+  if (tokenId === void 0) {
+    return makePrepareMint721TokenParams({
+      salesConfigAndTokenInfo,
+      tokenAddress,
+      ...rest
+    });
+  }
+  return makePrepareMint1155TokenParams({
+    salesConfigAndTokenInfo,
+    tokenAddress,
+    tokenId,
+    ...rest
+  });
+}
+async function makePrepareMint721TokenParams({
+  tokenAddress,
+  salesConfigAndTokenInfo,
+  minterAccount,
+  mintArguments
+}) {
+  const mintValue = getMintCosts({
+    salesConfigAndTokenInfo,
+    quantityToMint: BigInt(mintArguments.quantityToMint)
+  }).totalCost;
+  const result = {
+    abi: zora721Abi,
+    address: tokenAddress,
+    account: minterAccount,
+    functionName: "mintWithRewards",
+    value: mintValue,
+    args: [
+      mintArguments.mintToAddress,
+      BigInt(mintArguments.quantityToMint),
+      mintArguments.mintComment || "",
+      mintArguments.mintReferral || zeroAddress3
+    ]
+  };
+  return result;
+}
+function getMintCosts({
+  salesConfigAndTokenInfo,
+  quantityToMint
+}) {
+  const mintFeeForTokens = salesConfigAndTokenInfo.mintFeePerQuantity * quantityToMint;
+  const tokenPurchaseCost = BigInt(salesConfigAndTokenInfo.fixedPrice.pricePerToken) * quantityToMint;
+  return {
+    mintFee: mintFeeForTokens,
+    tokenPurchaseCost,
+    totalCost: mintFeeForTokens + tokenPurchaseCost
+  };
+}
+async function makePrepareMint1155TokenParams({
+  tokenId,
+  salesConfigAndTokenInfo,
+  minterAccount,
+  tokenAddress,
+  mintArguments
+}) {
+  const mintQuantity = BigInt(mintArguments.quantityToMint);
+  const mintValue = getMintCosts({
+    salesConfigAndTokenInfo,
+    quantityToMint: mintQuantity
+  }).totalCost;
+  const result = {
+    abi: zoraCreator1155ImplABI2,
+    functionName: "mintWithRewards",
+    account: minterAccount,
+    value: mintValue,
+    address: tokenAddress,
+    /* args: minter, tokenId, quantity, minterArguments, mintReferral */
+    args: [
+      salesConfigAndTokenInfo?.fixedPrice.address || zoraCreatorFixedPriceSaleStrategyAddress2[999],
+      BigInt(tokenId),
+      mintQuantity,
+      encodeAbiParameters(parseAbiParameters("address, string"), [
+        mintArguments.mintToAddress,
+        mintArguments.mintComment || ""
+      ]),
+      mintArguments.mintReferral || zeroAddress3
+    ]
+  };
+  return result;
+}
+
+// src/create/1155-create-helper.ts
+import {
+  zoraCreator1155FactoryImplABI,
+  zoraCreator1155FactoryImplAddress,
+  zoraCreator1155ImplABI as zoraCreator1155ImplABI3,
+  zoraCreatorFixedPriceSaleStrategyABI
+} 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
+}) {
+  if (!maxSupply) {
+    maxSupply = OPEN_EDITION_MINT_SIZE;
+  }
+  maxSupply = BigInt(maxSupply);
+  mintToCreatorCount = BigInt(mintToCreatorCount);
+  const salesConfigWithDefaults = {
+    // Set static sales default.
+    ...DEFAULT_SALE_SETTINGS,
+    // Override with user settings.
+    ...salesConfig
+  };
+  const setupActions = [
+    encodeFunctionData({
+      abi: zoraCreator1155ImplABI3,
+      functionName: "assumeLastTokenIdMatches",
+      args: [nextTokenId - 1n]
+    }),
+    createReferral ? encodeFunctionData({
+      abi: zoraCreator1155ImplABI3,
+      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: [
+        nextTokenId,
+        fixedPriceMinterAddress,
+        encodeFunctionData({
+          abi: zoraCreatorFixedPriceSaleStrategyABI,
+          functionName: "setSale",
+          args: [nextTokenId, salesConfigWithDefaults]
+        })
+      ]
+    })
+  ];
+  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 setupActions;
+}
+var getTokenIdFromCreateReceipt = (receipt) => {
+  for (const data of receipt.logs) {
+    try {
+      const decodedLog = decodeEventLog2({
+        abi: zoraCreator1155ImplABI3,
+        eventName: "SetupNewToken",
+        ...data
+      });
+      if (decodedLog && decodedLog.eventName === "SetupNewToken") {
+        return decodedLog.args.tokenId;
+      }
+    } catch (err) {
+    }
+  }
+};
+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",
+      args: [
+        account,
+        contract.uri,
+        contract.name,
+        contract.defaultAdmin || account
+      ]
+    });
+    try {
+      await publicClient.readContract({
+        abi: zoraCreator1155ImplABI3,
+        address: contractAddress,
+        functionName: "contractVersion"
+      });
+      contractExists = true;
+    } catch (e) {
+    }
+    return { contractAddress, contractExists };
+  }
+  return {
+    contractExists: true,
+    contractAddress: contract
+  };
+}
+function create1155CreatorClient({
+  publicClient
+}) {
+  async function createNew1155Token({
+    contract,
+    tokenMetadataURI,
+    mintToCreatorCount = 1,
+    salesConfig = {},
+    maxSupply,
+    account,
+    royaltySettings,
+    getAdditionalSetupActions
+  }) {
+    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
+    });
+    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 = {
+        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 = {
+        abi: zoraCreator1155ImplABI3,
+        functionName: "multicall",
+        account,
+        address: contractAddress,
+        args: [tokenSetupActions]
+      };
+      return {
+        request,
+        tokenSetupActions,
+        contractAddress,
+        contractExists
+      };
+    }
+    throw new Error("Unsupported contract argument type");
+  }
+  return { createNew1155Token };
+}
+export {
+  DEFAULT_SALE_SETTINGS,
+  Errors,
+  MintAPIClient,
+  PremintAPIClient,
+  PremintConfigVersion,
+  PreminterDomain,
+  ZORA_API_BASE,
+  applyUpdateToPremint,
+  convertCollectionFromApi,
+  convertGetPremintApiResponse,
+  convertPremintFromApi,
+  create1155CreatorClient,
+  create1155TokenSetupArgs,
+  createMintClient,
+  createPremintClient,
+  defaultTokenConfigV1MintArguments,
+  defaultTokenConfigV2MintArguments,
+  encodePostSignatureInput,
+  encodePremintForAPI,
+  getApiNetworkConfigForChain,
+  getDefaultFixedPriceMinterAddress,
+  getMintCosts,
+  getPremintCollectionAddress,
+  getPremintExecutorAddress,
+  getPremintMintCosts,
+  getPremintMintFee,
+  getPremintedLogFromReceipt,
+  getTokenIdFromCreateReceipt,
+  isAuthorizedToCreatePremint,
+  isValidSignature,
+  makeMintRewardsRecipient,
+  makeNewPremint,
+  markPremintDeleted,
+  migratePremintConfigToV2,
+  premintTypedDataDefinition,
+  recoverCreatorFromCreatorAttribution,
+  recoverPremintSigner,
+  supportedPremintVersions,
+  supportsPremintVersion,
+  tryRecoverPremintSigner,
+  v1Types,
+  v2Types
+};
+//# sourceMappingURL=index.js.map