@0xsequence/marketplace-sdk 0.5.0 → 0.5.2

package/dist/{chunk-HV2X2VZN.js → chunk-I37CRQ4S.js}

@@ -77,78 +77,14 @@ import {
 } from "./chunk-WM4RGBFQ.js";
 
 // src/react/hooks/useAutoSelectFeeOption.tsx
-import { useAccount, useConfig } from "wagmi";
-import { getBalance } from "wagmi/actions";
+import { zeroAddress } from "viem";
+import { useAccount } from "wagmi";
 import { useCallback } from "react";
-function useAutoSelectFeeOption({
-  pendingFeeOptionConfirmation
-}) {
-  const { address: userAddress } = useAccount();
-  const config = useConfig();
-  const findAffordableOption = useCallback(async () => {
-    if (!userAddress) {
-      return {
-        selectedOption: null,
-        error: "User not connected",
-        isLoading: false
-      };
-    }
-    if (!pendingFeeOptionConfirmation.options) {
-      return {
-        selectedOption: null,
-        error: "No options provided",
-        isLoading: false
-      };
-    }
-    try {
-      for (const option of pendingFeeOptionConfirmation.options) {
-        if (!option.token.contractAddress) continue;
-        try {
-          const balance = await getBalance(config, {
-            address: userAddress,
-            token: option.token.contractAddress,
-            chainId: pendingFeeOptionConfirmation.chainId
-          });
-          const optionValue = BigInt(option.value);
-          if (balance.value >= optionValue) {
-            return {
-              selectedOption: option,
-              error: null,
-              isLoading: false
-            };
-          }
-        } catch (error) {
-          console.error(
-            "Error fetching balance for currency:",
-            option.token.contractAddress,
-            error
-          );
-        }
-      }
-      return {
-        selectedOption: null,
-        error: "Insufficient balance for any fee option",
-        isLoading: false
-      };
-    } catch (error) {
-      return {
-        selectedOption: null,
-        error: "Failed to check balances",
-        isLoading: false
-      };
-    }
-  }, [
-    pendingFeeOptionConfirmation.options,
-    pendingFeeOptionConfirmation.chainId,
-    userAddress,
-    config
-  ]);
-  return findAffordableOption();
-}
+import { useChain } from "@0xsequence/kit";
 
-// src/react/hooks/useBalanceOfCollectible.tsx
-import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
+// src/react/hooks/useCollectionBalanceDetails.tsx
 import { z } from "zod";
+import { queryOptions, useQuery } from "@tanstack/react-query";
 
 // src/react/hooks/useConfig.tsx
 import { useContext } from "react";
