@zoralabs/protocol-sdk 0.3.3-prerelease.0 → 0.3.4

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/premint/premint-client.ts
-import { decodeEventLog } from "viem";
+import { createPublicClient, decodeEventLog, http } from "viem";
 import {
   zoraCreator1155PremintExecutorImplABI,
   zoraCreator1155PremintExecutorImplAddress,
@@ -124,6 +124,11 @@ var retries = async (tryFn, maxTries = 3, atTry = 1, linearBackoffMS = 200) => {
     throw err;
   }
 };
+var httpClient = {
+  get,
+  post,
+  retries
+};
 
 // src/constants.ts
 var ZORA_API_BASE = "https://api.zora.co/";
@@ -133,29 +138,6 @@ function getSubgraph(name, version) {
   return `${SUBGRAPH_CONFIG_BASE}/${name}/${version}/gn`;
 }
 
-// src/premint/premint-api-client.ts
-var postSignature = async (data) => retries(
-  () => post(`${ZORA_API_BASE}premint/signature`, data)
-);
-var getNextUID = async (path) => retries(
-  () => get(
-    `${ZORA_API_BASE}premint/signature/${path.chain_name}/${path.collection_address}/next_uid`
-  )
-);
-var getSignature = async (path) => retries(
-  () => get(
-    `${ZORA_API_BASE}premint/signature/${path.chain_name}/${path.collection_address}/${path.uid}`
-  )
-);
-var PremintAPIClient = {
-  postSignature,
-  getSignature,
-  getNextUID
-};
-
-// src/apis/client-base.ts
-import { createPublicClient, http } from "viem";
-
 // src/apis/chain-constants.ts
 import {
   base,
@@ -246,27 +228,125 @@ var networkConfigByChain = {
   }
 };
 
