@zoralabs/protocol-sdk 0.2.0

package/dist/index.js

@@ -0,0 +1,984 @@
+// src/premint/premint-client.ts
+import { decodeEventLog } from "viem";
+import {
+  zoraCreator1155PremintExecutorImplABI,
+  zoraCreator1155PremintExecutorImplAddress,
+  zoraCreatorFixedPriceSaleStrategyAddress
+} from "@zoralabs/protocol-deployments";
+
+// src/premint/preminter.ts
+var preminterTypedDataDefinition = ({
+  verifyingContract,
+  premintConfig,
+  chainId
+}) => {
+  const { tokenConfig, uid, version, deleted } = premintConfig;
+  const types = {
+    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" }
+    ]
+  };
+  const result = {
+    domain: {
+      chainId,
+      name: "Preminter",
+      version: "1",
+      verifyingContract
+    },
+    types,
+    message: {
+      tokenConfig,
+      uid,
+      version,
+      deleted
+    },
+    primaryType: "CreatorAttribution"
+  };
+  return result;
+};
+
+// 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;
+  }
+};
+
+// src/constants.ts
+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`;
+}
+
+// src/premint/premint-api-client.ts
+var postSignature = async (data) => retries(
+  () => post(`${ZORA_API_BASE}premint/signature`, data)
+);
+var getNextUID = async (path) => retries(
+  () => get(
+    `${ZORA_API_BASE}premint/signature/${path.chain_name}/${path.collection_address}/next_uid`
+  )
+);
+var getSignature = async (path) => retries(
+  () => get(
+    `${ZORA_API_BASE}premint/signature/${path.chain_name}/${path.collection_address}/${path.uid}`
+  )
+);
+var PremintAPIClient = {
+  postSignature,
+  getSignature,
+  getNextUID
+};
+
+// src/apis/client-base.ts
+import { createPublicClient, http } from "viem";
+
+// src/apis/chain-constants.ts
+import {
+  base,
+  baseGoerli,
+  foundry,
+  goerli,
+  mainnet,
+  optimism,
+  optimismGoerli,
+  zora,
+  zoraTestnet
+} from "viem/chains";
+import { parseEther } from "viem";
+var REWARD_PER_TOKEN = parseEther("0.000777");
+var BackendChainNamesLookup = {
+  ZORA_MAINNET: "ZORA-MAINNET",
+  ZORA_GOERLI: "ZORA-GOERLI",
+  OPTIMISM_MAINNET: "OPTIMISM-MAINNET",
+  OPTIMISM_GOERLI: "OPTIMISM-GOERLI",
+  ETHEREUM_MAINNET: "ETHEREUM-MAINNET",
+  ETHEREUM_GOERLI: "ETHEREUM-GOERLI",
+  BASE_MAINNET: "BASE-MAINNET",
+  BASE_GOERLI: "BASE-GOERLI"
+};
+var networkConfigByChain = {
+  [mainnet.id]: {
+    chainId: mainnet.id,
+    isTestnet: false,
+    zoraPathChainName: "eth",
+    zoraBackendChainName: BackendChainNamesLookup.ETHEREUM_MAINNET,
+    subgraphUrl: getSubgraph("zora-create-mainnet", "stable")
+  },
+  [goerli.id]: {
+    chainId: goerli.id,
+    isTestnet: true,
+    zoraPathChainName: "gor",
+    zoraBackendChainName: BackendChainNamesLookup.ETHEREUM_GOERLI,
+    subgraphUrl: getSubgraph("zora-create-goerli", "stable")
+  },
+  [zora.id]: {
+    chainId: zora.id,
+    isTestnet: false,
+    zoraPathChainName: "zora",
+    zoraBackendChainName: BackendChainNamesLookup.ZORA_MAINNET,
+    subgraphUrl: getSubgraph("zora-create-zora-mainnet", "stable")
+  },
+  [zoraTestnet.id]: {
+    chainId: zora.id,
+    isTestnet: true,
+    zoraPathChainName: "zgor",
+    zoraBackendChainName: BackendChainNamesLookup.ZORA_GOERLI,
+    subgraphUrl: getSubgraph("zora-create-zora-testnet", "stable")
+  },
+  [optimism.id]: {
+    chainId: optimism.id,
+    isTestnet: false,
+    zoraPathChainName: "opt",
+    zoraBackendChainName: BackendChainNamesLookup.OPTIMISM_MAINNET,
+    subgraphUrl: getSubgraph("zora-create-optimism", "stable")
+  },
+  [optimismGoerli.id]: {
+    chainId: optimismGoerli.id,
+    isTestnet: true,
+    zoraPathChainName: "ogor",
+    zoraBackendChainName: BackendChainNamesLookup.OPTIMISM_GOERLI,
+    subgraphUrl: getSubgraph("zora-create-optimism-goerli", "stable")
+  },
+  [base.id]: {
+    chainId: base.id,
+    isTestnet: false,
+    zoraPathChainName: "base",
+    zoraBackendChainName: BackendChainNamesLookup.BASE_MAINNET,
+    subgraphUrl: getSubgraph("zora-create-base-mainnet", "stable")
+  },
+  [baseGoerli.id]: {
+    chainId: baseGoerli.id,
+    isTestnet: true,
+    zoraPathChainName: "bgor",
+    zoraBackendChainName: BackendChainNamesLookup.BASE_GOERLI,
+    subgraphUrl: getSubgraph("zora-create-base-goerli", "stable")
+  },
+  [foundry.id]: {
+    chainId: foundry.id,
+    isTestnet: true,
+    zoraPathChainName: "zgor",
+    zoraBackendChainName: BackendChainNamesLookup.ZORA_GOERLI,
+    subgraphUrl: getSubgraph("zora-create-zora-testnet", "stable")
+  }
+};
+
+// src/apis/client-base.ts
+var ClientBase = class {
+  constructor(chain) {
+    this.chain = chain;
+    const networkConfig = networkConfigByChain[chain.id];
+    if (!networkConfig) {
+      throw new Error(`Not configured for chain ${chain.id}`);
+    }
+    this.network = networkConfig;
+  }
+  /**
+   * Getter for public client that instantiates a publicClient as needed
+   *
+   * @param publicClient Optional viem public client
+   * @returns Existing public client or makes a new one for the given chain as needed.
+   */
+  getPublicClient(publicClient) {
+    if (publicClient) {
+      return publicClient;
+    }
+    return createPublicClient({ chain: this.chain, transport: http() });
+  }
+};
+
+// src/premint/premint-client.ts
+var DefaultMintArguments = {
+  maxSupply: OPEN_EDITION_MINT_SIZE,
+  maxTokensPerAddress: 0n,
+  pricePerToken: 0n,
+  mintDuration: BigInt(60 * 60 * 24 * 7),
+  // 1 week
+  mintStart: 0n,
+  royaltyMintSchedule: 0,
+  royaltyBPS: 1e3
+  // 10%,
+};
+function getPremintedLogFromReceipt(receipt) {
+  for (const data of receipt.logs) {
+    try {
+      const decodedLog = decodeEventLog({
+        abi: zoraCreator1155PremintExecutorImplABI,
+        eventName: "Preminted",
+        ...data
+      });
+      if (decodedLog.eventName === "Preminted") {
+        return decodedLog.args;
+      }
+    } catch (err) {
+    }
+  }
+}
+var convertPremint = (premint) => ({
+  ...premint,
+  tokenConfig: {
+    ...premint.tokenConfig,
+    fixedPriceMinter: premint.tokenConfig.fixedPriceMinter,
+    royaltyRecipient: premint.tokenConfig.royaltyRecipient,
+    maxSupply: BigInt(premint.tokenConfig.maxSupply),
+    pricePerToken: BigInt(premint.tokenConfig.pricePerToken),
+    mintStart: BigInt(premint.tokenConfig.mintStart),
+    mintDuration: BigInt(premint.tokenConfig.mintDuration),
+    maxTokensPerAddress: BigInt(premint.tokenConfig.maxTokensPerAddress)
+  }
+});
+var convertCollection = (collection) => ({
+  ...collection,
+  contractAdmin: collection.contractAdmin
+});
+var encodePremintForAPI = ({
+  tokenConfig,
+  ...premint
+}) => ({
+  ...premint,
+  tokenConfig: {
+    ...tokenConfig,
+    maxSupply: tokenConfig.maxSupply.toString(),
+    pricePerToken: tokenConfig.pricePerToken.toString(),
+    mintStart: tokenConfig.mintStart.toString(),
+    mintDuration: tokenConfig.mintDuration.toString(),
+    maxTokensPerAddress: tokenConfig.maxTokensPerAddress.toString()
+  }
+});
+var PremintClient = class extends ClientBase {
+  constructor(chain, apiClient) {
+    super(chain);
+    if (!apiClient) {
+      apiClient = PremintAPIClient;
+    }
+    this.apiClient = apiClient;
+  }
+  /**
+   * The premint executor address is deployed to the same address across all chains.
+   * Can be overridden as needed by making a parent class.
+   *
+   * @returns Executor address for premints
+   */
+  getExecutorAddress() {
+    return zoraCreator1155PremintExecutorImplAddress[999];
+  }
+  /**
+   * The fixed price minter address is the same across all chains for our current
+   * deployer strategy.
+   * Can be overridden as needed by making a parent class.
+   *
+   * @returns Fixed price sale strategy
+   */
+  getFixedPriceMinterAddress() {
+    return zoraCreatorFixedPriceSaleStrategyAddress[999];
+  }
+  /**
+   * 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,
+    token,
+    account
+  }) {
+    const signatureResponse = await this.apiClient.getSignature({
+      chain_name: this.network.zoraBackendChainName,
+      collection_address: collection.toLowerCase(),
+      uid
+    });
+    const convertedPremint = convertPremint(signatureResponse.premint);
+    const signerData = {
+      ...signatureResponse,
+      premint: {
+        ...convertedPremint,
+        tokenConfig: {
+          ...convertedPremint.tokenConfig,
+          ...token
+        }
+      }
+    };
+    return await this.signAndSubmitPremint({
+      walletClient,
+      account,
+      checkSignature: false,
+      verifyingContract: collection,
+      publicClient: this.getPublicClient(),
+      uid,
+      collection: {
+        ...signerData.collection,
+        contractAdmin: signerData.collection.contractAdmin
+      },
+      premintConfig: signerData.premint
+    });
+  }
+  /**
+   * 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,
+    publicClient
+  }) {
+    const signatureResponse = await this.apiClient.getSignature({
+      chain_name: this.network.zoraBackendChainName,
+      collection_address: collection.toLowerCase(),
+      uid
+    });
+    const signerData = {
+      ...signatureResponse,
+      collection: convertCollection(signatureResponse.collection),
+      premint: {
+        ...convertPremint(signatureResponse.premint),
+        deleted: true
+      }
+    };
+    return await this.signAndSubmitPremint({
+      walletClient,
+      account,
+      checkSignature: false,
+      verifyingContract: collection,
+      publicClient: this.getPublicClient(publicClient),
+      uid,
+      collection: signerData.collection,
+      premintConfig: signerData.premint
+    });
+  }
+  /**
+   * Internal function to sign and submit a premint request.
+   *
+   * @param premintArguments Arguments to premint
+   * @returns
+   */
+  async signAndSubmitPremint({
+    walletClient,
+    publicClient,
+    verifyingContract,
+    premintConfig,
+    uid,
+    account,
+    checkSignature,
+    collection
+  }) {
+    if (!account) {
+      account = walletClient.account;
+    }
+    if (!account) {
+      throw new Error("No account provided");
+    }
+    const signature = await walletClient.signTypedData({
+      account,
+      ...preminterTypedDataDefinition({
+        verifyingContract,
+        premintConfig,
+        chainId: this.chain.id
+      })
+    });
+    if (checkSignature) {
+      const [isValidSignature] = await publicClient.readContract({
+        abi: zoraCreator1155PremintExecutorImplABI,
+        address: this.getExecutorAddress(),
+        functionName: "isValidSignature",
+        args: [convertCollection(collection), premintConfig, signature]
+      });
+      if (!isValidSignature) {
+        throw new Error("Invalid signature");
+      }
+    }
+    const apiData = {
+      collection,
+      premint: encodePremintForAPI(premintConfig),
+      chain_name: this.network.zoraBackendChainName,
+      signature
+    };
+    const premint = await this.apiClient.postSignature(apiData);
+    return {
+      urls: this.makeUrls({ address: verifyingContract, uid }),
+      uid,
+      verifyingContract,
+      premint
+    };
+  }
+  /**
+   * 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.token Mint argument settings, optional settings are overridden with sensible defaults.
+   * @param settings.publicClient Public client (optional) – instantiated if not passed in with defaults.
+   * @param settings.walletClient Required wallet client for signing the premint message.
+   * @param settings.executionSettings Execution settings for premint options
+   * @param settings.executionSettings.deleted If this UID should be deleted. If omitted, set to false.
+   * @param settings.executionSettings.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({
+    account,
+    collection,
+    token,
+    publicClient,
+    walletClient,
+    executionSettings,
+    checkSignature = false
+  }) {
+    publicClient = this.getPublicClient(publicClient);
+    const newContractAddress = await publicClient.readContract({
+      address: this.getExecutorAddress(),
+      abi: zoraCreator1155PremintExecutorImplABI,
+      functionName: "getContractAddress",
+      args: [convertCollection(collection)]
+    });
+    const tokenConfig = {
+      ...DefaultMintArguments,
+      fixedPriceMinter: this.getFixedPriceMinterAddress(),
+      royaltyRecipient: account,
+      ...token
+    };
+    let uid = executionSettings?.uid;
+    if (!uid) {
+      const uidResponse = await this.apiClient.getNextUID({
+        chain_name: this.network.zoraBackendChainName,
+        collection_address: newContractAddress.toLowerCase()
+      });
+      uid = uidResponse.next_uid;
+    }
+    if (!uid) {
+      throw new Error("UID is missing but required");
+    }
+    let deleted = executionSettings?.deleted || false;
+    const premintConfig = {
+      tokenConfig,
+      uid,
+      version: 1,
+      deleted
+    };
+    return await this.signAndSubmitPremint({
+      uid,
+      verifyingContract: newContractAddress,
+      premintConfig,
+      checkSignature,
+      account,
+      publicClient,
+      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 getPremintData({
+    address,
+    uid
+  }) {
+    return await this.apiClient.getSignature({
+      chain_name: this.network.zoraBackendChainName,
+      collection_address: address,
+      uid
+    });
+  }
+  /**
+   * Check user signature for v1
+   *
+   * @param data Signature data from the API
+   * @returns isValid = signature is valid or not, contractAddress = assumed contract address, recoveredSigner = signer from contract
+   */
+  async isValidSignature({
+    data,
+    publicClient
+  }) {
+    publicClient = this.getPublicClient(publicClient);
+    const [isValid, contractAddress, recoveredSigner] = await publicClient.readContract({
+      abi: zoraCreator1155PremintExecutorImplABI,
+      address: this.getExecutorAddress(),
+      functionName: "isValidSignature",
+      args: [
+        convertCollection(data.collection),
+        convertPremint(data.premint),
+        data.signature
+      ]
+    });
+    return { isValid, contractAddress, recoveredSigner };
+  }
+  makeUrls({
+    uid,
+    address,
+    tokenId
+  }) {
+    if ((!uid || !tokenId) && !address) {
+      return { explorer: null, zoraCollect: null, zoraManage: null };
+    }
+    const zoraTokenPath = uid ? `premint-${uid}` : tokenId;
+    return {
+      explorer: tokenId ? `https://${this.chain.blockExplorers?.default.url}/token/${address}/instance/${tokenId}` : null,
+      zoraCollect: `https://${this.network.isTestnet ? "testnet." : ""}zora.co/collect/${this.network.zoraPathChainName}:${address}/${zoraTokenPath}`,
+      zoraManage: `https://${this.network.isTestnet ? "testnet." : ""}zora.co/collect/${this.network.zoraPathChainName}:${address}/${zoraTokenPath}`
+    };
+  }
+  /**
+   * 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 executePremintWithWallet({
+    data,
+    account,
+    walletClient,
+    mintArguments,
+    publicClient
+  }) {
+    publicClient = this.getPublicClient(publicClient);
+    if (mintArguments && mintArguments?.quantityToMint < 1) {
+      throw new Error("Quantity to mint cannot be below 1");
+    }
+    const targetAddress = this.getExecutorAddress();
+    const numberToMint = BigInt(mintArguments?.quantityToMint || 1);
+    const args = [
+      convertCollection(data.collection),
+      convertPremint(data.premint),
+      data.signature,
+      numberToMint,
+      mintArguments?.mintComment || ""
+    ];
+    if (!account) {
+      account = walletClient.account;
+    }
+    if (!account) {
+      throw new Error("Wallet not passed in");
+    }
+    const value = numberToMint * REWARD_PER_TOKEN;
+    const { request } = await publicClient.simulateContract({
+      account,
+      abi: zoraCreator1155PremintExecutorImplABI,
+      functionName: "premint",
+      value,
+      address: targetAddress,
+      args
+    });
+    const hash = await walletClient.writeContract(request);
+    const receipt = await publicClient.waitForTransactionReceipt({ hash });
+    const premintedLog = getPremintedLogFromReceipt(receipt);
+    return {
+      receipt,
+      premintedLog,
+      urls: this.makeUrls({
+        address: premintedLog?.contractAddress,
+        tokenId: premintedLog?.tokenId
+      })
+    };
+  }
+};
+
+// src/mint/mint-api-client.ts
+function encodeQueryParameters(params) {
+  return new URLSearchParams(params).toString();
+}
+var getMintable = async (path, query) => retries(() => {
+  return get(
+    `${ZORA_API_BASE}discover/mintables/${path.chain_name}/${path.collection_address}${query?.token_id ? `?${encodeQueryParameters(query)}` : ""}`
+  );
+});
+var getSalesConfigFixedPrice = async ({
+  contractAddress,
+  tokenId,
+  subgraphUrl
+}) => retries(async () => {
+  const response = await post(subgraphUrl, {
+    query: "query($id: ID!) {\n  zoraCreateToken(id: $id) {\n    id\n    salesStrategies{\n      fixedPrice {\n        address\n      }\n    }\n  }\n}",
+    variables: { id: `${contractAddress.toLowerCase()}-${tokenId}` }
+  });
+  return response.zoraCreateToken?.salesStrategies?.find(() => true)?.fixedPriceMinterAddress;
+});
+var MintAPIClient = {
+  getMintable,
+  getSalesConfigFixedPrice
+};
+
+// src/create/1155-create-helper.ts
+import {
+  zoraCreator1155FactoryImplABI,
+  zoraCreator1155FactoryImplAddress,
+  zoraCreator1155ImplABI,
+  zoraCreatorFixedPriceSaleStrategyABI
+} from "@zoralabs/protocol-deployments";
+import { decodeEventLog as decodeEventLog2, encodeFunctionData, zeroAddress } from "viem";
+var SALE_END_FOREVER = 18446744073709551615n;
+var ROYALTY_BPS_DEFAULT = 1e3;
+var DEFAULT_SALE_SETTINGS = {
+  fundsRecipient: zeroAddress,
+  // Free Mint
+  pricePerToken: 0n,
+  // Sale start time – defaults to beginning of unix time
+  saleStart: 0n,
+  // This is the end of uint64, plenty of time
+  saleEnd: SALE_END_FOREVER,
+  // 0 Here means no limit
+  maxTokensPerAddress: 0n
+};
+var PERMISSION_BIT_MINTER = 2n ** 2n;
+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: zoraCreator1155ImplABI,
+      functionName: "addPermission",
+      args: [0n, fixedPriceMinterAddress, PERMISSION_BIT_MINTER]
+    }),
+    encodeFunctionData({
+      abi: zoraCreator1155ImplABI,
+      functionName: "assumeLastTokenIdMatches",
+      args: [nextTokenId - 1n]
+    }),
+    createReferral ? encodeFunctionData({
+      abi: zoraCreator1155ImplABI,
+      functionName: "setupNewTokenWithCreateReferral",
+      args: [tokenMetadataURI, maxSupply, createReferral]
+    }) : encodeFunctionData({
+      abi: zoraCreator1155ImplABI,
+      functionName: "setupNewToken",
+      args: [tokenMetadataURI, maxSupply]
+    }),
+    encodeFunctionData({
+      abi: zoraCreator1155ImplABI,
+      functionName: "callSale",
+      args: [
+        nextTokenId,
+        fixedPriceMinterAddress,
+        encodeFunctionData({
+          abi: zoraCreatorFixedPriceSaleStrategyABI,
+          functionName: "setSale",
+          args: [nextTokenId, salesConfigWithDefaults]
+        })
+      ]
+    })
+  ];
+  if (mintToCreatorCount) {
+    setupActions.push(
+      encodeFunctionData({
+        abi: zoraCreator1155ImplABI,
+        functionName: "adminMint",
+        args: [account, nextTokenId, mintToCreatorCount, "0x"]
+      })
+    );
+  }
+  if (royaltySettings) {
+    setupActions.push(
+      encodeFunctionData({
+        abi: zoraCreator1155ImplABI,
+        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: zoraCreator1155ImplABI,
+        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: zoraCreator1155ImplABI,
+        address: contractAddress,
+        functionName: "contractVersion"
+      });
+      contractExists = true;
+    } catch (e) {
+    }
+    return { contractAddress, contractExists };
+  }
+  return {
+    contractExists: true,
+    contractAddress: contract
+  };
+}
+async function createNew1155Token({
+  publicClient,
+  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: zoraCreator1155ImplABI,
+      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 } = await publicClient.simulateContract({
+      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 {
+      send: (walletClient) => walletClient.writeContract(request),
+      tokenSetupActions,
+      contractAddress,
+      contractExists
+    };
+  } else if (contractExists) {
+    const { request } = await publicClient.simulateContract({
+      abi: zoraCreator1155ImplABI,
+      functionName: "multicall",
+      account,
+      address: contractAddress,
+      args: [tokenSetupActions]
+    });
+    return {
+      send: (walletClient) => walletClient.writeContract(request),
+      tokenSetupActions,
+      contractAddress,
+      contractExists
+    };
+  }
+  throw new Error("Unsupported contract argument type");
+}
+export {
+  DEFAULT_SALE_SETTINGS,
+  DefaultMintArguments,
+  MintAPIClient,
+  PremintAPIClient,
+  PremintClient,
+  ZORA_API_BASE,
+  convertCollection,
+  convertPremint,
+  create1155TokenSetupArgs,
+  createNew1155Token,
+  encodePremintForAPI,
+  getPremintedLogFromReceipt,
+  getSalesConfigFixedPrice,
+  getTokenIdFromCreateReceipt,
+  preminterTypedDataDefinition
+};
+//# sourceMappingURL=index.js.map