@@ -197,7 +133,7 @@ function MarketplaceProvider({
 }
 
 // src/react/hooks/useConfig.tsx
-function useConfig2() {
+function useConfig() {
   const context = useContext(MarketplaceSdkContext);
   if (!context) {
     throw new MarketplaceSdkProviderNotFoundError();
@@ -205,12 +141,157 @@ function useConfig2() {
   return context;
 }
 
+// src/react/hooks/useCollectionBalanceDetails.tsx
+var filterSchema = z.object({
+  accountAddresses: z.array(AddressSchema),
+  contractWhitelist: z.array(AddressSchema).optional(),
+  omitNativeBalances: z.boolean()
+});
+var useCollectionBalanceDetailsArgsSchema = z.object({
+  chainId: ChainIdSchema.pipe(z.coerce.number()),
+  filter: filterSchema,
+  query: QueryArgSchema.optional()
+});
+var fetchCollectionBalanceDetails = async (args, indexerClient) => {
+  const promises = args.filter.accountAddresses.map(
+    (accountAddress) => indexerClient.getTokenBalancesDetails({
+      filter: {
+        accountAddresses: [accountAddress],
+        contractWhitelist: args.filter.contractWhitelist,
+        omitNativeBalances: args.filter.omitNativeBalances
+      }
+    })
+  );
+  const responses = await Promise.all(promises);
+  const mergedResponse = responses.reduce(
+    (acc, curr) => {
+      if (!curr) return acc;
+      return {
+        page: curr.page,
+        nativeBalances: [
+          ...acc.nativeBalances || [],
+          ...curr.nativeBalances || []
+        ],
+        balances: [...acc.balances || [], ...curr.balances || []]
+      };
+    },
+    { page: {}, nativeBalances: [], balances: [] }
+  );
+  if (!mergedResponse) {
+    throw new Error("Failed to fetch collection balance details");
+  }
+  return mergedResponse;
+};
+var collectionBalanceDetailsOptions = (args, config) => {
+  const parsedArgs = useCollectionBalanceDetailsArgsSchema.parse(args);
+  const indexerClient = getIndexerClient(parsedArgs.chainId, config);
+  return queryOptions({
+    queryKey: [...balanceQueries.collectionBalanceDetails, args, config],
+    queryFn: () => fetchCollectionBalanceDetails(parsedArgs, indexerClient),
+    ...args.query
+  });
+};
+var useCollectionBalanceDetails = (args) => {
+  const config = useConfig();
+  return useQuery(collectionBalanceDetailsOptions(args, config));
+};
+
+// src/react/hooks/useAutoSelectFeeOption.tsx
+function useAutoSelectFeeOption({
+  pendingFeeOptionConfirmation
+}) {
+  const { address: userAddress } = useAccount();
+  const contractWhitelist = pendingFeeOptionConfirmation.options?.map(
+    (option) => option.token.contractAddress === null ? zeroAddress : option.token.contractAddress
+  );
+  const {
+    data: balanceDetails,
+    isLoading: isBalanceDetailsLoading,
+    isError: isBalanceDetailsError
+  } = useCollectionBalanceDetails({
+    chainId: pendingFeeOptionConfirmation.chainId,
+    filter: {
+      accountAddresses: userAddress ? [userAddress] : [],
+      contractWhitelist,
+      omitNativeBalances: false
+    },
+    query: {
+      enabled: !!pendingFeeOptionConfirmation.options && !!userAddress
+    }
+  });
+  const chain = useChain(pendingFeeOptionConfirmation.chainId);
+  const combinedBalances = balanceDetails && [
+    ...balanceDetails.nativeBalances.map((b) => ({
+      chainId: pendingFeeOptionConfirmation.chainId,
+      balance: b.balance,
+      symbol: chain?.nativeCurrency.symbol,
+      contractAddress: zeroAddress
+    })),
+    ...balanceDetails.balances.map((b) => ({
+      chainId: b.chainId,
+      balance: b.balance,
+      symbol: b.contractInfo?.symbol,
+      contractAddress: b.contractAddress
+    }))
+  ];
+  console.debug("currency balances", combinedBalances);
+  const autoSelectedOption = useCallback(async () => {
+    if (!userAddress) {
+      return {
+        selectedOption: null,
+        error: "User not connected" /* UserNotConnected */
+      };
+    }
+    if (!pendingFeeOptionConfirmation.options) {
+      return {
+        selectedOption: null,
+        error: "No options provided" /* NoOptionsProvided */
+      };
+    }
+    if (isBalanceDetailsLoading) {
+      return { selectedOption: null, error: null, isLoading: true };
+    }
+    if (isBalanceDetailsError || !combinedBalances) {
+      return {
+        selectedOption: null,
+        error: "Failed to check balances" /* FailedToCheckBalances */
+      };
+    }
+    const selectedOption = pendingFeeOptionConfirmation.options.find(
+      (option) => {
+        const tokenBalance = combinedBalances.find(
+          (balance) => balance.contractAddress.toLowerCase() === (option.token.contractAddress === null ? zeroAddress : option.token.contractAddress).toLowerCase()
+        );
+        if (!tokenBalance) return false;
+        return BigInt(tokenBalance.balance) >= BigInt(option.value);
+      }
+    );
+    if (!selectedOption) {
+      return {
+        selectedOption: null,
+        error: "Insufficient balance for any fee option" /* InsufficientBalanceForAnyFeeOption */
+      };
+    }
+    console.debug("auto selected option", selectedOption);
+    return { selectedOption, error: null };
+  }, [
+    userAddress,
+    pendingFeeOptionConfirmation.options,
+    isBalanceDetailsLoading,
+    isBalanceDetailsError,
+    combinedBalances
+  ]);
+  return autoSelectedOption();
+}
+
 // src/react/hooks/useBalanceOfCollectible.tsx
-var fetchBalanceOfCollectibleSchema = z.object({
+import { queryOptions as queryOptions2, skipToken, useQuery as useQuery2 } from "@tanstack/react-query";
+import { z as z2 } from "zod";
+var fetchBalanceOfCollectibleSchema = z2.object({
   collectionAddress: AddressSchema,
-  collectableId: CollectableIdSchema.pipe(z.coerce.string()),
+  collectableId: CollectableIdSchema.pipe(z2.coerce.string()),
   userAddress: AddressSchema,
-  chainId: ChainIdSchema.pipe(z.coerce.number())
+  chainId: ChainIdSchema.pipe(z2.coerce.number())
 });
 var fetchBalanceOfCollectible = async (args, config) => {
   const parsedArgs = fetchBalanceOfCollectibleSchema.parse(args);
@@ -228,7 +309,7 @@ var fetchBalanceOfCollectible = async (args, config) => {
 };
 var balanceOfCollectibleOptions = (args, config) => {
   const enabled = !!args.userAddress && (args.query?.enabled ?? true);
-  return queryOptions({
+  return queryOptions2({
     ...args.query,
     queryKey: [...collectableKeys.userBalances, args],
     queryFn: enabled ? () => fetchBalanceOfCollectible(
@@ -243,574 +324,574 @@ var balanceOfCollectibleOptions = (args, config) => {
   });
 };
 var useBalanceOfCollectible = (args) => {
-  const config = useConfig2();
-  return useQuery(balanceOfCollectibleOptions(args, config));
+  const config = useConfig();
+  return useQuery2(balanceOfCollectibleOptions(args, config));
 };
 
 // src/react/hooks/useCountOfCollectables.tsx
-import { queryOptions as queryOptions2, useQuery as useQuery2 } from "@tanstack/react-query";
-import { z as z3 } from "zod";
+import { queryOptions as queryOptions3, useQuery as useQuery3 } from "@tanstack/react-query";
+import { z as z4 } from "zod";
 
 // src/react/_internal/api/zod-schema.ts
-import { z as z2 } from "zod";
-var assetSchema = z2.object({
-  id: z2.number(),
-  collectionId: z2.number(),
-  tokenId: z2.string(),
-  url: z2.string().optional(),
-  metadataField: z2.string(),
-  name: z2.string().optional(),
-  filesize: z2.number().optional(),
-  mimeType: z2.string().optional(),
-  width: z2.number().optional(),
-  height: z2.number().optional(),
-  updatedAt: z2.string().optional()
-});
-var sortOrderSchema = z2.nativeEnum(SortOrder);
-var propertyTypeSchema = z2.nativeEnum(PropertyType);
-var marketplaceKindSchema = z2.nativeEnum(MarketplaceKind);
-var orderbookKindSchema = z2.nativeEnum(OrderbookKind);
-var sourceKindSchema = z2.nativeEnum(SourceKind);
-var orderSideSchema = z2.nativeEnum(OrderSide);
-var orderStatusSchema = z2.nativeEnum(OrderStatus);
-var contractTypeSchema = z2.nativeEnum(ContractType);
-var collectionStatusSchema = z2.nativeEnum(CollectionStatus);
-var projectStatusSchema = z2.nativeEnum(ProjectStatus);
-var collectibleStatusSchema = z2.nativeEnum(CollectibleStatus);
-var walletKindSchema = z2.nativeEnum(WalletKind);
-var stepTypeSchema = z2.nativeEnum(StepType);
-var transactionCryptoSchema = z2.nativeEnum(TransactionCrypto);
-var transactionNFTCheckoutProviderSchema = z2.nativeEnum(
+import { z as z3 } from "zod";
+var assetSchema = z3.object({
+  id: z3.number(),
+  collectionId: z3.number(),
+  tokenId: z3.string(),
+  url: z3.string().optional(),
+  metadataField: z3.string(),
+  name: z3.string().optional(),
+  filesize: z3.number().optional(),
+  mimeType: z3.string().optional(),
+  width: z3.number().optional(),
+  height: z3.number().optional(),
+  updatedAt: z3.string().optional()
+});
+var sortOrderSchema = z3.nativeEnum(SortOrder);
+var propertyTypeSchema = z3.nativeEnum(PropertyType);
+var marketplaceKindSchema = z3.nativeEnum(MarketplaceKind);
+var orderbookKindSchema = z3.nativeEnum(OrderbookKind);
+var sourceKindSchema = z3.nativeEnum(SourceKind);
+var orderSideSchema = z3.nativeEnum(OrderSide);
+var orderStatusSchema = z3.nativeEnum(OrderStatus);
+var contractTypeSchema = z3.nativeEnum(ContractType);
+var collectionStatusSchema = z3.nativeEnum(CollectionStatus);
+var projectStatusSchema = z3.nativeEnum(ProjectStatus);
+var collectibleStatusSchema = z3.nativeEnum(CollectibleStatus);
+var walletKindSchema = z3.nativeEnum(WalletKind);
+var stepTypeSchema = z3.nativeEnum(StepType);
+var transactionCryptoSchema = z3.nativeEnum(TransactionCrypto);
+var transactionNFTCheckoutProviderSchema = z3.nativeEnum(
   TransactionNFTCheckoutProvider
 );
-var transactionOnRampProviderSchema = z2.nativeEnum(
+var transactionOnRampProviderSchema = z3.nativeEnum(
   TransactionOnRampProvider
 );
-var transactionSwapProviderSchema = z2.nativeEnum(
+var transactionSwapProviderSchema = z3.nativeEnum(
   TransactionSwapProvider
 );
-var executeTypeSchema = z2.nativeEnum(ExecuteType);
-var sortBySchema = z2.object({
-  column: z2.string(),
+var executeTypeSchema = z3.nativeEnum(ExecuteType);
+var sortBySchema = z3.object({
+  column: z3.string(),
   order: sortOrderSchema
 });
-var propertyFilterSchema = z2.object({
-  name: z2.string(),
+var propertyFilterSchema = z3.object({
+  name: z3.string(),
   type: propertyTypeSchema,
-  min: z2.number().optional(),
-  max: z2.number().optional(),
-  values: z2.array(z2.any()).optional()
-});
-var collectiblesFilterSchema = z2.object({
-  includeEmpty: z2.boolean(),
-  searchText: z2.string().optional(),
-  properties: z2.array(propertyFilterSchema).optional(),
-  marketplaces: z2.array(marketplaceKindSchema).optional(),
-  inAccounts: z2.array(z2.string()).optional(),
-  notInAccounts: z2.array(z2.string()).optional(),
-  ordersCreatedBy: z2.array(z2.string()).optional(),
-  ordersNotCreatedBy: z2.array(z2.string()).optional()
-});
-var feeBreakdownSchema = z2.object({
-  kind: z2.string(),
-  recipientAddress: z2.string(),
-  bps: z2.number()
-});
-var orderFilterSchema = z2.object({
-  createdBy: z2.array(z2.string()).optional(),
-  marketplace: z2.array(marketplaceKindSchema).optional(),
-  currencies: z2.array(z2.string()).optional()
-});
-var collectionLastSyncedSchema = z2.object({
-  allOrders: z2.string(),
-  newOrders: z2.string()
-});
-var projectSchema = z2.object({
-  projectId: z2.number(),
-  chainId: z2.number(),
-  contractAddress: z2.string(),
+  min: z3.number().optional(),
+  max: z3.number().optional(),
+  values: z3.array(z3.any()).optional()
+});
+var collectiblesFilterSchema = z3.object({
+  includeEmpty: z3.boolean(),
+  searchText: z3.string().optional(),
+  properties: z3.array(propertyFilterSchema).optional(),
+  marketplaces: z3.array(marketplaceKindSchema).optional(),
+  inAccounts: z3.array(z3.string()).optional(),
+  notInAccounts: z3.array(z3.string()).optional(),
+  ordersCreatedBy: z3.array(z3.string()).optional(),
+  ordersNotCreatedBy: z3.array(z3.string()).optional()
+});
+var feeBreakdownSchema = z3.object({
+  kind: z3.string(),
+  recipientAddress: z3.string(),
+  bps: z3.number()
+});
+var orderFilterSchema = z3.object({
+  createdBy: z3.array(z3.string()).optional(),
+  marketplace: z3.array(marketplaceKindSchema).optional(),
+  currencies: z3.array(z3.string()).optional()
+});
+var collectionLastSyncedSchema = z3.object({
+  allOrders: z3.string(),
+  newOrders: z3.string()
+});
+var projectSchema = z3.object({
+  projectId: z3.number(),
+  chainId: z3.number(),
+  contractAddress: z3.string(),
   status: projectStatusSchema,
-  createdAt: z2.string(),
-  updatedAt: z2.string(),
-  deletedAt: z2.string().optional()
+  createdAt: z3.string(),
+  updatedAt: z3.string(),
+  deletedAt: z3.string().optional()
 });
-var collectibleSchema = z2.object({
-  chainId: z2.number(),
-  contractAddress: z2.string(),
+var collectibleSchema = z3.object({
+  chainId: z3.number(),
+  contractAddress: z3.string(),
   status: collectibleStatusSchema,
-  tokenId: z2.string(),
-  createdAt: z2.string(),
-  updatedAt: z2.string(),
-  deletedAt: z2.string().optional()
-});
-var currencySchema = z2.object({
-  chainId: z2.number(),
-  contractAddress: z2.string(),
-  name: z2.string(),
-  symbol: z2.string(),
-  decimals: z2.number(),
-  imageUrl: z2.string(),
-  exchangeRate: z2.number(),
-  defaultChainCurrency: z2.boolean(),
-  nativeCurrency: z2.boolean(),
-  createdAt: z2.string(),
-  updatedAt: z2.string(),
-  deletedAt: z2.string().optional()
-});
-var orderDataSchema = z2.object({
-  orderId: z2.string(),
-  quantity: z2.string()
-});
-var additionalFeeSchema = z2.object({
-  amount: z2.string(),
-  receiver: z2.string()
-});
-var postRequestSchema = z2.object({
-  endpoint: z2.string(),
-  method: z2.string(),
-  body: z2.any()
-});
-var createReqSchema = z2.object({
-  tokenId: z2.string(),
-  quantity: z2.string(),
-  expiry: z2.string(),
-  currencyAddress: z2.string(),
-  pricePerToken: z2.string()
-});
-var getOrdersInputSchema = z2.object({
-  contractAddress: z2.string(),
-  orderId: z2.string(),
+  tokenId: z3.string(),
+  createdAt: z3.string(),
+  updatedAt: z3.string(),
+  deletedAt: z3.string().optional()
+});
+var currencySchema = z3.object({
+  chainId: z3.number(),
+  contractAddress: z3.string(),
+  name: z3.string(),
+  symbol: z3.string(),
+  decimals: z3.number(),
+  imageUrl: z3.string(),
+  exchangeRate: z3.number(),
+  defaultChainCurrency: z3.boolean(),
+  nativeCurrency: z3.boolean(),
+  createdAt: z3.string(),
+  updatedAt: z3.string(),
+  deletedAt: z3.string().optional()
+});
+var orderDataSchema = z3.object({
+  orderId: z3.string(),
+  quantity: z3.string()
+});
+var additionalFeeSchema = z3.object({
+  amount: z3.string(),
+  receiver: z3.string()
+});
+var postRequestSchema = z3.object({
+  endpoint: z3.string(),
+  method: z3.string(),
+  body: z3.any()
+});
+var createReqSchema = z3.object({
+  tokenId: z3.string(),
+  quantity: z3.string(),
+  expiry: z3.string(),
+  currencyAddress: z3.string(),
+  pricePerToken: z3.string()
+});
+var getOrdersInputSchema = z3.object({
+  contractAddress: z3.string(),
+  orderId: z3.string(),
   marketplace: marketplaceKindSchema
 });
-var domainSchema = z2.object({
-  name: z2.string(),
-  version: z2.string(),
-  chainId: z2.number(),
-  verifyingContract: z2.string()
+var domainSchema = z3.object({
+  name: z3.string(),
+  version: z3.string(),
+  chainId: z3.number(),
+  verifyingContract: z3.string()
 });
-var checkoutOptionsMarketplaceOrderSchema = z2.object({
-  contractAddress: z2.string(),
-  orderId: z2.string(),
+var checkoutOptionsMarketplaceOrderSchema = z3.object({
+  contractAddress: z3.string(),
+  orderId: z3.string(),
   marketplace: marketplaceKindSchema
 });
-var checkoutOptionsItemSchema = z2.object({
-  tokenId: z2.string(),
-  quantity: z2.string()
+var checkoutOptionsItemSchema = z3.object({
+  tokenId: z3.string(),
+  quantity: z3.string()
 });
-var checkoutOptionsSchema = z2.object({
+var checkoutOptionsSchema = z3.object({
   crypto: transactionCryptoSchema,
-  swap: z2.array(transactionSwapProviderSchema),
-  nftCheckout: z2.array(transactionNFTCheckoutProviderSchema),
-  onRamp: z2.array(transactionOnRampProviderSchema)
+  swap: z3.array(transactionSwapProviderSchema),
+  nftCheckout: z3.array(transactionNFTCheckoutProviderSchema),
+  onRamp: z3.array(transactionOnRampProviderSchema)
 });
-var listCurrenciesArgsSchema = z2.object({});
-var listCurrenciesReturnSchema = z2.object({
-  currencies: z2.array(currencySchema)
+var listCurrenciesArgsSchema = z3.object({});
+var listCurrenciesReturnSchema = z3.object({
+  currencies: z3.array(currencySchema)
 });
-var getCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string()
+var getCollectibleArgsSchema = z3.object({
+  contractAddress: z3.string(),
+  tokenId: z3.string()
 });
-var getLowestPriceOfferForCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
+var getLowestPriceOfferForCollectibleArgsSchema = z3.object({
+  contractAddress: z3.string(),
+  tokenId: z3.string(),
   filter: orderFilterSchema.optional()
 });
-var getHighestPriceOfferForCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
+var getHighestPriceOfferForCollectibleArgsSchema = z3.object({
+  contractAddress: z3.string(),
+  tokenId: z3.string(),
   filter: orderFilterSchema.optional()
 });
-var getLowestPriceListingForCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
+var getLowestPriceListingForCollectibleArgsSchema = z3.object({
+  contractAddress: z3.string(),
+  tokenId: z3.string(),
   filter: orderFilterSchema.optional()
 });
-var getHighestPriceListingForCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
+var getHighestPriceListingForCollectibleArgsSchema = z3.object({
+  contractAddress: z3.string(),
+  tokenId: z3.string(),
   filter: orderFilterSchema.optional()
 });
-var getCollectibleLowestOfferArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
+var getCollectibleLowestOfferArgsSchema = z3.object({
+  contractAddress: z3.string(),
+  tokenId: z3.string(),
   filter: orderFilterSchema.optional()
 });
-var getCollectibleHighestOfferArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
+var getCollectibleHighestOfferArgsSchema = z3.object({
+  contractAddress: z3.string(),
+  tokenId: z3.string(),
   filter: orderFilterSchema.optional()
 });
-var getCollectibleLowestListingArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
+var getCollectibleLowestListingArgsSchema = z3.object({
+  contractAddress: z3.string(),
+  tokenId: z3.string(),
   filters: orderFilterSchema.optional()
 });
-var getCollectibleHighestListingArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
+var getCollectibleHighestListingArgsSchema = z3.object({
+  contractAddress: z3.string(),
+  tokenId: z3.string(),
   filter: orderFilterSchema.optional()
 });
-var generateBuyTransactionArgsSchema = z2.object({
-  collectionAddress: z2.string(),
-  buyer: z2.string(),
+var generateBuyTransactionArgsSchema = z3.object({
+  collectionAddress: z3.string(),
+  buyer: z3.string(),
   marketplace: marketplaceKindSchema,
-  ordersData: z2.array(orderDataSchema),
-  additionalFees: z2.array(additionalFeeSchema),
+  ordersData: z3.array(orderDataSchema),
+  additionalFees: z3.array(additionalFeeSchema),
   walletType: walletKindSchema.optional()
 });
-var generateSellTransactionArgsSchema = z2.object({
-  collectionAddress: z2.string(),
-  seller: z2.string(),
+var generateSellTransactionArgsSchema = z3.object({
+  collectionAddress: z3.string(),
+  seller: z3.string(),
   marketplace: marketplaceKindSchema,
-  ordersData: z2.array(orderDataSchema),
-  additionalFees: z2.array(additionalFeeSchema),
+  ordersData: z3.array(orderDataSchema),
+  additionalFees: z3.array(additionalFeeSchema),
   walletType: walletKindSchema.optional()
 });
-var generateListingTransactionArgsSchema = z2.object({
-  collectionAddress: z2.string(),
-  owner: z2.string(),
+var generateListingTransactionArgsSchema = z3.object({
+  collectionAddress: z3.string(),
+  owner: z3.string(),
   contractType: contractTypeSchema,
   orderbook: orderbookKindSchema,
   listing: createReqSchema,
   walletType: walletKindSchema.optional()
 });
-var generateOfferTransactionArgsSchema = z2.object({
-  collectionAddress: z2.string(),
-  maker: z2.string(),
+var generateOfferTransactionArgsSchema = z3.object({
+  collectionAddress: z3.string(),
+  maker: z3.string(),
   contractType: contractTypeSchema,
   orderbook: orderbookKindSchema,
   offer: createReqSchema,
   walletType: walletKindSchema.optional()
 });
-var executeArgsSchema = z2.object({
-  signature: z2.string(),
+var executeArgsSchema = z3.object({
+  signature: z3.string(),
   executeType: executeTypeSchema,
-  body: z2.any()
+  body: z3.any()
 });
-var executeReturnSchema = z2.object({
-  orderId: z2.string()
+var executeReturnSchema = z3.object({
+  orderId: z3.string()
 });
-var getCountOfAllCollectiblesArgsSchema = z2.object({
-  contractAddress: z2.string()
+var getCountOfAllCollectiblesArgsSchema = z3.object({
+  contractAddress: z3.string()
 });
-var getCountOfAllCollectiblesReturnSchema = z2.object({
-  count: z2.number()
+var getCountOfAllCollectiblesReturnSchema = z3.object({
+  count: z3.number()
 });
-var getCountOfFilteredCollectiblesArgsSchema = z2.object({
+var getCountOfFilteredCollectiblesArgsSchema = z3.object({
   side: orderSideSchema,
-  contractAddress: z2.string(),
+  contractAddress: z3.string(),
   filter: collectiblesFilterSchema.optional()
 });
-var getCountOfFilteredCollectiblesReturnSchema = z2.object({
-  count: z2.number()
+var getCountOfFilteredCollectiblesReturnSchema = z3.object({
+  count: z3.number()
 });
-var getFloorOrderArgsSchema = z2.object({
-  contractAddress: z2.string(),
+var getFloorOrderArgsSchema = z3.object({
+  contractAddress: z3.string(),
   filter: collectiblesFilterSchema.optional()
 });
-var syncOrderReturnSchema = z2.object({});
-var syncOrdersReturnSchema = z2.object({});
-var checkoutOptionsMarketplaceArgsSchema = z2.object({
-  wallet: z2.string(),
-  orders: z2.array(checkoutOptionsMarketplaceOrderSchema),
-  additionalFee: z2.number()
+var syncOrderReturnSchema = z3.object({});
+var syncOrdersReturnSchema = z3.object({});
+var checkoutOptionsMarketplaceArgsSchema = z3.object({
+  wallet: z3.string(),
+  orders: z3.array(checkoutOptionsMarketplaceOrderSchema),
+  additionalFee: z3.number()
 });
-var checkoutOptionsMarketplaceReturnSchema = z2.object({
+var checkoutOptionsMarketplaceReturnSchema = z3.object({
   options: checkoutOptionsSchema
 });
-var checkoutOptionsSalesContractArgsSchema = z2.object({
-  wallet: z2.string(),
-  contractAddress: z2.string(),
-  collectionAddress: z2.string(),
-  items: z2.array(checkoutOptionsItemSchema)
+var checkoutOptionsSalesContractArgsSchema = z3.object({
+  wallet: z3.string(),
+  contractAddress: z3.string(),
+  collectionAddress: z3.string(),
+  items: z3.array(checkoutOptionsItemSchema)
 });
-var checkoutOptionsSalesContractReturnSchema = z2.object({
+var checkoutOptionsSalesContractReturnSchema = z3.object({
   options: checkoutOptionsSchema
 });
-var countListingsForCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
+var countListingsForCollectibleArgsSchema = z3.object({
+  contractAddress: z3.string(),
+  tokenId: z3.string(),
   filter: orderFilterSchema.optional()
 });
-var countListingsForCollectibleReturnSchema = z2.object({
-  count: z2.number()
+var countListingsForCollectibleReturnSchema = z3.object({
+  count: z3.number()
 });
-var countOffersForCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
+var countOffersForCollectibleArgsSchema = z3.object({
+  contractAddress: z3.string(),
+  tokenId: z3.string(),
   filter: orderFilterSchema.optional()
 });
-var countOffersForCollectibleReturnSchema = z2.object({
-  count: z2.number()
-});
-var tokenMetadataSchema = z2.object({
-  tokenId: z2.string(),
-  name: z2.string(),
-  description: z2.string().optional(),
-  image: z2.string().optional(),
-  video: z2.string().optional(),
-  audio: z2.string().optional(),
-  properties: z2.record(z2.any()).optional(),
-  attributes: z2.array(z2.record(z2.any())),
-  image_data: z2.string().optional(),
-  external_url: z2.string().optional(),
-  background_color: z2.string().optional(),
-  animation_url: z2.string().optional(),
-  decimals: z2.number().optional(),
-  updatedAt: z2.string().optional(),
-  assets: z2.array(assetSchema).optional()
-});
-var pageSchema = z2.object({
-  page: z2.number(),
-  pageSize: z2.number(),
-  more: z2.boolean().optional(),
-  sort: z2.array(sortBySchema).optional()
-});
-var filterSchema = z2.object({
-  text: z2.string().optional(),
-  properties: z2.array(propertyFilterSchema).optional()
-});
-var orderSchema = z2.object({
-  orderId: z2.string(),
+var countOffersForCollectibleReturnSchema = z3.object({
+  count: z3.number()
+});
+var tokenMetadataSchema = z3.object({
+  tokenId: z3.string(),
+  name: z3.string(),
+  description: z3.string().optional(),
+  image: z3.string().optional(),
+  video: z3.string().optional(),
+  audio: z3.string().optional(),
+  properties: z3.record(z3.any()).optional(),
+  attributes: z3.array(z3.record(z3.any())),
+  image_data: z3.string().optional(),
+  external_url: z3.string().optional(),
+  background_color: z3.string().optional(),
+  animation_url: z3.string().optional(),
+  decimals: z3.number().optional(),
+  updatedAt: z3.string().optional(),
+  assets: z3.array(assetSchema).optional()
+});
+var pageSchema = z3.object({
+  page: z3.number(),
+  pageSize: z3.number(),
+  more: z3.boolean().optional(),
+  sort: z3.array(sortBySchema).optional()
+});
+var filterSchema2 = z3.object({
+  text: z3.string().optional(),
+  properties: z3.array(propertyFilterSchema).optional()
+});
+var orderSchema = z3.object({
+  orderId: z3.string(),
   marketplace: marketplaceKindSchema,
   side: orderSideSchema,
   status: orderStatusSchema,
-  chainId: z2.number(),
-  collectionContractAddress: z2.string(),
-  tokenId: z2.string(),
-  createdBy: z2.string(),
-  priceAmount: z2.string(),
-  priceAmountFormatted: z2.string(),
-  priceAmountNet: z2.string(),
-  priceAmountNetFormatted: z2.string(),
-  priceCurrencyAddress: z2.string(),
-  priceDecimals: z2.number(),
-  priceUSD: z2.number(),
-  quantityInitial: z2.string(),
-  quantityInitialFormatted: z2.string(),
-  quantityRemaining: z2.string(),
-  quantityRemainingFormatted: z2.string(),
-  quantityAvailable: z2.string(),
-  quantityAvailableFormatted: z2.string(),
-  quantityDecimals: z2.number(),
-  feeBps: z2.number(),
-  feeBreakdown: z2.array(feeBreakdownSchema),
-  validFrom: z2.string(),
-  validUntil: z2.string(),
-  blockNumber: z2.number(),
-  orderCreatedAt: z2.string().optional(),
-  orderUpdatedAt: z2.string().optional(),
-  createdAt: z2.string(),
-  updatedAt: z2.string(),
-  deletedAt: z2.string().optional()
-});
-var collectibleOrderSchema = z2.object({
+  chainId: z3.number(),
+  collectionContractAddress: z3.string(),
+  tokenId: z3.string(),
+  createdBy: z3.string(),
+  priceAmount: z3.string(),
+  priceAmountFormatted: z3.string(),
+  priceAmountNet: z3.string(),
+  priceAmountNetFormatted: z3.string(),
+  priceCurrencyAddress: z3.string(),
+  priceDecimals: z3.number(),
+  priceUSD: z3.number(),
+  quantityInitial: z3.string(),
+  quantityInitialFormatted: z3.string(),
+  quantityRemaining: z3.string(),
+  quantityRemainingFormatted: z3.string(),
+  quantityAvailable: z3.string(),
+  quantityAvailableFormatted: z3.string(),
+  quantityDecimals: z3.number(),
+  feeBps: z3.number(),
+  feeBreakdown: z3.array(feeBreakdownSchema),
+  validFrom: z3.string(),
+  validUntil: z3.string(),
+  blockNumber: z3.number(),
+  orderCreatedAt: z3.string().optional(),
+  orderUpdatedAt: z3.string().optional(),
+  createdAt: z3.string(),
+  updatedAt: z3.string(),
+  deletedAt: z3.string().optional()
+});
+var collectibleOrderSchema = z3.object({
   metadata: tokenMetadataSchema,
   order: orderSchema.optional()
 });
-var activitySchema = z2.object({
-  type: z2.string(),
-  fromAddress: z2.string(),
-  toAddress: z2.string(),
-  txHash: z2.string(),
-  timestamp: z2.number(),
-  tokenId: z2.string(),
-  tokenImage: z2.string(),
-  tokenName: z2.string(),
+var activitySchema = z3.object({
+  type: z3.string(),
+  fromAddress: z3.string(),
+  toAddress: z3.string(),
+  txHash: z3.string(),
+  timestamp: z3.number(),
+  tokenId: z3.string(),
+  tokenImage: z3.string(),
+  tokenName: z3.string(),
   currency: currencySchema.optional()
 });
-var collectionConfigSchema = z2.object({
-  lastSynced: z2.record(collectionLastSyncedSchema),
-  collectiblesSynced: z2.string()
+var collectionConfigSchema = z3.object({
+  lastSynced: z3.record(collectionLastSyncedSchema),
+  collectiblesSynced: z3.string()
 });
-var signatureSchema = z2.object({
+var signatureSchema = z3.object({
   domain: domainSchema,
-  types: z2.any(),
-  primaryType: z2.string(),
-  value: z2.any()
+  types: z3.any(),
+  primaryType: z3.string(),
+  value: z3.any()
 });
-var getCollectibleReturnSchema = z2.object({
+var getCollectibleReturnSchema = z3.object({
   metadata: tokenMetadataSchema
 });
-var getLowestPriceOfferForCollectibleReturnSchema = z2.object({
+var getLowestPriceOfferForCollectibleReturnSchema = z3.object({
   order: orderSchema
 });
-var getHighestPriceOfferForCollectibleReturnSchema = z2.object({
+var getHighestPriceOfferForCollectibleReturnSchema = z3.object({
   order: orderSchema
 });
-var getLowestPriceListingForCollectibleReturnSchema = z2.object({
+var getLowestPriceListingForCollectibleReturnSchema = z3.object({
   order: orderSchema
 });
-var getHighestPriceListingForCollectibleReturnSchema = z2.object({
+var getHighestPriceListingForCollectibleReturnSchema = z3.object({
   order: orderSchema
 });
-var listListingsForCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
+var listListingsForCollectibleArgsSchema = z3.object({
+  contractAddress: z3.string(),
+  tokenId: z3.string(),
   filter: orderFilterSchema.optional(),
   page: pageSchema.optional()
 });
-var listListingsForCollectibleReturnSchema = z2.object({
-  listings: z2.array(orderSchema),
+var listListingsForCollectibleReturnSchema = z3.object({
+  listings: z3.array(orderSchema),
   page: pageSchema.optional()
 });
-var listOffersForCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
+var listOffersForCollectibleArgsSchema = z3.object({
+  contractAddress: z3.string(),
+  tokenId: z3.string(),
   filter: orderFilterSchema.optional(),
   page: pageSchema.optional()
 });
-var listOffersForCollectibleReturnSchema = z2.object({
-  offers: z2.array(orderSchema),
+var listOffersForCollectibleReturnSchema = z3.object({
+  offers: z3.array(orderSchema),
   page: pageSchema.optional()
 });
-var getListCollectibleActivitiesArgsSchema = z2.object({
-  chainId: ChainIdSchema.pipe(z2.coerce.string()),
+var getListCollectibleActivitiesArgsSchema = z3.object({
+  chainId: ChainIdSchema.pipe(z3.coerce.string()),
   collectionAddress: AddressSchema,
-  tokenId: CollectableIdSchema.pipe(z2.coerce.string()),
+  tokenId: CollectableIdSchema.pipe(z3.coerce.string()),
   query: pageSchema.extend({
-    enabled: z2.boolean().optional()
+    enabled: z3.boolean().optional()
   }).optional()
 });
-var getListCollectibleActivitiesReturnSchema = z2.object({
-  activities: z2.array(activitySchema),
+var getListCollectibleActivitiesReturnSchema = z3.object({
+  activities: z3.array(activitySchema),
   page: pageSchema.optional()
 });
-var getListCollectionActivitiesArgsSchema = z2.object({
-  chainId: ChainIdSchema.pipe(z2.coerce.string()),
+var getListCollectionActivitiesArgsSchema = z3.object({
+  chainId: ChainIdSchema.pipe(z3.coerce.string()),
   collectionAddress: AddressSchema,
   query: pageSchema.extend({
-    enabled: z2.boolean().optional()
+    enabled: z3.boolean().optional()
   }).optional()
 });
-var getListCollectionActivitiesReturnSchema = z2.object({
-  activities: z2.array(activitySchema),
+var getListCollectionActivitiesReturnSchema = z3.object({
+  activities: z3.array(activitySchema),
   page: pageSchema.optional()
 });
-var getCollectibleLowestOfferReturnSchema = z2.object({
+var getCollectibleLowestOfferReturnSchema = z3.object({
   order: orderSchema.optional()
 });
-var getCollectibleHighestOfferReturnSchema = z2.object({
+var getCollectibleHighestOfferReturnSchema = z3.object({
   order: orderSchema.optional()
 });
-var getCollectibleLowestListingReturnSchema = z2.object({
+var getCollectibleLowestListingReturnSchema = z3.object({
   order: orderSchema.optional()
 });
-var getCollectibleHighestListingReturnSchema = z2.object({
+var getCollectibleHighestListingReturnSchema = z3.object({
   order: orderSchema.optional()
 });
-var listCollectibleListingsArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
+var listCollectibleListingsArgsSchema = z3.object({
+  contractAddress: z3.string(),
+  tokenId: z3.string(),
   filter: orderFilterSchema.optional(),
   page: pageSchema.optional()
 });
-var listCollectibleListingsReturnSchema = z2.object({
-  listings: z2.array(orderSchema),
+var listCollectibleListingsReturnSchema = z3.object({
+  listings: z3.array(orderSchema),
   page: pageSchema.optional()
 });
-var listCollectibleOffersArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
+var listCollectibleOffersArgsSchema = z3.object({
+  contractAddress: z3.string(),
+  tokenId: z3.string(),
   filter: orderFilterSchema.optional(),
   page: pageSchema.optional()
 });
-var listCollectibleOffersReturnSchema = z2.object({
-  offers: z2.array(orderSchema),
+var listCollectibleOffersReturnSchema = z3.object({
+  offers: z3.array(orderSchema),
   page: pageSchema.optional()
 });
-var listCollectiblesArgsSchema = z2.object({
+var listCollectiblesArgsSchema = z3.object({
   side: orderSideSchema,
-  contractAddress: z2.string(),
+  contractAddress: z3.string(),
   filter: collectiblesFilterSchema.optional(),
   page: pageSchema.optional()
 });
-var listCollectiblesReturnSchema = z2.object({
-  collectibles: z2.array(collectibleOrderSchema),
+var listCollectiblesReturnSchema = z3.object({
+  collectibles: z3.array(collectibleOrderSchema),
   page: pageSchema.optional()
 });
-var getFloorOrderReturnSchema = z2.object({
+var getFloorOrderReturnSchema = z3.object({
   collectible: collectibleOrderSchema
 });
-var listCollectiblesWithLowestListingArgsSchema = z2.object({
-  contractAddress: z2.string(),
+var listCollectiblesWithLowestListingArgsSchema = z3.object({
+  contractAddress: z3.string(),
   filter: collectiblesFilterSchema.optional(),
   page: pageSchema.optional()
 });
-var listCollectiblesWithLowestListingReturnSchema = z2.object({
-  collectibles: z2.array(collectibleOrderSchema),
+var listCollectiblesWithLowestListingReturnSchema = z3.object({
+  collectibles: z3.array(collectibleOrderSchema),
   page: pageSchema.optional()
 });
-var listCollectiblesWithHighestOfferArgsSchema = z2.object({
-  contractAddress: z2.string(),
+var listCollectiblesWithHighestOfferArgsSchema = z3.object({
+  contractAddress: z3.string(),
   filter: collectiblesFilterSchema.optional(),
   page: pageSchema.optional()
 });
-var listCollectiblesWithHighestOfferReturnSchema = z2.object({
-  collectibles: z2.array(collectibleOrderSchema),
+var listCollectiblesWithHighestOfferReturnSchema = z3.object({
+  collectibles: z3.array(collectibleOrderSchema),
   page: pageSchema.optional()
 });
-var syncOrderArgsSchema = z2.object({
+var syncOrderArgsSchema = z3.object({
   order: orderSchema
 });
-var syncOrdersArgsSchema = z2.object({
-  orders: z2.array(orderSchema)
+var syncOrdersArgsSchema = z3.object({
+  orders: z3.array(orderSchema)
 });
-var getOrdersArgsSchema = z2.object({
-  input: z2.array(getOrdersInputSchema),
+var getOrdersArgsSchema = z3.object({
+  input: z3.array(getOrdersInputSchema),
   page: pageSchema.optional()
 });
-var getOrdersReturnSchema = z2.object({
-  orders: z2.array(orderSchema),
+var getOrdersReturnSchema = z3.object({
+  orders: z3.array(orderSchema),
   page: pageSchema.optional()
 });
-var collectionSchema = z2.object({
+var collectionSchema = z3.object({
   status: collectionStatusSchema,
-  chainId: z2.number(),
-  contractAddress: z2.string(),
+  chainId: z3.number(),
+  contractAddress: z3.string(),
   contractType: contractTypeSchema,
-  tokenQuantityDecimals: z2.number(),
+  tokenQuantityDecimals: z3.number(),
   config: collectionConfigSchema,
-  createdAt: z2.string(),
-  updatedAt: z2.string(),
-  deletedAt: z2.string().optional()
+  createdAt: z3.string(),
+  updatedAt: z3.string(),
+  deletedAt: z3.string().optional()
 });
-var stepSchema = z2.object({
+var stepSchema = z3.object({
   id: stepTypeSchema,
-  data: z2.string(),
-  to: z2.string(),
-  value: z2.string(),
+  data: z3.string(),
+  to: z3.string(),
+  value: z3.string(),
   signature: signatureSchema.optional(),
   post: postRequestSchema.optional(),
   executeType: executeTypeSchema.optional()
 });
-var generateBuyTransactionReturnSchema = z2.object({
-  steps: z2.array(stepSchema)
+var generateBuyTransactionReturnSchema = z3.object({
+  steps: z3.array(stepSchema)
 });
-var generateSellTransactionReturnSchema = z2.object({
-  steps: z2.array(stepSchema)
+var generateSellTransactionReturnSchema = z3.object({
+  steps: z3.array(stepSchema)
 });
-var generateListingTransactionReturnSchema = z2.object({
-  steps: z2.array(stepSchema)
+var generateListingTransactionReturnSchema = z3.object({
+  steps: z3.array(stepSchema)
 });
-var generateOfferTransactionReturnSchema = z2.object({
-  steps: z2.array(stepSchema)
+var generateOfferTransactionReturnSchema = z3.object({
+  steps: z3.array(stepSchema)
 });
 
 // src/react/hooks/useCountOfCollectables.tsx
-var BaseSchema = z3.object({
-  chainId: ChainIdSchema.pipe(z3.coerce.string()),
+var BaseSchema = z4.object({
+  chainId: ChainIdSchema.pipe(z4.coerce.string()),
   collectionAddress: AddressSchema,
   query: QueryArgSchema
 });
 var UseCountOfCollectableSchema = BaseSchema.extend({
   filter: collectiblesFilterSchema,
-  side: z3.nativeEnum(OrderSide)
+  side: z4.nativeEnum(OrderSide)
 }).or(
   BaseSchema.extend({
-    filter: z3.undefined(),
-    side: z3.undefined()
+    filter: z4.undefined(),
+    side: z4.undefined()
   })
 );
 var fetchCountOfCollectables = async (args, config) => {
@@ -830,24 +911,24 @@ var fetchCountOfCollectables = async (args, config) => {
   }).then((resp) => resp.count);
 };
 var countOfCollectablesOptions = (args, config) => {
-  return queryOptions2({
+  return queryOptions3({
     ...args.query,
     queryKey: [...collectableKeys.counts, args],
     queryFn: () => fetchCountOfCollectables(args, config)
   });
 };
 var useCountOfCollectables = (args) => {
-  const config = useConfig2();
-  return useQuery2(countOfCollectablesOptions(args, config));
+  const config = useConfig();
+  return useQuery3(countOfCollectablesOptions(args, config));
 };
 
 // src/react/hooks/useCollectible.tsx
-import { queryOptions as queryOptions3, useQuery as useQuery3 } from "@tanstack/react-query";
-import { z as z4 } from "zod";
-var UseCollectibleSchema = z4.object({
-  chainId: ChainIdSchema.pipe(z4.coerce.string()),
+import { queryOptions as queryOptions4, useQuery as useQuery4 } from "@tanstack/react-query";
+import { z as z5 } from "zod";
+var UseCollectibleSchema = z5.object({
+  chainId: ChainIdSchema.pipe(z5.coerce.string()),
   collectionAddress: AddressSchema,
-  collectibleId: z4.string(),
+  collectibleId: z5.string(),
   query: QueryArgSchema
 });
 var fetchCollectible = async (args, config) => {
@@ -860,22 +941,22 @@ var fetchCollectible = async (args, config) => {
   }).then((resp) => resp.tokenMetadata[0]);
 };
 var collectibleOptions = (args, config) => {
-  return queryOptions3({
+  return queryOptions4({
     ...args.query,
     queryKey: [...collectableKeys.details, args, config],
     queryFn: () => fetchCollectible(args, config)
   });
 };
 var useCollectible = (args) => {
-  const config = useConfig2();
-  return useQuery3(collectibleOptions(args, config));
+  const config = useConfig();
+  return useQuery4(collectibleOptions(args, config));
 };
 
 // src/react/hooks/useCollection.tsx
-import { queryOptions as queryOptions4, useQuery as useQuery4 } from "@tanstack/react-query";
-import { z as z5 } from "zod";
-var UseCollectionSchema = z5.object({
-  chainId: ChainIdSchema.pipe(z5.coerce.string()),
+import { queryOptions as queryOptions5, useQuery as useQuery5 } from "@tanstack/react-query";
+import { z as z6 } from "zod";
+var UseCollectionSchema = z6.object({
+  chainId: ChainIdSchema.pipe(z6.coerce.string()),
   collectionAddress: AddressSchema,
   query: QueryArgSchema
 });
@@ -888,77 +969,20 @@ var fetchCollection = async (args, config) => {
   }).then((resp) => resp.contractInfo);
 };
 var collectionOptions = (args, config) => {
-  return queryOptions4({
+  return queryOptions5({
     ...args.query,
     queryKey: [...collectionKeys.detail, args, config],
     queryFn: () => fetchCollection(args, config)
   });
 };
 var useCollection = (args) => {
-  const config = useConfig2();
-  return useQuery4(collectionOptions(args, config));
-};
-
-// src/react/hooks/useCollectionBalanceDetails.tsx
-import { z as z6 } from "zod";
-import { queryOptions as queryOptions5, useQuery as useQuery5 } from "@tanstack/react-query";
-var filterSchema2 = z6.object({
-  accountAddresses: z6.array(AddressSchema),
-  contractWhitelist: z6.array(AddressSchema).optional(),
-  omitNativeBalances: z6.boolean()
-});
-var useCollectionBalanceDetailsArgsSchema = z6.object({
-  chainId: ChainIdSchema.pipe(z6.coerce.number()),
-  filter: filterSchema2,
-  query: QueryArgSchema.optional()
-});
-var fetchCollectionBalanceDetails = async (args, indexerClient) => {
-  const promises = args.filter.accountAddresses.map(
-    (accountAddress) => indexerClient.getTokenBalancesDetails({
-      filter: {
-        accountAddresses: [accountAddress],
-        contractWhitelist: args.filter.contractWhitelist,
-        omitNativeBalances: args.filter.omitNativeBalances
-      }
-    })
-  );
-  const responses = await Promise.all(promises);
-  const mergedResponse = responses.reduce(
-    (acc, curr) => {
-      if (!curr) return acc;
-      return {
-        page: curr.page,
-        nativeBalances: [
-          ...acc.nativeBalances || [],
-          ...curr.nativeBalances || []
-        ],
-        balances: [...acc.balances || [], ...curr.balances || []]
-      };
-    },
-    { page: {}, nativeBalances: [], balances: [] }
-  );
-  if (!mergedResponse) {
-    throw new Error("Failed to fetch collection balance details");
-  }
-  return mergedResponse;
-};
-var collectionBalanceDetailsOptions = (args, config) => {
-  const parsedArgs = useCollectionBalanceDetailsArgsSchema.parse(args);
-  const indexerClient = getIndexerClient(parsedArgs.chainId, config);
-  return queryOptions5({
-    queryKey: [...balanceQueries.collectionBalanceDetails, args, config],
-    queryFn: () => fetchCollectionBalanceDetails(parsedArgs, indexerClient),
-    ...args.query
-  });
-};
-var useCollectionBalanceDetails = (args) => {
-  const config = useConfig2();
-  return useQuery5(collectionBalanceDetailsOptions(args, config));
+  const config = useConfig();
+  return useQuery5(collectionOptions(args, config));
 };
 
 // src/react/hooks/useCurrencies.tsx
 import { queryOptions as queryOptions6, useQuery as useQuery6 } from "@tanstack/react-query";
-import { zeroAddress } from "viem";
+import { zeroAddress as zeroAddress2 } from "viem";
 import { z as z7 } from "zod";
 var ChainIdCoerce = ChainIdSchema.transform((val) => val.toString());
 var UseCurrenciesArgsSchema = z7.object({
@@ -974,7 +998,7 @@ var fetchCurrencies = async (chainId, config) => {
     (resp) => resp.currencies.map((currency) => ({
       ...currency,
       // TODO: remove this, when we are sure of the schema
-      contractAddress: currency.contractAddress || zeroAddress
+      contractAddress: currency.contractAddress || zeroAddress2
     }))
   );
 };
@@ -1004,7 +1028,7 @@ var currenciesOptions = (args, config) => {
   });
 };
 var useCurrencies = (args) => {
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery6(currenciesOptions(args, config));
 };
 
@@ -1060,7 +1084,7 @@ var marketplaceConfigOptions = (config) => {
 
 // src/react/hooks/useMarketplaceConfig.tsx
 var useMarketplaceConfig = () => {
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery7(marketplaceConfigOptions(config));
 };
 
@@ -1112,7 +1136,7 @@ var currencyOptions = (args, config) => {
   });
 };
 var useCurrency = (args) => {
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery8(currencyOptions(args, config));
 };
 
@@ -1140,7 +1164,7 @@ var filtersOptions = (args, config) => {
   });
 };
 var useFilters = (args) => {
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery9(filtersOptions(args, config));
 };
 
@@ -1163,7 +1187,7 @@ var floorOrderOptions = (args, config) => {
   });
 };
 var useFloorOrder = (args) => {
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery10(floorOrderOptions(args, config));
 };
 
@@ -1193,7 +1217,7 @@ var highestOfferOptions = (args, config) => {
   });
 };
 var useHighestOffer = (args) => {
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery11(highestOfferOptions(args, config));
 };
 
@@ -1250,7 +1274,7 @@ var listBalancesOptions = (args, config) => {
   });
 };
 var useListBalances = (args) => {
-  const config = useConfig2();
+  const config = useConfig();
   return useInfiniteQuery(listBalancesOptions(args, config));
 };
 
@@ -1278,7 +1302,7 @@ var listCollectibleActivitiesOptions = (args, config) => {
   });
 };
 var useListCollectibleActivities = (args) => {
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery12(listCollectibleActivitiesOptions(args, config));
 };
 
@@ -1311,7 +1335,7 @@ var listCollectiblesOptions = (args, config) => {
   });
 };
 var useListCollectibles = (args) => {
-  const config = useConfig2();
+  const config = useConfig();
   return useInfiniteQuery2(listCollectiblesOptions(args, config));
 };
 
@@ -1338,7 +1362,7 @@ var listCollectionActivitiesOptions = (args, config) => {
   });
 };
 var useListCollectionActivities = (args) => {
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery13(listCollectionActivitiesOptions(args, config));
 };
 
@@ -1367,7 +1391,7 @@ var listOffersForCollectibleOptions = (args, config) => {
   });
 };
 var useListOffersForCollectible = (args) => {
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery14(listOffersForCollectibleOptions(args, config));
 };
 
@@ -1400,7 +1424,7 @@ var countOffersForCollectibleOptions = (args, config) => {
   });
 };
 var useCountOffersForCollectible = (args) => {
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery15(countOffersForCollectibleOptions(args, config));
 };
 
@@ -1429,7 +1453,7 @@ var listListingsForCollectibleOptions = (args, config) => {
   });
 };
 var useListListingsForCollectible = (args) => {
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery16(listListingsForCollectibleOptions(args, config));
 };
 
@@ -1462,7 +1486,7 @@ var countListingsForCollectibleOptions = (args, config) => {
   });
 };
 var useCountListingsForCollectible = (args) => {
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery17(countListingsForCollectibleOptions(args, config));
 };
 
@@ -1492,7 +1516,7 @@ var lowestListingOptions = (args, config) => {
   });
 };
 var useLowestListing = (args) => {
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery18(lowestListingOptions(args, config));
 };
 
@@ -1552,7 +1576,7 @@ var generateListingTransaction = async (params, config, chainId) => {
   return (await marketplaceClient.generateListingTransaction(args)).steps;
 };
 var useGenerateListingTransaction = (params) => {
-  const config = useConfig2();
+  const config = useConfig();
   const { mutate, mutateAsync, ...result } = useMutation({
     onSuccess: params.onSuccess,
     mutationFn: (args) => generateListingTransaction(args, config, params.chainId)
@@ -1575,7 +1599,7 @@ var generateOfferTransaction = async (params, config, chainId) => {
   return (await marketplaceClient.generateOfferTransaction(args)).steps;
 };
 var useGenerateOfferTransaction = (params) => {
-  const config = useConfig2();
+  const config = useConfig();
   const { mutate, mutateAsync, ...result } = useMutation2({
     onSuccess: params.onSuccess,
     mutationFn: (args) => generateOfferTransaction(args, config, params.chainId)
@@ -1600,7 +1624,7 @@ var generateSellTransaction = async (args, config, chainId) => {
   return marketplaceClient.generateSellTransaction(args).then((data) => data.steps);
 };
 var useGenerateSellTransaction = (params) => {
-  const config = useConfig2();
+  const config = useConfig();
   const { mutate, mutateAsync, ...result } = useMutation3({
     onSuccess: params.onSuccess,
     mutationFn: (args) => generateSellTransaction(args, config, params.chainId)
@@ -1625,7 +1649,7 @@ var generateCancelTransaction = async (args, config, chainId) => {
   return marketplaceClient.generateCancelTransaction(args).then((data) => data.steps);
 };
 var useGenerateCancelTransaction = (params) => {
-  const config = useConfig2();
+  const config = useConfig();
   const { mutate, mutateAsync, ...result } = useMutation4({
     onSuccess: params.onSuccess,
     mutationFn: (args) => generateCancelTransaction(args, config, params.chainId)
@@ -1728,7 +1752,7 @@ var checkoutOptionsOptions = (args, config) => {
 };
 var useCheckoutOptions = (args) => {
   const { address } = useAccount3();
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery20(
     // biome-ignore lint/style/noNonNullAssertion: <explanation>
     checkoutOptionsOptions({ walletAddress: address, ...args }, config)
@@ -1771,7 +1795,7 @@ var listCollectionsOptions = (args, config) => {
   });
 };
 var useListCollections = (args = {}) => {
-  const config = useConfig2();
+  const config = useConfig();
   const { data: marketplaceConfig, isLoading: isLoadingConfig } = useMarketplaceConfig();
   return useQuery21({
     ...listCollectionsOptions(
@@ -1820,7 +1844,7 @@ var generateBuyTransactionOptions = (args, config) => {
 };
 var useGenerateBuyTransaction = (args) => {
   const { address } = useAccount4();
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery22(
     // biome-ignore lint/style/noNonNullAssertion: <explanation>
     generateBuyTransactionOptions({ buyer: address, ...args }, config)
@@ -2089,7 +2113,7 @@ var useWallet = () => {
   const { chains } = useSwitchChain();
   const { data: walletClient, isLoading: wagmiWalletIsLoading } = useWalletClient();
   const { connector, isConnected, isConnecting } = useAccount5();
-  const sdkConfig = useConfig2();
+  const sdkConfig = useConfig();
   const chainId = useChainId();
   const { data, isLoading, isError } = useQuery23({
     queryKey: ["wallet", chainId, connector?.uid],
@@ -2262,7 +2286,7 @@ var useCancelTransactionSteps = ({
   const { show: showSwitchChainModal } = useSwitchChainModal();
   const { wallet: wallet2, isLoading, isError } = useWallet();
   const walletIsInitialized = wallet2 && !isLoading && !isError;
-  const sdkConfig = useConfig2();
+  const sdkConfig = useConfig();
   const marketplaceClient = getMarketplaceClient(chainId, sdkConfig);
   const { generateCancelTransactionAsync } = useGenerateCancelTransaction({
     chainId
@@ -2424,7 +2448,7 @@ var useCancelOrder = ({
     null
   );
   const [pendingFeeOptionConfirmation, confirmPendingFeeOption] = useWaasFeeOptions();
-  const autoSelectFeeOptionResult = useAutoSelectFeeOption({
+  const autoSelectOptionPromise = useAutoSelectFeeOption({
     pendingFeeOptionConfirmation: pendingFeeOptionConfirmation ? {
       id: pendingFeeOptionConfirmation.id,
       options: pendingFeeOptionConfirmation.options?.map((opt) => ({
@@ -2444,27 +2468,18 @@ var useCancelOrder = ({
     }
   });
   useEffect(() => {
-    const handleFeeOptionSelection = async () => {
-      if (!pendingFeeOptionConfirmation) return;
-      const { selectedOption, error } = await autoSelectFeeOptionResult;
-      if (error) {
-        console.error("Error selecting fee option:", error);
-        onError?.(new Error(`Failed to select fee option: ${error}`));
-        return;
-      }
-      if (selectedOption?.token.contractAddress && pendingFeeOptionConfirmation.id) {
+    autoSelectOptionPromise.then((res) => {
+      if (pendingFeeOptionConfirmation?.id && res.selectedOption) {
         confirmPendingFeeOption(
           pendingFeeOptionConfirmation.id,
-          selectedOption.token.contractAddress
+          res.selectedOption.token.contractAddress
         );
       }
-    };
-    handleFeeOptionSelection();
+    });
   }, [
-    pendingFeeOptionConfirmation,
-    autoSelectFeeOptionResult,
+    autoSelectOptionPromise,
     confirmPendingFeeOption,
-    onError
+    pendingFeeOptionConfirmation
   ]);
   const { cancelOrder: cancelOrderBase } = useCancelTransactionSteps({
     collectionAddress,
@@ -2506,7 +2521,7 @@ var collectionDetailsOptions = (args, config) => {
   });
 };
 var useCollectionDetails = (args) => {
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery24(collectionDetailsOptions(args, config));
 };
 
@@ -2546,7 +2561,7 @@ var collectionDetailsPollingOptions = (args, config) => {
   });
 };
 var useCollectionDetailsPolling = (args) => {
-  const config = useConfig2();
+  const config = useConfig();
   return useQuery25(collectionDetailsPollingOptions(args, config));
 };
 
@@ -2554,8 +2569,10 @@ export {
   MarketplaceSdkContext,
   MarketplaceQueryClientProvider,
   MarketplaceProvider,
+  useConfig,
+  collectionBalanceDetailsOptions,
+  useCollectionBalanceDetails,
   useAutoSelectFeeOption,
-  useConfig2 as useConfig,
   balanceOfCollectibleOptions,
   useBalanceOfCollectible,
   countOfCollectablesOptions,
@@ -2564,8 +2581,6 @@ export {
   useCollectible,
   collectionOptions,
   useCollection,
-  collectionBalanceDetailsOptions,
-  useCollectionBalanceDetails,
   currenciesOptions,
   useCurrencies,
   marketplaceConfigOptions,
@@ -2629,4 +2644,4 @@ export {
   collectionDetailsPollingOptions,
   useCollectionDetailsPolling
 };
-//# sourceMappingURL=chunk-HV2X2VZN.js.map
+//# sourceMappingURL=chunk-I37CRQ4S.js.map