-// src/apis/client-base.ts
-var ClientBase = class {
-  constructor(chain) {
-    this.chain = chain;
-    const networkConfig = networkConfigByChain[chain.id];
-    if (!networkConfig) {
-      throw new Error(`Not configured for chain ${chain.id}`);
-    }
-    this.network = networkConfig;
+// src/mint/mint-api-client.ts
+function encodeQueryParameters(params) {
+  return new URLSearchParams(params).toString();
+}
+var getApiNetworkConfigForChain = (chainId) => {
+  if (!networkConfigByChain[chainId]) {
+    throw new Error(`chain id ${chainId} network not configured `);
   }
-  /**
-   * Getter for public client that instantiates a publicClient as needed
-   *
-   * @param publicClient Optional viem public client
-   * @returns Existing public client or makes a new one for the given chain as needed.
-   */
-  getPublicClient(publicClient) {
-    if (publicClient) {
-      return publicClient;
-    }
-    return createPublicClient({ chain: this.chain, transport: http() });
+  return networkConfigByChain[chainId];
+};
+var MintAPIClient = class {
+  constructor(chainId, httpClient2) {
+    this.httpClient = httpClient2 || httpClient;
+    this.networkConfig = getApiNetworkConfigForChain(chainId);
+  }
+  async getMintable(path, query) {
+    const httpClient2 = this.httpClient;
+    return httpClient2.retries(() => {
+      return httpClient2.get(
+        `${ZORA_API_BASE}discover/mintables/${path.chain_name}/${path.collection_address}${query?.token_id ? `?${encodeQueryParameters(query)}` : ""}`
+      );
+    });
+  }
+  async getSalesConfigFixedPrice({
+    contractAddress,
+    tokenId
+  }) {
+    const { retries: retries2, post: post2 } = this.httpClient;
+    return retries2(async () => {
+      const response = await post2(this.networkConfig.subgraphUrl, {
+        query: `query ($id: ID!) {
+          zoraCreateToken(id: $id) {
+            id
+            salesStrategies(where: {type: "FIXED_PRICE"}) {
+              type
+              fixedPrice {
+                address
+                pricePerToken
+                saleEnd
+                saleStart
+                maxTokensPerAddress
+              }
+            }
+          }
+        }`,
+        variables: {
+          id: `${contractAddress.toLowerCase()}-${tokenId.toString()}`
+        }
+      });
+      const fixedPrice = response.data?.zoraCreateToken?.salesStrategies?.find(() => true)?.fixedPrice;
+      return {
+        address: fixedPrice.address,
+        pricePerToken: BigInt(fixedPrice.pricePerToken)
+      };
+    });
+  }
+  async getMintableForToken({
+    tokenContract,
+    tokenId
+  }) {
+    return await this.getMintable(
+      {
+        chain_name: this.networkConfig.zoraBackendChainName,
+        collection_address: tokenContract
+      },
+      { token_id: tokenId?.toString() }
+    );
+  }
+};
+
+// src/premint/premint-api-client.ts
+var postSignature = async ({
+  httpClient: { post: post2, retries: retries2 } = httpClient,
+  ...data
+}) => retries2(
+  () => post2(`${ZORA_API_BASE}premint/signature`, data)
+);
+var getNextUID = async ({
+  chain_name,
+  collection_address,
+  httpClient: { retries: retries2, get: get2 } = httpClient
+}) => retries2(
+  () => get2(
+    `${ZORA_API_BASE}premint/signature/${chain_name}/${collection_address}/next_uid`
+  )
+);
+var getSignature = async ({
+  collection_address,
+  uid,
+  chain_name,
+  httpClient: { retries: retries2, get: get2 } = httpClient
+}) => retries2(
+  () => get2(
+    `${ZORA_API_BASE}premint/signature/${chain_name}/${collection_address}/${uid}`
+  )
+);
+var PremintAPIClient = class {
+  constructor(chainId, httpClient2) {
+    this.postSignature = async (data) => postSignature({
+      ...data,
+      chain_name: this.networkConfig.zoraBackendChainName,
+      httpClient: this.httpClient
+    });
+    this.getNextUID = async (path) => getNextUID({
+      ...path,
+      chain_name: this.networkConfig.zoraBackendChainName,
+      httpClient: this.httpClient
+    });
+    this.getSignature = async ({
+      collection_address,
+      uid
+    }) => getSignature({
+      collection_address,
+      uid,
+      chain_name: this.networkConfig.zoraBackendChainName,
+      httpClient: this.httpClient
+    });
+    this.httpClient = httpClient2 || httpClient;
+    this.networkConfig = getApiNetworkConfigForChain(chainId);
   }
 };
 
@@ -328,13 +408,11 @@ var encodePremintForAPI = ({
     maxTokensPerAddress: tokenConfig.maxTokensPerAddress.toString()
   }
 });
-var PremintClient = class extends ClientBase {
-  constructor(chain, apiClient) {
-    super(chain);
-    if (!apiClient) {
-      apiClient = PremintAPIClient;
-    }
-    this.apiClient = apiClient;
+var PremintClient = class {
+  constructor(chain, publicClient, httpClient2) {
+    this.chain = chain;
+    this.apiClient = new PremintAPIClient(chain.id, httpClient2);
+    this.publicClient = publicClient || createPublicClient({ chain, transport: http() });
   }
   /**
    * The premint executor address is deployed to the same address across all chains.
@@ -391,7 +469,6 @@ var PremintClient = class extends ClientBase {
     account
   }) {
     const signatureResponse = await this.apiClient.getSignature({
-      chain_name: this.network.zoraBackendChainName,
       collection_address: collection.toLowerCase(),
       uid
     });
@@ -411,7 +488,6 @@ var PremintClient = class extends ClientBase {
       account,
       checkSignature: false,
       verifyingContract: collection,
-      publicClient: this.getPublicClient(),
       uid,
       collection: {
         ...signerData.collection,
@@ -438,11 +514,9 @@ var PremintClient = class extends ClientBase {
     walletClient,
     uid,
     account,
-    collection,
-    publicClient
+    collection
   }) {
     const signatureResponse = await this.apiClient.getSignature({
-      chain_name: this.network.zoraBackendChainName,
       collection_address: collection.toLowerCase(),
       uid
     });
@@ -459,7 +533,6 @@ var PremintClient = class extends ClientBase {
       account,
       checkSignature: false,
       verifyingContract: collection,
-      publicClient: this.getPublicClient(publicClient),
       uid,
       collection: signerData.collection,
       premintConfig: signerData.premint
@@ -473,7 +546,6 @@ var PremintClient = class extends ClientBase {
    */
   async signAndSubmitPremint({
     walletClient,
-    publicClient,
     verifyingContract,
     premintConfig,
     uid,
@@ -496,7 +568,7 @@ var PremintClient = class extends ClientBase {
       })
     });
     if (checkSignature) {
-      const [isValidSignature] = await publicClient.readContract({
+      const [isValidSignature] = await this.publicClient.readContract({
         abi: zoraCreator1155PremintExecutorImplABI,
         address: this.getExecutorAddress(),
         functionName: "isValidSignature",
@@ -509,7 +581,6 @@ var PremintClient = class extends ClientBase {
     const apiData = {
       collection,
       premint: encodePremintForAPI(premintConfig),
-      chain_name: this.network.zoraBackendChainName,
       signature
     };
     const premint = await this.apiClient.postSignature(apiData);
@@ -539,13 +610,11 @@ var PremintClient = class extends ClientBase {
     account,
     collection,
     token,
-    publicClient,
     walletClient,
     executionSettings,
     checkSignature = false
   }) {
-    publicClient = this.getPublicClient(publicClient);
-    const newContractAddress = await publicClient.readContract({
+    const newContractAddress = await this.publicClient.readContract({
       address: this.getExecutorAddress(),
       abi: zoraCreator1155PremintExecutorImplABI,
       functionName: "getContractAddress",
@@ -560,7 +629,6 @@ var PremintClient = class extends ClientBase {
     let uid = executionSettings?.uid;
     if (!uid) {
       const uidResponse = await this.apiClient.getNextUID({
-        chain_name: this.network.zoraBackendChainName,
         collection_address: newContractAddress.toLowerCase()
       });
       uid = uidResponse.next_uid;
@@ -581,7 +649,6 @@ var PremintClient = class extends ClientBase {
       premintConfig,
       checkSignature,
       account,
-      publicClient,
       walletClient,
       collection
     });
@@ -598,7 +665,6 @@ var PremintClient = class extends ClientBase {
     uid
   }) {
     return await this.apiClient.getSignature({
-      chain_name: this.network.zoraBackendChainName,
       collection_address: address,
       uid
     });
@@ -610,11 +676,9 @@ var PremintClient = class extends ClientBase {
    * @returns isValid = signature is valid or not, contractAddress = assumed contract address, recoveredSigner = signer from contract
    */
   async isValidSignature({
-    data,
-    publicClient
+    data
   }) {
-    publicClient = this.getPublicClient(publicClient);
-    const [isValid, contractAddress, recoveredSigner] = await publicClient.readContract({
+    const [isValid, contractAddress, recoveredSigner] = await this.publicClient.readContract({
       abi: zoraCreator1155PremintExecutorImplABI,
       address: this.getExecutorAddress(),
       functionName: "isValidSignature",
@@ -635,10 +699,11 @@ var PremintClient = class extends ClientBase {
       return { explorer: null, zoraCollect: null, zoraManage: null };
     }
     const zoraTokenPath = uid ? `premint-${uid}` : tokenId;
+    const network = getApiNetworkConfigForChain(this.chain.id);
     return {
       explorer: tokenId ? `https://${this.chain.blockExplorers?.default.url}/token/${address}/instance/${tokenId}` : null,
-      zoraCollect: `https://${this.network.isTestnet ? "testnet." : ""}zora.co/collect/${this.network.zoraPathChainName}:${address}/${zoraTokenPath}`,
-      zoraManage: `https://${this.network.isTestnet ? "testnet." : ""}zora.co/collect/${this.network.zoraPathChainName}:${address}/${zoraTokenPath}`
+      zoraCollect: `https://${network.isTestnet ? "testnet." : ""}zora.co/collect/${network.zoraPathChainName}:${address}/${zoraTokenPath}`,
+      zoraManage: `https://${network.isTestnet ? "testnet." : ""}zora.co/collect/${network.zoraPathChainName}:${address}/${zoraTokenPath}`
     };
   }
   /**
@@ -653,7 +718,7 @@ var PremintClient = class extends ClientBase {
    * @param settings.publicClient Optional public client for preflight checks.
    * @returns receipt, log, zoraURL
    */
-  async executePremint({
+  async makeMintParameters({
     data,
     account,
     mintArguments
@@ -682,49 +747,25 @@ var PremintClient = class extends ClientBase {
       address: targetAddress,
       args
     };
-    return {
-      request
-    };
+    return request;
   }
 };
 function createPremintClient({
   chain,
-  premintAPIClient
+  httpClient: httpClient2,
+  publicClient
 }) {
-  return new PremintClient(chain, premintAPIClient);
+  return new PremintClient(chain, publicClient, httpClient2);
 }
 
-// src/mint/mint-api-client.ts
-function encodeQueryParameters(params) {
-  return new URLSearchParams(params).toString();
-}
-var getMintable = async (path, query) => retries(() => {
-  return get(
-    `${ZORA_API_BASE}discover/mintables/${path.chain_name}/${path.collection_address}${query?.token_id ? `?${encodeQueryParameters(query)}` : ""}`
-  );
-});
-var getSalesConfigFixedPrice = async ({
-  contractAddress,
-  tokenId,
-  subgraphUrl
-}) => retries(async () => {
-  const response = await post(subgraphUrl, {
-    query: "query($id: ID!) {\n  zoraCreateToken(id: $id) {\n    id\n    salesStrategies{\n      fixedPrice {\n        address\n      }\n    }\n  }\n}",
-    variables: { id: `${contractAddress.toLowerCase()}-${tokenId}` }
-  });
-  return response.zoraCreateToken?.salesStrategies?.find(() => true)?.fixedPriceMinterAddress;
-});
-var MintAPIClient = {
-  getMintable,
-  getSalesConfigFixedPrice
-};
-
 // src/mint/mint-client.ts
 import {
+  createPublicClient as createPublicClient2,
   encodeAbiParameters,
   parseAbi,
   parseAbiParameters,
-  zeroAddress
+  zeroAddress,
+  http as http2
 } from "viem";
 import {
   zoraCreator1155ImplABI,
@@ -742,145 +783,248 @@ var zora721Abi = parseAbi([
   "function mintWithRewards(address recipient, uint256 quantity, string calldata comment, address mintReferral) external payable",
   "function zoraFeeForAmount(uint256 amount) public view returns (address, uint256)"
 ]);
-var MintClient = class extends ClientBase {
-  constructor(chain, apiClient) {
-    super(chain);
-    if (!apiClient) {
-      apiClient = MintAPIClient;
-    }
-    this.apiClient = apiClient;
+var MintClient = class {
+  constructor(chain, publicClient, httpClient2) {
+    this.apiClient = new MintAPIClient(chain.id, httpClient2);
+    this.publicClient = publicClient || createPublicClient2({ chain, transport: http2() });
   }
+  /**
+   * Gets mintable information for a given token
+   * @param param0.tokenContract The contract address of the token to mint.
+   * @param param0.tokenId The token id to mint.
+   * @returns
+   */
   async getMintable({
     tokenContract,
     tokenId
   }) {
-    return this.apiClient.getMintable(
-      {
-        chain_name: this.network.zoraBackendChainName,
-        collection_address: tokenContract
-      },
-      { token_id: tokenId?.toString() }
-    );
+    return await this.apiClient.getMintableForToken({
+      tokenContract,
+      tokenId: tokenId?.toString()
+    });
   }
+  /**
+   * Returns the parameters needed to prepare a transaction mint a token.
+   * @param param0.minterAccount The account that will mint the token.
+   * @param param0.mintable The mintable token to mint.
+   * @param param0.mintArguments The arguments for the mint (mint recipient, comment, mint referral, quantity to mint)
+   * @returns
+   */
   async makePrepareMintTokenParams({
-    publicClient,
-    minterAccount,
+    ...rest
+  }) {
+    return makePrepareMintTokenParams({
+      ...rest,
+      apiClient: this.apiClient,
+      publicClient: this.publicClient
+    });
+  }
+  /**
+   * Returns the mintFee, sale fee, and total cost of minting x quantities of a token.
+   * @param param0.mintable The mintable token to mint.
+   * @param param0.quantityToMint The quantity of tokens to mint.
+   * @returns
+   */
+  async getMintCosts({
     mintable,
-    mintArguments
+    quantityToMint
   }) {
-    if (!mintable) {
-      throw new MintError("No mintable found");
-    }
-    if (!mintable.is_active) {
-      throw new MintInactiveError("Minting token is inactive");
-    }
-    if (!mintable.mint_context) {
-      throw new MintError("No minting context data from zora API");
-    }
-    if (!["zora_create", "zora_create_1155"].includes(
-      mintable.mint_context?.mint_context_type
-    )) {
-      throw new MintError(
-        `Mintable type ${mintable.mint_context.mint_context_type} is currently unsupported.`
-      );
-    }
-    const thisPublicClient = this.getPublicClient(publicClient);
-    if (mintable.mint_context.mint_context_type === "zora_create_1155") {
-      return {
-        simulateContractParameters: await this.prepareMintZora1155({
-          publicClient: thisPublicClient,
-          mintArguments,
-          sender: minterAccount,
-          mintable
-        })
-      };
+    const mintContextType = validateMintableAndGetContextType(mintable);
+    if (mintContextType === "zora_create_1155") {
+      return await get1155MintCosts({
+        mintable,
+        price: BigInt(mintable.cost.native_price.raw),
+        publicClient: this.publicClient,
+        quantityToMint: BigInt(quantityToMint)
+      });
     }
-    if (mintable.mint_context.mint_context_type === "zora_create") {
-      return {
-        simulateContractParameters: await this.prepareMintZora721({
-          publicClient: thisPublicClient,
-          mintArguments,
-          sender: minterAccount,
-          mintable
-        })
-      };
+    if (mintContextType === "zora_create") {
+      return await get721MintCosts({
+        mintable,
+        publicClient: this.publicClient,
+        quantityToMint: BigInt(quantityToMint)
+      });
     }
-    throw new Error("Mintable type not found or recognized.");
+    throw new MintError(
+      `Mintable type ${mintContextType} is currently unsupported.`
+    );
   }
-  async prepareMintZora1155({
+};
+function createMintClient({
+  chain,
+  publicClient,
+  httpClient: httpClient2
+}) {
+  return new MintClient(chain, publicClient, httpClient2);
+}
+function validateMintableAndGetContextType(mintable) {
+  if (!mintable) {
+    throw new MintError("No mintable found");
+  }
+  if (!mintable.is_active) {
+    throw new MintInactiveError("Minting token is inactive");
+  }
+  if (!mintable.mint_context) {
+    throw new MintError("No minting context data from zora API");
+  }
+  if (!["zora_create", "zora_create_1155"].includes(
+    mintable.mint_context?.mint_context_type
+  )) {
+    throw new MintError(
+      `Mintable type ${mintable.mint_context.mint_context_type} is currently unsupported.`
+    );
+  }
+  return mintable.mint_context.mint_context_type;
+}
+async function makePrepareMintTokenParams({
+  publicClient,
+  mintable,
+  apiClient,
+  ...rest
+}) {
+  const mintContextType = validateMintableAndGetContextType(mintable);
+  const thisPublicClient = publicClient;
+  if (mintContextType === "zora_create_1155") {
+    return makePrepareMint1155TokenParams({
+      apiClient,
+      publicClient: thisPublicClient,
+      mintable,
+      mintContextType,
+      ...rest
+    });
+  }
+  if (mintContextType === "zora_create") {
+    return makePrepareMint721TokenParams({
+      publicClient: thisPublicClient,
+      mintable,
+      mintContextType,
+      ...rest
+    });
+  }
+  throw new MintError(
+    `Mintable type ${mintContextType} is currently unsupported.`
+  );
+}
+async function get721MintCosts({
+  mintable,
+  publicClient,
+  quantityToMint
+}) {
+  const address = mintable.collection.address;
+  const [_, mintFee] = await publicClient.readContract({
+    abi: zora721Abi,
+    address,
+    functionName: "zoraFeeForAmount",
+    args: [BigInt(quantityToMint)]
+  });
+  const tokenPurchaseCost = BigInt(mintable.cost.native_price.raw) * quantityToMint;
+  return {
+    mintFee,
+    tokenPurchaseCost,
+    totalCost: mintFee + tokenPurchaseCost
+  };
+}
+async function makePrepareMint721TokenParams({
+  publicClient,
+  minterAccount,
+  mintable,
+  mintContextType,
+  mintArguments
+}) {
+  if (mintContextType !== "zora_create") {
+    throw new Error("Minted token type must be for 1155");
+  }
+  const mintValue = (await get721MintCosts({
     mintable,
-    sender,
     publicClient,
-    mintArguments
-  }) {
-    const mintQuantity = BigInt(mintArguments.quantityToMint);
-    const address = mintable.collection.address;
-    const mintFee = await publicClient.readContract({
-      abi: zoraCreator1155ImplABI,
-      functionName: "mintFee",
-      address
-    });
-    const tokenFixedPriceMinter = await this.apiClient.getSalesConfigFixedPrice(
-      {
-        contractAddress: mintable.contract_address,
-        tokenId: mintable.token_id,
-        subgraphUrl: this.network.subgraphUrl
-      }
-    );
-    const result = {
-      abi: zoraCreator1155ImplABI,
-      functionName: "mintWithRewards",
-      account: sender,
-      value: (mintFee + BigInt(mintable.cost.native_price.raw)) * mintQuantity,
-      address,
-      /* args: minter, tokenId, quantity, minterArguments, mintReferral */
-      args: [
-        tokenFixedPriceMinter || zoraCreatorFixedPriceSaleStrategyAddress2[999],
-        BigInt(mintable.token_id),
-        mintQuantity,
-        encodeAbiParameters(parseAbiParameters("address, string"), [
-          mintArguments.mintToAddress,
-          mintArguments.mintComment || ""
-        ]),
-        mintArguments.mintReferral || zeroAddress
-      ]
-    };
-    return result;
+    quantityToMint: BigInt(mintArguments.quantityToMint)
+  })).totalCost;
+  const result = {
+    abi: zora721Abi,
+    address: mintable.contract_address,
+    account: minterAccount,
+    functionName: "mintWithRewards",
+    value: mintValue,
+    args: [
+      mintArguments.mintToAddress,
+      BigInt(mintArguments.quantityToMint),
+      mintArguments.mintComment || "",
+      mintArguments.mintReferral || zeroAddress
+    ]
+  };
+  return result;
+}
+async function get1155MintFee({
+  collectionAddress,
+  publicClient
+}) {
+  return await publicClient.readContract({
+    abi: zoraCreator1155ImplABI,
+    functionName: "mintFee",
+    address: collectionAddress
+  });
+}
+async function get1155MintCosts({
+  mintable,
+  price,
+  publicClient,
+  quantityToMint
+}) {
+  const address = mintable.collection.address;
+  const mintFee = await get1155MintFee({
+    collectionAddress: address,
+    publicClient
+  });
+  const mintFeeForTokens = mintFee * quantityToMint;
+  const tokenPurchaseCost = price * quantityToMint;
+  return {
+    mintFee: mintFeeForTokens,
+    tokenPurchaseCost,
+    totalCost: mintFeeForTokens + tokenPurchaseCost
+  };
+}
+async function makePrepareMint1155TokenParams({
+  apiClient,
+  publicClient,
+  minterAccount,
+  mintable,
+  mintContextType,
+  mintArguments
+}) {
+  if (mintContextType !== "zora_create_1155") {
+    throw new Error("Minted token type must be for 1155");
   }
-  async prepareMintZora721({
+  const mintQuantity = BigInt(mintArguments.quantityToMint);
+  const address = mintable.collection.address;
+  const tokenFixedPriceMinter = await apiClient.getSalesConfigFixedPrice({
+    contractAddress: address,
+    tokenId: BigInt(mintable.token_id)
+  });
+  const mintValue = (await get1155MintCosts({
     mintable,
+    price: tokenFixedPriceMinter?.pricePerToken || BigInt(mintable.cost.native_price.raw),
     publicClient,
-    sender,
-    mintArguments
-  }) {
-    const [_, mintFee] = await publicClient.readContract({
-      abi: zora721Abi,
-      address: mintable.contract_address,
-      functionName: "zoraFeeForAmount",
-      args: [BigInt(mintArguments.quantityToMint)]
-    });
-    const result = {
-      abi: zora721Abi,
-      address: mintable.contract_address,
-      account: sender,
-      functionName: "mintWithRewards",
-      value: mintFee + BigInt(mintable.cost.native_price.raw) * BigInt(mintArguments.quantityToMint),
-      /* args: mint recipient, quantity to mint, mint comment, mintReferral */
-      args: [
+    quantityToMint: mintQuantity
+  })).totalCost;
+  const result = {
+    abi: zoraCreator1155ImplABI,
+    functionName: "mintWithRewards",
+    account: minterAccount,
+    value: mintValue,
+    address,
+    /* args: minter, tokenId, quantity, minterArguments, mintReferral */
+    args: [
+      tokenFixedPriceMinter?.address || zoraCreatorFixedPriceSaleStrategyAddress2[999],
+      BigInt(mintable.token_id),
+      mintQuantity,
+      encodeAbiParameters(parseAbiParameters("address, string"), [
         mintArguments.mintToAddress,
-        BigInt(mintArguments.quantityToMint),
-        mintArguments.mintComment || "",
-        mintArguments.mintReferral || zeroAddress
-      ]
-    };
-    return result;
-  }
-};
-function createMintClient({
-  chain,
-  mintAPIClient
-}) {
-  return new MintClient(chain, mintAPIClient);
+        mintArguments.mintComment || ""
+      ]),
+      mintArguments.mintReferral || zeroAddress
+    ]
+  };
+  return result;
 }
 
 // src/create/1155-create-helper.ts
@@ -904,7 +1048,7 @@ var DEFAULT_SALE_SETTINGS = {
   // 0 Here means no limit
   maxTokensPerAddress: 0n
 };
-var PERMISSION_BIT_MINTER = 2n ** 2n;
+var PERMISSION_BIT_MINTER = 4n;
 function create1155TokenSetupArgs({
   nextTokenId,
   // How many NFTs upon initialization to mint to the creator
@@ -1148,8 +1292,9 @@ export {
   createMintClient,
   createPremintClient,
   encodePremintForAPI,
+  get1155MintCosts,
+  getApiNetworkConfigForChain,
   getPremintedLogFromReceipt,
-  getSalesConfigFixedPrice,
   getTokenIdFromCreateReceipt,
   preminterTypedDataDefinition
 };