@zoralabs/protocol-sdk 0.11.12 → 0.12.0

package/dist/index.js

@@ -2503,152 +2503,584 @@ import {
   premintTypedDataDefinition as premintTypedDataDefinition2
 } from "@zoralabs/protocol-deployments";
 
-// src/mint/subgraph-queries.ts
-var NFT_SALE_STRATEGY_FRAGMENT = `
-fragment SaleStrategy on SalesStrategyConfig {
-  type
-  fixedPrice {
-    address
-    pricePerToken
-    saleEnd
-    saleStart
-    maxTokensPerAddress
-  }
-  erc20Minter {
-    address
-    pricePerToken
-    currency
-    saleEnd
-    saleStart
-    maxTokensPerAddress
-  }
-  presale {
-    address
-    presaleStart
-    presaleEnd
-    merkleRoot
+// src/utils.ts
+var makeContractParameters = (args) => args;
+function mintRecipientOrAccount({
+  mintRecipient,
+  minterAccount
+}) {
+  return mintRecipient || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
+}
+var addressOrAccountAddress = (address) => typeof address === "string" ? address : address.address;
+
+// src/apis/network-config.ts
+var getApiNetworkConfigForChain = (chainId) => {
+  if (!networkConfigByChain[chainId]) {
+    throw new Error(`chain id ${chainId} network not configured `);
   }
-  zoraTimedMinter {
-    address
-    mintFee
-    saleStart
-    saleEnd
-    erc20Z {
-      id 
-      pool
+  return networkConfigByChain[chainId];
+};
+
+// src/premint/premint-client.ts
+var defaultTokenConfigV1MintArguments = () => ({
+  maxSupply: OPEN_EDITION_MINT_SIZE,
+  maxTokensPerAddress: 0n,
+  pricePerToken: 0n,
+  mintDuration: 0n,
+  mintStart: 0n,
+  royaltyMintSchedule: 0,
+  royaltyBPS: 1e3
+  // 10%,
+});
+var pickTokenConfigV1 = (tokenConfig) => ({
+  maxSupply: tokenConfig.maxSupply,
+  maxTokensPerAddress: tokenConfig.maxTokensPerAddress,
+  pricePerToken: tokenConfig.pricePerToken,
+  mintDuration: tokenConfig.mintDuration,
+  mintStart: tokenConfig.mintStart,
+  royaltyBPS: tokenConfig.royaltyBPS,
+  tokenURI: tokenConfig.tokenURI,
+  royaltyRecipient: tokenConfig.payoutRecipient
+});
+var pickTokenConfigV2 = (tokenConfig) => ({
+  maxSupply: tokenConfig.maxSupply,
+  maxTokensPerAddress: tokenConfig.maxTokensPerAddress,
+  pricePerToken: tokenConfig.pricePerToken,
+  mintDuration: tokenConfig.mintDuration,
+  mintStart: tokenConfig.mintStart,
+  royaltyBPS: tokenConfig.royaltyBPS,
+  tokenURI: tokenConfig.tokenURI,
+  payoutRecipient: tokenConfig.payoutRecipient,
+  createReferral: tokenConfig.createReferral || zeroAddress2
+});
+var tokenConfigV1WithDefault = (tokenConfig, fixedPriceMinter) => ({
+  ...pickTokenConfigV1(tokenConfig),
+  ...defaultTokenConfigV1MintArguments(),
+  fixedPriceMinter
+});
+var tokenConfigV2WithDefault = (tokenConfig, fixedPriceMinter) => ({
+  ...pickTokenConfigV2(tokenConfig),
+  ...defaultTokenConfigV2MintArguments(),
+  fixedPriceMinter
+});
+var defaultTokenConfigV2MintArguments = () => ({
+  maxSupply: OPEN_EDITION_MINT_SIZE,
+  maxTokensPerAddress: 0n,
+  pricePerToken: 0n,
+  mintDuration: 0n,
+  mintStart: 0n,
+  royaltyBPS: 1e3
+  // 10%,
+});
+var makeTokenConfigWithDefaults = ({
+  chainId,
+  tokenCreationConfig,
+  supportedPremintVersions: supportedPremintVersions2
+}) => {
+  const fixedPriceMinter = getDefaultFixedPriceMinterAddress(chainId);
+  if (!supportedPremintVersions2.includes(PremintConfigVersion2.V2)) {
+    if (tokenCreationConfig.createReferral) {
+      throw new Error("Contract does not support create referral");
     }
-    secondaryActivated
-    marketCountdown
-    minimumMarketEth
+    return {
+      premintConfigVersion: PremintConfigVersion2.V1,
+      tokenConfig: tokenConfigV1WithDefault(
+        tokenCreationConfig,
+        fixedPriceMinter
+      )
+    };
   }
-}`;
-var TOKEN_FRAGMENT = `
-fragment Token on ZoraCreateToken {
-    creator
-    tokenId
-    uri
-    totalMinted
-    maxSupply
-    tokenStandard
-    salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER", "PRESALE", "ZORA_TIMED"]}) {
-      ...SaleStrategy
+  return {
+    premintConfigVersion: PremintConfigVersion2.V2,
+    tokenConfig: tokenConfigV2WithDefault(
+      tokenCreationConfig,
+      fixedPriceMinter
+    )
+  };
+};
+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) {
     }
-    contract {
-      address
-      mintFeePerQuantity
-      contractVersion
-      contractURI
-      name
-      salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER", "PRESALE", "ZORA_TIMED"]}) {
-        ...SaleStrategy
+  }
+}
+var PremintClient = class {
+  constructor({
+    chainId,
+    publicClient,
+    premintApi
+  }) {
+    this.chainId = chainId;
+    this.apiClient = premintApi;
+    this.publicClient = publicClient;
+  }
+  getDataFromPremintReceipt(receipt, blockExplorerUrl) {
+    return getDataFromPremintReceipt(receipt, this.chainId, blockExplorerUrl);
+  }
+  /**
+   * Prepares data for updating a premint
+   *
+   * @param parameters - Parameters for updating the premint {@link UpdatePremintParams}
+   * @returns A PremintReturn. {@link PremintReturn}
+   */
+  async updatePremint(args) {
+    return await updatePremint({
+      ...args,
+      apiClient: this.apiClient,
+      publicClient: this.publicClient,
+      chainId: this.chainId
+    });
+  }
+  /**
+   * Prepares data for deleting a premint
+   *
+   * @param parameters - Parameters for deleting the premint {@link DeletePremintParams}
+   * @returns A PremintReturn. {@link PremintReturn}
+   */
+  async deletePremint(params) {
+    return deletePremint({
+      ...params,
+      apiClient: this.apiClient,
+      publicClient: this.publicClient,
+      chainId: this.chainId
+    });
+  }
+  /**
+   * Prepares data for creating a premint
+   *
+   * @param parameters - Parameters for creating the premint {@link CreatePremintParameters}
+   * @returns A PremintReturn. {@link PremintReturn}
+   */
+  async createPremint(parameters) {
+    return createPremint({
+      ...parameters,
+      publicClient: this.publicClient,
+      apiClient: this.apiClient,
+      chainId: this.chainId
+    });
+  }
+  /**
+   * 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 getPremint({ address, uid }) {
+    return await this.apiClient.get({
+      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({
+      contract: collection,
+      publicClient: this.publicClient
+    });
+  }
+  async getMintCosts({
+    tokenContract,
+    quantityToMint,
+    pricePerToken
+  }) {
+    return await getPremintMintCosts({
+      publicClient: this.publicClient,
+      quantityToMint,
+      tokenContract,
+      tokenPrice: pricePerToken
+    });
+  }
+  /**
+   * Prepares the parameters to collect a premint; it brings the contract and token onchain, then collects
+   * tokens on that contract for the mint recipient.
+   *
+   * @param parameters - Parameters for collecting the Premint {@link MakeMintParametersArguments}
+   * @returns receipt, log, zoraURL
+   */
+  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 getDataFromPremintReceipt(receipt, chainId, blockExplorerUrl) {
+  const premintedLog = getPremintedLogFromReceipt(receipt);
+  return {
+    tokenId: premintedLog?.tokenId,
+    collectionAddres: premintedLog?.contractAddress,
+    premintedLog,
+    urls: makeUrls({
+      address: premintedLog?.contractAddress,
+      tokenId: premintedLog?.tokenId,
+      chainId,
+      blockExplorerUrl
+    })
+  };
+}
+function makePremintReturn({
+  premintConfig,
+  premintConfigVersion,
+  publicClient,
+  apiClient,
+  chainId,
+  ...collectionAndAddress
+}) {
+  const { collection, collectionAddress } = collectionAndAddress;
+  const typedDataDefinition = premintTypedDataDefinition2({
+    verifyingContract: collectionAddress,
+    premintConfig,
+    premintConfigVersion,
+    chainId
+  });
+  const signAndSubmit = async ({
+    walletClient,
+    account,
+    checkSignature
+  }) => {
+    const { signature, signerAccount } = await signPremint({
+      account,
+      walletClient,
+      typedDataDefinition
+    });
+    await submit({
+      signature,
+      checkSignature,
+      account: signerAccount
+    });
+    return {
+      signature,
+      signerAccount
+    };
+  };
+  const submit = async ({
+    signature,
+    checkSignature,
+    account
+  }) => {
+    if (checkSignature) {
+      const isAuthorized = await isAuthorizedToCreatePremint({
+        collectionAddress,
+        additionalAdmins: collection?.additionalAdmins,
+        contractAdmin: collection?.contractAdmin,
+        publicClient,
+        signer: account
+      });
+      if (!isAuthorized) {
+        throw new Error("Not authorized to create premint");
       }
     }
-}`;
-var FRAGMENTS = `
-${NFT_SALE_STRATEGY_FRAGMENT}
-${TOKEN_FRAGMENT}
-`;
-function buildNftTokenSalesQuery({
-  tokenId,
-  tokenAddress
+    await apiClient.postSignature({
+      ...toContractCreationConfigOrAddress(collectionAndAddress),
+      signature,
+      premintConfig,
+      premintConfigVersion
+    });
+  };
+  const urls = makeUrls({
+    chainId,
+    address: collectionAddress,
+    uid: premintConfig.uid
+  });
+  return {
+    premintConfig,
+    premintConfigVersion,
+    typedDataDefinition,
+    collectionAddress,
+    signAndSubmit,
+    submit,
+    urls
+  };
+}
+async function signPremint({
+  account,
+  walletClient,
+  typedDataDefinition
+}) {
+  if (!account) {
+    account = walletClient.account;
+  }
+  if (!account) {
+    throw new Error("No account provided");
+  }
+  const signature = await walletClient.signTypedData({
+    account,
+    ...typedDataDefinition
+  });
+  return {
+    signature,
+    signerAccount: account
+  };
+}
+async function createPremint({
+  token: tokenCreationConfig,
+  uid,
+  publicClient,
+  apiClient,
+  chainId,
+  ...collectionOrAddress
 }) {
-  return {
-    query: `
-${FRAGMENTS}
-query ($id: ID!) {
-  zoraCreateToken(id: $id) {
-    ...Token 
-  }
+  const {
+    premintConfig,
+    premintConfigVersion,
+    collectionAddress: collectionAddressToUse
+  } = await prepareCreatePremintConfig({
+    ...collectionOrAddress,
+    tokenCreationConfig,
+    uid,
+    publicClient,
+    apiClient,
+    chainId
+  });
+  return makePremintReturn({
+    premintConfig,
+    premintConfigVersion,
+    collectionAddress: collectionAddressToUse,
+    collection: collectionOrAddress.contract,
+    publicClient,
+    apiClient,
+    chainId
+  });
 }
-`,
-    variables: {
-      id: tokenId !== void 0 ? (
-        // Generic Token ID types all stringify down to the base numeric equivalent.
-        `${tokenAddress.toLowerCase()}-${tokenId}`
-      ) : `${tokenAddress.toLowerCase()}-0`
-    },
-    parseResponseData: (responseData) => responseData?.zoraCreateToken
+async function prepareCreatePremintConfig({
+  tokenCreationConfig,
+  uid,
+  publicClient,
+  apiClient,
+  chainId,
+  ...collectionOrAddress
+}) {
+  const newContractAddress = await getPremintCollectionAddress({
+    publicClient,
+    ...collectionOrAddress
+  });
+  let uidToUse = uid;
+  if (typeof uidToUse !== "number") {
+    uidToUse = await apiClient.getNextUID(newContractAddress);
+  }
+  const supportedVersions = await supportedPremintVersions({
+    tokenContract: newContractAddress,
+    publicClient
+  });
+  const tokenConfigAndVersion = makeTokenConfigWithDefaults({
+    tokenCreationConfig,
+    chainId,
+    supportedPremintVersions: supportedVersions
+  });
+  const premintConfig = makeNewPremint({
+    ...tokenConfigAndVersion,
+    uid: uidToUse
+  });
+  const premintConfigAndVersion = {
+    premintConfig,
+    premintConfigVersion: tokenConfigAndVersion.premintConfigVersion
+  };
+  return {
+    ...premintConfigAndVersion,
+    collectionAddress: newContractAddress
   };
 }
-function buildContractTokensQuery({
-  tokenAddress
+async function updatePremint({
+  uid,
+  collection,
+  tokenConfigUpdates,
+  apiClient,
+  publicClient,
+  chainId
 }) {
-  return {
-    query: `
-${FRAGMENTS}
-query ($contract: Bytes!) {
-  zoraCreateTokens(
-     where: {address: $contract}
-  ) {
-     ...Token
-  }
+  const {
+    premint: { premintConfig, premintConfigVersion },
+    collection: collectionCreationConfig
+  } = await apiClient.get({
+    collectionAddress: collection,
+    uid
+  });
+  const updatedPremint = applyUpdateToPremint({
+    uid: premintConfig.uid,
+    version: premintConfig.version,
+    tokenConfig: premintConfig.tokenConfig,
+    tokenConfigUpdates
+  });
+  return makePremintReturn({
+    premintConfig: updatedPremint,
+    premintConfigVersion,
+    collectionAddress: collection,
+    collection: collectionCreationConfig,
+    publicClient,
+    apiClient,
+    chainId
+  });
 }
-`,
-    variables: {
-      contract: tokenAddress.toLowerCase()
-    },
-    parseResponseData: (responseData) => responseData?.zoraCreateTokens
+async function deletePremint({
+  uid,
+  collection,
+  publicClient,
+  apiClient,
+  chainId
+}) {
+  const {
+    premint: { premintConfig, premintConfigVersion },
+    collection: collectionCreationConfig,
+    collectionAddress
+  } = await apiClient.get({
+    collectionAddress: collection,
+    uid
+  });
+  const deletedPremint = {
+    ...premintConfig,
+    version: premintConfig.version + 1,
+    deleted: true
   };
+  return makePremintReturn({
+    premintConfig: deletedPremint,
+    premintConfigVersion,
+    collectionAddress,
+    collection: collectionCreationConfig,
+    publicClient,
+    apiClient,
+    chainId
+  });
 }
-function buildPremintsOfContractQuery({
-  tokenAddress
+async function collectPremint({
+  uid,
+  tokenContract,
+  minterAccount,
+  quantityToMint,
+  mintComment = "",
+  mintReferral,
+  mintRecipient,
+  firstMinter,
+  premintGetter,
+  publicClient
 }) {
-  return {
-    query: `
-      query ($contractAddress: Bytes!) {
-        premints(where:{contractAddress:$contractAddress}) {
-          uid
-          tokenId
-        }
-      }
-    `,
-    variables: {
-      contractAddress: tokenAddress.toLowerCase()
+  if (typeof quantityToMint !== "undefined" && quantityToMint < 1) {
+    throw new Error("Quantity to mint cannot be below 1");
+  }
+  const premint = await premintGetter.get({
+    collectionAddress: tokenContract,
+    uid
+  });
+  const mintFee = await getPremintMintFee({
+    tokenContract,
+    publicClient
+  });
+  return buildPremintMintCall({
+    mintArguments: {
+      minterAccount,
+      quantityToMint,
+      firstMinter,
+      mintComment,
+      mintRecipient,
+      mintReferral
     },
-    parseResponseData: (responseData) => responseData?.premints
+    mintFee,
+    premint
+  });
+}
+var buildPremintMintCall = ({
+  mintArguments: {
+    minterAccount,
+    mintComment = "",
+    mintRecipient,
+    mintReferral,
+    firstMinter,
+    quantityToMint
+  },
+  premint: { collection, collectionAddress, premint, signature },
+  mintFee
+}) => {
+  const mintArgumentsContract = {
+    mintComment,
+    mintRecipient: mintRecipientOrAccount({
+      mintRecipient,
+      minterAccount
+    }),
+    mintRewardsRecipients: makeMintRewardsRecipient({
+      mintReferral
+    })
+  };
+  const collectionOrEmpty = collection ? defaultAdditionalAdmins(collection) : emptyContractCreationConfig();
+  const collectionAddressToSubmit = collection ? zeroAddress2 : collectionAddress;
+  const firstMinterToSubmit = firstMinter || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
+  if (premint.premintConfigVersion === PremintConfigVersion2.V3) {
+    throw new Error("PremintV3 not supported in premint SDK");
+  }
+  const value = (mintFee + premint.premintConfig.tokenConfig.pricePerToken) * BigInt(quantityToMint);
+  return makeContractParameters({
+    account: minterAccount,
+    abi: zoraCreator1155PremintExecutorImplABI2,
+    functionName: "premint",
+    value,
+    address: getPremintExecutorAddress(),
+    args: [
+      collectionOrEmpty,
+      collectionAddressToSubmit,
+      encodePremintConfig(premint),
+      signature,
+      BigInt(quantityToMint),
+      mintArgumentsContract,
+      firstMinterToSubmit,
+      zeroAddress2
+    ]
+  });
+};
+function makeUrls({
+  uid,
+  address,
+  tokenId,
+  chainId,
+  blockExplorerUrl
+}) {
+  if ((!uid || !tokenId) && !address) {
+    return { explorer: null, zoraCollect: null, zoraManage: null };
+  }
+  const zoraTokenPath = uid ? `premint-${uid}` : tokenId;
+  const network = getApiNetworkConfigForChain(chainId);
+  return {
+    explorer: tokenId ? `https://${blockExplorerUrl}/token/${address}/instance/${tokenId}` : null,
+    zoraCollect: `https://${network.isTestnet ? "testnet." : ""}zora.co/collect/${network.zoraCollectPathChainName}:${address}/${zoraTokenPath}`,
+    zoraManage: `https://${network.isTestnet ? "testnet." : ""}zora.co/collect/${network.zoraCollectPathChainName}:${address}/${zoraTokenPath}`
   };
 }
 
-// src/apis/subgraph-querier.ts
-var SubgraphQuerier = class {
-  constructor(httpClient2) {
-    this.httpClient = httpClient2;
-  }
-  async query({
-    subgraphUrl,
-    query,
-    variables
-  }) {
-    const { retries: retries2, post: post2 } = this.httpClient;
-    const result = await retries2(async () => {
-      return await post2(subgraphUrl, {
-        query,
-        variables
-      });
-    });
-    return result?.data;
-  }
-};
+// src/premint/contract-types.ts
+import {
+  PremintConfigVersion as PremintConfigVersionOrig
+} from "@zoralabs/protocol-deployments";
+var PremintConfigVersion3 = ((PremintConfigVersion4) => {
+  PremintConfigVersion4[PremintConfigVersion4["V1"] = PremintConfigVersionOrig.V1] = "V1";
+  PremintConfigVersion4[PremintConfigVersion4["V2"] = PremintConfigVersionOrig.V2] = "V2";
+  PremintConfigVersion4[PremintConfigVersion4["V3"] = PremintConfigVersionOrig.V3] = "V3";
+  return PremintConfigVersion4;
+})(PremintConfigVersion3 || {});
 
 // src/retries.ts
 async function wait(delayMs) {
@@ -2674,1027 +3106,609 @@ var retryInternal = async ({
           maxTries,
           atTry: atTry + 1,
           linearBackoffMS,
-          shouldRetryOnError
-        });
-      }
-    }
-    throw err;
-  }
-};
-var retriesGeneric = async (params) => {
-  return retryInternal({
-    ...params,
-    atTry: 1
-  });
-};
-
-// 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;
-  }
-};
-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 controller = new AbortController();
-  const { signal } = controller;
-  const timeout = 30 * 60 * 1e3;
-  const timeoutId = setTimeout(() => controller.abort(), timeout);
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      accept: "application/json"
-    },
-    body: JSON.stringify(data),
-    signal
-  });
-  clearTimeout(timeoutId);
-  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 defaultShouldRetry = (err) => {
-  return err instanceof BadResponseError && err.status >= 500;
-};
-var retries = async (tryFn, maxTries = 3, linearBackoffMS = 200, shouldRetry = defaultShouldRetry) => {
-  return retriesGeneric({
-    tryFn,
-    maxTries,
-    linearBackoffMS,
-    shouldRetryOnError: shouldRetry
-  });
-};
-var httpClient = {
-  get,
-  post,
-  retries
-};
-
-// src/apis/subgraph-getter.ts
-var SubgraphGetter = class {
-  constructor(chainId, subgraphQuerier) {
-    this.subgraphQuerier = subgraphQuerier || new SubgraphQuerier(httpClient);
-    this.networkConfig = getApiNetworkConfigForChain(chainId);
-  }
-  async querySubgraphWithRetries({
-    query,
-    variables,
-    parseResponseData
-  }) {
-    const responseData = await this.subgraphQuerier.query({
-      subgraphUrl: this.networkConfig.subgraphUrl,
-      query,
-      variables
-    });
-    return parseResponseData(responseData);
-  }
-};
-
-// src/mint/subgraph-mint-getter.ts
-var getApiNetworkConfigForChain = (chainId) => {
-  if (!networkConfigByChain[chainId]) {
-    throw new Error(`chain id ${chainId} network not configured `);
-  }
-  return networkConfigByChain[chainId];
-};
-function parseFixedPriceSalesConfig(fixedPrice, contractMintFee, blockTime) {
-  const saleEnd = BigInt(fixedPrice.saleEnd);
-  return {
-    salesStrategy: {
-      saleType: "fixedPrice",
-      ...fixedPrice,
-      maxTokensPerAddress: BigInt(fixedPrice.maxTokensPerAddress),
-      pricePerToken: BigInt(fixedPrice.pricePerToken),
-      mintFeePerQuantity: contractMintFee
-    },
-    saleEnd,
-    saleActive: BigInt(fixedPrice.saleStart) <= blockTime && BigInt(saleEnd) > blockTime
-  };
-}
-function parseERC20SalesConfig(erc20Minter, blockTime) {
-  const saleEnd = BigInt(erc20Minter.saleEnd);
-  return {
-    salesStrategy: {
-      saleType: "erc20",
-      ...erc20Minter,
-      maxTokensPerAddress: BigInt(erc20Minter.maxTokensPerAddress),
-      pricePerToken: BigInt(erc20Minter.pricePerToken),
-      mintFeePerQuantity: 0n
-    },
-    saleEnd,
-    saleActive: BigInt(erc20Minter.saleStart) <= blockTime && saleEnd > blockTime
-  };
-}
-function parsePresaleSalesConfig(presale, contractMintFee, blockTime) {
-  const saleEnd = BigInt(presale.presaleEnd);
-  return {
-    salesStrategy: {
-      saleType: "allowlist",
-      address: presale.address,
-      merkleRoot: presale.merkleRoot,
-      saleStart: presale.presaleStart,
-      saleEnd: presale.presaleEnd,
-      mintFeePerQuantity: contractMintFee
-    },
-    saleEnd,
-    saleActive: BigInt(presale.presaleStart) <= blockTime && saleEnd > blockTime
-  };
-}
-function parseZoraTimedSalesConfig(zoraTimedMinter, blockTime) {
-  const saleEnd = BigInt(zoraTimedMinter.saleEnd);
-  const hasSaleEnd = saleEnd > 0n;
-  return {
-    salesStrategy: {
-      saleType: "timed",
-      address: zoraTimedMinter.address,
-      mintFee: BigInt(zoraTimedMinter.mintFee),
-      saleStart: zoraTimedMinter.saleStart,
-      saleEnd: zoraTimedMinter.saleEnd,
-      erc20Z: zoraTimedMinter.erc20Z.id,
-      pool: zoraTimedMinter.erc20Z.pool,
-      secondaryActivated: zoraTimedMinter.secondaryActivated,
-      mintFeePerQuantity: BigInt(zoraTimedMinter.mintFee),
-      marketCountdown: zoraTimedMinter.marketCountdown ? BigInt(zoraTimedMinter.marketCountdown) : void 0,
-      minimumMarketEth: zoraTimedMinter.minimumMarketEth ? BigInt(zoraTimedMinter.minimumMarketEth) : void 0
-    },
-    saleEnd: hasSaleEnd ? saleEnd : void 0,
-    secondaryMarketActive: zoraTimedMinter.secondaryActivated,
-    saleActive: BigInt(zoraTimedMinter.saleStart) <= blockTime && (hasSaleEnd ? saleEnd > blockTime : true)
-  };
-}
-function parseSalesConfig(targetStrategy, contractMintFee, blockTime) {
-  switch (targetStrategy.type) {
-    case "FIXED_PRICE":
-      return parseFixedPriceSalesConfig(
-        targetStrategy.fixedPrice,
-        contractMintFee,
-        blockTime
-      );
-    case "ERC_20_MINTER":
-      return parseERC20SalesConfig(targetStrategy.erc20Minter, blockTime);
-    case "PRESALE":
-      return parsePresaleSalesConfig(
-        targetStrategy.presale,
-        contractMintFee,
-        blockTime
-      );
-    case "ZORA_TIMED":
-      return parseZoraTimedSalesConfig(
-        targetStrategy.zoraTimedMinter,
-        blockTime
-      );
-    default:
-      throw new Error("Unknown saleType");
-  }
-}
-function getTargetStrategy({
-  tokenId,
-  preferredSaleType,
-  token,
-  blockTime,
-  contractMintFee
-}) {
-  const allStrategies = (typeof tokenId !== "undefined" ? token.salesStrategies : token.contract.salesStrategies) || [];
-  const parsedStrategies = allStrategies.map(
-    (strategy) => parseSalesConfig(strategy, contractMintFee, blockTime)
-  );
-  const stillValidSalesStrategies = parsedStrategies.filter(
-    (strategy) => strategy.saleActive || strategy.secondaryMarketActive
-  );
-  const saleStrategies = stillValidSalesStrategies.sort(
-    (a, b) => (a.saleEnd ?? 0n) > (b.saleEnd ?? 0n) ? 1 : -1
-  );
-  let targetStrategy;
-  if (!preferredSaleType) {
-    return saleStrategies[0];
-  } else {
-    targetStrategy = saleStrategies.find(
-      ({ salesStrategy }) => salesStrategy.saleType === preferredSaleType
-    );
-    if (!targetStrategy) {
-      const targetStrategy2 = saleStrategies.find(
-        ({ salesStrategy }) => salesStrategy.saleType === "timed" || salesStrategy.saleType === "fixedPrice" || salesStrategy.saleType === "erc20"
-      );
-      if (!targetStrategy2)
-        throw new Error("Cannot find valid sale strategy");
-      return targetStrategy2;
-    }
-  }
-  return targetStrategy;
-}
-var SubgraphMintGetter = class extends SubgraphGetter {
-  constructor(chainId, subgraphQuerier) {
-    super(chainId, subgraphQuerier);
-    this.getMintable = async ({
-      tokenAddress,
-      tokenId,
-      preferredSaleType: saleType,
-      blockTime
-    }) => {
-      const token = await this.querySubgraphWithRetries(
-        buildNftTokenSalesQuery({
-          tokenId,
-          tokenAddress
-        })
-      );
-      if (!token) {
-        throw new Error("Cannot find token");
+          shouldRetryOnError
+        });
       }
-      const defaultMintFee = await this.getContractMintFee(token.contract);
-      return parseTokenQueryResult({
-        token,
-        defaultMintFee,
-        tokenId,
-        preferredSaleType: saleType,
-        blockTime
-      });
-    };
+    }
+    throw err;
   }
