@0xsequence/marketplace-sdk 0.8.10 → 0.8.11

package/dist/chunk-SXVUTSMT.js

@@ -1,2895 +0,0 @@
-'use client';
-
-import {
-  collectionOptions
-} from "./chunk-WH5BZC7W.js";
-import {
-  InfoIcon_default
-} from "./chunk-RVIUUJTP.js";
-import {
-  SEQUENCE_MARKET_V1_ADDRESS,
-  SEQUENCE_MARKET_V2_ADDRESS
-} from "./chunk-Y63BOO6M.js";
-import {
-  compareAddress,
-  getPresentableChainName
-} from "./chunk-5O44EPXZ.js";
-import {
-  ERC1155_ABI
-} from "./chunk-FUM4OGOQ.js";
-import {
-  EIP2981_ABI
-} from "./chunk-XX4EVWBF.js";
-import {
-  balanceOfCollectibleOptions,
-  highestOfferOptions,
-  inventoryOptions,
-  listBalancesOptions,
-  listCollectiblesOptions,
-  lowestListingOptions,
-  tokenMetadataOptions
-} from "./chunk-Y2HJO2VY.js";
-import {
-  marketplaceConfigOptions
-} from "./chunk-A7BVFBWB.js";
-import {
-  AddressSchema,
-  CollectableIdSchema,
-  PROVIDER_ID,
-  QueryArgSchema
-} from "./chunk-DWTLVJAW.js";
-import {
-  CollectibleStatus,
-  CollectionStatus,
-  ContractType,
-  MarketplaceKind,
-  OrderSide,
-  OrderStatus,
-  OrderbookKind,
-  ProjectStatus,
-  PropertyType,
-  SortOrder,
-  SourceKind,
-  StepType,
-  TransactionCrypto,
-  TransactionNFTCheckoutProvider,
-  TransactionOnRampProvider,
-  TransactionSwapProvider,
-  WalletKind,
-  balanceQueries,
-  collectableKeys,
-  collectionKeys,
-  currencyKeys,
-  getIndexerClient,
-  getMarketplaceClient,
-  getMetadataClient,
-  getQueryClient
-} from "./chunk-7F27CJZW.js";
-import {
-  BaseError,
-  ChainSwitchError,
-  ChainSwitchUserRejectedError,
-  NoWalletConnectedError,
-  TransactionConfirmationError,
-  TransactionExecutionError,
-  TransactionSignatureError,
-  UserRejectedRequestError,
-  WalletInstanceNotFoundError
-} from "./chunk-NX52D7NX.js";
-
-// src/react/hooks/useAutoSelectFeeOption.tsx
-import { zeroAddress } from "viem";
-import { useChain } from "@0xsequence/connect";
-import { useCallback, useEffect } from "react";
-import { useAccount } from "wagmi";
-
-// src/react/hooks/useCollectionBalanceDetails.tsx
-import { queryOptions, useQuery } from "@tanstack/react-query";
-import { z } from "zod";
-
-// src/react/hooks/useConfig.tsx
-import { useContext } from "react";
-
-// src/utils/_internal/error/context.ts
-var MarketplaceSdkProviderNotFoundError = class extends BaseError {
-  name = "MarketplaceSDKProviderNotFoundError";
-  constructor() {
-    super("`useConfig` must be used within `MarketplaceSdkProvider`.");
-  }
-};
-
-// src/react/provider.tsx
-import { QueryClientProvider } from "@tanstack/react-query";
-import { createContext } from "react";
-
-// src/utils/_internal/error/config.ts
-var ConfigError = class extends BaseError {
-  name = "ConfigError";
-};
-var InvalidProjectAccessKeyError = class extends ConfigError {
-  name = "InvalidProjectAccessKeyError";
-  constructor(projectAccessKey) {
-    super(`Invalid project access key: ${projectAccessKey}`);
-  }
-};
-
-// src/react/provider.tsx
-import { jsx } from "react/jsx-runtime";
-var MarketplaceSdkContext = createContext({});
-function MarketplaceQueryClientProvider({
-  children
-}) {
-  const queryClient = getQueryClient();
-  return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children });
-}
-function MarketplaceProvider({
-  config,
-  children
-}) {
-  if (config.projectAccessKey === "" || !config.projectAccessKey) {
-    throw new InvalidProjectAccessKeyError(config.projectAccessKey);
-  }
-  return /* @__PURE__ */ jsx(MarketplaceQueryClientProvider, { children: /* @__PURE__ */ jsx(MarketplaceSdkContext.Provider, { value: config, children: /* @__PURE__ */ jsx("div", { id: PROVIDER_ID, children }) }) });
-}
-
-// src/react/hooks/useConfig.tsx
-function useConfig() {
-  const context = useContext(MarketplaceSdkContext);
-  if (!context) {
-    throw new MarketplaceSdkProviderNotFoundError();
-  }
-  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: z.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,
-  enabled
-}) {
-  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 && enabled
-    }
-  });
-  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
-    }))
-  ];
-  useEffect(() => {
-    if (combinedBalances) {
-      console.debug("currency balances", combinedBalances);
-    }
-  }, [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
-import { useQuery as useQuery3 } from "@tanstack/react-query";
-
-// src/react/hooks/useMarketplaceConfig.tsx
-import { useQuery as useQuery2 } from "@tanstack/react-query";
-var useMarketplaceConfig = () => {
-  const config = useConfig();
-  return useQuery2(marketplaceConfigOptions(config));
-};
-
-// src/react/hooks/useBalanceOfCollectible.tsx
-function useBalanceOfCollectible(args) {
-  const config = useConfig();
-  const { data: marketplaceConfig } = useMarketplaceConfig();
-  const isLaos721 = marketplaceConfig?.collections.find(
-    (collection) => collection.address === args.collectionAddress
-  )?.isLAOSERC721;
-  if (isLaos721) {
-    args.isLaos721 = true;
-  }
-  return useQuery3(balanceOfCollectibleOptions(args, config));
-}
-
-// src/react/hooks/useCountOfCollectables.tsx
-import { queryOptions as queryOptions2, useQuery as useQuery4 } from "@tanstack/react-query";
-import { z as z3 } 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(
-  TransactionNFTCheckoutProvider
-);
-var transactionOnRampProviderSchema = z2.nativeEnum(
-  TransactionOnRampProvider
-);
-var transactionSwapProviderSchema = z2.nativeEnum(
-  TransactionSwapProvider
-);
-var sortBySchema = z2.object({
-  column: z2.string(),
-  order: sortOrderSchema
-});
-var propertyFilterSchema = z2.object({
-  name: z2.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(),
-  status: projectStatusSchema,
-  createdAt: z2.string(),
-  updatedAt: z2.string(),
-  deletedAt: z2.string().optional()
-});
-var collectibleSchema = z2.object({
-  chainId: z2.number(),
-  contractAddress: z2.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(),
-  marketplace: marketplaceKindSchema
-});
-var domainSchema = z2.object({
-  name: z2.string(),
-  version: z2.string(),
-  chainId: z2.number(),
-  verifyingContract: z2.string()
-});
-var checkoutOptionsMarketplaceOrderSchema = z2.object({
-  contractAddress: z2.string(),
-  orderId: z2.string(),
-  marketplace: marketplaceKindSchema
-});
-var checkoutOptionsItemSchema = z2.object({
-  tokenId: z2.string(),
-  quantity: z2.string()
-});
-var checkoutOptionsSchema = z2.object({
-  crypto: transactionCryptoSchema,
-  swap: z2.array(transactionSwapProviderSchema),
-  nftCheckout: z2.array(transactionNFTCheckoutProviderSchema),
-  onRamp: z2.array(transactionOnRampProviderSchema)
-});
-var listCurrenciesArgsSchema = z2.object({});
-var listCurrenciesReturnSchema = z2.object({
-  currencies: z2.array(currencySchema)
-});
-var getCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string()
-});
-var getLowestPriceOfferForCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
-  filter: orderFilterSchema.optional()
-});
-var getHighestPriceOfferForCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
-  filter: orderFilterSchema.optional()
-});
-var getLowestPriceListingForCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
-  filter: orderFilterSchema.optional()
-});
-var getHighestPriceListingForCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
-  filter: orderFilterSchema.optional()
-});
-var getCollectibleLowestOfferArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
-  filter: orderFilterSchema.optional()
-});
-var getCollectibleHighestOfferArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
-  filter: orderFilterSchema.optional()
-});
-var getCollectibleLowestListingArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
-  filters: orderFilterSchema.optional()
-});
-var getCollectibleHighestListingArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
-  filter: orderFilterSchema.optional()
-});
-var generateBuyTransactionArgsSchema = z2.object({
-  collectionAddress: z2.string(),
-  buyer: z2.string(),
-  marketplace: marketplaceKindSchema,
-  ordersData: z2.array(orderDataSchema),
-  additionalFees: z2.array(additionalFeeSchema),
-  walletType: walletKindSchema.optional()
-});
-var generateSellTransactionArgsSchema = z2.object({
-  collectionAddress: z2.string(),
-  seller: z2.string(),
-  marketplace: marketplaceKindSchema,
-  ordersData: z2.array(orderDataSchema),
-  additionalFees: z2.array(additionalFeeSchema),
-  walletType: walletKindSchema.optional()
-});
-var generateListingTransactionArgsSchema = z2.object({
-  collectionAddress: z2.string(),
-  owner: z2.string(),
-  contractType: contractTypeSchema,
-  orderbook: orderbookKindSchema,
-  listing: createReqSchema,
-  walletType: walletKindSchema.optional()
-});
-var generateOfferTransactionArgsSchema = z2.object({
-  collectionAddress: z2.string(),
-  maker: z2.string(),
-  contractType: contractTypeSchema,
-  orderbook: orderbookKindSchema,
-  offer: createReqSchema,
-  walletType: walletKindSchema.optional()
-});
-var getCountOfAllCollectiblesArgsSchema = z2.object({
-  contractAddress: z2.string()
-});
-var getCountOfAllCollectiblesReturnSchema = z2.object({
-  count: z2.number()
-});
-var getCountOfFilteredCollectiblesArgsSchema = z2.object({
-  side: orderSideSchema,
-  contractAddress: z2.string(),
-  filter: collectiblesFilterSchema.optional()
-});
-var getCountOfFilteredCollectiblesReturnSchema = z2.object({
-  count: z2.number()
-});
-var getFloorOrderArgsSchema = z2.object({
-  contractAddress: z2.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 checkoutOptionsMarketplaceReturnSchema = z2.object({
-  options: checkoutOptionsSchema
-});
-var checkoutOptionsSalesContractArgsSchema = z2.object({
-  wallet: z2.string(),
-  contractAddress: z2.string(),
-  collectionAddress: z2.string(),
-  items: z2.array(checkoutOptionsItemSchema)
-});
-var checkoutOptionsSalesContractReturnSchema = z2.object({
-  options: checkoutOptionsSchema
-});
-var countListingsForCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
-  filter: orderFilterSchema.optional()
-});
-var countListingsForCollectibleReturnSchema = z2.object({
-  count: z2.number()
-});
-var countOffersForCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.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 filterSchema2 = z2.object({
-  text: z2.string().optional(),
-  properties: z2.array(propertyFilterSchema).optional()
-});
-var orderSchema = z2.object({
-  orderId: z2.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({
-  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(),
-  currency: currencySchema.optional()
-});
-var collectionConfigSchema = z2.object({
-  lastSynced: z2.record(collectionLastSyncedSchema),
-  collectiblesSynced: z2.string()
-});
-var signatureSchema = z2.object({
-  domain: domainSchema,
-  types: z2.any(),
-  primaryType: z2.string(),
-  value: z2.any()
-});
-var getCollectibleReturnSchema = z2.object({
-  metadata: tokenMetadataSchema
-});
-var getLowestPriceOfferForCollectibleReturnSchema = z2.object({
-  order: orderSchema
-});
-var getHighestPriceOfferForCollectibleReturnSchema = z2.object({
-  order: orderSchema
-});
-var getLowestPriceListingForCollectibleReturnSchema = z2.object({
-  order: orderSchema
-});
-var getHighestPriceListingForCollectibleReturnSchema = z2.object({
-  order: orderSchema
-});
-var listListingsForCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
-  filter: orderFilterSchema.optional(),
-  page: pageSchema.optional()
-});
-var listListingsForCollectibleReturnSchema = z2.object({
-  listings: z2.array(orderSchema),
-  page: pageSchema.optional()
-});
-var listOffersForCollectibleArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
-  filter: orderFilterSchema.optional(),
-  page: pageSchema.optional()
-});
-var listOffersForCollectibleReturnSchema = z2.object({
-  offers: z2.array(orderSchema),
-  page: pageSchema.optional()
-});
-var getListCollectibleActivitiesArgsSchema = z2.object({
-  chainId: z2.number(),
-  collectionAddress: AddressSchema,
-  tokenId: CollectableIdSchema.pipe(z2.coerce.string()),
-  query: pageSchema.extend({
-    enabled: z2.boolean().optional()
-  }).optional()
-});
-var getListCollectibleActivitiesReturnSchema = z2.object({
-  activities: z2.array(activitySchema),
-  page: pageSchema.optional()
-});
-var getListCollectionActivitiesArgsSchema = z2.object({
-  chainId: z2.number(),
-  collectionAddress: AddressSchema,
-  query: pageSchema.extend({
-    enabled: z2.boolean().optional()
-  }).optional()
-});
-var getListCollectionActivitiesReturnSchema = z2.object({
-  activities: z2.array(activitySchema),
-  page: pageSchema.optional()
-});
-var getCollectibleLowestOfferReturnSchema = z2.object({
-  order: orderSchema.optional()
-});
-var getCollectibleHighestOfferReturnSchema = z2.object({
-  order: orderSchema.optional()
-});
-var getCollectibleLowestListingReturnSchema = z2.object({
-  order: orderSchema.optional()
-});
-var getCollectibleHighestListingReturnSchema = z2.object({
-  order: orderSchema.optional()
-});
-var listCollectibleListingsArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
-  filter: orderFilterSchema.optional(),
-  page: pageSchema.optional()
-});
-var listCollectibleListingsReturnSchema = z2.object({
-  listings: z2.array(orderSchema),
-  page: pageSchema.optional()
-});
-var listCollectibleOffersArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  tokenId: z2.string(),
-  filter: orderFilterSchema.optional(),
-  page: pageSchema.optional()
-});
-var listCollectibleOffersReturnSchema = z2.object({
-  offers: z2.array(orderSchema),
-  page: pageSchema.optional()
-});
-var listCollectiblesArgsSchema = z2.object({
-  side: orderSideSchema,
-  contractAddress: z2.string(),
-  filter: collectiblesFilterSchema.optional(),
-  page: pageSchema.optional()
-});
-var listCollectiblesReturnSchema = z2.object({
-  collectibles: z2.array(collectibleOrderSchema),
-  page: pageSchema.optional()
-});
-var getFloorOrderReturnSchema = z2.object({
-  collectible: collectibleOrderSchema
-});
-var listCollectiblesWithLowestListingArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  filter: collectiblesFilterSchema.optional(),
-  page: pageSchema.optional()
-});
-var listCollectiblesWithLowestListingReturnSchema = z2.object({
-  collectibles: z2.array(collectibleOrderSchema),
-  page: pageSchema.optional()
-});
-var listCollectiblesWithHighestOfferArgsSchema = z2.object({
-  contractAddress: z2.string(),
-  filter: collectiblesFilterSchema.optional(),
-  page: pageSchema.optional()
-});
-var listCollectiblesWithHighestOfferReturnSchema = z2.object({
-  collectibles: z2.array(collectibleOrderSchema),
-  page: pageSchema.optional()
-});
-var syncOrderArgsSchema = z2.object({
-  order: orderSchema
-});
-var syncOrdersArgsSchema = z2.object({
-  orders: z2.array(orderSchema)
-});
-var getOrdersArgsSchema = z2.object({
-  input: z2.array(getOrdersInputSchema),
-  page: pageSchema.optional()
-});
-var getOrdersReturnSchema = z2.object({
-  orders: z2.array(orderSchema),
-  page: pageSchema.optional()
-});
-var collectionSchema = z2.object({
-  status: collectionStatusSchema,
-  chainId: z2.number(),
-  contractAddress: z2.string(),
-  contractType: contractTypeSchema,
-  tokenQuantityDecimals: z2.number(),
-  config: collectionConfigSchema,
-  createdAt: z2.string(),
-  updatedAt: z2.string(),
-  deletedAt: z2.string().optional()
-});
-var stepSchema = z2.object({
-  id: z2.nativeEnum(StepType),
-  data: z2.string().optional(),
-  to: z2.string().optional(),
-  value: z2.string().optional(),
-  price: z2.string().optional(),
-  signature: signatureSchema.optional(),
-  post: postRequestSchema.optional(),
-  method: z2.string().optional(),
-  endpoint: z2.string().optional()
-});
-var generateBuyTransactionReturnSchema = z2.object({
-  steps: z2.array(stepSchema)
-});
-var generateSellTransactionReturnSchema = z2.object({
-  steps: z2.array(stepSchema)
-});
-var generateListingTransactionReturnSchema = z2.object({
-  steps: z2.array(stepSchema)
-});
-var generateOfferTransactionReturnSchema = z2.object({
-  steps: z2.array(stepSchema)
-});
-
-// src/react/hooks/useCountOfCollectables.tsx
-var BaseSchema = z3.object({
-  chainId: z3.number(),
-  collectionAddress: AddressSchema,
-  query: QueryArgSchema
-});
-var UseCountOfCollectableSchema = BaseSchema.extend({
-  filter: collectiblesFilterSchema,
-  side: z3.nativeEnum(OrderSide)
-}).or(
-  BaseSchema.extend({
-    filter: z3.undefined(),
-    side: z3.undefined()
-  })
-);
-var fetchCountOfCollectables = async (args, config) => {
-  const parsedArgs = UseCountOfCollectableSchema.parse(args);
-  const marketplaceClient = getMarketplaceClient(parsedArgs.chainId, config);
-  if (parsedArgs.filter) {
-    return marketplaceClient.getCountOfFilteredCollectibles({
-      ...parsedArgs,
-      contractAddress: parsedArgs.collectionAddress,
-      // biome-ignore lint/style/noNonNullAssertion: safe to assert here, as it's validated
-      side: parsedArgs.side
-    }).then((resp) => resp.count);
-  }
-  return marketplaceClient.getCountOfAllCollectibles({
-    ...parsedArgs,
-    contractAddress: parsedArgs.collectionAddress
-  }).then((resp) => resp.count);
-};
-var countOfCollectablesOptions = (args, config) => {
-  return queryOptions2({
-    ...args.query,
-    queryKey: [...collectableKeys.counts, args],
-    queryFn: () => fetchCountOfCollectables(args, config)
-  });
-};
-var useCountOfCollectables = (args) => {
-  const config = useConfig();
-  return useQuery4(countOfCollectablesOptions(args, config));
-};
-
-// src/react/hooks/useCollectible.tsx
-import { queryOptions as queryOptions3, useQuery as useQuery5 } from "@tanstack/react-query";
-import { z as z4 } from "zod";
-var UseCollectibleSchema = z4.object({
-  chainId: z4.number(),
-  collectionAddress: AddressSchema,
-  collectibleId: z4.string().optional(),
-  query: QueryArgSchema
-});
-var fetchCollectible = async (args, config) => {
-  const parsedArgs = UseCollectibleSchema.parse(args);
-  const metadataClient = getMetadataClient(config);
-  const tokenIds = parsedArgs.collectibleId ? [parsedArgs.collectibleId] : [];
-  return metadataClient.getTokenMetadata({
-    chainID: parsedArgs.chainId.toString(),
-    contractAddress: parsedArgs.collectionAddress,
-    tokenIDs: tokenIds
-  }).then((resp) => resp.tokenMetadata[0]);
-};
-var collectibleOptions = (args, config) => {
-  return queryOptions3({
-    ...args.query,
-    queryKey: [...collectableKeys.details, args, config],
-    queryFn: () => fetchCollectible(args, config)
-  });
-};
-var useCollectible = (args) => {
-  const config = useConfig();
-  return useQuery5(collectibleOptions(args, config));
-};
-
-// src/react/hooks/useCollection.tsx
-import { useQuery as useQuery6 } from "@tanstack/react-query";
-var useCollection = (args) => {
-  const config = useConfig();
-  return useQuery6(collectionOptions(args, config));
-};
-
-// src/react/hooks/useComparePrices.tsx
-import { queryOptions as queryOptions6, useQuery as useQuery9 } from "@tanstack/react-query";
-import { z as z7 } from "zod";
-
-// src/react/hooks/useConvertPriceToUSD.tsx
-import { queryOptions as queryOptions5, useQuery as useQuery8 } from "@tanstack/react-query";
-import { formatUnits } from "viem";
-import { z as z6 } from "zod";
-
-// src/react/hooks/useCurrencies.tsx
-import { queryOptions as queryOptions4, useQuery as useQuery7 } from "@tanstack/react-query";
-import { zeroAddress as zeroAddress2 } from "viem";
-import { z as z5 } from "zod";
-var UseCurrenciesArgsSchema = z5.object({
-  chainId: z5.number(),
-  includeNativeCurrency: z5.boolean().optional().default(true),
-  collectionAddress: AddressSchema.optional(),
-  query: QueryArgSchema
-});
-var fetchCurrencies = async (args, config) => {
-  const parsedArgs = UseCurrenciesArgsSchema.parse(args);
-  const marketplaceClient = getMarketplaceClient(parsedArgs.chainId, config);
-  let currencies = await marketplaceClient.listCurrencies().then(
-    (resp) => resp.currencies.map((currency) => ({
-      ...currency,
-      contractAddress: currency.contractAddress || zeroAddress2
-    }))
-  );
-  if (parsedArgs.collectionAddress) {
-    const queryClient = getQueryClient();
-    const marketplaceConfig = await queryClient.fetchQuery(
-      marketplaceConfigOptions(config)
-    );
-    const currenciesOptions2 = marketplaceConfig.collections.find(
-      (collection) => collection.address === args.collectionAddress
-    )?.currencyOptions;
-    if (currenciesOptions2) {
-      currencies = currencies.filter(
-        (currency) => currenciesOptions2.includes(currency.contractAddress)
-      );
-    }
-  }
-  if (!parsedArgs.includeNativeCurrency) {
-    currencies = currencies.filter((currency) => !currency.nativeCurrency);
-  }
-  return currencies;
-};
-var currenciesOptions = (args, config) => {
-  return queryOptions4({
-    ...args.query,
-    queryKey: [...currencyKeys.lists, args],
-    queryFn: () => fetchCurrencies(args, config),
-    enabled: args.query?.enabled
-  });
-};
-var useCurrencies = (args) => {
-  const config = useConfig();
-  return useQuery7(currenciesOptions(args, config));
-};
-
-// src/react/hooks/useConvertPriceToUSD.tsx
-var UseConvertPriceToUSDArgsSchema = z6.object({
-  chainId: z6.number(),
-  currencyAddress: AddressSchema,
-  amountRaw: z6.string(),
-  query: QueryArgSchema
-});
-var convertPriceToUSD = async (args, config) => {
-  const parsedArgs = UseConvertPriceToUSDArgsSchema.parse(args);
-  const queryClient = getQueryClient();
-  const currencies = await queryClient.fetchQuery(
-    currenciesOptions(
-      {
-        chainId: parsedArgs.chainId
-      },
-      config
-    )
-  );
-  const currencyDetails = currencies.find(
-    (c) => c.contractAddress.toLowerCase() === parsedArgs.currencyAddress.toLowerCase()
-  );
-  if (!currencyDetails) {
-    throw new Error("Currency not found");
-  }
-  const amountDecimal = Number(
-    formatUnits(BigInt(parsedArgs.amountRaw), currencyDetails.decimals)
-  );
-  const usdAmount = amountDecimal * currencyDetails.exchangeRate;
-  return {
-    usdAmount,
-    usdAmountFormatted: usdAmount.toFixed(2)
-  };
-};
-var convertPriceToUSDOptions = (args, config) => {
-  return queryOptions5({
-    ...args.query,
-    queryKey: [
-      ...currencyKeys.conversion,
-      args.chainId,
-      args.currencyAddress,
-      args.amountRaw
-    ],
-    queryFn: () => convertPriceToUSD(args, config)
-  });
-};
-var useConvertPriceToUSD = (args) => {
-  const config = useConfig();
-  return useQuery8(convertPriceToUSDOptions(args, config));
-};
-
-// src/react/hooks/useComparePrices.tsx
-var UseComparePricesArgsSchema = z7.object({
-  chainId: z7.number(),
-  // First price details
-  priceAmountRaw: z7.string(),
-  priceCurrencyAddress: AddressSchema,
-  // Second price details (to compare against)
-  compareToPriceAmountRaw: z7.string(),
-  compareToPriceCurrencyAddress: AddressSchema,
-  query: QueryArgSchema
-});
-var comparePrices = async (args, config) => {
-  const parsedArgs = UseComparePricesArgsSchema.parse(args);
-  const [priceUSD, compareToPriceUSD] = await Promise.all([
-    convertPriceToUSD(
-      {
-        chainId: parsedArgs.chainId,
-        currencyAddress: parsedArgs.priceCurrencyAddress,
-        amountRaw: parsedArgs.priceAmountRaw,
-        query: {}
-      },
-      config
-    ),
-    convertPriceToUSD(
-      {
-        chainId: parsedArgs.chainId,
-        currencyAddress: parsedArgs.compareToPriceCurrencyAddress,
-        amountRaw: parsedArgs.compareToPriceAmountRaw,
-        query: {}
-      },
-      config
-    )
-  ]);
-  const difference = priceUSD.usdAmount - compareToPriceUSD.usdAmount;
-  if (compareToPriceUSD.usdAmount === 0) {
-    throw new Error("Cannot compare to zero price");
-  }
-  const percentageDifference = difference / compareToPriceUSD.usdAmount * 100;
-  const isAbove = percentageDifference > 0;
-  const isSame = percentageDifference === 0;
-  return {
-    percentageDifference,
-    percentageDifferenceFormatted: Math.abs(percentageDifference).toFixed(2),
-    status: isAbove ? "above" : isSame ? "same" : "below"
-  };
-};
-var comparePricesOptions = (args, config) => {
-  return queryOptions6({
-    ...args.query,
-    queryKey: [...currencyKeys.conversion, "compare", args],
-    queryFn: () => comparePrices(args, config)
-  });
-};
-var useComparePrices = (args) => {
-  const config = useConfig();
-  return useQuery9(comparePricesOptions(args, config));
-};
-
-// src/react/hooks/useCurrency.tsx
-import { queryOptions as queryOptions7, skipToken, useQuery as useQuery10 } from "@tanstack/react-query";
-import { z as z8 } from "zod";
-var UseCurrencyArgsSchema = z8.object({
-  chainId: z8.number(),
-  currencyAddress: AddressSchema.optional(),
-  query: QueryArgSchema
-});
-var fetchCurrency = async (chainId, currencyAddress, config) => {
-  const queryClient = getQueryClient();
-  let currencies = queryClient.getQueryData([...currencyKeys.lists, chainId]);
-  if (!currencies) {
-    const marketplaceClient = getMarketplaceClient(chainId, config);
-    currencies = await marketplaceClient.listCurrencies().then((resp) => resp.currencies);
-  }
-  if (!currencies?.length) {
-    throw new Error("No currencies returned");
-  }
-  const currency = currencies.find(
-    (currency2) => currency2.contractAddress.toLowerCase() === currencyAddress.toLowerCase()
-  );
-  if (!currency) {
-    throw new Error("Currency not found");
-  }
-  return currency;
-};
-var currencyOptions = (args, config) => {
-  const { chainId, currencyAddress } = args;
-  return queryOptions7({
-    ...args.query,
-    queryKey: [...currencyKeys.details, args.chainId, args.currencyAddress],
-    queryFn: chainId && currencyAddress ? () => fetchCurrency(chainId, currencyAddress, config) : skipToken
-  });
-};
-var useCurrency = (args) => {
-  const config = useConfig();
-  return useQuery10(currencyOptions(args, config));
-};
-
-// src/react/hooks/useFilters.tsx
-import { queryOptions as queryOptions8, useQuery as useQuery11 } from "@tanstack/react-query";
-import { z as z9 } from "zod";
-var UseFiltersSchema = z9.object({
-  chainId: z9.number(),
-  collectionAddress: AddressSchema,
-  showAllFilters: z9.boolean().default(false).optional(),
-  query: QueryArgSchema,
-  excludePropertyValues: z9.boolean().default(false).optional()
-});
-var fetchFilters = async (args, config) => {
-  const parsedArgs = UseFiltersSchema.parse(args);
-  const metadataClient = getMetadataClient(config);
-  const filters = await metadataClient.getTokenMetadataPropertyFilters({
-    chainID: parsedArgs.chainId.toString(),
-    contractAddress: parsedArgs.collectionAddress,
-    excludeProperties: [],
-    // TODO: We can leverage this for some of the exclusion logic
-    excludePropertyValues: parsedArgs.excludePropertyValues
-  }).then((resp) => resp.filters);
-  if (args.showAllFilters) return filters;
-  const queryClient = getQueryClient();
-  const marketplaceConfig = await queryClient.fetchQuery(
-    marketplaceConfigOptions(config)
-  );
-  const collectionFilters = marketplaceConfig.collections.find(
-    (c) => compareAddress(c.address, parsedArgs.collectionAddress)
-  )?.filterSettings;
-  if (!collectionFilters?.exclusions || collectionFilters.exclusions.length === 0 || !collectionFilters.filterOrder || collectionFilters.filterOrder.length === 0)
-    return filters;
-  const { filterOrder, exclusions } = collectionFilters;
-  const sortedFilters = filters.toSorted((a, b) => {
-    const aIndex = filterOrder.indexOf(a.name) > -1 ? filterOrder.indexOf(a.name) : filterOrder.length;
-    const bIndex = filterOrder.indexOf(b.name) > -1 ? filterOrder.indexOf(b.name) : filterOrder.length;
-    return aIndex - bIndex;
-  });
-  const filteredResults = sortedFilters.reduce(
-    (acc, filter) => {
-      const exclusionRule = exclusions.find((rule) => rule.key === filter.name);
-      if (!exclusionRule) {
-        acc.push(filter);
-        return acc;
-      }
-      if (exclusionRule.condition === "ENTIRE_KEY" /* ENTIRE_KEY */) {
-        return acc;
-      }
-      if (exclusionRule.condition === "SPECIFIC_VALUE" /* SPECIFIC_VALUE */ && exclusionRule.value) {
-        const filteredValues = filter.values?.filter((value) => value !== exclusionRule.value) || [];
-        if (filteredValues.length > 0) {
-          acc.push({ ...filter, values: filteredValues });
-        }
-      }
-      return acc;
-    },
-    []
-  );
-  return filteredResults;
-};
-var filtersOptions = (args, config) => {
-  return queryOptions8({
-    ...args.query,
-    queryKey: [...collectableKeys.filter, args, config],
-    queryFn: () => fetchFilters(args, config)
-  });
-};
-var useFilters = (args) => {
-  const config = useConfig();
-  return useQuery11(filtersOptions(args, config));
-};
-var useFiltersProgressive = (args) => {
-  const config = useConfig();
-  const namesQuery = useQuery11(
-    filtersOptions({ ...args, excludePropertyValues: true }, config)
-  );
-  const fullQuery = useQuery11({
-    ...filtersOptions(args, config),
-    placeholderData: namesQuery.data
-  });
-  const isLoadingNames = namesQuery.isLoading;
-  const isFetchingValues = fullQuery.isPlaceholderData && fullQuery.isFetching;
-  return {
-    ...fullQuery,
-    isFetchingValues,
-    isLoadingNames
-  };
-};
-
-// src/react/hooks/useFilterState.tsx
-import { useMemo } from "react";
-import {
-  createSerializer,
-  parseAsBoolean,
-  parseAsJson,
-  parseAsString,
-  useQueryState
-} from "nuqs";
-var validateFilters = (value) => {
-  if (!Array.isArray(value)) return [];
-  return value.filter(
-    (f) => typeof f === "object" && typeof f.name === "string" && Object.values(PropertyType).includes(f.type)
-  );
-};
-var filtersParser = parseAsJson(validateFilters).withDefault([]);
-var searchParser = parseAsString.withDefault("");
-var listedOnlyParser = parseAsBoolean.withDefault(false);
-var serialize = createSerializer(
-  {
-    filters: filtersParser,
-    search: searchParser,
-    listedOnly: listedOnlyParser
-  },
-  {
-    urlKeys: {
-      filters: "f",
-      search: "q",
-      listedOnly: "l"
-    }
-  }
-);
-function useFilterState() {
-  const [filterOptions, setFilterOptions] = useQueryState(
-    "filters",
-    filtersParser
-  );
-  const [searchText, setSearchText] = useQueryState("search", searchParser);
-  const [showListedOnly, setShowListedOnly] = useQueryState(
-    "listedOnly",
-    listedOnlyParser
-  );
-  const helpers = useMemo(
-    () => ({
-      getFilter: (name) => {
-        return filterOptions?.find((f) => f.name === name);
-      },
-      getFilterValues: (name) => {
-        const filter = filterOptions?.find((f) => f.name === name);
-        if (!filter) return void 0;
-        if (filter.type === "INT" /* INT */) {
-          return {
-            type: "INT" /* INT */,
-            min: filter.min ?? 0,
-            max: filter.max ?? 0
-          };
-        }
-        return {
-          type: "STRING" /* STRING */,
-          values: filter.values ?? []
-        };
-      },
-      isFilterActive: (name) => {
-        return !!filterOptions?.find((f) => f.name === name);
-      },
-      isStringValueSelected: (name, value) => {
-        const filter = filterOptions?.find((f) => f.name === name);
-        if (!filter || filter.type !== "STRING" /* STRING */) return false;
-        return filter.values?.includes(value) ?? false;
-      },
-      isIntFilterActive: (name) => {
-        const filter = filterOptions?.find((f) => f.name === name);
-        return !!filter && filter.type === "INT" /* INT */;
-      },
-      getIntFilterRange: (name) => {
-        const filter = filterOptions?.find((f) => f.name === name);
-        if (!filter || filter.type !== "INT" /* INT */) return void 0;
-        return [filter.min ?? 0, filter.max ?? 0];
-      },
-      deleteFilter: (name) => {
-        const otherFilters = filterOptions?.filter((f) => !(f.name === name)) ?? [];
-        setFilterOptions(otherFilters);
-      },
-      toggleStringFilterValue: (name, value) => {
-        const otherFilters = filterOptions?.filter((f) => !(f.name === name)) ?? [];
-        const filter = filterOptions?.find((f) => f.name === name);
-        const existingValues = filter?.type === "STRING" /* STRING */ ? filter.values ?? [] : [];
-        if (existingValues.includes(value)) {
-          const newValues = existingValues.filter((v) => v !== value);
-          if (newValues.length === 0) {
-            setFilterOptions(otherFilters);
-            return;
-          }
-          setFilterOptions([
-            ...otherFilters,
-            { name, type: "STRING" /* STRING */, values: newValues }
-          ]);
-        } else {
-          setFilterOptions([
-            ...otherFilters,
-            {
-              name,
-              type: "STRING" /* STRING */,
-              values: [...existingValues, value]
-            }
-          ]);
-        }
-      },
-      setIntFilterValue: (name, min, max) => {
-        if (min === max && min === 0) {
-          const otherFilters2 = filterOptions?.filter((f) => !(f.name === name)) ?? [];
-          setFilterOptions(otherFilters2);
-          return;
-        }
-        const otherFilters = filterOptions?.filter((f) => !(f.name === name)) ?? [];
-        setFilterOptions([
-          ...otherFilters,
-          { name, type: "INT" /* INT */, min, max }
-        ]);
-      },
-      clearAllFilters: () => {
-        void setShowListedOnly(false);
-        void setFilterOptions([]);
-        void setSearchText("");
-      }
-    }),
-    [filterOptions, setFilterOptions, setShowListedOnly, setSearchText]
-  );
-  return {
-    filterOptions,
-    searchText,
-    showListedOnly,
-    setFilterOptions,
-    setSearchText,
-    setShowListedOnly,
-    ...helpers,
-    serialize
-  };
-}
-
-// src/react/hooks/useFloorOrder.tsx
-import { queryOptions as queryOptions9, useQuery as useQuery12 } from "@tanstack/react-query";
-import { z as z10 } from "zod";
-var UseFloorOrderSchema = z10.object({
-  chainId: z10.number(),
-  collectionAddress: AddressSchema,
-  query: QueryArgSchema
-});
-var fetchFloorOrder = async (args, config) => {
-  const marketplaceClient = getMarketplaceClient(args.chainId, config);
-  return marketplaceClient.getFloorOrder({ contractAddress: args.collectionAddress }).then((data) => data.collectible);
-};
-var floorOrderOptions = (args, config) => {
-  return queryOptions9({
-    queryKey: [...collectableKeys.floorOrders, args, config],
-    queryFn: () => fetchFloorOrder(args, config)
-  });
-};
-var useFloorOrder = (args) => {
-  const config = useConfig();
-  return useQuery12(floorOrderOptions(args, config));
-};
-
-// src/react/hooks/useHighestOffer.tsx
-import { useQuery as useQuery13 } from "@tanstack/react-query";
-function useHighestOffer(args) {
-  const config = useConfig();
-  return useQuery13(highestOfferOptions(args, config));
-}
-
-// src/react/hooks/useInventory.tsx
-import { useInfiniteQuery } from "@tanstack/react-query";
-function useInventory(args) {
-  const config = useConfig();
-  const marketplaceConfig = useMarketplaceConfig();
-  const isLaos721 = marketplaceConfig.data?.collections.find(
-    (c) => c.address === args.collectionAddress
-  )?.isLAOSERC721 ?? false;
-  return useInfiniteQuery(inventoryOptions({ ...args, isLaos721 }, config));
-}
-
-// src/react/hooks/useListBalances.tsx
-import { useInfiniteQuery as useInfiniteQuery2 } from "@tanstack/react-query";
-function useListBalances(args) {
-  const config = useConfig();
-  const { data: marketplaceConfig } = useMarketplaceConfig();
-  const isLaos721 = marketplaceConfig?.collections.find(
-    (collection) => collection.address === args.contractAddress
-  )?.isLAOSERC721;
-  if (isLaos721) {
-    args.isLaos721 = true;
-  }
-  return useInfiniteQuery2(listBalancesOptions(args, config));
-}
-
-// src/react/hooks/useListCollectibleActivities.tsx
-import { queryOptions as queryOptions10, useQuery as useQuery14 } from "@tanstack/react-query";
-var fetchCollectibleActivities = async (args, config) => {
-  const marketplaceClient = getMarketplaceClient(args.chainId, config);
-  return marketplaceClient.listCollectibleActivities({
-    contractAddress: args.collectionAddress,
-    tokenId: args.tokenId,
-    page: args.query?.enabled ? {
-      page: args.query.page ?? 1,
-      pageSize: args.query.pageSize ?? 10,
-      sort: args.query.sort
-    } : void 0
-  }).then((data) => ({
-    activities: data.activities,
-    page: data.page
-  }));
-};
-var listCollectibleActivitiesOptions = (args, config) => {
-  return queryOptions10({
-    queryKey: [...collectableKeys.collectibleActivities, args, config],
-    queryFn: () => fetchCollectibleActivities(args, config),
-    enabled: args.query?.enabled ?? true
-  });
-};
-var useListCollectibleActivities = (args) => {
-  const config = useConfig();
-  return useQuery14(listCollectibleActivitiesOptions(args, config));
-};
-
-// src/react/hooks/useListCollectibles.tsx
-import { useInfiniteQuery as useInfiniteQuery3 } from "@tanstack/react-query";
-function useListCollectibles(args) {
-  const config = useConfig();
-  const { data: marketplaceConfig } = useMarketplaceConfig();
-  const isLaos721 = marketplaceConfig?.collections.find(
-    (collection) => collection.address === args.collectionAddress
-  )?.isLAOSERC721;
-  if (isLaos721) {
-    args.isLaos721 = true;
-  }
-  return useInfiniteQuery3(listCollectiblesOptions(args, config));
-}
-
-// src/react/hooks/useListCollectiblesPaginated.tsx
-import { queryOptions as queryOptions11, useQuery as useQuery15 } from "@tanstack/react-query";
-import { z as z11 } from "zod";
-var UseListCollectiblesPaginatedArgsSchema = listCollectiblesArgsSchema.omit({
-  contractAddress: true
-}).extend({
-  collectionAddress: AddressSchema,
-  chainId: z11.number(),
-  query: z11.object({
-    enabled: z11.boolean().optional(),
-    page: z11.number().optional().default(1),
-    pageSize: z11.number().optional().default(30)
-  }).optional().default({})
-});
-var fetchCollectiblesPaginated = async (args, marketplaceClient) => {
-  const parsedArgs = UseListCollectiblesPaginatedArgsSchema.parse(args);
-  const page = {
-    page: parsedArgs.query?.page ?? 1,
-    pageSize: parsedArgs.query?.pageSize ?? 30
-  };
-  const arg = {
-    ...parsedArgs,
-    contractAddress: parsedArgs.collectionAddress,
-    page
-  };
-  return marketplaceClient.listCollectibles(arg);
-};
-var listCollectiblesPaginatedOptions = (args, config) => {
-  const marketplaceClient = getMarketplaceClient(args.chainId, config);
-  return queryOptions11({
-    queryKey: [...collectableKeys.lists, "paginated", args],
-    queryFn: () => fetchCollectiblesPaginated(args, marketplaceClient),
-    enabled: args.query?.enabled ?? true
-  });
-};
-var useListCollectiblesPaginated = (args) => {
-  const config = useConfig();
-  return useQuery15(listCollectiblesPaginatedOptions(args, config));
-};
-
-// src/react/hooks/useListCollectionActivities.tsx
-import { queryOptions as queryOptions12, useQuery as useQuery16 } from "@tanstack/react-query";
-var fetchListCollectionActivities = async (args, config) => {
-  const marketplaceClient = getMarketplaceClient(args.chainId, config);
-  return marketplaceClient.listCollectionActivities({
-    contractAddress: args.collectionAddress,
-    page: args.query?.enabled ? {
-      page: args.query.page ?? 1,
-      pageSize: args.query.pageSize ?? 10,
-      sort: args.query.sort
-    } : void 0
-  }).then((data) => ({
-    activities: data.activities,
-    page: data.page
-  }));
-};
-var listCollectionActivitiesOptions = (args, config) => {
-  return queryOptions12({
-    queryKey: [...collectionKeys.collectionActivities, args, config],
-    queryFn: () => fetchListCollectionActivities(args, config),
-    enabled: args.query?.enabled ?? true
-  });
-};
-var useListCollectionActivities = (args) => {
-  const config = useConfig();
-  return useQuery16(listCollectionActivitiesOptions(args, config));
-};
-
-// src/react/hooks/useListOffersForCollectible.tsx
-import { queryOptions as queryOptions13, useQuery as useQuery17 } from "@tanstack/react-query";
-import { z as z12 } from "zod";
-var UseListOffersForCollectibleArgsSchema = listOffersForCollectibleArgsSchema.extend({
-  chainId: z12.number(),
-  collectionAddress: z12.string(),
-  collectibleId: z12.string()
-}).omit({ contractAddress: true, tokenId: true });
-var fetchListOffersForCollectible = async (config, args) => {
-  const arg = {
-    contractAddress: args.collectionAddress,
-    tokenId: args.collectibleId,
-    filter: args.filter,
-    page: args.page
-  };
-  const marketplaceClient = getMarketplaceClient(args.chainId, config);
-  return marketplaceClient.listCollectibleOffers(arg);
-};
-var listOffersForCollectibleOptions = (args, config) => {
-  return queryOptions13({
-    queryKey: [...collectableKeys.offers, args, config],
-    queryFn: () => fetchListOffersForCollectible(config, args)
-  });
-};
-var useListOffersForCollectible = (args) => {
-  const config = useConfig();
-  return useQuery17(listOffersForCollectibleOptions(args, config));
-};
-
-// src/react/hooks/useCountOffersForCollectible.tsx
-import { queryOptions as queryOptions14, useQuery as useQuery18 } from "@tanstack/react-query";
-import { z as z13 } from "zod";
-var UseCountOffersForCollectibleArgsSchema = countOffersForCollectibleArgsSchema.omit({
-  contractAddress: true,
-  tokenId: true
-}).extend({
-  collectionAddress: AddressSchema,
-  collectibleId: z13.string(),
-  chainId: z13.number(),
-  query: QueryArgSchema
-});
-var fetchCountOffersForCollectible = async (args, config) => {
-  const parsedArgs = UseCountOffersForCollectibleArgsSchema.parse(args);
-  const marketplaceClient = getMarketplaceClient(parsedArgs.chainId, config);
-  return marketplaceClient.getCountOfOffersForCollectible({
-    ...parsedArgs,
-    contractAddress: parsedArgs.collectionAddress,
-    tokenId: parsedArgs.collectibleId
-  });
-};
-var countOffersForCollectibleOptions = (args, config) => {
-  return queryOptions14({
-    ...args.query,
-    queryKey: [...collectableKeys.offersCount, args, config],
-    queryFn: () => fetchCountOffersForCollectible(args, config)
-  });
-};
-var useCountOffersForCollectible = (args) => {
-  const config = useConfig();
-  return useQuery18(countOffersForCollectibleOptions(args, config));
-};
-
-// src/react/hooks/useListListingsForCollectible.tsx
-import { queryOptions as queryOptions15, useQuery as useQuery19 } from "@tanstack/react-query";
-import { z as z14 } from "zod";
-var UseListListingsForCollectibleArgsSchema = listListingsForCollectibleArgsSchema.extend({
-  chainId: z14.number(),
-  collectionAddress: z14.string(),
-  collectibleId: z14.string()
-}).omit({ contractAddress: true, tokenId: true });
-var fetchListListingsForCollectible = async (config, args) => {
-  const arg = {
-    contractAddress: args.collectionAddress,
-    tokenId: args.collectibleId,
-    filter: args.filter,
-    page: args.page
-  };
-  const marketplaceClient = getMarketplaceClient(args.chainId, config);
-  return marketplaceClient.listCollectibleListings(arg);
-};
-var listListingsForCollectibleOptions = (args, config) => {
-  return queryOptions15({
-    queryKey: [...collectableKeys.listings, args, config],
-    queryFn: () => fetchListListingsForCollectible(config, args)
-  });
-};
-var useListListingsForCollectible = (args) => {
-  const config = useConfig();
-  return useQuery19(listListingsForCollectibleOptions(args, config));
-};
-
-// src/react/hooks/useCountListingsForCollectible.tsx
-import { queryOptions as queryOptions16, useQuery as useQuery20 } from "@tanstack/react-query";
-import { z as z15 } from "zod";
-var UseCountListingsForCollectibleArgsSchema = countListingsForCollectibleArgsSchema.omit({
-  contractAddress: true,
-  tokenId: true
-}).extend({
-  collectionAddress: AddressSchema,
-  collectibleId: z15.string(),
-  chainId: z15.number(),
-  query: QueryArgSchema
-});
-var fetchCountListingsForCollectible = async (args, config) => {
-  const parsedArgs = UseCountListingsForCollectibleArgsSchema.parse(args);
-  const marketplaceClient = getMarketplaceClient(parsedArgs.chainId, config);
-  return marketplaceClient.getCountOfListingsForCollectible({
-    ...parsedArgs,
-    contractAddress: parsedArgs.collectionAddress,
-    tokenId: parsedArgs.collectibleId
-  });
-};
-var countListingsForCollectibleOptions = (args, config) => {
-  return queryOptions16({
-    ...args.query,
-    queryKey: [...collectableKeys.listingsCount, args, config],
-    queryFn: () => fetchCountListingsForCollectible(args, config)
-  });
-};
-var useCountListingsForCollectible = (args) => {
-  const config = useConfig();
-  return useQuery20(countListingsForCollectibleOptions(args, config));
-};
-
-// src/react/hooks/useLowestListing.tsx
-import { useQuery as useQuery21 } from "@tanstack/react-query";
-function useLowestListing(args) {
-  const config = useConfig();
-  return useQuery21(lowestListingOptions(args, config));
-}
-
-// src/react/hooks/useRoyalty.tsx
-import { useReadContract } from "wagmi";
-import { z as z16 } from "zod";
-var UseRoyaltySchema = z16.object({
-  chainId: z16.number(),
-  collectionAddress: AddressSchema,
-  collectibleId: z16.string(),
-  query: QueryArgSchema.optional()
-});
-var useRoyalty = (args) => {
-  const { chainId, collectionAddress, collectibleId, query } = args;
-  const scopeKey = `${collectableKeys.royaltyPercentage.join(".")}-${chainId}-${collectionAddress}-${collectibleId}`;
-  const contractResult = useReadContract({
-    scopeKey,
-    abi: EIP2981_ABI,
-    address: collectionAddress,
-    functionName: "royaltyInfo",
-    args: [BigInt(collectibleId), BigInt(100)],
-    chainId,
-    query
-  });
-  const [recipient, percentage] = contractResult.data ?? [];
-  const formattedData = recipient && percentage ? {
-    percentage,
-    recipient
-  } : null;
-  return {
-    ...contractResult,
-    data: formattedData
-  };
-};
-
-// src/react/hooks/useGenerateListingTransaction.tsx
-import { useMutation } from "@tanstack/react-query";
-
-// src/utils/date.ts
-var dateToUnixTime = (date) => Math.floor(date.getTime() / 1e3).toString();
-
-// src/react/hooks/useGenerateListingTransaction.tsx
-var generateListingTransaction = async (params, config, chainId) => {
-  const args = {
-    ...params,
-    listing: {
-      ...params.listing,
-      expiry: dateToUnixTime(params.listing.expiry)
-    }
-  };
-  const marketplaceClient = getMarketplaceClient(chainId, config);
-  return (await marketplaceClient.generateListingTransaction(args)).steps;
-};
-var useGenerateListingTransaction = (params) => {
-  const config = useConfig();
-  const { mutate, mutateAsync, ...result } = useMutation({
-    onSuccess: params.onSuccess,
-    mutationFn: (args) => generateListingTransaction(args, config, params.chainId)
-  });
-  return {
-    ...result,
-    generateListingTransaction: mutate,
-    generateListingTransactionAsync: mutateAsync
-  };
-};
-
-// src/react/hooks/useGenerateOfferTransaction.tsx
-import { useMutation as useMutation2 } from "@tanstack/react-query";
-
-// src/react/_internal/wallet/useWallet.ts
-import { skipToken as skipToken2, useQuery as useQuery22 } from "@tanstack/react-query";
-import {
-  useAccount as useAccount2,
-  useChainId,
-  usePublicClient,
-  useSwitchChain,
-  useWalletClient
-} from "wagmi";
-
-// src/react/_internal/wallet/wallet.ts
-import {
-  BaseError as BaseError2,
-  TransactionReceiptNotFoundError,
-  UserRejectedRequestError as ViemUserRejectedRequestError,
-  WaitForTransactionReceiptTimeoutError,
-  custom,
-  erc20Abi,
-  erc721Abi,
-  hexToBigInt,
-  isHex
-} from "viem";
-
-// src/react/_internal/logger.ts
-var TransactionLogger = class {
-  constructor(context, enabled = true) {
-    this.context = context;
-    this.enabled = enabled;
-  }
-  formatData(data) {
-    if (data instanceof Error) {
-      return {
-        name: data.name,
-        message: data.message,
-        cause: data.cause instanceof Error ? this.formatData(data.cause) : data.cause,
-        stack: data.stack?.split("\n").slice(0, 3)
-      };
-    }
-    if (Array.isArray(data)) {
-      return data.map((item) => this.formatData(item));
-    }
-    if (typeof data === "object" && data !== null) {
-      return Object.fromEntries(
-        Object.entries(data).map(([key, value]) => [
-          key,
-          this.formatData(value)
-        ])
-      );
-    }
-    return data;
-  }
-  log(level, message, data) {
-    if (!this.enabled) return;
-    console[level](
-      `[${this.context}] ${message}`,
-      data ? this.formatData(data) : ""
-    );
-  }
-  debug(message, data) {
-    this.log("debug", message, data);
-  }
-  error(message, error) {
-    this.log("error", message, error);
-  }
-  info(message, data) {
-    this.log("info", message, data);
-  }
-  state(from, to) {
-    this.info(`State transition: ${from} -> ${to}`);
-  }
-};
-var createLogger = (context, enabled = true) => new TransactionLogger(context, enabled);
-
-// src/react/_internal/wallet/wallet.ts
-var isSequenceWallet = (connector) => connector.id === "sequence" || connector.id === "sequence-waas";
-var wallet = ({
-  wallet: wallet2,
-  chains,
-  connector,
-  sdkConfig,
-  publicClient
-}) => {
-  const logger = createLogger("Wallet");
-  const walletInstance = {
-    transport: custom(wallet2.transport),
-    isWaaS: connector.id.endsWith("waas"),
-    walletKind: isSequenceWallet(connector) ? "sequence" /* sequence */ : "unknown" /* unknown */,
-    getChainId: wallet2.getChainId,
-    address: async () => {
-      let address = wallet2.account?.address;
-      if (!address) {
-        [address] = await wallet2.getAddresses();
-      }
-      return address;
-    },
-    switchChain: async (chainId) => {
-      logger.debug("Switching chain", { targetChainId: chainId });
-      try {
-        await wallet2.switchChain({
-          id: chainId
-        });
-        logger.info("Chain switch successful", { chainId });
-        return;
-      } catch (e) {
-        const error = e;
-        logger.error("Chain switch failed", error);
-        switch (error.name) {
-          case "SwitchChainNotSupportedError":
-            throw new ChainSwitchError(await wallet2.getChainId(), chainId);
-          case "UserRejectedRequestError":
-            throw new UserRejectedRequestError();
-          case "ChainNotConfiguredError":
-            return;
-          default:
-            throw new ChainSwitchError(await wallet2.getChainId(), chainId);
-        }
-      }
-    },
-    handleSignMessageStep: async (stepItem) => {
-      try {
-        if (stepItem.id === "signEIP191" /* signEIP191 */) {
-          logger.debug("Signing with EIP-191", { data: stepItem.data });
-          const message = isHex(stepItem.data) ? { raw: stepItem.data } : stepItem.data;
-          return await wallet2.signMessage({
-            account: wallet2.account,
-            message
-          });
-        } else if (stepItem.id === "signEIP712" /* signEIP712 */) {
-          logger.debug("Signing with EIP-712", {
-            domain: stepItem.domain,
-            types: stepItem.signature?.types
-          });
-          return await wallet2.signTypedData({
-            account: wallet2.account,
-            // biome-ignore lint/style/noNonNullAssertion: <explanation>
-            domain: stepItem.signature.domain,
-            // biome-ignore lint/style/noNonNullAssertion: <explanation>
-            types: stepItem.signature.types,
-            // biome-ignore lint/style/noNonNullAssertion: <explanation>
-            primaryType: stepItem.signature.primaryType,
-            // biome-ignore lint/style/noNonNullAssertion: <explanation>
-            message: stepItem.signature.value
-          });
-        }
-      } catch (e) {
-        const error = e;
-        logger.error("Signature failed", error);
-        if (error.cause instanceof BaseError2) {
-          const viemError = error.cause;
-          if (viemError instanceof ViemUserRejectedRequestError) {
-            throw new UserRejectedRequestError();
-          }
-        }
-        throw new TransactionSignatureError(stepItem.id, error);
-      }
-    },
-    handleSendTransactionStep: async (chainId, stepItem) => {
-      logger.debug("Sending transaction", {
-        chainId,
-        to: stepItem.to,
-        value: stepItem.value
-      });
-      const chain = chains.find((chain2) => chain2.id === chainId);
-      try {
-        return await wallet2.sendTransaction({
-          chain,
-          data: stepItem.data,
-          account: wallet2.account,
-          to: stepItem.to,
-          value: hexToBigInt(stepItem.value || "0x0"),
-          ...stepItem.maxFeePerGas && {
-            maxFeePerGas: hexToBigInt(stepItem.maxFeePerGas)
-          },
-          ...stepItem.maxPriorityFeePerGas && {
-            maxPriorityFeePerGas: hexToBigInt(stepItem.maxPriorityFeePerGas)
-          },
-          ...stepItem.gas && {
-            gas: hexToBigInt(stepItem.gas)
-          }
-        });
-      } catch (e) {
-        const error = e;
-        logger.error("Transaction failed", error);
-        if (error.cause instanceof BaseError2) {
-          const viemError = error.cause;
-          if (viemError instanceof ViemUserRejectedRequestError) {
-            throw new UserRejectedRequestError();
-          }
-        }
-        throw new TransactionExecutionError(stepItem.id, error);
-      }
-    },
-    handleConfirmTransactionStep: async (txHash, chainId) => {
-      logger.debug("Confirming transaction", { txHash, chainId });
-      try {
-        const receipt = await awaitTransactionReceipt({
-          txHash,
-          chainId,
-          sdkConfig
-        });
-        logger.info("Transaction confirmed", { txHash, receipt });
-        return receipt;
-      } catch (error) {
-        logger.error("Transaction confirmation failed", error);
-        throw new TransactionConfirmationError(txHash, error);
-      }
-    },
-    hasTokenApproval: async ({
-      tokenType,
-      contractAddress,
-      spender
-    }) => {
-      const walletAddress = await walletInstance.address();
-      const spenderAddress = spender === "sequenceMarketV1" ? SEQUENCE_MARKET_V1_ADDRESS : spender === "sequenceMarketV2" ? SEQUENCE_MARKET_V2_ADDRESS : spender;
-      switch (tokenType) {
-        case "ERC20":
-          return await publicClient.readContract({
-            address: contractAddress,
-            abi: erc20Abi,
-            functionName: "allowance",
-            args: [walletAddress, spenderAddress]
-          });
-        case "ERC721":
-          return await publicClient.readContract({
-            address: contractAddress,
-            abi: erc721Abi,
-            functionName: "isApprovedForAll",
-            args: [walletAddress, spenderAddress]
-          });
-        case "ERC1155":
-          return await publicClient.readContract({
-            address: contractAddress,
-            abi: ERC1155_ABI,
-            functionName: "isApprovedForAll",
-            args: [walletAddress, spenderAddress]
-          });
-        default:
-          throw new Error("Unsupported contract type for approval checking");
-      }
-    },
-    publicClient
-  };
-  return walletInstance;
-};
-var ONE_MIN = 60 * 1e3;
-var THREE_MIN = 3 * ONE_MIN;
-var awaitTransactionReceipt = async ({
-  txHash,
-  chainId,
-  sdkConfig,
-  timeout = THREE_MIN
-}) => {
-  const indexer = getIndexerClient(chainId, sdkConfig);
-  return Promise.race([
-    new Promise((resolve, reject) => {
-      indexer.subscribeReceipts(
-        {
-          filter: {
-            txnHash: txHash
-          }
-        },
-        {
-          onMessage: ({ receipt }) => {
-            resolve(receipt);
-          },
-          onError: () => {
-            reject(TransactionReceiptNotFoundError);
-          }
-        }
-      );
-    }),
-    new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(WaitForTransactionReceiptTimeoutError);
-      }, timeout);
-    })
-  ]);
-};
-
-// src/react/_internal/wallet/useWallet.ts
-var useWallet = () => {
-  const { chains } = useSwitchChain();
-  const {
-    data: walletClient,
-    isLoading: wagmiWalletIsLoading,
-    isError: wagmiWalletIsError
-  } = useWalletClient();
-  const { connector, isConnected, isConnecting } = useAccount2();
-  const sdkConfig = useConfig();
-  const chainId = useChainId();
-  const publicClient = usePublicClient();
-  const { data, isLoading, isError } = useQuery22({
-    queryKey: ["wallet", chainId, connector?.uid],
-    queryFn: walletClient && connector && isConnected && publicClient ? () => {
-      return wallet({
-        wallet: walletClient,
-        chains,
-        connector,
-        sdkConfig,
-        publicClient
-      });
-    } : skipToken2,
-    staleTime: Number.POSITIVE_INFINITY
-  });
-  return {
-    wallet: data,
-    isLoading: isLoading || isConnecting || wagmiWalletIsLoading,
-    isError: isError || wagmiWalletIsError
-  };
-};
-
-// src/react/hooks/useGenerateOfferTransaction.tsx
-var generateOfferTransaction = async (params, config, chainId, walletKind) => {
-  const args = {
-    ...params,
-    offer: { ...params.offer, expiry: dateToUnixTime(params.offer.expiry) },
-    walletType: walletKind
-  };
-  const marketplaceClient = getMarketplaceClient(chainId, config);
-  return (await marketplaceClient.generateOfferTransaction(args)).steps;
-};
-var useGenerateOfferTransaction = (params) => {
-  const config = useConfig();
-  const { wallet: wallet2 } = useWallet();
-  const { mutate, mutateAsync, ...result } = useMutation2({
-    onSuccess: params.onSuccess,
-    mutationFn: (args) => generateOfferTransaction(
-      args,
-      config,
-      params.chainId,
-      wallet2?.walletKind
-    )
-  });
-  return {
-    ...result,
-    generateOfferTransaction: mutate,
-    generateOfferTransactionAsync: mutateAsync
-  };
-};
-
-// src/react/hooks/useGenerateSellTransaction.tsx
-import { useMutation as useMutation3 } from "@tanstack/react-query";
-import { z as z17 } from "zod";
-var UserGeneratSellTransactionArgsSchema = z17.object({
-  chainId: z17.number(),
-  onSuccess: z17.function().args(stepSchema.array().optional()).optional()
-});
-var generateSellTransaction = async (args, config, chainId) => {
-  const marketplaceClient = getMarketplaceClient(chainId, config);
-  return marketplaceClient.generateSellTransaction(args).then((data) => data.steps);
-};
-var useGenerateSellTransaction = (params) => {
-  const config = useConfig();
-  const { mutate, mutateAsync, ...result } = useMutation3({
-    onSuccess: params.onSuccess,
-    mutationFn: (args) => generateSellTransaction(args, config, params.chainId)
-  });
-  return {
-    ...result,
-    generateSellTransaction: mutate,
-    generateSellTransactionAsync: mutateAsync
-  };
-};
-
-// src/react/hooks/useGenerateCancelTransaction.tsx
-import { useMutation as useMutation4 } from "@tanstack/react-query";
-import { z as z18 } from "zod";
-var UserGenerateCancelTransactionArgsSchema = z18.object({
-  chainId: z18.number(),
-  onSuccess: z18.function().args(stepSchema.array().optional()).optional()
-});
-var generateCancelTransaction = async (args, config, chainId) => {
-  const marketplaceClient = getMarketplaceClient(chainId, config);
-  return marketplaceClient.generateCancelTransaction(args).then((data) => data.steps);
-};
-var useGenerateCancelTransaction = (params) => {
-  const config = useConfig();
-  const { mutate, mutateAsync, ...result } = useMutation4({
-    onSuccess: params.onSuccess,
-    mutationFn: (args) => generateCancelTransaction(args, config, params.chainId)
-  });
-  return {
-    ...result,
-    generateCancelTransaction: mutate,
-    generateCancelTransactionAsync: mutateAsync
-  };
-};
-
-// src/react/hooks/useTransferTokens.tsx
-import { erc721Abi as erc721Abi2 } from "viem";
-import { useAccount as useAccount3, useWriteContract } from "wagmi";
-var prepareTransferConfig = (params, accountAddress) => {
-  if (params.contractType === "ERC721") {
-    return {
-      abi: erc721Abi2,
-      address: params.collectionAddress,
-      functionName: "safeTransferFrom",
-      args: [
-        accountAddress,
-        params.receiverAddress,
-        BigInt(params.tokenId)
-      ]
-    };
-  }
-  return {
-    abi: ERC1155_ABI,
-    address: params.collectionAddress,
-    functionName: "safeTransferFrom",
-    args: [
-      accountAddress,
-      params.receiverAddress,
-      BigInt(params.tokenId),
-      params.quantity,
-      "0x"
-      // data
-    ]
-  };
-};
-var useTransferTokens = () => {
-  const { address: accountAddress } = useAccount3();
-  const {
-    writeContractAsync,
-    data: hash,
-    isPending,
-    isError,
-    isSuccess
-  } = useWriteContract();
-  const transferTokensAsync = async (params) => {
-    if (!accountAddress) {
-      throw new NoWalletConnectedError();
-    }
-    const config = prepareTransferConfig(params, accountAddress);
-    return await writeContractAsync(config);
-  };
-  return {
-    transferTokensAsync,
-    hash,
-    transferring: isPending,
-    transferFailed: isError,
-    transferSuccess: isSuccess
-  };
-};
-
-// src/react/hooks/useCheckoutOptions.tsx
-import { queryOptions as queryOptions17, useQuery as useQuery23 } from "@tanstack/react-query";
-import { useAccount as useAccount4 } from "wagmi";
-import { z as z19 } from "zod";
-var UseCheckoutOptionsSchema = z19.object({
-  chainId: z19.number(),
-  orders: z19.array(
-    z19.object({
-      collectionAddress: AddressSchema,
-      orderId: z19.string(),
-      marketplace: z19.nativeEnum(MarketplaceKind)
-    })
-  ),
-  query: QueryArgSchema
-});
-var fetchCheckoutOptions = async (args, config) => {
-  const marketplaceClient = getMarketplaceClient(args.chainId, config);
-  return marketplaceClient.checkoutOptionsMarketplace({
-    wallet: args.walletAddress,
-    orders: args.orders.map((order) => ({
-      contractAddress: order.collectionAddress,
-      orderId: order.orderId,
-      marketplace: order.marketplace
-    })),
-    additionalFee: 0
-    //TODO: add additional fee
-  });
-};
-var checkoutOptionsOptions = (args, config) => {
-  return queryOptions17({
-    queryKey: ["checkoutOptions", args],
-    queryFn: () => fetchCheckoutOptions(args, config)
-  });
-};
-var useCheckoutOptions = (args) => {
-  const { address } = useAccount4();
-  const config = useConfig();
-  return useQuery23(
-    // biome-ignore lint/style/noNonNullAssertion: <explanation>
-    checkoutOptionsOptions({ walletAddress: address, ...args }, config)
-  );
-};
-
-// src/react/hooks/useListCollections.tsx
-import { queryOptions as queryOptions18, useQuery as useQuery24 } from "@tanstack/react-query";
-import { z as z20 } from "zod";
-var UseListCollectionsSchema = z20.object({
-  query: QueryArgSchema.optional().default({})
-});
-var fetchListCollections = async ({ marketplaceConfig }, config) => {
-  const metadataClient = getMetadataClient(config);
-  if (!marketplaceConfig?.collections?.length) {
-    return [];
-  }
-  const collectionsByChain = marketplaceConfig.collections.reduce((acc, curr) => {
-    const { chainId, address } = curr;
-    if (!acc[chainId]) {
-      acc[chainId] = [];
-    }
-    acc[chainId].push(address);
-    return acc;
-  }, {});
-  const promises = Object.entries(collectionsByChain).map(
-    ([chainId, addresses]) => metadataClient.getContractInfoBatch({
-      chainID: chainId,
-      contractAddresses: addresses
-    }).then((resp) => Object.values(resp.contractInfoMap))
-  );
-  const results = await Promise.all(promises);
-  return results.flat();
-};
-var listCollectionsOptions = (args, config) => {
-  return queryOptions18({
-    ...args.query,
-    queryKey: [...collectionKeys.list],
-    queryFn: () => fetchListCollections(args, config)
-  });
-};
-var useListCollections = (args = {}) => {
-  const config = useConfig();
-  const { data: marketplaceConfig, isLoading: isLoadingConfig } = useMarketplaceConfig();
-  return useQuery24({
-    ...listCollectionsOptions(
-      // biome-ignore lint/style/noNonNullAssertion: <explanation>
-      { marketplaceConfig, query: args.query },
-      config
-    ),
-    enabled: !isLoadingConfig && !!marketplaceConfig
-  });
-};
-
-// src/react/hooks/useCancelOrder.tsx
-import { useWaasFeeOptions } from "@0xsequence/connect";
-import { useEffect as useEffect2, useState } from "react";
-
-// src/react/ui/modals/_internal/components/switchChainModal/index.tsx
-import { Button, Modal, Spinner, Text as Text2 } from "@0xsequence/design-system";
-import { observer } from "@legendapp/state/react";
-import { useSwitchChain as useSwitchChain2 } from "wagmi";
-
-// src/react/ui/modals/_internal/components/alertMessage/index.tsx
-import { Text, WarningIcon } from "@0xsequence/design-system";
-import { jsx as jsx2, jsxs } from "react/jsx-runtime";
-function AlertMessage({ message, type }) {
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      className: `flex items-center justify-between gap-3 rounded-xl p-4 ${type === "warning" ? "bg-[hsla(39,71%,40%,0.3)]" : "bg-[hsla(247,100%,75%,0.3)]"}`,
-      children: [
-        /* @__PURE__ */ jsx2(Text, { className: "font-body text-sm", color: "white", fontWeight: "medium", children: message }),
-        type === "warning" && /* @__PURE__ */ jsx2(WarningIcon, { size: "sm", color: "white" }),
-        type === "info" && /* @__PURE__ */ jsx2(InfoIcon_default, { size: "sm", color: "white" })
-      ]
-    }
-  );
-}
-
-// src/react/ui/modals/_internal/components/consts.ts
-var MODAL_WIDTH = "360px";
-var MODAL_OVERLAY_PROPS = {
-  style: {
-    background: "hsla(0, 0%, 15%, 0.9)"
-  }
-};
-var MODAL_CONTENT_PROPS = {
-  style: {
-    width: MODAL_WIDTH,
-    height: "auto"
-  }
-};
-
-// src/react/ui/modals/_internal/components/switchChainModal/store.ts
-import { observable } from "@legendapp/state";
-var initialState = {
-  isOpen: false,
-  open: ({ chainIdToSwitchTo, onError, onSuccess, onClose }) => {
-    switchChainModal$.state.set({
-      ...switchChainModal$.state.get(),
-      chainIdToSwitchTo,
-      onError,
-      onSuccess,
-      onClose
-    });
-    switchChainModal$.isOpen.set(true);
-  },
-  close: () => {
-    switchChainModal$.isOpen.set(false);
-  },
-  state: {
-    chainIdToSwitchTo: void 0,
-    onError: void 0,
-    onSuccess: void 0,
-    onClose: void 0,
-    isSwitching: false
-  }
-};
-var switchChainModal$ = observable(initialState);
-
-// src/react/ui/modals/_internal/components/switchChainModal/index.tsx
-import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
-var useSwitchChainModal = () => {
-  return {
-    show: (args) => switchChainModal$.open(args),
-    close: () => switchChainModal$.delete(),
-    isSwitching$: switchChainModal$.state.isSwitching
-  };
-};
-var SwitchChainModal = observer(() => {
-  const chainIdToSwitchTo = switchChainModal$.state.chainIdToSwitchTo.get();
-  const isSwitching$ = switchChainModal$.state.isSwitching;
-  const chainName = chainIdToSwitchTo ? getPresentableChainName(chainIdToSwitchTo) : "";
-  const { switchChainAsync } = useSwitchChain2();
-  async function handleSwitchChain() {
-    isSwitching$.set(true);
-    try {
-      if (!chainIdToSwitchTo) return;
-      await switchChainAsync({ chainId: Number(chainIdToSwitchTo) });
-      if (switchChainModal$.state.onSuccess.get() && typeof switchChainModal$.state.onSuccess.get() === "function") {
-        switchChainModal$.state.onSuccess();
-      }
-      switchChainModal$.delete();
-    } catch (error) {
-      if (error instanceof Error && switchChainModal$.state.onError.get() && typeof switchChainModal$.state.onError.get() === "function") {
-        switchChainModal$.state.onError.get()?.(error);
-      }
-    } finally {
-      isSwitching$.set(false);
-    }
-  }
-  const handleClose = () => {
-    if (switchChainModal$.state.onClose && typeof switchChainModal$.state.onClose === "function") {
-      switchChainModal$.state.onClose();
-    }
-    switchChainModal$.delete();
-  };
-  if (!chainIdToSwitchTo) return null;
-  return /* @__PURE__ */ jsx3(
-    Modal,
-    {
-      isDismissible: true,
-      onClose: handleClose,
-      disableAnimation: true,
-      size: "sm",
-      overlayProps: MODAL_OVERLAY_PROPS,
-      children: /* @__PURE__ */ jsxs2("div", { className: "grid flex-col gap-6 p-7", children: [
-        /* @__PURE__ */ jsx3(Text2, { className: "text-xl", fontWeight: "bold", color: "text100", children: "Wrong network" }),
-        /* @__PURE__ */ jsx3(
-          AlertMessage,
-          {
-            type: "warning",
-            message: `You need to switch to ${chainName} network before completing the transaction`
-          }
-        ),
-        /* @__PURE__ */ jsx3(
-          Button,
-          {
-            className: `${isSwitching$.get() ? "flex w-[147px] items-center justify-center [&>div]:justify-center" : "w-[147px]"} flex justify-self-end`,
-            name: "switch-chain",
-            id: "switch-chain-button",
-            size: "sm",
-            label: isSwitching$.get() ? /* @__PURE__ */ jsx3("div", { "data-testid": "switch-chain-spinner", children: /* @__PURE__ */ jsx3(Spinner, { className: "spinner" }) }) : "Switch Network",
-            variant: "primary",
-            pending: isSwitching$.get(),
-            shape: "square",
-            onClick: handleSwitchChain,
-            "data-testid": "switch-chain-button"
-          }
-        )
-      ] })
-    }
-  );
-});
-var switchChainModal_default = SwitchChainModal;
-
-// src/react/hooks/util/optimisticCancelUpdates.ts
-var SECOND = 1e3;
-var updateQueriesOnCancel = ({
-  orderId,
-  queryClient
-}) => {
-  queryClient.setQueriesData(
-    { queryKey: collectableKeys.offersCount, exact: false },
-    (oldData) => {
-      if (!oldData) return { count: 0 };
-      return { count: Math.max(0, oldData.count - 1) };
-    }
-  );
-  console.log("query client ", queryClient, "orderId", orderId);
-  queryClient.setQueriesData(
-    { queryKey: collectableKeys.offers, exact: false },
-    (oldData) => {
-      if (!oldData || !oldData.offers) return oldData;
-      return {
-        ...oldData,
-        offers: oldData.offers.filter((offer) => offer.orderId !== orderId)
-      };
-    }
-  );
-  setTimeout(() => {
-    queryClient.invalidateQueries({
-      queryKey: collectableKeys.highestOffers,
-      exact: false
-    });
-  }, 2 * SECOND);
-  queryClient.setQueriesData(
-    { queryKey: collectableKeys.listingsCount, exact: false },
-    (oldData) => {
-      if (!oldData) return { count: 0 };
-      return { count: Math.max(0, oldData.count - 1) };
-    }
-  );
-  queryClient.setQueriesData(
-    { queryKey: collectableKeys.listings, exact: false },
-    (oldData) => {
-      if (!oldData || !oldData.listings) return oldData;
-      return {
-        ...oldData,
-        listings: oldData.listings.filter(
-          (listing) => listing.orderId !== orderId
-        )
-      };
-    }
-  );
-  setTimeout(() => {
-    queryClient.invalidateQueries({
-      queryKey: collectableKeys.lowestListings,
-      exact: false
-    });
-  }, 2 * SECOND);
-};
-var invalidateQueriesOnCancel = ({
-  queryClient
-}) => {
-  queryClient.invalidateQueries({
-    queryKey: collectableKeys.offers,
-    exact: false
-  });
-  queryClient.invalidateQueries({
-    queryKey: collectableKeys.offersCount,
-    exact: false
-  });
-  queryClient.invalidateQueries({
-    queryKey: collectableKeys.listings,
-    exact: false
-  });
-  queryClient.invalidateQueries({
-    queryKey: collectableKeys.listingsCount,
-    exact: false
-  });
-  queryClient.invalidateQueries({
-    queryKey: collectableKeys.highestOffers,
-    exact: false
-  });
-  queryClient.invalidateQueries({
-    queryKey: collectableKeys.lowestListings,
-    exact: false
-  });
-};
-
-// src/react/hooks/useCancelTransactionSteps.tsx
-var useCancelTransactionSteps = ({
-  collectionAddress,
-  chainId,
-  callbacks,
-  setSteps,
-  onSuccess,
-  onError
-}) => {
-  const { show: showSwitchChainModal } = useSwitchChainModal();
-  const { wallet: wallet2, isLoading, isError } = useWallet();
-  const walletIsInitialized = wallet2 && !isLoading && !isError;
-  const sdkConfig = useConfig();
-  const marketplaceClient = getMarketplaceClient(chainId, sdkConfig);
-  const { generateCancelTransactionAsync } = useGenerateCancelTransaction({
-    chainId
-  });
-  const getWalletChainId = async () => {
-    return await wallet2?.getChainId();
-  };
-  const switchChain = async () => {
-    await wallet2?.switchChain(Number(chainId));
-  };
-  const checkAndSwitchChain = async () => {
-    const walletChainId = await getWalletChainId();
-    const isWaaS = wallet2?.isWaaS;
-    const chainIdMismatch = walletChainId !== Number(chainId);
-    return new Promise((resolve, reject) => {
-      if (chainIdMismatch) {
-        if (isWaaS) {
-          switchChain().then(resolve).catch(reject);
-        } else {
-          showSwitchChainModal({
-            chainIdToSwitchTo: chainId,
-            onSuccess: () => resolve({ chainId }),
-            onError: (error) => reject(error),
-            onClose: () => reject(new ChainSwitchUserRejectedError())
-          });
-        }
-      } else {
-        resolve({ chainId });
-      }
-    });
-  };
-  const getCancelSteps = async ({
-    orderId,
-    marketplace
-  }) => {
-    try {
-      const address = await wallet2?.address();
-      if (!address) {
-        throw new Error("Wallet address not found");
-      }
-      const steps = await generateCancelTransactionAsync({
-        collectionAddress,
-        maker: address,
-        marketplace,
-        orderId
-      });
-      return steps;
-    } catch (error) {
-      if (callbacks?.onError) {
-        callbacks.onError(error);
-      } else {
-        console.debug("onError callback not provided:", error);
-      }
-    }
-  };
-  const cancelOrder = async ({
-    orderId,
-    marketplace
-  }) => {
-    const queryClient = getQueryClient();
-    if (!walletIsInitialized) {
-      throw new WalletInstanceNotFoundError();
-    }
-    try {
-      await checkAndSwitchChain();
-      setSteps((prev) => ({
-        ...prev,
-        isExecuting: true
-      }));
-      const cancelSteps = await getCancelSteps({
-        orderId,
-        marketplace
-      });
-      const transactionStep = cancelSteps?.find(
-        (step) => step.id === "cancel" /* cancel */
-      );
-      const signatureStep = cancelSteps?.find(
-        (step) => step.id === "signEIP712" /* signEIP712 */
-      );
-      console.debug("transactionStep", transactionStep);
-      console.debug("signatureStep", signatureStep);
-      if (!transactionStep && !signatureStep) {
-        throw new Error("No transaction or signature step found");
-      }
-      let hash;
-      let reservoirOrderId;
-      if (transactionStep && wallet2) {
-        hash = await executeTransaction({ transactionStep });
-        if (hash) {
-          await wallet2.handleConfirmTransactionStep(hash, Number(chainId));
-          if (onSuccess && typeof onSuccess === "function") {
-            onSuccess({ hash });
-            updateQueriesOnCancel({
-              orderId,
-              queryClient
-            });
-          }
-          setSteps((prev) => ({
-            ...prev,
-            isExecuting: false
-          }));
-        }
-      }
-      if (signatureStep) {
-        reservoirOrderId = await executeSignature({ signatureStep });
-        if (onSuccess && typeof onSuccess === "function") {
-          onSuccess({ orderId: reservoirOrderId });
-          updateQueriesOnCancel({
-            orderId: reservoirOrderId,
-            queryClient
-          });
-        }
-        setSteps((prev) => ({
-          ...prev,
-          isExecuting: false
-        }));
-      }
-    } catch (error) {
-      invalidateQueriesOnCancel({
-        queryClient
-      });
-      setSteps((prev) => ({
-        ...prev,
-        isExecuting: false
-      }));
-      if (onError && typeof onError === "function") {
-        onError(error);
-      }
-    }
-  };
-  const executeTransaction = async ({
-    transactionStep
-  }) => {
-    const hash = await wallet2?.handleSendTransactionStep(
-      Number(chainId),
-      transactionStep
-    );
-    return hash;
-  };
-  const executeSignature = async ({
-    signatureStep
-  }) => {
-    const signature = await wallet2?.handleSignMessageStep(
-      signatureStep
-    );
-    const result = await marketplaceClient.execute({
-      signature,
-      method: signatureStep.post?.method,
-      endpoint: signatureStep.post?.endpoint,
-      body: signatureStep.post?.body
-    });
-    return result.orderId;
-  };
-  return {
-    cancelOrder
-  };
-};
-
-// src/react/hooks/useCancelOrder.tsx
-var useCancelOrder = ({
-  collectionAddress,
-  chainId,
-  onSuccess,
-  onError
-}) => {
-  const [steps, setSteps] = useState({
-    exist: false,
-    isExecuting: false,
-    execute: () => Promise.resolve()
-  });
-  const [cancellingOrderId, setCancellingOrderId] = useState(
-    null
-  );
-  const [pendingFeeOptionConfirmation, confirmPendingFeeOption] = useWaasFeeOptions();
-  const autoSelectOptionPromise = useAutoSelectFeeOption({
-    pendingFeeOptionConfirmation: pendingFeeOptionConfirmation ? {
-      id: pendingFeeOptionConfirmation.id,
-      options: pendingFeeOptionConfirmation.options?.map((opt) => ({
-        ...opt,
-        token: {
-          ...opt.token,
-          contractAddress: opt.token.contractAddress || null,
-          decimals: opt.token.decimals || 0,
-          tokenID: opt.token.tokenID || null
-        }
-      })),
-      chainId
-    } : {
-      id: "",
-      options: void 0,
-      chainId
-    },
-    enabled: !!pendingFeeOptionConfirmation
-  });
-  useEffect2(() => {
-    autoSelectOptionPromise.then((res) => {
-      if (pendingFeeOptionConfirmation?.id && res.selectedOption) {
-        confirmPendingFeeOption(
-          pendingFeeOptionConfirmation.id,
-          res.selectedOption.token.contractAddress
-        );
-      }
-    });
-  }, [
-    autoSelectOptionPromise,
-    confirmPendingFeeOption,
-    pendingFeeOptionConfirmation
-  ]);
-  const { cancelOrder: cancelOrderBase } = useCancelTransactionSteps({
-    collectionAddress,
-    chainId,
-    onSuccess: (result) => {
-      setCancellingOrderId(null);
-      onSuccess?.(result);
-    },
-    onError: (error) => {
-      setCancellingOrderId(null);
-      onError?.(error);
-    },
-    setSteps
-  });
-  const cancelOrder = async (params) => {
-    setCancellingOrderId(params.orderId);
-    return cancelOrderBase(params);
-  };
-  return {
-    cancelOrder,
-    isExecuting: steps.isExecuting,
-    cancellingOrderId
-  };
-};
-
-// src/react/hooks/useCollectionDetails.tsx
-import { queryOptions as queryOptions19, useQuery as useQuery25 } from "@tanstack/react-query";
-var fetchCollectionDetails = async (args, marketplaceClient) => {
-  const { collection } = await marketplaceClient.getCollectionDetail({
-    contractAddress: args.collectionAddress
-  });
-  return collection;
-};
-var collectionDetailsOptions = (args, config) => {
-  const marketplaceClient = getMarketplaceClient(args.chainId, config);
-  return queryOptions19({
-    queryKey: ["collectionDetails", args],
-    queryFn: () => fetchCollectionDetails(args, marketplaceClient)
-  });
-};
-var useCollectionDetails = (args) => {
-  const config = useConfig();
-  return useQuery25(collectionDetailsOptions(args, config));
-};
-
-// src/react/hooks/useCollectionDetailsPolling.tsx
-import { queryOptions as queryOptions20, useQuery as useQuery26 } from "@tanstack/react-query";
-var INITIAL_POLLING_INTERVAL = 2e3;
-var MAX_POLLING_INTERVAL = 3e4;
-var MAX_ATTEMPTS = 30;
-var isTerminalState = (status) => {
-  return [
-    "active" /* active */,
-    "failed" /* failed */,
-    "inactive" /* inactive */,
-    "incompatible_type" /* incompatible_type */
-  ].includes(status);
-};
-var collectionDetailsPollingOptions = (args, config) => {
-  return queryOptions20({
-    ...collectionDetailsOptions(args, config),
-    refetchInterval: (query) => {
-      const data = query.state.data;
-      if (data && isTerminalState(data.status)) {
-        return false;
-      }
-      const currentAttempt = (query.state.dataUpdateCount || 0) + 1;
-      if (currentAttempt >= MAX_ATTEMPTS) {
-        return false;
-      }
-      const interval = Math.min(
-        INITIAL_POLLING_INTERVAL * 1.5 ** currentAttempt,
-        MAX_POLLING_INTERVAL
-      );
-      return interval;
-    },
-    refetchOnWindowFocus: false,
-    retry: false
-  });
-};
-var useCollectionDetailsPolling = (args) => {
-  const config = useConfig();
-  return useQuery26(collectionDetailsPollingOptions(args, config));
-};
-
-// src/react/hooks/useListTokenMetadata.ts
-import { useQuery as useQuery27 } from "@tanstack/react-query";
-var useListTokenMetadata = (args) => {
-  const config = useConfig();
-  const { chainId, contractAddress, tokenIds, query } = args;
-  return useQuery27({
-    ...tokenMetadataOptions(
-      { chainId, contractAddress, tokenIds, query },
-      config
-    )
-  });
-};
-
-export {
-  MarketplaceSdkContext,
-  MarketplaceQueryClientProvider,
-  MarketplaceProvider,
-  useConfig,
-  collectionBalanceDetailsOptions,
-  useCollectionBalanceDetails,
-  useAutoSelectFeeOption,
-  useMarketplaceConfig,
-  useBalanceOfCollectible,
-  countOfCollectablesOptions,
-  useCountOfCollectables,
-  collectibleOptions,
-  useCollectible,
-  useCollection,
-  currenciesOptions,
-  useCurrencies,
-  convertPriceToUSD,
-  convertPriceToUSDOptions,
-  useConvertPriceToUSD,
-  comparePricesOptions,
-  useComparePrices,
-  currencyOptions,
-  useCurrency,
-  fetchFilters,
-  filtersOptions,
-  useFilters,
-  useFiltersProgressive,
-  useFilterState,
-  floorOrderOptions,
-  useFloorOrder,
-  useHighestOffer,
-  useInventory,
-  useListBalances,
-  listCollectibleActivitiesOptions,
-  useListCollectibleActivities,
-  useListCollectibles,
-  listCollectiblesPaginatedOptions,
-  useListCollectiblesPaginated,
-  listCollectionActivitiesOptions,
-  useListCollectionActivities,
-  listOffersForCollectibleOptions,
-  useListOffersForCollectible,
-  countOffersForCollectibleOptions,
-  useCountOffersForCollectible,
-  listListingsForCollectibleOptions,
-  useListListingsForCollectible,
-  countListingsForCollectibleOptions,
-  useCountListingsForCollectible,
-  useLowestListing,
-  useRoyalty,
-  dateToUnixTime,
-  generateListingTransaction,
-  useGenerateListingTransaction,
-  useWallet,
-  generateOfferTransaction,
-  useGenerateOfferTransaction,
-  generateSellTransaction,
-  useGenerateSellTransaction,
-  generateCancelTransaction,
-  useGenerateCancelTransaction,
-  useTransferTokens,
-  checkoutOptionsOptions,
-  useCheckoutOptions,
-  listCollectionsOptions,
-  useListCollections,
-  AlertMessage,
-  MODAL_OVERLAY_PROPS,
-  MODAL_CONTENT_PROPS,
-  useSwitchChainModal,
-  switchChainModal_default,
-  useCancelOrder,
-  collectionDetailsOptions,
-  useCollectionDetails,
-  collectionDetailsPollingOptions,
-  useCollectionDetailsPolling,
-  useListTokenMetadata
-};
-//# sourceMappingURL=chunk-SXVUTSMT.js.map