@0xsequence/marketplace-sdk 0.5.2 → 0.5.4

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

@@ -15,9 +15,10 @@ import {
   switchChainModalContent
 } from "./chunk-FI723DGL.js";
 import {
+  compareAddress,
   getPresentableChainName,
   getPublicRpcClient
-} from "./chunk-XP3WY5AX.js";
+} from "./chunk-7C7ADZ2H.js";
 import {
   EIP2981_ABI
 } from "./chunk-3OHM45R3.js";
@@ -78,9 +79,9 @@ import {
 
 // src/react/hooks/useAutoSelectFeeOption.tsx
 import { zeroAddress } from "viem";
-import { useAccount } from "wagmi";
-import { useCallback } from "react";
 import { useChain } from "@0xsequence/kit";
+import { useCallback } from "react";
+import { useAccount } from "wagmi";
 
 // src/react/hooks/useCollectionBalanceDetails.tsx
 import { z } from "zod";
@@ -981,65 +982,18 @@ var useCollection = (args) => {
 };
 
 // src/react/hooks/useCurrencies.tsx
-import { queryOptions as queryOptions6, useQuery as useQuery6 } from "@tanstack/react-query";
+import { queryOptions as queryOptions7, useQuery as useQuery7 } from "@tanstack/react-query";
 import { zeroAddress as zeroAddress2 } from "viem";
 import { z as z7 } from "zod";
-var ChainIdCoerce = ChainIdSchema.transform((val) => val.toString());
-var UseCurrenciesArgsSchema = z7.object({
-  chainId: ChainIdCoerce,
-  includeNativeCurrency: z7.boolean().optional().default(true),
-  currencyOptions: z7.array(AddressSchema).optional(),
-  query: QueryArgSchema
-});
-var fetchCurrencies = async (chainId, config) => {
-  const parsedChainId = ChainIdCoerce.parse(chainId);
-  const marketplaceClient = getMarketplaceClient(parsedChainId, config);
-  return marketplaceClient.listCurrencies().then(
-    (resp) => resp.currencies.map((currency) => ({
-      ...currency,
-      // TODO: remove this, when we are sure of the schema
-      contractAddress: currency.contractAddress || zeroAddress2
-    }))
-  );
-};
-var selectCurrencies = (data, args) => {
-  const argsParsed = UseCurrenciesArgsSchema.parse(args);
-  let filteredData = data;
-  if (!argsParsed.includeNativeCurrency) {
-    filteredData = filteredData.filter((currency) => !currency.nativeCurrency);
-  }
-  if (argsParsed.currencyOptions) {
-    const lowerCaseCurrencyOptions = argsParsed.currencyOptions.map(
-      (option) => option.toLowerCase()
-    );
-    filteredData = filteredData.filter(
-      (currency) => lowerCaseCurrencyOptions.includes(currency.contractAddress.toLowerCase())
-    );
-  }
-  return filteredData;
-};
-var currenciesOptions = (args, config) => {
-  return queryOptions6({
-    ...args.query,
-    queryKey: [...currencyKeys.lists, args.chainId],
-    queryFn: () => fetchCurrencies(args.chainId, config),
-    select: (data) => selectCurrencies(data, args),
-    enabled: args.query?.enabled
-  });
-};
-var useCurrencies = (args) => {
-  const config = useConfig();
-  return useQuery6(currenciesOptions(args, config));
-};
 
 // src/react/hooks/useMarketplaceConfig.tsx
-import { useQuery as useQuery7 } from "@tanstack/react-query";
+import { useQuery as useQuery6 } from "@tanstack/react-query";
 
 // src/react/hooks/options/marketplaceConfigOptions.ts
-import { queryOptions as queryOptions7 } from "@tanstack/react-query";
+import { queryOptions as queryOptions6 } from "@tanstack/react-query";
 var fetchBuilderConfig = async (projectId, env) => {
   const url = `${builderMarketplaceApi(projectId, env)}`;
-  const response = await fetch(`${url}/config.json`);
+  const response = await fetch(`${url}/settings.json`);
   const json = await response.json();
   if (!response.ok) {
     console.error("Failed to fetch marketplace config:", response.status, json);
@@ -1076,7 +1030,7 @@ var marketplaceConfigOptions = (config) => {
     env = config._internal.builderEnv ?? env;
   }
   const projectId = config.projectId;
-  return queryOptions7({
+  return queryOptions6({
     queryKey: [...configKeys.marketplace, env, projectId],
     queryFn: () => fetchMarketplaceConfig(env, projectId)
   });
@@ -1085,19 +1039,56 @@ var marketplaceConfigOptions = (config) => {
 // src/react/hooks/useMarketplaceConfig.tsx
 var useMarketplaceConfig = () => {
   const config = useConfig();
-  return useQuery7(marketplaceConfigOptions(config));
+  return useQuery6(marketplaceConfigOptions(config));
 };
 
-// src/react/hooks/useCurrencyOptions.tsx
-var useCurrencyOptions = ({
-  collectionAddress
-}) => {
-  const { data: marketplaceConfig } = useMarketplaceConfig();
-  const collections = marketplaceConfig?.collections;
-  const currencyOptions2 = collections?.find(
-    (collection) => collection.collectionAddress === collectionAddress
-  )?.currencyOptions;
-  return currencyOptions2;
+// src/react/hooks/useCurrencies.tsx
+var ChainIdCoerce = ChainIdSchema.transform((val) => val.toString());
+var UseCurrenciesArgsSchema = z7.object({
+  chainId: ChainIdCoerce,
+  includeNativeCurrency: z7.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 queryOptions7({
+    ...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/useCurrency.tsx
@@ -1146,15 +1137,53 @@ import { z as z9 } from "zod";
 var UseFiltersSchema = z9.object({
   chainId: ChainIdSchema.pipe(z9.coerce.string()),
   collectionAddress: AddressSchema,
+  showAllFilters: z9.boolean().default(false).optional(),
   query: QueryArgSchema
 });
 var fetchFilters = async (args, config) => {
   const parsedArgs = UseFiltersSchema.parse(args);
   const metadataClient = getMetadataClient(config);
-  return metadataClient.tokenCollectionFilters({
+  const filters = await metadataClient.tokenCollectionFilters({
     chainID: parsedArgs.chainId,
     contractAddress: parsedArgs.collectionAddress
   }).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 queryOptions9({
@@ -1298,7 +1327,8 @@ var fetchCollectibleActivities = async (args, config) => {
 var listCollectibleActivitiesOptions = (args, config) => {
   return queryOptions12({
     queryKey: [...collectableKeys.collectibleActivities, args, config],
-    queryFn: () => fetchCollectibleActivities(args, config)
+    queryFn: () => fetchCollectibleActivities(args, config),
+    enabled: args.query?.enabled ?? true
   });
 };
 var useListCollectibleActivities = (args) => {
@@ -1331,7 +1361,8 @@ var listCollectiblesOptions = (args, config) => {
     queryKey: [...collectableKeys.lists, args],
     queryFn: ({ pageParam }) => fetchCollectibles(args, marketplaceClient, pageParam),
     initialPageParam: { page: 1, pageSize: 30 },
-    getNextPageParam: (lastPage) => lastPage.page?.more ? lastPage.page : void 0
+    getNextPageParam: (lastPage) => lastPage.page?.more ? lastPage.page : void 0,
+    enabled: args.query?.enabled ?? true
   });
 };
 var useListCollectibles = (args) => {
@@ -1339,8 +1370,51 @@ var useListCollectibles = (args) => {
   return useInfiniteQuery2(listCollectiblesOptions(args, config));
 };
 
-// src/react/hooks/useListCollectionActivities.tsx
+// src/react/hooks/useListCollectiblesPaginated.tsx
 import { queryOptions as queryOptions13, useQuery as useQuery13 } from "@tanstack/react-query";
+import { z as z14 } from "zod";
+var UseListCollectiblesPaginatedArgsSchema = listCollectiblesArgsSchema.omit({
+  contractAddress: true
+}).extend({
+  collectionAddress: AddressSchema,
+  chainId: ChainIdSchema.pipe(z14.coerce.string()),
+  query: z14.object({
+    enabled: z14.boolean().optional(),
+    page: z14.number().optional().default(1),
+    pageSize: z14.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 queryOptions13({
+    queryKey: [...collectableKeys.lists, "paginated", args],
+    queryFn: () => fetchCollectiblesPaginated(args, marketplaceClient),
+    enabled: args.query?.enabled ?? true
+  });
+};
+var useListCollectiblesPaginated = (args) => {
+  const config = useConfig();
+  return useQuery13(listCollectiblesPaginatedOptions(args, config));
+};
+
+// src/react/hooks/useListCollectionActivities.tsx
+import { queryOptions as queryOptions14, useQuery as useQuery14 } from "@tanstack/react-query";
 var fetchListCollectionActivities = async (args, config) => {
   const marketplaceClient = getMarketplaceClient(args.chainId, config);
   return marketplaceClient.listCollectionActivities({
@@ -1356,23 +1430,24 @@ var fetchListCollectionActivities = async (args, config) => {
   }));
 };
 var listCollectionActivitiesOptions = (args, config) => {
-  return queryOptions13({
+  return queryOptions14({
     queryKey: [...collectionKeys.collectionActivities, args, config],
-    queryFn: () => fetchListCollectionActivities(args, config)
+    queryFn: () => fetchListCollectionActivities(args, config),
+    enabled: args.query?.enabled ?? true
   });
 };
 var useListCollectionActivities = (args) => {
   const config = useConfig();
-  return useQuery13(listCollectionActivitiesOptions(args, config));
+  return useQuery14(listCollectionActivitiesOptions(args, config));
 };
 
 // src/react/hooks/useListOffersForCollectible.tsx
-import { queryOptions as queryOptions14, useQuery as useQuery14 } from "@tanstack/react-query";
-import { z as z14 } from "zod";
+import { queryOptions as queryOptions15, useQuery as useQuery15 } from "@tanstack/react-query";
+import { z as z15 } from "zod";
 var UseListOffersForCollectibleArgsSchema = listOffersForCollectibleArgsSchema.extend({
-  chainId: ChainIdSchema.pipe(z14.coerce.string()),
-  collectionAddress: z14.string(),
-  collectibleId: z14.string()
+  chainId: ChainIdSchema.pipe(z15.coerce.string()),
+  collectionAddress: z15.string(),
+  collectibleId: z15.string()
 }).omit({ contractAddress: true, tokenId: true });
 var fetchListOffersForCollectible = async (config, args) => {
   const arg = {
@@ -1385,26 +1460,26 @@ var fetchListOffersForCollectible = async (config, args) => {
   return marketplaceClient.listCollectibleOffers(arg);
 };
 var listOffersForCollectibleOptions = (args, config) => {
-  return queryOptions14({
+  return queryOptions15({
     queryKey: [...collectableKeys.offers, args, config],
     queryFn: () => fetchListOffersForCollectible(config, args)
   });
 };
 var useListOffersForCollectible = (args) => {
   const config = useConfig();
-  return useQuery14(listOffersForCollectibleOptions(args, config));
+  return useQuery15(listOffersForCollectibleOptions(args, config));
 };
 
 // src/react/hooks/useCountOffersForCollectible.tsx
-import { queryOptions as queryOptions15, useQuery as useQuery15 } from "@tanstack/react-query";
-import { z as z15 } from "zod";
+import { queryOptions as queryOptions16, useQuery as useQuery16 } from "@tanstack/react-query";
+import { z as z16 } from "zod";
 var UseCountOffersForCollectibleArgsSchema = countOffersForCollectibleArgsSchema.omit({
   contractAddress: true,
   tokenId: true
 }).extend({
   collectionAddress: AddressSchema,
-  collectibleId: z15.string(),
-  chainId: ChainIdSchema.pipe(z15.coerce.string()),
+  collectibleId: z16.string(),
+  chainId: ChainIdSchema.pipe(z16.coerce.string()),
   query: QueryArgSchema
 });
 var fetchCountOffersForCollectible = async (args, config) => {
@@ -1417,7 +1492,7 @@ var fetchCountOffersForCollectible = async (args, config) => {
   });
 };
 var countOffersForCollectibleOptions = (args, config) => {
-  return queryOptions15({
+  return queryOptions16({
     ...args.query,
     queryKey: [...collectableKeys.offersCount, args, config],
     queryFn: () => fetchCountOffersForCollectible(args, config)
@@ -1425,16 +1500,16 @@ var countOffersForCollectibleOptions = (args, config) => {
 };
 var useCountOffersForCollectible = (args) => {
   const config = useConfig();
-  return useQuery15(countOffersForCollectibleOptions(args, config));
+  return useQuery16(countOffersForCollectibleOptions(args, config));
 };
 
 // src/react/hooks/useListListingsForCollectible.tsx
-import { queryOptions as queryOptions16, useQuery as useQuery16 } from "@tanstack/react-query";
-import { z as z16 } from "zod";
+import { queryOptions as queryOptions17, useQuery as useQuery17 } from "@tanstack/react-query";
+import { z as z17 } from "zod";
 var UseListListingsForCollectibleArgsSchema = listListingsForCollectibleArgsSchema.extend({
-  chainId: ChainIdSchema.pipe(z16.coerce.string()),
-  collectionAddress: z16.string(),
-  collectibleId: z16.string()
+  chainId: ChainIdSchema.pipe(z17.coerce.string()),
+  collectionAddress: z17.string(),
+  collectibleId: z17.string()
 }).omit({ contractAddress: true, tokenId: true });
 var fetchListListingsForCollectible = async (config, args) => {
   const arg = {
@@ -1447,26 +1522,26 @@ var fetchListListingsForCollectible = async (config, args) => {
   return marketplaceClient.listCollectibleListings(arg);
 };
 var listListingsForCollectibleOptions = (args, config) => {
-  return queryOptions16({
+  return queryOptions17({
     queryKey: [...collectableKeys.listings, args, config],
     queryFn: () => fetchListListingsForCollectible(config, args)
   });
 };
 var useListListingsForCollectible = (args) => {
   const config = useConfig();
-  return useQuery16(listListingsForCollectibleOptions(args, config));
+  return useQuery17(listListingsForCollectibleOptions(args, config));
 };
 
 // src/react/hooks/useCountListingsForCollectible.tsx
-import { queryOptions as queryOptions17, useQuery as useQuery17 } from "@tanstack/react-query";
-import { z as z17 } from "zod";
+import { queryOptions as queryOptions18, useQuery as useQuery18 } from "@tanstack/react-query";
+import { z as z18 } from "zod";
 var UseCountListingsForCollectibleArgsSchema = countListingsForCollectibleArgsSchema.omit({
   contractAddress: true,
   tokenId: true
 }).extend({
   collectionAddress: AddressSchema,
-  collectibleId: z17.string(),
-  chainId: ChainIdSchema.pipe(z17.coerce.string()),
+  collectibleId: z18.string(),
+  chainId: ChainIdSchema.pipe(z18.coerce.string()),
   query: QueryArgSchema
 });
 var fetchCountListingsForCollectible = async (args, config) => {
@@ -1479,7 +1554,7 @@ var fetchCountListingsForCollectible = async (args, config) => {
   });
 };
 var countListingsForCollectibleOptions = (args, config) => {
-  return queryOptions17({
+  return queryOptions18({
     ...args.query,
     queryKey: [...collectableKeys.listingsCount, args, config],
     queryFn: () => fetchCountListingsForCollectible(args, config)
@@ -1487,17 +1562,17 @@ var countListingsForCollectibleOptions = (args, config) => {
 };
 var useCountListingsForCollectible = (args) => {
   const config = useConfig();
-  return useQuery17(countListingsForCollectibleOptions(args, config));
+  return useQuery18(countListingsForCollectibleOptions(args, config));
 };
 
 // src/react/hooks/useLowestListing.tsx
-import { queryOptions as queryOptions18, useQuery as useQuery18 } from "@tanstack/react-query";
-import { z as z18 } from "zod";
+import { queryOptions as queryOptions19, useQuery as useQuery19 } from "@tanstack/react-query";
+import { z as z19 } from "zod";
 var UseLowestListingSchema = getCollectibleLowestListingArgsSchema.omit({
   contractAddress: true
 }).extend({
   collectionAddress: AddressSchema,
-  chainId: ChainIdSchema.pipe(z18.coerce.string()),
+  chainId: ChainIdSchema.pipe(z19.coerce.string()),
   query: QueryArgSchema
 });
 var fetchLowestListing = async (args, config) => {
@@ -1509,7 +1584,7 @@ var fetchLowestListing = async (args, config) => {
   });
 };
 var lowestListingOptions = (args, config) => {
-  return queryOptions18({
+  return queryOptions19({
     ...args.query,
     queryKey: [...collectableKeys.lowestListings, args, config],
     queryFn: () => fetchLowestListing(args, config)
@@ -1517,17 +1592,17 @@ var lowestListingOptions = (args, config) => {
 };
 var useLowestListing = (args) => {
   const config = useConfig();
-  return useQuery18(lowestListingOptions(args, config));
+  return useQuery19(lowestListingOptions(args, config));
 };
 
 // src/react/hooks/useRoyaltyPercentage.tsx
-import { queryOptions as queryOptions19, useQuery as useQuery19 } from "@tanstack/react-query";
+import { queryOptions as queryOptions20, useQuery as useQuery20 } from "@tanstack/react-query";
 import { getContract } from "viem";
-import { z as z19 } from "zod";
-var UseRoyaletyPercentageSchema = z19.object({
-  chainId: ChainIdSchema.pipe(z19.coerce.string()),
+import { z as z20 } from "zod";
+var UseRoyaletyPercentageSchema = z20.object({
+  chainId: ChainIdSchema.pipe(z20.coerce.string()),
   collectionAddress: AddressSchema,
-  collectibleId: z19.string(),
+  collectibleId: z20.string(),
   query: QueryArgSchema
 });
 var fetchRoyaletyPercentage = async (args) => {
@@ -1548,13 +1623,13 @@ var fetchRoyaletyPercentage = async (args) => {
     return 0n;
   }
 };
-var royaletyPercentageOptions = (args) => queryOptions19({
+var royaletyPercentageOptions = (args) => queryOptions20({
   ...args.query,
   queryKey: [...collectableKeys.royaltyPercentage, args],
   queryFn: () => fetchRoyaletyPercentage(args)
 });
 var useRoyaltyPercentage = (args) => {
-  return useQuery19(royaletyPercentageOptions(args));
+  return useQuery20(royaletyPercentageOptions(args));
 };
 
 // src/react/hooks/useGenerateListingTransaction.tsx
@@ -1613,13 +1688,13 @@ var useGenerateOfferTransaction = (params) => {
 
 // src/react/hooks/useGenerateSellTransaction.tsx
 import { useMutation as useMutation3 } from "@tanstack/react-query";
-import { z as z20 } from "zod";
-var UserGeneratSellTransactionArgsSchema = z20.object({
-  chainId: ChainIdSchema.pipe(z20.coerce.string()),
-  onSuccess: z20.function().args(stepSchema.array().optional()).optional()
+import { z as z21 } from "zod";
+var UserGeneratSellTransactionArgsSchema = z21.object({
+  chainId: ChainIdSchema.pipe(z21.coerce.string()),
+  onSuccess: z21.function().args(stepSchema.array().optional()).optional()
 });
 var generateSellTransaction = async (args, config, chainId) => {
-  const parsedChainId = ChainIdSchema.pipe(z20.coerce.string()).parse(chainId);
+  const parsedChainId = ChainIdSchema.pipe(z21.coerce.string()).parse(chainId);
   const marketplaceClient = getMarketplaceClient(parsedChainId, config);
   return marketplaceClient.generateSellTransaction(args).then((data) => data.steps);
 };
@@ -1638,13 +1713,13 @@ var useGenerateSellTransaction = (params) => {
 
 // src/react/hooks/useGenerateCancelTransaction.tsx
 import { useMutation as useMutation4 } from "@tanstack/react-query";
-import { z as z21 } from "zod";
-var UserGenerateCancelTransactionArgsSchema = z21.object({
-  chainId: ChainIdSchema.pipe(z21.coerce.string()),
-  onSuccess: z21.function().args(stepSchema.array().optional()).optional()
+import { z as z22 } from "zod";
+var UserGenerateCancelTransactionArgsSchema = z22.object({
+  chainId: ChainIdSchema.pipe(z22.coerce.string()),
+  onSuccess: z22.function().args(stepSchema.array().optional()).optional()
 });
 var generateCancelTransaction = async (args, config, chainId) => {
-  const parsedChainId = ChainIdSchema.pipe(z21.coerce.string()).parse(chainId);
+  const parsedChainId = ChainIdSchema.pipe(z22.coerce.string()).parse(chainId);
   const marketplaceClient = getMarketplaceClient(parsedChainId, config);
   return marketplaceClient.generateCancelTransaction(args).then((data) => data.steps);
 };
@@ -1717,16 +1792,16 @@ var useTransferTokens = () => {
 };
 
 // src/react/hooks/useCheckoutOptions.tsx
-import { queryOptions as queryOptions20, useQuery as useQuery20 } from "@tanstack/react-query";
+import { queryOptions as queryOptions21, useQuery as useQuery21 } from "@tanstack/react-query";
 import { useAccount as useAccount3 } from "wagmi";
-import { z as z22 } from "zod";
-var UseCheckoutOptionsSchema = z22.object({
-  chainId: ChainIdSchema.pipe(z22.coerce.string()),
-  orders: z22.array(
-    z22.object({
+import { z as z23 } from "zod";
+var UseCheckoutOptionsSchema = z23.object({
+  chainId: ChainIdSchema.pipe(z23.coerce.string()),
+  orders: z23.array(
+    z23.object({
       collectionAddress: AddressSchema,
-      orderId: z22.string(),
-      marketplace: z22.nativeEnum(MarketplaceKind)
+      orderId: z23.string(),
+      marketplace: z23.nativeEnum(MarketplaceKind)
     })
   ),
   query: QueryArgSchema
@@ -1745,7 +1820,7 @@ var fetchCheckoutOptions = async (args, config) => {
   });
 };
 var checkoutOptionsOptions = (args, config) => {
-  return queryOptions20({
+  return queryOptions21({
     queryKey: ["checkoutOptions", args],
     queryFn: () => fetchCheckoutOptions(args, config)
   });
@@ -1753,16 +1828,16 @@ var checkoutOptionsOptions = (args, config) => {
 var useCheckoutOptions = (args) => {
   const { address } = useAccount3();
   const config = useConfig();
-  return useQuery20(
+  return useQuery21(
     // biome-ignore lint/style/noNonNullAssertion: <explanation>
     checkoutOptionsOptions({ walletAddress: address, ...args }, config)
   );
 };
 
 // src/react/hooks/useListCollections.tsx
-import { queryOptions as queryOptions21, useQuery as useQuery21 } from "@tanstack/react-query";
-import { z as z23 } from "zod";
-var UseListCollectionsSchema = z23.object({
+import { queryOptions as queryOptions22, useQuery as useQuery22 } from "@tanstack/react-query";
+import { z as z24 } from "zod";
+var UseListCollectionsSchema = z24.object({
   query: QueryArgSchema.optional().default({})
 });
 var fetchListCollections = async ({ marketplaceConfig }, config) => {
@@ -1771,11 +1846,11 @@ var fetchListCollections = async ({ marketplaceConfig }, config) => {
     return [];
   }
   const collectionsByChain = marketplaceConfig.collections.reduce((acc, curr) => {
-    const { chainId, collectionAddress } = curr;
+    const { chainId, address } = curr;
     if (!acc[chainId]) {
       acc[chainId] = [];
     }
-    acc[chainId].push(collectionAddress);
+    acc[chainId].push(address);
     return acc;
   }, {});
   const promises = Object.entries(collectionsByChain).map(
@@ -1788,7 +1863,7 @@ var fetchListCollections = async ({ marketplaceConfig }, config) => {
   return results.flat();
 };
 var listCollectionsOptions = (args, config) => {
-  return queryOptions21({
+  return queryOptions22({
     ...args.query,
     queryKey: [...collectionKeys.list],
     queryFn: () => fetchListCollections(args, config)
@@ -1797,7 +1872,7 @@ var listCollectionsOptions = (args, config) => {
 var useListCollections = (args = {}) => {
   const config = useConfig();
   const { data: marketplaceConfig, isLoading: isLoadingConfig } = useMarketplaceConfig();
-  return useQuery21({
+  return useQuery22({
     ...listCollectionsOptions(
       // biome-ignore lint/style/noNonNullAssertion: <explanation>
       { marketplaceConfig, query: args.query },
@@ -1808,21 +1883,21 @@ var useListCollections = (args = {}) => {
 };
 
 // src/react/hooks/useGenerateBuyTransaction.tsx
-import { queryOptions as queryOptions22, useQuery as useQuery22 } from "@tanstack/react-query";
+import { queryOptions as queryOptions23, skipToken as skipToken2, useQuery as useQuery23 } from "@tanstack/react-query";
 import { useAccount as useAccount4 } from "wagmi";
-import { z as z24 } from "zod";
-var UseGenerateBuyTransactionArgsSchema = z24.object({
-  chainId: ChainIdSchema.pipe(z24.coerce.string()),
+import { z as z25 } from "zod";
+var UseGenerateBuyTransactionArgsSchema = z25.object({
+  chainId: ChainIdSchema.pipe(z25.coerce.string()),
   collectionAddress: AddressSchema,
-  marketplace: z24.nativeEnum(MarketplaceKind),
-  ordersData: z24.array(
-    z24.object({
-      orderId: z24.string(),
-      quantity: z24.string(),
-      marketplace: z24.string()
+  marketplace: z25.nativeEnum(MarketplaceKind),
+  ordersData: z25.array(
+    z25.object({
+      orderId: z25.string(),
+      quantity: z25.string(),
+      marketplace: z25.string()
     })
   ),
-  walletType: z24.nativeEnum(WalletKind).optional(),
+  walletType: z25.nativeEnum(WalletKind).optional(),
   query: QueryArgSchema
 });
 var fetchGenerateBuyTransaction = async (args, config) => {
@@ -1836,7 +1911,7 @@ var fetchGenerateBuyTransaction = async (args, config) => {
   }).then((data) => data.steps);
 };
 var generateBuyTransactionOptions = (args, config) => {
-  return queryOptions22({
+  return queryOptions23({
     queryKey: ["generateBuyTransaction", args],
     queryFn: () => fetchGenerateBuyTransaction(args, config),
     ...args.query
@@ -1845,10 +1920,15 @@ var generateBuyTransactionOptions = (args, config) => {
 var useGenerateBuyTransaction = (args) => {
   const { address } = useAccount4();
   const config = useConfig();
-  return useQuery22(
-    // biome-ignore lint/style/noNonNullAssertion: <explanation>
-    generateBuyTransactionOptions({ buyer: address, ...args }, config)
-  );
+  return useQuery23({
+    queryKey: ["generateBuyTransaction", args],
+    queryFn: address ? () => {
+      return fetchGenerateBuyTransaction(
+        { buyer: address, ...args },
+        config
+      );
+    } : skipToken2
+  });
 };
 
 // src/react/hooks/useCancelOrder.tsx
@@ -1856,7 +1936,7 @@ import { useState, useEffect } from "react";
 
 // src/react/_internal/wallet/useWallet.ts
 import { useAccount as useAccount5, useChainId, useSwitchChain, useWalletClient } from "wagmi";
-import { useQuery as useQuery23 } from "@tanstack/react-query";
+import { useQuery as useQuery24 } from "@tanstack/react-query";
 
 // src/react/_internal/wallet/wallet.ts
 import {
@@ -1978,6 +2058,7 @@ var wallet = ({
           });
           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,
@@ -2115,7 +2196,7 @@ var useWallet = () => {
   const { connector, isConnected, isConnecting } = useAccount5();
   const sdkConfig = useConfig();
   const chainId = useChainId();
-  const { data, isLoading, isError } = useQuery23({
+  const { data, isLoading, isError } = useQuery24({
     queryKey: ["wallet", chainId, connector?.uid],
     queryFn: () => {
       if (!walletClient || !connector || !isConnected) {
@@ -2292,10 +2373,10 @@ var useCancelTransactionSteps = ({
     chainId
   });
   const getWalletChainId = async () => {
-    return await wallet2.getChainId();
+    return await wallet2?.getChainId();
   };
   const switchChain = async () => {
-    await wallet2.switchChain(Number(chainId));
+    await wallet2?.switchChain(Number(chainId));
   };
   const checkAndSwitchChain = async () => {
     const walletChainId = await getWalletChainId();
@@ -2323,7 +2404,10 @@ var useCancelTransactionSteps = ({
     marketplace
   }) => {
     try {
-      const address = await wallet2.address();
+      const address = await wallet2?.address();
+      if (!address) {
+        throw new Error("Wallet address not found");
+      }
       const steps = await generateCancelTransactionAsync({
         collectionAddress,
         maker: address,
@@ -2368,7 +2452,8 @@ var useCancelTransactionSteps = ({
       if (!transactionStep && !signatureStep) {
         throw new Error("No transaction or signature step found");
       }
-      let hash, reservoirOrderId;
+      let hash;
+      let reservoirOrderId;
       if (transactionStep && wallet2) {
         hash = await executeTransaction({ transactionStep });
         if (hash) {
@@ -2407,7 +2492,7 @@ var useCancelTransactionSteps = ({
   const executeTransaction = async ({
     transactionStep
   }) => {
-    const hash = await wallet2.handleSendTransactionStep(
+    const hash = await wallet2?.handleSendTransactionStep(
       Number(chainId),
       transactionStep
     );
@@ -2416,7 +2501,7 @@ var useCancelTransactionSteps = ({
   const executeSignature = async ({
     signatureStep
   }) => {
-    const signature = await wallet2.handleSignMessageStep(
+    const signature = await wallet2?.handleSignMessageStep(
       signatureStep
     );
     const result = await marketplaceClient.execute({
@@ -2506,7 +2591,7 @@ var useCancelOrder = ({
 };
 
 // src/react/hooks/useCollectionDetails.tsx
-import { queryOptions as queryOptions23, useQuery as useQuery24 } from "@tanstack/react-query";
+import { queryOptions as queryOptions24, useQuery as useQuery25 } from "@tanstack/react-query";
 var fetchCollectionDetails = async (args, marketplaceClient) => {
   const { collection } = await marketplaceClient.getCollectionDetail({
     contractAddress: args.collectionAddress
@@ -2515,18 +2600,18 @@ var fetchCollectionDetails = async (args, marketplaceClient) => {
 };
 var collectionDetailsOptions = (args, config) => {
   const marketplaceClient = getMarketplaceClient(args.chainId, config);
-  return queryOptions23({
+  return queryOptions24({
     queryKey: ["collectionDetails", args],
     queryFn: () => fetchCollectionDetails(args, marketplaceClient)
   });
 };
 var useCollectionDetails = (args) => {
   const config = useConfig();
-  return useQuery24(collectionDetailsOptions(args, config));
+  return useQuery25(collectionDetailsOptions(args, config));
 };
 
 // src/react/hooks/useCollectionDetailsPolling.tsx
-import { queryOptions as queryOptions24, useQuery as useQuery25 } from "@tanstack/react-query";
+import { queryOptions as queryOptions25, useQuery as useQuery26 } from "@tanstack/react-query";
 var INITIAL_POLLING_INTERVAL = 2e3;
 var MAX_POLLING_INTERVAL = 3e4;
 var MAX_ATTEMPTS = 30;
@@ -2539,7 +2624,7 @@ var isTerminalState = (status) => {
   ].includes(status);
 };
 var collectionDetailsPollingOptions = (args, config) => {
-  return queryOptions24({
+  return queryOptions25({
     ...collectionDetailsOptions(args, config),
     refetchInterval: (query) => {
       const data = query.state.data;
@@ -2551,7 +2636,7 @@ var collectionDetailsPollingOptions = (args, config) => {
         return false;
       }
       const interval = Math.min(
-        INITIAL_POLLING_INTERVAL * Math.pow(1.5, currentAttempt),
+        INITIAL_POLLING_INTERVAL * 1.5 ** currentAttempt,
         MAX_POLLING_INTERVAL
       );
       return interval;
@@ -2562,7 +2647,7 @@ var collectionDetailsPollingOptions = (args, config) => {
 };
 var useCollectionDetailsPolling = (args) => {
   const config = useConfig();
-  return useQuery25(collectionDetailsPollingOptions(args, config));
+  return useQuery26(collectionDetailsPollingOptions(args, config));
 };
 
 export {
@@ -2581,11 +2666,10 @@ export {
   useCollectible,
   collectionOptions,
   useCollection,
-  currenciesOptions,
-  useCurrencies,
   marketplaceConfigOptions,
   useMarketplaceConfig,
-  useCurrencyOptions,
+  currenciesOptions,
+  useCurrencies,
   currencyOptions,
   useCurrency,
   fetchFilters,
@@ -2602,6 +2686,8 @@ export {
   useListCollectibleActivities,
   listCollectiblesOptions,
   useListCollectibles,
+  listCollectiblesPaginatedOptions,
+  useListCollectiblesPaginated,
   listCollectionActivitiesOptions,
   useListCollectionActivities,
   listOffersForCollectibleOptions,
@@ -2644,4 +2730,4 @@ export {
   collectionDetailsPollingOptions,
   useCollectionDetailsPolling
 };
-//# sourceMappingURL=chunk-I37CRQ4S.js.map
+//# sourceMappingURL=chunk-JWNONWD6.js.map