-  async getContractMintFee(contract) {
-    return BigInt(contract.mintFeePerQuantity);
+};
+var retriesGeneric = async (params) => {
+  return retryInternal({
+    ...params,
+    atTry: 1
+  });
+};
+
+// 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 getContractMintable({
-    tokenAddress,
-    preferredSaleType,
-    blockTime
-  }) {
-    const tokens = await this.querySubgraphWithRetries(
-      buildContractTokensQuery({
-        tokenAddress
-      })
-    );
-    if (!tokens || tokens.length === 0)
-      return [];
-    const defaultMintFee = await this.getContractMintFee(tokens[0].contract);
-    return tokens.filter((x) => x.tokenId !== "0").map(
-      (token) => parseTokenQueryResult({
-        token,
-        tokenId: token.tokenId,
-        preferredSaleType,
-        defaultMintFee,
-        blockTime
-      })
+};
+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
     );
   }
-  async getContractPremintTokenIds({
-    tokenAddress
-  }) {
-    const premints = await this.querySubgraphWithRetries(
-      buildPremintsOfContractQuery({
-        tokenAddress
-      })
+  return await response.json();
+};
+var post = async (url, data) => {
+  const controller = new AbortController();
+  const { signal } = controller;
+  const timeout = 30 * 60 * 1e3;
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json"
+    },
+    body: JSON.stringify(data),
+    signal
+  });
+  clearTimeout(timeoutId);
+  if (response.status !== 200) {
+    let json;
+    try {
+      json = await response.json();
+    } catch (e) {
+    }
+    throw new BadResponseError(
+      `Bad response: ${response.status}`,
+      response.status,
+      json
     );
-    return premints?.map((premint) => ({
-      tokenId: BigInt(premint.tokenId),
-      uid: +premint.uid
-    })) || [];
   }
+  return await response.json();
 };
-function getTargetStrategyAndMintFeeAndSaleActive({
-  token,
-  tokenId,
-  preferredSaleType,
-  defaultMintFee,
-  blockTime
-}) {
-  const targetStrategy = getTargetStrategy({
-    tokenId,
-    preferredSaleType,
-    token,
-    blockTime,
-    contractMintFee: defaultMintFee
-  });
-  return targetStrategy;
-}
-function parseTokenQueryResult({
-  token,
-  tokenId,
-  preferredSaleType,
-  defaultMintFee,
-  blockTime
-}) {
-  const salesStrategyAndMintInfo = getTargetStrategyAndMintFeeAndSaleActive({
-    token,
-    tokenId,
-    preferredSaleType,
-    defaultMintFee,
-    blockTime
-  });
-  const tokenInfo = parseTokenInfo({
-    token
+var defaultShouldRetry = (err) => {
+  return err instanceof BadResponseError && err.status >= 500;
+};
+var retries = async (tryFn, maxTries = 3, linearBackoffMS = 200, shouldRetry = defaultShouldRetry) => {
+  return retriesGeneric({
+    tryFn,
+    maxTries,
+    linearBackoffMS,
+    shouldRetryOnError: shouldRetry
   });
-  return {
-    salesConfigAndTokenInfo: {
-      ...tokenInfo,
-      salesConfig: salesStrategyAndMintInfo?.salesStrategy
-    },
-    primaryMintActive: salesStrategyAndMintInfo?.saleActive ?? false,
-    primaryMintEnd: salesStrategyAndMintInfo?.saleEnd,
-    secondaryMarketActive: salesStrategyAndMintInfo?.secondaryMarketActive ?? false
-  };
-}
-function parseTokenInfo({
-  token
-}) {
-  return {
-    contract: {
-      address: token.contract.address,
-      name: token.contract.name,
-      URI: token.contract.contractURI
-    },
-    tokenURI: token.uri,
-    tokenId: token.tokenId ? BigInt(token.tokenId) : void 0,
-    mintType: token.tokenStandard === "ERC721" ? "721" : "1155",
-    creator: token.creator,
-    totalMinted: BigInt(token.totalMinted),
-    maxSupply: BigInt(token.maxSupply),
-    contractVersion: token.contract.contractVersion
-  };
-}
-
-// src/utils.ts
-var makeContractParameters = (args) => args;
-function mintRecipientOrAccount({
-  mintRecipient,
-  minterAccount
-}) {
-  return mintRecipient || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
-}
-var addressOrAccountAddress = (address) => typeof address === "string" ? address : address.address;
+};
+var httpClient = {
+  get,
+  post,
+  retries
+};
 
-// src/premint/premint-client.ts
-var defaultTokenConfigV1MintArguments = () => ({
-  maxSupply: OPEN_EDITION_MINT_SIZE,
-  maxTokensPerAddress: 0n,
-  pricePerToken: 0n,
-  mintDuration: 0n,
-  mintStart: 0n,
-  royaltyMintSchedule: 0,
-  royaltyBPS: 1e3
-  // 10%,
-});
-var pickTokenConfigV1 = (tokenConfig) => ({
-  maxSupply: tokenConfig.maxSupply,
-  maxTokensPerAddress: tokenConfig.maxTokensPerAddress,
-  pricePerToken: tokenConfig.pricePerToken,
-  mintDuration: tokenConfig.mintDuration,
-  mintStart: tokenConfig.mintStart,
-  royaltyBPS: tokenConfig.royaltyBPS,
-  tokenURI: tokenConfig.tokenURI,
-  royaltyRecipient: tokenConfig.payoutRecipient
-});
-var pickTokenConfigV2 = (tokenConfig) => ({
-  maxSupply: tokenConfig.maxSupply,
-  maxTokensPerAddress: tokenConfig.maxTokensPerAddress,
-  pricePerToken: tokenConfig.pricePerToken,
-  mintDuration: tokenConfig.mintDuration,
-  mintStart: tokenConfig.mintStart,
-  royaltyBPS: tokenConfig.royaltyBPS,
-  tokenURI: tokenConfig.tokenURI,
-  payoutRecipient: tokenConfig.payoutRecipient,
-  createReferral: tokenConfig.createReferral || zeroAddress2
-});
-var tokenConfigV1WithDefault = (tokenConfig, fixedPriceMinter) => ({
-  ...pickTokenConfigV1(tokenConfig),
-  ...defaultTokenConfigV1MintArguments(),
-  fixedPriceMinter
-});
-var tokenConfigV2WithDefault = (tokenConfig, fixedPriceMinter) => ({
-  ...pickTokenConfigV2(tokenConfig),
-  ...defaultTokenConfigV2MintArguments(),
-  fixedPriceMinter
-});
-var defaultTokenConfigV2MintArguments = () => ({
-  maxSupply: OPEN_EDITION_MINT_SIZE,
-  maxTokensPerAddress: 0n,
-  pricePerToken: 0n,
-  mintDuration: 0n,
-  mintStart: 0n,
-  royaltyBPS: 1e3
-  // 10%,
-});
-var makeTokenConfigWithDefaults = ({
+// 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 getOfCollection = async ({
+  collectionAddress,
   chainId,
-  tokenCreationConfig,
-  supportedPremintVersions: supportedPremintVersions2
+  httpClient: { retries: retries2, get: get2 } = httpClient
 }) => {
-  const fixedPriceMinter = getDefaultFixedPriceMinterAddress(chainId);
-  if (!supportedPremintVersions2.includes(PremintConfigVersion2.V2)) {
-    if (tokenCreationConfig.createReferral) {
-      throw new Error("Contract does not support create referral");
-    }
-    return {
-      premintConfigVersion: PremintConfigVersion2.V1,
-      tokenConfig: tokenConfigV1WithDefault(
-        tokenCreationConfig,
-        fixedPriceMinter
-      )
-    };
-  }
-  return {
-    premintConfigVersion: PremintConfigVersion2.V2,
-    tokenConfig: tokenConfigV2WithDefault(
-      tokenCreationConfig,
-      fixedPriceMinter
+  const chainName = getApiNetworkConfigForChain(chainId).zoraBackendChainName;
+  const result = await retries2(
+    () => get2(
+      `${ZORA_API_BASE}premint/signature/${chainName}/${collectionAddress.toLowerCase()}`
     )
-  };
+  );
+  return convertGetPremintOfCollectionApiResponse(result);
 };
-function getPremintedLogFromReceipt(receipt) {
-  for (const data of receipt.logs) {
-    try {
-      const decodedLog = decodeEventLog({
-        abi: zoraCreator1155PremintExecutorImplABI2,
-        eventName: "PremintedV2",
-        ...data
+var PremintAPIClient = class {
+  constructor(chainId, httpClient2) {
+    this.postSignature = ({
+      signature,
+      ...rest
+    }) => {
+      const data = encodePostSignatureInput({
+        ...rest,
+        chainId: this.chainId,
+        signature
       });
-      if (decodedLog.eventName === "PremintedV2") {
-        return decodedLog.args;
-      }
-    } catch (err) {
-    }
-  }
-}
-var PremintClient = class {
-  constructor({
-    chainId,
-    publicClient,
-    premintApi
-  }) {
+      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.get = async ({ collectionAddress, uid }) => {
+      return getSignature({
+        collectionAddress,
+        uid,
+        chainId: this.chainId,
+        httpClient: this.httpClient
+      });
+    };
+    this.getOfCollection = async ({
+      collectionAddress
+    }) => {
+      return getOfCollection({
+        collectionAddress,
+        chainId: this.chainId,
+        httpClient: this.httpClient
+      });
+    };
     this.chainId = chainId;
-    this.apiClient = premintApi;
-    this.publicClient = publicClient;
-  }
-  getDataFromPremintReceipt(receipt, blockExplorerUrl) {
-    return getDataFromPremintReceipt(receipt, this.chainId, blockExplorerUrl);
-  }
-  /**
-   * Prepares data for updating a premint
-   *
-   * @param parameters - Parameters for updating the premint {@link UpdatePremintParams}
-   * @returns A PremintReturn. {@link PremintReturn}
-   */
-  async updatePremint(args) {
-    return await updatePremint({
-      ...args,
-      apiClient: this.apiClient,
-      publicClient: this.publicClient,
-      chainId: this.chainId
-    });
-  }
-  /**
-   * Prepares data for deleting a premint
-   *
-   * @param parameters - Parameters for deleting the premint {@link DeletePremintParams}
-   * @returns A PremintReturn. {@link PremintReturn}
-   */
-  async deletePremint(params) {
-    return deletePremint({
-      ...params,
-      apiClient: this.apiClient,
-      publicClient: this.publicClient,
-      chainId: this.chainId
-    });
-  }
-  /**
-   * Prepares data for creating a premint
-   *
-   * @param parameters - Parameters for creating the premint {@link CreatePremintParameters}
-   * @returns A PremintReturn. {@link PremintReturn}
-   */
-  async createPremint(parameters) {
-    return createPremint({
-      ...parameters,
-      publicClient: this.publicClient,
-      apiClient: this.apiClient,
-      chainId: this.chainId
-    });
-  }
-  /**
-   * 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 getPremint({ address, uid }) {
-    return await this.apiClient.get({
-      collectionAddress: address,
-      uid
-    });
+    this.httpClient = httpClient2 || httpClient;
   }
-  /**
-   * 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({
-      contract: collection,
-      publicClient: this.publicClient
-    });
+};
+
+// src/mint/subgraph-queries.ts
+var NFT_SALE_STRATEGY_FRAGMENT = `
+fragment SaleStrategy on SalesStrategyConfig {
+  type
+  fixedPrice {
+    address
+    pricePerToken
+    saleEnd
+    saleStart
+    maxTokensPerAddress
   }
-  async getMintCosts({
-    tokenContract,
-    quantityToMint,
+  erc20Minter {
+    address
     pricePerToken
-  }) {
-    return await getPremintMintCosts({
-      publicClient: this.publicClient,
-      quantityToMint,
-      tokenContract,
-      tokenPrice: pricePerToken
-    });
+    currency
+    saleEnd
+    saleStart
+    maxTokensPerAddress
   }
-  /**
-   * Prepares the parameters to collect a premint; it brings the contract and token onchain, then collects
-   * tokens on that contract for the mint recipient.
-   *
-   * @param parameters - Parameters for collecting the Premint {@link MakeMintParametersArguments}
-   * @returns receipt, log, zoraURL
-   */
-  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
-    });
+  presale {
+    address
+    presaleStart
+    presaleEnd
+    merkleRoot
   }
-};
-function getDataFromPremintReceipt(receipt, chainId, blockExplorerUrl) {
-  const premintedLog = getPremintedLogFromReceipt(receipt);
+  zoraTimedMinter {
+    address
+    mintFee
+    saleStart
+    saleEnd
+    erc20Z {
+      id 
+      pool
+    }
+    secondaryActivated
+    marketCountdown
+    minimumMarketEth
+  }
+}`;
+var TOKEN_FRAGMENT = `
+fragment Token on ZoraCreateToken {
+    creator
+    tokenId
+    uri
+    totalMinted
+    maxSupply
+    tokenStandard
+    salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER", "PRESALE", "ZORA_TIMED"]}) {
+      ...SaleStrategy
+    }
+    contract {
+      address
+      mintFeePerQuantity
+      contractVersion
+      contractURI
+      name
+      salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER", "PRESALE", "ZORA_TIMED"]}) {
+        ...SaleStrategy
+      }
+    }
+}`;
+var FRAGMENTS = `
+${NFT_SALE_STRATEGY_FRAGMENT}
+${TOKEN_FRAGMENT}
+`;
+function buildNftTokenSalesQuery({
+  tokenId,
+  tokenAddress
+}) {
   return {
-    tokenId: premintedLog?.tokenId,
-    collectionAddres: premintedLog?.contractAddress,
-    premintedLog,
-    urls: makeUrls({
-      address: premintedLog?.contractAddress,
-      tokenId: premintedLog?.tokenId,
-      chainId,
-      blockExplorerUrl
-    })
+    query: `
+${FRAGMENTS}
+query ($id: ID!) {
+  zoraCreateToken(id: $id) {
+    ...Token 
+  }
+}
+`,
+    variables: {
+      id: tokenId !== void 0 ? (
+        // Generic Token ID types all stringify down to the base numeric equivalent.
+        `${tokenAddress.toLowerCase()}-${tokenId}`
+      ) : `${tokenAddress.toLowerCase()}-0`
+    },
+    parseResponseData: (responseData) => responseData?.zoraCreateToken
   };
 }
-function makePremintReturn({
-  premintConfig,
-  premintConfigVersion,
-  publicClient,
-  apiClient,
-  chainId,
-  ...collectionAndAddress
+function buildContractTokensQuery({
+  tokenAddress
 }) {
-  const { collection, collectionAddress } = collectionAndAddress;
-  const typedDataDefinition = premintTypedDataDefinition2({
-    verifyingContract: collectionAddress,
-    premintConfig,
-    premintConfigVersion,
-    chainId
-  });
-  const signAndSubmit = async ({
-    walletClient,
-    account,
-    checkSignature
-  }) => {
-    const { signature, signerAccount } = await signPremint({
-      account,
-      walletClient,
-      typedDataDefinition
-    });
-    await submit({
-      signature,
-      checkSignature,
-      account: signerAccount
-    });
-    return {
-      signature,
-      signerAccount
-    };
-  };
-  const submit = async ({
-    signature,
-    checkSignature,
-    account
-  }) => {
-    if (checkSignature) {
-      const isAuthorized = await isAuthorizedToCreatePremint({
-        collectionAddress,
-        additionalAdmins: collection?.additionalAdmins,
-        contractAdmin: collection?.contractAdmin,
-        publicClient,
-        signer: account
-      });
-      if (!isAuthorized) {
-        throw new Error("Not authorized to create premint");
-      }
-    }
-    await apiClient.postSignature({
-      ...toContractCreationConfigOrAddress(collectionAndAddress),
-      signature,
-      premintConfig,
-      premintConfigVersion
-    });
-  };
-  const urls = makeUrls({
-    chainId,
-    address: collectionAddress,
-    uid: premintConfig.uid
-  });
   return {
-    premintConfig,
-    premintConfigVersion,
-    typedDataDefinition,
-    collectionAddress,
-    signAndSubmit,
-    submit,
-    urls
+    query: `
+${FRAGMENTS}
+query ($contract: Bytes!) {
+  zoraCreateTokens(
+     where: {address: $contract}
+  ) {
+     ...Token
+  }
+}
+`,
+    variables: {
+      contract: tokenAddress.toLowerCase()
+    },
+    parseResponseData: (responseData) => responseData?.zoraCreateTokens
   };
 }
-async function signPremint({
-  account,
-  walletClient,
-  typedDataDefinition
+function buildPremintsOfContractQuery({
+  tokenAddress
 }) {
-  if (!account) {
-    account = walletClient.account;
+  return {
+    query: `
+      query ($contractAddress: Bytes!) {
+        premints(where:{contractAddress:$contractAddress}) {
+          uid
+          tokenId
+        }
+      }
+    `,
+    variables: {
+      contractAddress: tokenAddress.toLowerCase()
+    },
+    parseResponseData: (responseData) => responseData?.premints
+  };
+}
+
+// src/apis/subgraph-querier.ts
+var SubgraphQuerier = class {
+  constructor(httpClient2) {
+    this.httpClient = httpClient2;
   }
-  if (!account) {
-    throw new Error("No account provided");
+  async query({
+    subgraphUrl,
+    query,
+    variables
+  }) {
+    const { retries: retries2, post: post2 } = this.httpClient;
+    const result = await retries2(async () => {
+      return await post2(subgraphUrl, {
+        query,
+        variables
+      });
+    });
+    return result?.data;
   }
-  const signature = await walletClient.signTypedData({
-    account,
-    ...typedDataDefinition
-  });
+};
+
+// src/apis/subgraph-getter.ts
+var SubgraphGetter = class {
+  constructor(chainId, subgraphQuerier) {
+    this.subgraphQuerier = subgraphQuerier || new SubgraphQuerier(httpClient);
+    this.networkConfig = getApiNetworkConfigForChain(chainId);
+  }
+  async querySubgraphWithRetries({
+    query,
+    variables,
+    parseResponseData
+  }) {
+    const responseData = await this.subgraphQuerier.query({
+      subgraphUrl: this.networkConfig.subgraphUrl,
+      query,
+      variables
+    });
+    return parseResponseData(responseData);
+  }
+};
+
+// src/mint/strategies-parsing.ts
+function parseFixedPriceSalesConfig(fixedPrice, contractMintFee) {
   return {
-    signature,
-    signerAccount: account
+    salesStrategy: {
+      saleType: "fixedPrice",
+      ...fixedPrice,
+      maxTokensPerAddress: BigInt(fixedPrice.maxTokensPerAddress),
+      pricePerToken: BigInt(fixedPrice.pricePerToken),
+      mintFeePerQuantity: contractMintFee
+    },
+    saleEnd: BigInt(fixedPrice.saleEnd),
+    saleStart: BigInt(fixedPrice.saleStart)
+    // saleActive:
+    //   BigInt(fixedPrice.saleStart) <= blockTime && BigInt(saleEnd) > blockTime,
   };
 }
-async function createPremint({
-  token: tokenCreationConfig,
-  uid,
-  publicClient,
-  apiClient,
-  chainId,
-  ...collectionOrAddress
-}) {
-  const {
-    premintConfig,
-    premintConfigVersion,
-    collectionAddress: collectionAddressToUse
-  } = await prepareCreatePremintConfig({
-    ...collectionOrAddress,
-    tokenCreationConfig,
-    uid,
-    publicClient,
-    apiClient,
-    chainId
-  });
-  return makePremintReturn({
-    premintConfig,
-    premintConfigVersion,
-    collectionAddress: collectionAddressToUse,
-    collection: collectionOrAddress.contract,
-    publicClient,
-    apiClient,
-    chainId
-  });
-}
-async function prepareCreatePremintConfig({
-  tokenCreationConfig,
-  uid,
-  publicClient,
-  apiClient,
-  chainId,
-  ...collectionOrAddress
-}) {
-  const newContractAddress = await getPremintCollectionAddress({
-    publicClient,
-    ...collectionOrAddress
-  });
-  let uidToUse = uid;
-  if (typeof uidToUse !== "number") {
-    uidToUse = await apiClient.getNextUID(newContractAddress);
-  }
-  const supportedVersions = await supportedPremintVersions({
-    tokenContract: newContractAddress,
-    publicClient
-  });
-  const tokenConfigAndVersion = makeTokenConfigWithDefaults({
-    tokenCreationConfig,
-    chainId,
-    supportedPremintVersions: supportedVersions
-  });
-  const premintConfig = makeNewPremint({
-    ...tokenConfigAndVersion,
-    uid: uidToUse
-  });
-  const premintConfigAndVersion = {
-    premintConfig,
-    premintConfigVersion: tokenConfigAndVersion.premintConfigVersion
+function parseERC20SalesConfig(erc20Minter) {
+  return {
+    salesStrategy: {
+      saleType: "erc20",
+      ...erc20Minter,
+      maxTokensPerAddress: BigInt(erc20Minter.maxTokensPerAddress),
+      pricePerToken: BigInt(erc20Minter.pricePerToken),
+      mintFeePerQuantity: 0n
+    },
+    saleEnd: BigInt(erc20Minter.saleEnd),
+    saleStart: BigInt(erc20Minter.saleStart)
+    // saleActive:
+    //   BigInt(erc20Minter.saleStart) <= blockTime && saleEnd > blockTime,
   };
+}
+function parsePresaleSalesConfig(presale, contractMintFee) {
   return {
-    ...premintConfigAndVersion,
-    collectionAddress: newContractAddress
+    salesStrategy: {
+      saleType: "allowlist",
+      address: presale.address,
+      merkleRoot: presale.merkleRoot,
+      saleStart: presale.presaleStart,
+      saleEnd: presale.presaleEnd,
+      mintFeePerQuantity: contractMintFee
+    },
+    saleEnd: BigInt(presale.presaleEnd),
+    saleStart: BigInt(presale.presaleStart)
+    // saleActive:
+    // BigInt(presale.presaleStart) <= blockTime && saleEnd > blockTime,
   };
 }
-async function updatePremint({
-  uid,
-  collection,
-  tokenConfigUpdates,
-  apiClient,
-  publicClient,
-  chainId
+function parseZoraTimedSalesConfig(zoraTimedMinter) {
+  const saleEnd = BigInt(zoraTimedMinter.saleEnd);
+  return {
+    salesStrategy: {
+      saleType: "timed",
+      address: zoraTimedMinter.address,
+      mintFee: BigInt(zoraTimedMinter.mintFee),
+      saleStart: zoraTimedMinter.saleStart,
+      saleEnd: zoraTimedMinter.saleEnd,
+      erc20Z: zoraTimedMinter.erc20Z.id,
+      pool: zoraTimedMinter.erc20Z.pool,
+      secondaryActivated: zoraTimedMinter.secondaryActivated,
+      mintFeePerQuantity: BigInt(zoraTimedMinter.mintFee),
+      marketCountdown: zoraTimedMinter.marketCountdown ? BigInt(zoraTimedMinter.marketCountdown) : void 0,
+      minimumMarketEth: zoraTimedMinter.minimumMarketEth ? BigInt(zoraTimedMinter.minimumMarketEth) : void 0
+    },
+    saleEnd: saleEnd > 0n ? saleEnd : void 0,
+    saleStart: BigInt(zoraTimedMinter.saleStart)
+    // saleActive:
+    //   BigInt(zoraTimedMinter.saleStart) <= blockTime &&
+    // (hasSaleEnd ? saleEnd > blockTime : true),
+  };
+}
+function parseSalesConfig(targetStrategy, contractMintFee) {
+  switch (targetStrategy.type) {
+    case "FIXED_PRICE":
+      return parseFixedPriceSalesConfig(
+        targetStrategy.fixedPrice,
+        contractMintFee
+        // blockTime,
+      );
+    case "ERC_20_MINTER":
+      return parseERC20SalesConfig(targetStrategy.erc20Minter);
+    case "PRESALE":
+      return parsePresaleSalesConfig(
+        targetStrategy.presale,
+        contractMintFee
+        // blockTime,
+      );
+    case "ZORA_TIMED":
+      return parseZoraTimedSalesConfig(
+        targetStrategy.zoraTimedMinter
+        // blockTime,
+      );
+    default:
+      throw new Error("Unknown saleType");
+  }
+}
+function isPrimaryMintActive(sale, blockTime) {
+  if (sale.saleStart > blockTime)
+    return false;
+  if (!sale.saleEnd)
+    return true;
+  return sale.saleEnd > blockTime;
+}
+function isSecondaryMinter(result) {
+  return result.saleType === "timed";
+}
+function isSecondaryMarketActive(sale) {
+  const salesStrategy = sale.salesStrategy;
+  if (isSecondaryMinter(salesStrategy)) {
+    return salesStrategy.secondaryActivated;
+  }
+  return false;
+}
+function getTargetStrategy({
+  preferredSaleType,
+  blockTime,
+  parsedStrategies
 }) {
-  const {
-    premint: { premintConfig, premintConfigVersion },
-    collection: collectionCreationConfig
-  } = await apiClient.get({
-    collectionAddress: collection,
-    uid
-  });
-  const updatedPremint = applyUpdateToPremint({
-    uid: premintConfig.uid,
-    version: premintConfig.version,
-    tokenConfig: premintConfig.tokenConfig,
-    tokenConfigUpdates
-  });
-  return makePremintReturn({
-    premintConfig: updatedPremint,
-    premintConfigVersion,
-    collectionAddress: collection,
-    collection: collectionCreationConfig,
-    publicClient,
-    apiClient,
-    chainId
-  });
+  const withPrimaryAndSecondaryMintActive = parsedStrategies.map(
+    (strategy) => ({
+      strategy,
+      primaryMintActive: isPrimaryMintActive(strategy, blockTime),
+      secondaryMarketActive: isSecondaryMarketActive(strategy)
+    })
+  );
+  const stillValidSalesStrategies = withPrimaryAndSecondaryMintActive.filter(
+    ({ primaryMintActive, secondaryMarketActive }) => primaryMintActive || secondaryMarketActive
+  );
+  const saleStrategies = stillValidSalesStrategies.sort(
+    (a, b) => (a.strategy.saleEnd ?? 0n) > (b.strategy.saleEnd ?? 0n) ? 1 : -1
+  );
+  let targetStrategy;
+  if (!preferredSaleType) {
+    return saleStrategies[0];
+  } else {
+    targetStrategy = saleStrategies.find(
+      ({ strategy: { salesStrategy } }) => salesStrategy.saleType === preferredSaleType
+    );
+    if (!targetStrategy) {
+      targetStrategy = saleStrategies.find(
+        ({ strategy: { salesStrategy } }) => salesStrategy.saleType === "timed" || salesStrategy.saleType === "fixedPrice" || salesStrategy.saleType === "erc20"
+      );
+      if (!targetStrategy)
+        throw new Error("Cannot find valid sale strategy");
+      return targetStrategy;
+    }
+  }
+  return targetStrategy;
 }
-async function deletePremint({
-  uid,
-  collection,
-  publicClient,
-  apiClient,
-  chainId
+function findTargetStrategyWithPrimaryOrSecondarySaleActive({
+  token,
+  tokenId,
+  preferredSaleType,
+  defaultMintFee,
+  blockTime
 }) {
-  const {
-    premint: { premintConfig, premintConfigVersion },
-    collection: collectionCreationConfig,
-    collectionAddress
-  } = await apiClient.get({
-    collectionAddress: collection,
-    uid
-  });
-  const deletedPremint = {
-    ...premintConfig,
-    version: premintConfig.version + 1,
-    deleted: true
-  };
-  return makePremintReturn({
-    premintConfig: deletedPremint,
-    premintConfigVersion,
-    collectionAddress,
-    collection: collectionCreationConfig,
-    publicClient,
-    apiClient,
-    chainId
+  const allStrategies = (typeof tokenId !== "undefined" ? token.salesStrategies : token.contract.salesStrategies) || [];
+  const parsedStrategies = allStrategies.map(
+    (strategy) => parseSalesConfig(strategy, defaultMintFee)
+  );
+  const targetStrategy = getTargetStrategy({
+    preferredSaleType,
+    blockTime,
+    parsedStrategies
   });
+  return targetStrategy;
 }
-async function collectPremint({
-  uid,
-  tokenContract,
-  minterAccount,
-  quantityToMint,
-  mintComment = "",
-  mintReferral,
-  mintRecipient,
-  firstMinter,
-  premintGetter,
-  publicClient
+function parseAndFilterTokenQueryResult({
+  token,
+  tokenId,
+  preferredSaleType,
+  blockTime
 }) {
-  if (typeof quantityToMint !== "undefined" && quantityToMint < 1) {
-    throw new Error("Quantity to mint cannot be below 1");
-  }
-  const premint = await premintGetter.get({
-    collectionAddress: tokenContract,
-    uid
+  const defaultMintFee = BigInt(token.contract.mintFeePerQuantity);
+  const salesStrategyAndMintInfo = findTargetStrategyWithPrimaryOrSecondarySaleActive({
+    token,
+    tokenId,
+    preferredSaleType,
+    defaultMintFee,
+    blockTime
   });
-  const mintFee = await getPremintMintFee({
-    tokenContract,
-    publicClient
+  const tokenInfo = parseTokenInfo({
+    token
   });
-  return buildPremintMintCall({
-    mintArguments: {
-      minterAccount,
-      quantityToMint,
-      firstMinter,
-      mintComment,
-      mintRecipient,
-      mintReferral
+  return {
+    salesConfigAndTokenInfo: {
+      ...tokenInfo,
+      salesConfig: salesStrategyAndMintInfo?.strategy.salesStrategy
     },
-    mintFee,
-    premint
-  });
-}
-var buildPremintMintCall = ({
-  mintArguments: {
-    minterAccount,
-    mintComment = "",
-    mintRecipient,
-    mintReferral,
-    firstMinter,
-    quantityToMint
-  },
-  premint: { collection, collectionAddress, premint, signature },
-  mintFee
-}) => {
-  const mintArgumentsContract = {
-    mintComment,
-    mintRecipient: mintRecipientOrAccount({
-      mintRecipient,
-      minterAccount
-    }),
-    mintRewardsRecipients: makeMintRewardsRecipient({
-      mintReferral
-    })
+    primaryMintActive: salesStrategyAndMintInfo?.primaryMintActive ?? false,
+    primaryMintEnd: salesStrategyAndMintInfo?.strategy.saleEnd,
+    secondaryMarketActive: salesStrategyAndMintInfo?.secondaryMarketActive ?? false
   };
-  const collectionOrEmpty = collection ? defaultAdditionalAdmins(collection) : emptyContractCreationConfig();
-  const collectionAddressToSubmit = collection ? zeroAddress2 : collectionAddress;
-  const firstMinterToSubmit = firstMinter || (typeof minterAccount === "string" ? minterAccount : minterAccount.address);
-  if (premint.premintConfigVersion === PremintConfigVersion2.V3) {
-    throw new Error("PremintV3 not supported in premint SDK");
-  }
-  const value = (mintFee + premint.premintConfig.tokenConfig.pricePerToken) * BigInt(quantityToMint);
-  return makeContractParameters({
-    account: minterAccount,
-    abi: zoraCreator1155PremintExecutorImplABI2,
-    functionName: "premint",
-    value,
-    address: getPremintExecutorAddress(),
-    args: [
-      collectionOrEmpty,
-      collectionAddressToSubmit,
-      encodePremintConfig(premint),
-      signature,
-      BigInt(quantityToMint),
-      mintArgumentsContract,
-      firstMinterToSubmit,
-      zeroAddress2
-    ]
-  });
-};
-function makeUrls({
-  uid,
-  address,
-  tokenId,
-  chainId,
-  blockExplorerUrl
-}) {
-  if ((!uid || !tokenId) && !address) {
-    return { explorer: null, zoraCollect: null, zoraManage: null };
-  }
-  const zoraTokenPath = uid ? `premint-${uid}` : tokenId;
-  const network = getApiNetworkConfigForChain(chainId);
+}
+function parseTokenInfo({
+  token
+}) {
   return {
-    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}`
+    contract: {
+      address: token.contract.address,
+      name: token.contract.name,
+      URI: token.contract.contractURI
+    },
+    tokenURI: token.uri,
+    tokenId: token.tokenId ? BigInt(token.tokenId) : void 0,
+    mintType: token.tokenStandard === "ERC721" ? "721" : "1155",
+    creator: token.creator,
+    totalMinted: BigInt(token.totalMinted),
+    maxSupply: BigInt(token.maxSupply),
+    contractVersion: token.contract.contractVersion
   };
 }
 
-// src/premint/contract-types.ts
-import {
-  PremintConfigVersion as PremintConfigVersionOrig
-} from "@zoralabs/protocol-deployments";
-var PremintConfigVersion3 = ((PremintConfigVersion4) => {
-  PremintConfigVersion4[PremintConfigVersion4["V1"] = PremintConfigVersionOrig.V1] = "V1";
-  PremintConfigVersion4[PremintConfigVersion4["V2"] = PremintConfigVersionOrig.V2] = "V2";
-  PremintConfigVersion4[PremintConfigVersion4["V3"] = PremintConfigVersionOrig.V3] = "V3";
-  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 getOfCollection = async ({
-  collectionAddress,
-  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()}`
-    )
-  );
-  return convertGetPremintOfCollectionApiResponse(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.get = async ({ collectionAddress, uid }) => {
-      return getSignature({
-        collectionAddress,
-        uid,
-        chainId: this.chainId,
-        httpClient: this.httpClient
-      });
-    };
-    this.getOfCollection = async ({
-      collectionAddress
+// src/mint/subgraph-mint-getter.ts
+var SubgraphMintGetter = class extends SubgraphGetter {
+  constructor(chainId, subgraphQuerier) {
+    super(chainId, subgraphQuerier);
+    this.getMintable = async ({
+      tokenAddress,
+      tokenId
     }) => {
-      return getOfCollection({
-        collectionAddress,
-        chainId: this.chainId,
-        httpClient: this.httpClient
-      });
+      const token = await this.querySubgraphWithRetries(
+        buildNftTokenSalesQuery({
+          tokenId,
+          tokenAddress
+        })
+      );
+      if (!token) {
+        throw new Error("Cannot find token");
+      }
+      return token;
     };
-    this.chainId = chainId;
-    this.httpClient = httpClient2 || httpClient;
+  }
+  async getContractMintable({
+    tokenAddress,
+    preferredSaleType,
+    blockTime
+  }) {
+    const tokens = await this.querySubgraphWithRetries(
+      buildContractTokensQuery({
+        tokenAddress
+      })
+    );
+    if (!tokens || tokens.length === 0)
+      return [];
+    return tokens.filter((x) => x.tokenId !== "0").map(
+      (token) => parseAndFilterTokenQueryResult({
+        token,
+        tokenId: token.tokenId,
+        preferredSaleType,
+        blockTime
+      })
+    );
+  }
+  async getContractPremintTokenIds({
+    tokenAddress
+  }) {
+    const premints = await this.querySubgraphWithRetries(
+      buildPremintsOfContractQuery({
+        tokenAddress
+      })
+    );
+    return premints?.map((premint) => ({
+      tokenId: BigInt(premint.tokenId),
+      uid: +premint.uid
+    })) || [];
   }
 };
 
@@ -3999,32 +4013,33 @@ function parseMintCosts({
 }
 
 // src/mint/mint-queries.ts
-async function getMint({
-  params,
-  mintGetter,
-  premintGetter,
-  publicClient,
-  chainId
-}) {
-  const { tokenContract } = params;
+async function getToken(params) {
+  const { premintGetter, publicClient } = params;
+  const chainId = publicClient.chain.id;
   if (isOnChainMint(params)) {
     const tokenId = is1155Mint(params) ? params.tokenId : void 0;
     const blockTime = (await publicClient.getBlock()).timestamp;
-    const result = await mintGetter.getMintable({
+    const mintGetterOrDefault = params.mintGetter ?? new SubgraphMintGetter(chainId);
+    const result = await mintGetterOrDefault.getMintable({
+      tokenId,
+      tokenAddress: params.tokenContract
+    });
+    const token = parseAndFilterTokenQueryResult({
+      token: result,
       tokenId,
-      tokenAddress: tokenContract,
       preferredSaleType: params.preferredSaleType,
       blockTime
     });
-    return toMintableReturn(result, chainId);
+    return toMintableReturn(token, chainId);
   }
-  const premint = await premintGetter.get({
-    collectionAddress: tokenContract,
+  const premintGetterOrDefault = premintGetter ?? new PremintAPIClient(chainId);
+  const premint = await premintGetterOrDefault.get({
+    collectionAddress: params.tokenContract,
     uid: params.uid
   });
   const mintFee = await getPremintMintFee({
     publicClient,
-    tokenContract
+    tokenContract: params.tokenContract
   });
   return toPremintMintReturn({ premint, mintFee });
 }
@@ -4050,19 +4065,20 @@ async function getPremintsOfCollectionWithTokenIds({
     premints: premintsWithTokenId
   };
 }
-async function getMintsOfContract({
-  params,
+async function getTokensOfContract({
   mintGetter,
   premintGetter,
   publicClient,
-  chainId
+  ...params
 }) {
-  const onchainMints = (await mintGetter.getContractMintable({
+  const chainId = publicClient.chain.id;
+  const mintGetterOrDefault = mintGetter ?? new SubgraphMintGetter(chainId);
+  const onchainMints = (await mintGetterOrDefault.getContractMintable({
     tokenAddress: params.tokenContract
   })).map((result) => toMintableReturn(result, chainId));
   const offchainMints = await getPremintsOfContractMintable({
-    mintGetter,
-    premintGetter,
+    mintGetter: mintGetterOrDefault,
+    premintGetter: premintGetter ?? new PremintAPIClient(chainId),
     publicClient,
     params: {
       tokenContract: params.tokenContract
@@ -4085,16 +4101,20 @@ async function getMintCosts({
   if (isOnChainMint(params)) {
     const tokenId = is1155Mint(params) ? params.tokenId : void 0;
     const blockTime = (await publicClient.getBlock()).timestamp;
-    const { salesConfigAndTokenInfo } = await mintGetter.getMintable({
+    const result = await mintGetter.getMintable({
+      tokenId,
+      tokenAddress: collection
+    });
+    const token = parseAndFilterTokenQueryResult({
+      token: result,
       tokenId,
-      tokenAddress: collection,
       blockTime
     });
-    if (!salesConfigAndTokenInfo.salesConfig) {
+    if (!token.salesConfigAndTokenInfo.salesConfig) {
       throw new Error("No valid sales config found for token");
     }
     return parseMintCosts({
-      salesConfig: salesConfigAndTokenInfo.salesConfig,
+      salesConfig: token.salesConfigAndTokenInfo.salesConfig,
       quantityToMint: BigInt(quantityToMint),
       allowListEntry
     });
@@ -4144,7 +4164,7 @@ async function getPremintsOfContractMintable({
     });
   });
 }
-function isPrimaryMintActive(premint) {
+function isPrimaryMintActive2(premint) {
   const currentTime = (/* @__PURE__ */ new Date()).getTime() / 1e3;
   return premint.premintConfig.tokenConfig.mintStart < currentTime;
 }
@@ -4237,7 +4257,7 @@ function toPremintMintReturn({
   mintFee
 }) {
   const mintable = parsePremint({ premint, mintFee });
-  const primaryMintActive = isPrimaryMintActive(premint.premint);
+  const primaryMintActive = isPrimaryMintActive2(premint.premint);
   if (!primaryMintActive) {
     return {
       token: mintable,
@@ -4276,13 +4296,11 @@ var MintClient = class {
   constructor({
     publicClient,
     premintGetter,
-    mintGetter,
-    chainId
+    mintGetter
   }) {
     this.publicClient = publicClient;
     this.mintGetter = mintGetter;
     this.premintGetter = premintGetter;
-    this.chainId = chainId;
   }
   /**
    * Returns the parameters needed to prepare a transaction mint a token.
@@ -4293,26 +4311,24 @@ var MintClient = class {
    */
   async mint(parameters) {
     return mint({
-      parameters,
+      ...parameters,
       publicClient: this.publicClient,
       mintGetter: this.mintGetter,
-      premintGetter: this.premintGetter,
-      chainId: this.chainId
+      premintGetter: this.premintGetter
     });
   }
   /**
    * Gets an 1155, 721, or premint, and returns both information about it, and a function
    * that can be used to build a mint transaction for a quantity of items to mint.
-   * @param parameters - Token to get {@link GetMintParameters}
+   * @param parameters - Token to get {@link GetMintParametersArguments}
    * @Returns Information about the mint and a function to build a mint transaction {@link MintableReturn}
    */
   async get(parameters) {
-    return getMint({
-      params: parameters,
+    return getToken({
+      ...parameters,
       mintGetter: this.mintGetter,
       premintGetter: this.premintGetter,
-      publicClient: this.publicClient,
-      chainId: this.chainId
+      publicClient: this.publicClient
     });
   }
   /**
@@ -4322,17 +4338,16 @@ var MintClient = class {
    * @Returns Array of tokens, each containing information about the token and a function to build a mint transaction.
    */
   async getOfContract(params) {
-    return getMintsOfContract({
-      params,
+    return getTokensOfContract({
+      ...params,
       mintGetter: this.mintGetter,
       premintGetter: this.premintGetter,
-      publicClient: this.publicClient,
-      chainId: this.chainId
+      publicClient: this.publicClient
     });
   }
   /**
    * Gets the costs to mint the quantity of tokens specified for a mint.
-   * @param parameters - Parameters for the mint {@link GetMintCostsParameters}
+   * @param parameters - Parameters for the mint {@link GetMintCostsParameterArguments}
    * @returns Costs to mint the quantity of tokens specified
    */
   async getMintCosts(parameters) {
@@ -4345,18 +4360,16 @@ var MintClient = class {
   }
 };
 async function mint({
-  parameters,
   publicClient,
   mintGetter,
   premintGetter,
-  chainId
+  ...parameters
 }) {
-  const { prepareMint, primaryMintActive } = await getMint({
-    params: parameters,
+  const { prepareMint, primaryMintActive } = await getToken({
+    ...parameters,
     mintGetter,
     premintGetter,
-    publicClient,
-    chainId
+    publicClient
   });
   if (!primaryMintActive) {
     throw new Error("Primary mint is not active");
@@ -4371,7 +4384,7 @@ async function mint({
   });
 }
 
-// src/create/1155-create-helper.ts
+// src/create/create-client.ts
 import {
   zoraCreator1155FactoryImplABI as zoraCreator1155FactoryImplABI2,
   zoraCreator1155FactoryImplAddress as zoraCreator1155FactoryImplAddress2,
@@ -4397,9 +4410,9 @@ async function getDeterministicContractAddress({
   publicClient,
   account,
   setupActions,
-  contract,
-  chainId
+  contract
 }) {
+  const chainId = publicClient.chain.id;
   const contractAddress = await publicClient.readContract({
     abi: zoraCreator1155FactoryImplABI,
     address: zoraCreator1155FactoryImplAddress[chainId],
@@ -4929,27 +4942,85 @@ function makeOnchainPrepareMintFromCreate({
       salesConfig: result
     });
     return {
-      parameters: makePrepareMint1155TokenParams({
-        salesConfigAndTokenInfo: {
-          salesConfig: subgraphSalesConfig,
-          contractVersion
-        },
-        ...params,
-        tokenContract: contractAddress,
-        tokenId,
-        chainId
-      }),
-      costs: parseMintCosts({
-        allowListEntry: params.allowListEntry,
-        quantityToMint: BigInt(params.quantityToMint),
-        salesConfig: subgraphSalesConfig
-      }),
-      erc20Approval: getRequiredErc20Approvals(params, subgraphSalesConfig)
+      parameters: makePrepareMint1155TokenParams({
+        salesConfigAndTokenInfo: {
+          salesConfig: subgraphSalesConfig,
+          contractVersion
+        },
+        ...params,
+        tokenContract: contractAddress,
+        tokenId,
+        chainId
+      }),
+      costs: parseMintCosts({
+        allowListEntry: params.allowListEntry,
+        quantityToMint: BigInt(params.quantityToMint),
+        salesConfig: subgraphSalesConfig
+      }),
+      erc20Approval: getRequiredErc20Approvals(params, subgraphSalesConfig)
+    };
+  };
+}
+
+// src/create/subgraph-queries.ts
+function buildContractInfoQuery({
+  contractAddress
+}) {
+  return {
+    query: `
+    query ($contractAddress: Bytes!) {
+      zoraCreateContract(id: $contractAddress) {
+        contractVersion
+        name
+        mintFeePerQuantity
+        tokens(first: 1, orderBy: tokenId, orderDirection: desc) {
+          tokenId
+        }
+      }
+    }
+    `,
+    variables: {
+      contractAddress: contractAddress.toLowerCase()
+    },
+    parseResponseData: (responseData) => responseData.zoraCreateContract
+  };
+}
+
+// src/create/contract-getter.ts
+var SubgraphContractGetter = class extends SubgraphGetter {
+  constructor(chainId, subgraphQuerier) {
+    super(chainId, subgraphQuerier);
+  }
+  async getContractInfo({
+    contractAddress,
+    retries: retries2 = 1
+  }) {
+    const tryFn = async () => {
+      const responseData2 = await this.querySubgraphWithRetries(
+        buildContractInfoQuery({ contractAddress })
+      );
+      if (!responseData2) {
+        console.log("could not find contract");
+        throw new Error("Cannot find contract");
+      }
+      return responseData2;
+    };
+    const responseData = await retriesGeneric({
+      tryFn,
+      maxTries: retries2,
+      linearBackoffMS: 1e3
+    });
+    const nextTokenId = responseData.tokens.length === 0 ? 1n : BigInt(responseData.tokens[0].tokenId) + 1n;
+    return {
+      name: responseData.name,
+      contractVersion: responseData.contractVersion,
+      mintFee: BigInt(responseData.mintFeePerQuantity),
+      nextTokenId
     };
-  };
-}
+  }
+};
 
-// src/create/1155-create-helper.ts
+// src/create/create-client.ts
 var ROYALTY_BPS_DEFAULT = 1e3;
 var getTokenIdFromCreateReceipt = (receipt) => {
   for (const data of receipt.logs) {
@@ -5030,19 +5101,16 @@ function makeCreateTokenCall({
 }
 var Create1155Client = class {
   constructor({
-    chainId,
     publicClient,
     contractGetter
   }) {
-    this.chainId = chainId;
     this.publicClient = publicClient;
     this.contractGetter = contractGetter;
   }
   async createNew1155(props) {
-    return createNew1155ContractAndToken({
+    return create1155({
       ...props,
-      publicClient: this.publicClient,
-      chainId: this.chainId
+      publicClient: this.publicClient
     });
   }
   async createNew1155OnExistingContract({
@@ -5056,83 +5124,100 @@ var Create1155Client = class {
       account,
       token,
       getAdditionalSetupActions,
-      publicClient: this.publicClient,
-      chainId: this.chainId,
-      contractGetter: this.contractGetter
+      contractGetter: this.contractGetter,
+      chainId: this.publicClient.chain.id
     });
   }
 };
-async function createNew1155ContractAndToken({
+async function create1155({
   contract,
   account,
-  chainId,
   token,
   publicClient,
   getAdditionalSetupActions
 }) {
   const nextTokenId = 1n;
+  const chainId = publicClient.chain.id;
   const contractVersion = new1155ContractVersion(chainId);
-  const {
-    minter,
-    newToken,
-    setupActions: tokenSetupActions
-  } = prepareSetupActions({
-    chainId,
-    account,
-    contractVersion,
-    nextTokenId,
-    token,
-    getAdditionalSetupActions,
-    contractName: contract.name
-  });
-  const request = makeCreateContractAndTokenCall({
+  const result = prepareNew1155ContractAndToken({
     contract,
     account,
     chainId,
-    tokenSetupActions,
-    fundsRecipient: token.payoutRecipient,
-    royaltyBPS: token.royaltyBPS
+    token,
+    getAdditionalSetupActions,
+    nextTokenId,
+    contractVersion
   });
   const contractAddress = await getDeterministicContractAddress({
     account: typeof account === "string" ? account : account.address,
     publicClient,
-    setupActions: tokenSetupActions,
-    chainId,
+    setupActions: result.setupActions,
     contract
   });
   const prepareMint = makeOnchainPrepareMintFromCreate({
     contractAddress,
     contractVersion,
-    minter,
-    result: newToken.salesConfig,
+    minter: result.minter,
+    result: result.newToken.salesConfig,
     tokenId: nextTokenId,
+    chainId,
     // to get the contract wide mint fee, we get what it would be for a new contract
     getContractMintFee: async () => getNewContractMintFee({
       publicClient,
       chainId
-    }),
-    chainId
+    })
   });
   return {
-    parameters: request,
-    tokenSetupActions,
-    newTokenId: nextTokenId,
-    newToken,
+    ...result,
+    prepareMint,
     contractAddress,
     contractVersion,
-    minter,
-    prepareMint
+    newTokenId: nextTokenId
   };
 }
-async function createNew1155Token({
+function prepareNew1155ContractAndToken({
+  account,
+  chainId,
+  token,
+  getAdditionalSetupActions,
+  nextTokenId,
+  contractVersion,
+  contract
+}) {
+  const { minter, newToken, setupActions } = prepareSetupActions({
+    chainId,
+    account,
+    contractVersion,
+    nextTokenId,
+    token,
+    getAdditionalSetupActions,
+    contractName: contract.name
+  });
+  const request = makeCreateContractAndTokenCall({
+    contract,
+    account,
+    chainId,
+    tokenSetupActions: setupActions,
+    fundsRecipient: token.payoutRecipient,
+    royaltyBPS: token.royaltyBPS
+  });
+  return {
+    parameters: request,
+    setupActions,
+    newToken,
+    minter
+  };
+}
+function prepareNew1155Token({
   contractAddress,
   account,
   getAdditionalSetupActions,
   token,
   chainId,
-  contractGetter
+  nextTokenId,
+  contractVersion,
+  contractName
 }) {
-  const { nextTokenId, contractVersion, mintFee, name } = await contractGetter.getContractInfo({ contractAddress, retries: 5 });
   const {
     minter,
     newToken,
@@ -5144,30 +5229,57 @@ async function createNew1155Token({
     nextTokenId,
     token,
     getAdditionalSetupActions,
-    contractName: name
+    contractName
   });
   const request = makeCreateTokenCall({
     contractAddress,
     account,
     tokenSetupActions
   });
+  return {
+    parameters: request,
+    setupActions: tokenSetupActions,
+    newToken,
+    minter
+  };
+}
+async function createNew1155Token({
+  contractAddress,
+  account,
+  getAdditionalSetupActions,
+  token,
+  chainId,
+  contractGetter
+}) {
+  const contractGetterOrDefault = contractGetter ?? new SubgraphContractGetter(chainId);
+  const { nextTokenId, contractVersion, mintFee, name } = await contractGetterOrDefault.getContractInfo({
+    contractAddress,
+    retries: 5
+  });
+  const preparedToken = prepareNew1155Token({
+    contractAddress,
+    account,
+    getAdditionalSetupActions,
+    token,
+    chainId,
+    nextTokenId,
+    contractVersion,
+    contractName: name
+  });
   const prepareMint = makeOnchainPrepareMintFromCreate({
     contractAddress,
     contractVersion,
-    minter,
-    result: newToken.salesConfig,
+    minter: preparedToken.minter,
+    result: preparedToken.newToken.salesConfig,
     tokenId: nextTokenId,
     getContractMintFee: async () => mintFee,
     chainId
   });
   return {
-    parameters: request,
-    tokenSetupActions,
+    ...preparedToken,
+    prepareMint,
     newTokenId: nextTokenId,
-    newToken,
-    contractVersion,
-    minter,
-    prepareMint
+    contractVersion
   };
 }
 function prepareSetupActions({
@@ -5440,123 +5552,65 @@ var encodePremintOnManager = ({
 });
 var makePermitToCollectPremintOrNonPremint = ({
   mintsOwner,
-  chainId,
-  deadline,
-  tokenIds,
-  // this quantity of MINTs will be used to collect premint
-  // and will be burned.  This same quantity is the quantity of
-  // premint to collect.
-  quantities,
-  nonce,
-  premint,
-  collect
-}) => {
-  let safeTransferData;
-  if (premint) {
-    safeTransferData = encodePremintOnManager(premint);
-  } else if (collect) {
-    safeTransferData = encodeCollectOnManager(collect);
-  } else {
-    throw new Error("Invalid operation");
-  }
-  return makePermitTransferBatchAndTypeData({
-    tokenIds,
-    quantities,
-    chainId,
-    mintsOwner,
-    nonce,
-    deadline,
-    safeTransferData,
-    to: zoraMintsManagerImplConfig.address[chainId]
-  });
-};
-function collectPremintV2WithMintsParams({
-  tokenIds,
-  quantities,
-  paidMintPricePerToken,
-  account,
-  chainId,
-  ...rest
-}) {
-  const call = encodePremintOnManager({
-    ...rest
-  });
-  return makeContractParameters({
-    abi: zoraMints1155Config.abi,
-    address: zoraMints1155Config.address[chainId],
-    functionName: "transferBatchToManagerAndCall",
-    args: [tokenIds, quantities, call],
-    value: getPaidMintValue(quantities, paidMintPricePerToken),
-    account
-  });
-}
-function decodeCallFailedError(error) {
-  if (error.data?.errorName !== "CallFailed")
-    throw new Error("Not a CallFailed error");
-  const internalErrorData = error.data?.args?.[0];
-  return decodeErrorResult({
-    abi: zoraMintsManagerImplABI,
-    data: internalErrorData
-  });
-}
-
-// src/create/subgraph-queries.ts
-function buildContractInfoQuery({
-  contractAddress
-}) {
-  return {
-    query: `
-    query ($contractAddress: Bytes!) {
-      zoraCreateContract(id: $contractAddress) {
-        contractVersion
-        name
-        mintFeePerQuantity
-        tokens(first: 1, orderBy: tokenId, orderDirection: desc) {
-          tokenId
-        }
-      }
-    }
-    `,
-    variables: {
-      contractAddress: contractAddress.toLowerCase()
-    },
-    parseResponseData: (responseData) => responseData.zoraCreateContract
-  };
-}
-
-// src/create/contract-getter.ts
-var SubgraphContractGetter = class extends SubgraphGetter {
-  constructor(chainId, subgraphQuerier) {
-    super(chainId, subgraphQuerier);
-  }
-  async getContractInfo({
-    contractAddress,
-    retries: retries2 = 1
-  }) {
-    const tryFn = async () => {
-      const responseData2 = await this.querySubgraphWithRetries(
-        buildContractInfoQuery({ contractAddress })
-      );
-      if (!responseData2) {
-        console.log("could not find contract");
-        throw new Error("Cannot find contract");
-      }
-      return responseData2;
-    };
-    const responseData = await retriesGeneric({
-      tryFn,
-      maxTries: retries2,
-      linearBackoffMS: 1e3
-    });
-    const nextTokenId = responseData.tokens.length === 0 ? 1n : BigInt(responseData.tokens[0].tokenId) + 1n;
-    return {
-      name: responseData.name,
-      contractVersion: responseData.contractVersion,
-      mintFee: BigInt(responseData.mintFeePerQuantity),
-      nextTokenId
-    };
+  chainId,
+  deadline,
+  tokenIds,
+  // this quantity of MINTs will be used to collect premint
+  // and will be burned.  This same quantity is the quantity of
+  // premint to collect.
+  quantities,
+  nonce,
+  premint,
+  collect
+}) => {
+  let safeTransferData;
+  if (premint) {
+    safeTransferData = encodePremintOnManager(premint);
+  } else if (collect) {
+    safeTransferData = encodeCollectOnManager(collect);
+  } else {
+    throw new Error("Invalid operation");
   }
+  return makePermitTransferBatchAndTypeData({
+    tokenIds,
+    quantities,
+    chainId,
+    mintsOwner,
+    nonce,
+    deadline,
+    safeTransferData,
+    to: zoraMintsManagerImplConfig.address[chainId]
+  });
 };
+function collectPremintV2WithMintsParams({
+  tokenIds,
+  quantities,
+  paidMintPricePerToken,
+  account,
+  chainId,
+  ...rest
+}) {
+  const call = encodePremintOnManager({
+    ...rest
+  });
+  return makeContractParameters({
+    abi: zoraMints1155Config.abi,
+    address: zoraMints1155Config.address[chainId],
+    functionName: "transferBatchToManagerAndCall",
+    args: [tokenIds, quantities, call],
+    value: getPaidMintValue(quantities, paidMintPricePerToken),
+    account
+  });
+}
+function decodeCallFailedError(error) {
+  if (error.data?.errorName !== "CallFailed")
+    throw new Error("Not a CallFailed error");
+  const internalErrorData = error.data?.args?.[0];
+  return decodeErrorResult({
+    abi: zoraMintsManagerImplABI,
+    data: internalErrorData
+  });
+}
 
 // src/rewards/rewards-queries.ts
 import {
@@ -5580,6 +5634,56 @@ var multicall3Abi = [
 ];
 var multicall3Address = "0xcA11bde05977b3631167028862bE2a173976CA11";
 
+// src/rewards/subgraph-queries.ts
+function buildCreatorERC20zs({
+  address
+}) {
+  return {
+    query: `
+    query ($address: Bytes!) {
+      zoraCreateTokens(
+        where: { royalties_: { royaltyRecipient: $address }, salesStrategies_: { type: "ZORA_TIMED" } }
+      ) {
+        royalties {
+          user
+        }
+        salesStrategies {
+          zoraTimedMinter {
+            erc20Z {
+              id
+            }
+          }
+        }
+      }
+    }
+    `,
+    variables: { address },
+    parseResponseData: (responseData) => {
+      return responseData?.zoraCreateTokens;
+    }
+  };
+}
+
+// src/rewards/subgraph-rewards-getter.ts
+var SubgraphRewardsGetter = class extends SubgraphGetter {
+  constructor(chainId, subgraphQuerier) {
+    super(chainId, subgraphQuerier);
+  }
+  async getErc20ZzForCreator({ address }) {
+    const queryResults = await this.querySubgraphWithRetries(
+      buildCreatorERC20zs({ address })
+    );
+    const results = (queryResults?.map((result) => {
+      const timedMinter = result.salesStrategies[0].zoraTimedMinter;
+      if (!timedMinter) {
+        return null;
+      }
+      return timedMinter.erc20Z.id;
+    }) || []).filter((id) => !!id);
+    return results;
+  }
+};
+
 // src/rewards/rewards-queries.ts
 function aggregateUnclaimedFees(unclaimedFees, wethAddress2) {
   let ethBalance = 0n;
@@ -5606,21 +5710,47 @@ function aggregateUnclaimedFees(unclaimedFees, wethAddress2) {
     erc20: unclaimedFeesAggregate
   };
 }
-var getRewardsBalance = async ({
+var getErc20zsWithPositions = async ({
+  address,
+  publicClient,
+  rewardsGetter
+}) => {
+  const chainId = publicClient.chain.id;
+  const rewardsGetterOrDefault = rewardsGetter ?? new SubgraphRewardsGetter(chainId);
+  const erc20zsForCreator = await rewardsGetterOrDefault.getErc20ZzForCreator({
+    address
+  });
+  const royaltiesAddress = erc20ZRoyaltiesAddress[chainId];
+  const positionsByErc20z = await publicClient.multicall({
+    contracts: erc20zsForCreator.map((erc20z) => ({
+      address: royaltiesAddress,
+      abi: erc20ZRoyaltiesABI,
+      functionName: "positionsByErc20z",
+      args: [erc20z]
+    })),
+    multicallAddress: multicall3Address,
+    allowFailure: false
+  });
+  const erc20zsWithPositions = erc20zsForCreator.filter(
+    (_, i) => positionsByErc20z[i] !== 0n
+  );
+  return erc20zsWithPositions;
+};
+var getRewardsBalances = async ({
   account,
   // The account to check rewards for (Address or Account object)
   publicClient,
   // The public client for making blockchain queries
-  chainId,
-  // The ID of the blockchain network
   rewardsGetter
   // Interface for getting ERC20Z tokens for a creator
 }) => {
+  const chainId = publicClient.chain.id;
   const address = typeof account === "string" ? account : account.address;
-  const erc20ZsAndSecondaryActivated = await rewardsGetter.getErc20ZzForCreator(
-    { address }
-  );
-  const validErc20Zs = erc20ZsAndSecondaryActivated.filter(({ secondaryActivated }) => secondaryActivated).map(({ erc20z }) => erc20z);
+  const erc20zsWithPositions = await getErc20zsWithPositions({
+    address,
+    publicClient,
+    rewardsGetter
+  });
   const result = await publicClient.multicall({
     contracts: [
       {
@@ -5633,7 +5763,7 @@ var getRewardsBalance = async ({
         address: erc20ZRoyaltiesAddress[chainId],
         abi: erc20ZRoyaltiesABI,
         functionName: "getUnclaimedFeesBatch",
-        args: [validErc20Zs]
+        args: [erc20zsWithPositions]
       }
     ],
     multicallAddress: multicall3Address,
@@ -5664,12 +5794,14 @@ var withdrawProtocolRewards = ({
 var makeClaimSecondaryRoyaltiesCalls = async ({
   claimFor,
   chainId,
-  rewardsGetter
+  rewardsGetter,
+  publicClient
 }) => {
-  const erc20ZsAndSecondaryActivated = await rewardsGetter.getErc20ZzForCreator(
-    { address: claimFor }
-  );
-  const erc20z = erc20ZsAndSecondaryActivated.filter(({ secondaryActivated }) => secondaryActivated).map(({ erc20z: erc20z2 }) => erc20z2);
+  const erc20z = await getErc20zsWithPositions({
+    address: claimFor,
+    publicClient,
+    rewardsGetter
+  });
   const royaltiesAddress = erc20ZRoyaltiesAddress[chainId];
   if (erc20z.length === 0) {
     return [];
@@ -5700,37 +5832,57 @@ var createMulticallParameters = (calls, account) => makeContractParameters({
   args: [calls],
   account
 });
-var withdrawRewards = async ({
-  account,
-  withdrawFor,
-  claimSecondaryRoyalties = true,
+var handleProtocolRewardsOnly = ({
   chainId,
-  rewardsGetter
+  withdrawFor,
+  account
+}) => ({
+  ...withdrawProtocolRewards({ chainId, withdrawFor }),
+  account
+});
+var handleAllRewards = async ({
+  withdrawFor,
+  account,
+  rewardsGetter,
+  publicClient
 }) => {
-  if (!claimSecondaryRoyalties) {
-    return {
-      ...withdrawProtocolRewards({ chainId, withdrawFor }),
-      account
-    };
-  }
+  const chainId = publicClient.chain.id;
   const protocolRewardsCall = createProtocolRewardsCall(chainId, withdrawFor);
   const secondaryRoyaltiesCalls = await makeClaimSecondaryRoyaltiesCalls({
     chainId,
     claimFor: withdrawFor,
-    rewardsGetter
+    rewardsGetter,
+    publicClient
   });
   const allCalls = [protocolRewardsCall, ...secondaryRoyaltiesCalls];
   return createMulticallParameters(allCalls, account);
 };
+var withdrawRewards = async ({
+  account,
+  withdrawFor,
+  claimSecondaryRoyalties = true,
+  rewardsGetter,
+  publicClient
+}) => {
+  const parameters = claimSecondaryRoyalties ? await handleAllRewards({
+    withdrawFor,
+    account,
+    rewardsGetter,
+    publicClient
+  }) : await handleProtocolRewardsOnly({
+    chainId: publicClient.chain.id,
+    withdrawFor,
+    account
+  });
+  return { parameters };
+};
 
 // src/rewards/rewards-client.ts
 var RewardsClient = class {
   constructor({
-    chainId,
     publicClient,
     rewardsGetter
   }) {
-    this.chainId = chainId;
     this.publicClient = publicClient;
     this.rewardsGetter = rewardsGetter;
   }
@@ -5740,83 +5892,24 @@ var RewardsClient = class {
     withdrawFor,
     claimSecondaryRoyalties
   }) {
-    return {
-      parameters: await withdrawRewards({
-        chainId: this.chainId,
-        rewardsGetter: this.rewardsGetter,
-        withdrawFor,
-        claimSecondaryRoyalties,
-        account
-      })
-    };
+    return await withdrawRewards({
+      rewardsGetter: this.rewardsGetter,
+      withdrawFor,
+      claimSecondaryRoyalties,
+      account,
+      publicClient: this.publicClient
+    });
   }
   /** Retrieves the rewards balances for a given account */
   async getRewardsBalances(params) {
-    return getRewardsBalance({
+    return getRewardsBalances({
       account: params.account,
-      chainId: this.chainId,
       publicClient: this.publicClient,
       rewardsGetter: this.rewardsGetter
     });
   }
 };
 
-// src/rewards/subgraph-queries.ts
-function buildCreatorERC20zs({
-  address
-}) {
-  return {
-    query: `
-    query ($address: Bytes!) {
-      zoraCreateTokens(
-        where: { royalties_: { royaltyRecipient: $address }, salesStrategies_: { type: "ZORA_TIMED" } }
-      ) {
-        royalties {
-          user
-        }
-        salesStrategies {
-          zoraTimedMinter {
-            secondaryActivated
-            erc20Z {
-              id
-            }
-          }
-        }
-      }
-    }
-    `,
-    variables: { address },
-    parseResponseData: (responseData) => {
-      return responseData?.zoraCreateTokens;
-    }
-  };
-}
-
-// src/rewards/subgraph-rewards-getter.ts
-var SubgraphRewardsGetter = class extends SubgraphGetter {
-  constructor(chainId, subgraphQuerier) {
-    super(chainId, subgraphQuerier);
-  }
-  async getErc20ZzForCreator({ address }) {
-    const queryResults = await this.querySubgraphWithRetries(
-      buildCreatorERC20zs({ address })
-    );
-    const results = (queryResults?.map((result) => {
-      const timedMinter = result.salesStrategies[0].zoraTimedMinter;
-      if (!timedMinter) {
-        return null;
-      }
-      return {
-        secondaryActivated: timedMinter.secondaryActivated,
-        erc20z: timedMinter.erc20Z.id
-      };
-    }) || []).filter(
-      (idAndActivated) => !!idAndActivated
-    );
-    return results;
-  }
-};
-
 // src/secondary/secondary-client.ts
 import { encodeAbiParameters as encodeAbiParameters2 } from "viem";
 import {
@@ -6005,7 +6098,8 @@ async function getPoolInfo({
   };
 }
 async function getUniswapQuote(input, client) {
-  const { type, quantity, poolAddress, chainId, erc20z } = input;
+  const { type, quantity, poolAddress, erc20z } = input;
+  const chainId = client.chain.id;
   const WETH = wethAddresses[chainId];
   const pool = await getPoolInfo({ poolAddress, WETH, erc20z, client });
   const { fee, wethBalance, erc20zBalance } = pool;
@@ -6076,10 +6170,10 @@ var MARKET_REWARD = parseEther5("0.0000222");
 async function getSecondaryInfo({
   contract,
   tokenId,
-  publicClient,
-  chainId
+  publicClient
 }) {
   let result;
+  const chainId = publicClient.chain.id;
   try {
     result = await publicClient.readContract({
       abi: zoraTimedSaleStrategyABI3,
@@ -6131,7 +6225,6 @@ async function makeBuy({
   quantity,
   account,
   recipient,
-  chainId,
   slippage,
   publicClient,
   comment
@@ -6152,7 +6245,7 @@ async function makeBuy({
     return handleBuyWithComment({
       accountAddress,
       recipient,
-      chainId,
+      chainId: publicClient.chain.id,
       quantity,
       contract,
       tokenId,
@@ -6167,7 +6260,7 @@ async function makeBuy({
     recipient,
     accountAddress,
     costWithSlippage,
-    chainId,
+    chainId: publicClient.chain.id,
     account
   });
 }
@@ -6251,12 +6344,11 @@ function handleBuyWithoutComment({
     })
   };
 }
-async function buyWithSlippage({
+async function buy1155OnSecondary({
   contract,
   tokenId,
   publicClient,
   quantity,
-  chainId,
   account,
   slippage = UNISWAP_SLIPPAGE,
   recipient,
@@ -6265,8 +6357,7 @@ async function buyWithSlippage({
   const secondaryInfo = await getSecondaryInfo({
     contract,
     tokenId,
-    publicClient,
-    chainId
+    publicClient
   });
   if (!secondaryInfo) {
     return makeError(ERROR_SECONDARY_NOT_CONFIGURED);
@@ -6280,8 +6371,7 @@ async function buyWithSlippage({
       type: "buy",
       quantity,
       poolAddress: pool,
-      erc20z,
-      chainId
+      erc20z
     },
     publicClient
   );
@@ -6294,7 +6384,6 @@ async function buyWithSlippage({
     quantity,
     account,
     recipient,
-    chainId,
     slippage,
     comment,
     publicClient
@@ -6312,7 +6401,6 @@ async function makeSell({
   quantity,
   account,
   recipient,
-  chainId,
   slippage,
   publicClient
 }) {
@@ -6337,6 +6425,7 @@ async function makeSell({
     receivedWithSlippage,
     0n
   ]);
+  const chainId = publicClient.chain.id;
   return {
     parameters: makeContractParameters({
       abi: zoraCreator1155ImplABI7,
@@ -6353,12 +6442,11 @@ async function makeSell({
     })
   };
 }
-async function sellWithSlippage({
+async function sell1155OnSecondary({
   contract,
   tokenId,
   publicClient,
   quantity,
-  chainId,
   account,
   slippage = UNISWAP_SLIPPAGE,
   recipient
@@ -6366,8 +6454,7 @@ async function sellWithSlippage({
   const secondaryInfo = await getSecondaryInfo({
     contract,
     tokenId,
-    publicClient,
-    chainId
+    publicClient
   });
   if (!secondaryInfo) {
     return makeError(ERROR_SECONDARY_NOT_CONFIGURED);
@@ -6377,7 +6464,7 @@ async function sellWithSlippage({
     return makeError(ERROR_SECONDARY_NOT_STARTED);
   }
   const { poolBalance, amount, price } = await getUniswapQuote(
-    { type: "sell", quantity, poolAddress: pool, chainId, erc20z },
+    { type: "sell", quantity, poolAddress: pool, erc20z },
     publicClient
   );
   const call = await makeSell({
@@ -6388,7 +6475,6 @@ async function sellWithSlippage({
     quantity,
     account,
     recipient,
-    chainId,
     slippage,
     publicClient
   });
@@ -6403,12 +6489,8 @@ var SecondaryClient = class {
    * @param publicClient - The public client for interacting with the blockchain.
    * @param chainId - The ID of the blockchain network.
    */
-  constructor({
-    publicClient,
-    chainId
-  }) {
+  constructor({ publicClient }) {
     this.publicClient = publicClient;
-    this.chainId = chainId;
   }
   /**
    * Get the secondary info for a given contract and token ID.
@@ -6423,8 +6505,7 @@ var SecondaryClient = class {
     return getSecondaryInfo({
       contract,
       tokenId,
-      publicClient: this.publicClient,
-      chainId: this.chainId
+      publicClient: this.publicClient
     });
   }
   /**
@@ -6433,10 +6514,9 @@ var SecondaryClient = class {
    * @returns A promise that resolves to the result of the buy operation, including price breakdown and transaction parameters.
    */
   async buy1155OnSecondary(input) {
-    return buyWithSlippage({
+    return buy1155OnSecondary({
       ...input,
-      publicClient: this.publicClient,
-      chainId: this.chainId
+      publicClient: this.publicClient
     });
   }
   /**
@@ -6445,10 +6525,9 @@ var SecondaryClient = class {
    * @returns A promise that resolves to the result of the sell operation, including price breakdown and transaction parameters.
    */
   async sell1155OnSecondary(input) {
-    return sellWithSlippage({
+    return sell1155OnSecondary({
       ...input,
-      publicClient: this.publicClient,
-      chainId: this.chainId
+      publicClient: this.publicClient
     });
   }
 };
@@ -6461,12 +6540,10 @@ function createCreatorClient(clientConfig) {
     premintApi: clientConfig.premintApi || new PremintAPIClient(clientConfig.chainId)
   });
   const create1155CreatorClient = new Create1155Client({
-    chainId: clientConfig.chainId,
     publicClient: clientConfig.publicClient,
     contractGetter: clientConfig.contractGetter || new SubgraphContractGetter(clientConfig.chainId)
   });
   const rewardsClient = new RewardsClient({
-    chainId: clientConfig.chainId,
     publicClient: clientConfig.publicClient,
     rewardsGetter: clientConfig.rewardsGetter || new SubgraphRewardsGetter(clientConfig.chainId)
   });
@@ -6486,12 +6563,10 @@ function createCollectorClient(params) {
   const mintClient = new MintClient({
     publicClient: params.publicClient,
     premintGetter: premintGetterToUse,
-    mintGetter: mintGetterToUse,
-    chainId: params.chainId
+    mintGetter: mintGetterToUse
   });
   const secondaryClient = new SecondaryClient({
-    publicClient: params.publicClient,
-    chainId: params.chainId
+    publicClient: params.publicClient
   });
   return {
     getPremint: (p) => premintGetterToUse.get({
@@ -7735,10 +7810,12 @@ export {
   PremintAPIClient,
   PremintClient,
   PremintConfigVersion3 as PremintConfigVersion,
+  SubgraphContractGetter,
   SubgraphMintGetter,
   ZORA_API_BASE,
   applyUpdateToPremint,
   buildPremintMintCall,
+  buy1155OnSecondary,
   collectPremint,
   collectPremintV2WithMintsParams,
   collectWithMintsParams,
@@ -7746,9 +7823,11 @@ export {
   convertGetPremintApiResponse,
   convertGetPremintOfCollectionApiResponse,
   convertPremintFromApi,
+  create1155,
   createAllowList,
   createCollectorClient,
   createCreatorClient,
+  createNew1155Token,
   decodeCallFailedError,
   defaultAdditionalAdmins,
   defaultTokenConfigV1MintArguments,
@@ -7757,8 +7836,8 @@ export {
   encodeCollectOnManager,
   encodePostSignatureInput,
   encodePremintForAPI,
+  findTargetStrategyWithPrimaryOrSecondarySaleActive,
   generateTextNftMetadataFiles,
-  getApiNetworkConfigForChain,
   getContractAddressFromReceipt,
   getDataFromPremintReceipt,
   getDefaultFixedPriceMinterAddress,
@@ -7771,31 +7850,46 @@ export {
   getPremintMintFee,
   getPremintPricePerToken,
   getPremintedLogFromReceipt,
+  getRewardsBalances,
+  getSecondaryInfo,
   getSignature,
+  getToken,
   getTokenIdFromCreateReceipt,
+  getTokensOfContract,
+  is1155Mint,
   isAuthorizedToCreatePremint,
+  isOnChainMint,
   isPremintConfigV1,
   isPremintConfigV2,
   isValidSignature,
   makeCreateContractAndTokenCall,
+  makeCreateTokenCall,
   makeMediaTokenMetadata,
   makeMintRewardsRecipient,
   makeNewPremint,
+  makeOnchainPrepareMintFromCreate,
   makePermitToCollectPremintOrNonPremint,
   makePermitTransferBatchAndTypeData,
   makePermitTransferTypeData,
   makeTextTokenMetadata,
   makeUrls,
   migratePremintConfigToV2,
+  mint,
   mintWithEthParams,
   mintsBalanceOfAccountParams,
+  new1155ContractVersion,
+  parseAndFilterTokenQueryResult,
+  prepareSetupActions,
   recoverCreatorFromCreatorAttribution,
   recoverPremintSigner,
   selectMintsToCollectWithFromQueryResult,
+  sell1155OnSecondary,
   sumBalances,
   supportedPremintVersions,
   supportsPremintVersion,
   toContractCreationConfigOrAddress,
-  tryRecoverPremintSigner
+  toMintableReturn,
+  tryRecoverPremintSigner,
+  withdrawRewards
 };
 //# sourceMappingURL=index.js.map