@0xsequence/marketplace-sdk 0.5.7 → 0.6.0

package/dist/{chunk-YA3DWLDC.js → chunk-A5ICXOCZ.js}

@@ -2,6 +2,10 @@
 import {
   InfoIcon_default
 } from "./chunk-QTJF5GDQ.js";
+import {
+  collectionOptions,
+  marketplaceConfigOptions
+} from "./chunk-6WMO5YM5.js";
 import {
   SEQUENCE_MARKET_V1_ADDRESS,
   SEQUENCE_MARKET_V2_ADDRESS
@@ -17,7 +21,7 @@ import {
 import {
   compareAddress,
   getPresentableChainName
-} from "./chunk-OMCWTRBR.js";
+} from "./chunk-NKHM2AIS.js";
 import {
   ERC1155_ABI
 } from "./chunk-WFE6OCYF.js";
@@ -31,7 +35,7 @@ import {
   PROVIDER_ID,
   QueryArgSchema,
   getProviderEl
-} from "./chunk-YOKGP2EQ.js";
+} from "./chunk-FG2BBP3P.js";
 import {
   CollectibleStatus,
   CollectionStatus,
@@ -52,10 +56,8 @@ import {
   TransactionSwapProvider,
   WalletKind,
   balanceQueries,
-  builderMarketplaceApi,
   collectableKeys,
   collectionKeys,
-  configKeys,
   currencyKeys,
   getIndexerClient,
   getMarketplaceClient,
@@ -66,9 +68,7 @@ import {
   BaseError,
   ChainSwitchError,
   ChainSwitchUserRejectedError,
-  MarketplaceConfigFetchError,
   NoWalletConnectedError,
-  ProjectNotFoundError,
   TransactionConfirmationError,
   TransactionExecutionError,
   TransactionSignatureError,
@@ -83,8 +83,8 @@ import { useCallback } from "react";
 import { useAccount } from "wagmi";
 
 // src/react/hooks/useCollectionBalanceDetails.tsx
-import { z } from "zod";
 import { queryOptions, useQuery } from "@tanstack/react-query";
+import { z } from "zod";
 
 // src/react/hooks/useConfig.tsx
 import { useContext } from "react";
@@ -953,98 +953,28 @@ var useCollectible = (args) => {
 };
 
 // src/react/hooks/useCollection.tsx
-import { queryOptions as queryOptions5, useQuery as useQuery5 } from "@tanstack/react-query";
-import { z as z6 } from "zod";
-var UseCollectionSchema = z6.object({
-  chainId: ChainIdSchema.pipe(z6.coerce.string()),
-  collectionAddress: AddressSchema,
-  query: QueryArgSchema
-});
-var fetchCollection = async (args, config) => {
-  const parsedArgs = UseCollectionSchema.parse(args);
-  const metadataClient = getMetadataClient(config);
-  return metadataClient.getContractInfo({
-    chainID: parsedArgs.chainId,
-    contractAddress: parsedArgs.collectionAddress
-  }).then((resp) => resp.contractInfo);
-};
-var collectionOptions = (args, config) => {
-  return queryOptions5({
-    ...args.query,
-    queryKey: [...collectionKeys.detail, args, config],
-    queryFn: () => fetchCollection(args, config)
-  });
-};
+import { useQuery as useQuery5 } from "@tanstack/react-query";
 var useCollection = (args) => {
   const config = useConfig();
   return useQuery5(collectionOptions(args, config));
 };
 
 // src/react/hooks/useComparePrices.tsx
-import { queryOptions as queryOptions9, useQuery as useQuery9 } from "@tanstack/react-query";
-import { z as z9 } from "zod";
+import { queryOptions as queryOptions7, useQuery as useQuery9 } from "@tanstack/react-query";
+import { z as z8 } from "zod";
 
 // src/react/hooks/useConvertPriceToUSD.tsx
-import { queryOptions as queryOptions8, useQuery as useQuery8 } from "@tanstack/react-query";
+import { queryOptions as queryOptions6, useQuery as useQuery8 } from "@tanstack/react-query";
 import { formatUnits } from "viem";
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 
 // src/react/hooks/useCurrencies.tsx
-import { queryOptions as queryOptions7, useQuery as useQuery7 } from "@tanstack/react-query";
+import { queryOptions as queryOptions5, useQuery as useQuery7 } from "@tanstack/react-query";
 import { zeroAddress as zeroAddress2 } from "viem";
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 
 // src/react/hooks/useMarketplaceConfig.tsx
 import { useQuery as useQuery6 } from "@tanstack/react-query";
-
-// src/react/hooks/options/marketplaceConfigOptions.ts
-import { queryOptions as queryOptions6 } from "@tanstack/react-query";
-var fetchBuilderConfig = async (projectId, env) => {
-  const url = `${builderMarketplaceApi(projectId, env)}`;
-  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);
-    switch (json.code) {
-      case 3e3:
-        throw new ProjectNotFoundError(projectId, url);
-      default:
-        throw new MarketplaceConfigFetchError(json.msg);
-    }
-  }
-  return json;
-};
-var fetchStyles = async (projectId, env) => {
-  const response = await fetch(
-    `${builderMarketplaceApi(projectId, env)}/styles.css`
-  );
-  const styles = await response.text();
-  return styles.replaceAll(/['"]/g, "");
-};
-var fetchMarketplaceConfig = async (env, projectId) => {
-  const [marketplaceConfig, cssString] = await Promise.all([
-    fetchBuilderConfig(projectId, env),
-    fetchStyles(projectId, env)
-  ]);
-  return {
-    ...marketplaceConfig,
-    cssString,
-    manifestUrl: `${builderMarketplaceApi(projectId, env)}/manifest.json`
-  };
-};
-var marketplaceConfigOptions = (config) => {
-  let env = "production";
-  if ("_internal" in config && config._internal !== void 0) {
-    env = config._internal.builderEnv ?? env;
-  }
-  const projectId = config.projectId;
-  return queryOptions6({
-    queryKey: [...configKeys.marketplace, env, projectId],
-    queryFn: () => fetchMarketplaceConfig(env, projectId)
-  });
-};
-
-// src/react/hooks/useMarketplaceConfig.tsx
 var useMarketplaceConfig = () => {
   const config = useConfig();
   return useQuery6(marketplaceConfigOptions(config));
@@ -1052,9 +982,9 @@ var useMarketplaceConfig = () => {
 
 // src/react/hooks/useCurrencies.tsx
 var ChainIdCoerce = ChainIdSchema.transform((val) => val.toString());
-var UseCurrenciesArgsSchema = z7.object({
+var UseCurrenciesArgsSchema = z6.object({
   chainId: ChainIdCoerce,
-  includeNativeCurrency: z7.boolean().optional().default(true),
+  includeNativeCurrency: z6.boolean().optional().default(true),
   collectionAddress: AddressSchema.optional(),
   query: QueryArgSchema
 });
@@ -1087,7 +1017,7 @@ var fetchCurrencies = async (args, config) => {
   return currencies;
 };
 var currenciesOptions = (args, config) => {
-  return queryOptions7({
+  return queryOptions5({
     ...args.query,
     queryKey: [...currencyKeys.lists, args],
     queryFn: () => fetchCurrencies(args, config),
@@ -1101,10 +1031,10 @@ var useCurrencies = (args) => {
 
 // src/react/hooks/useConvertPriceToUSD.tsx
 var ChainIdCoerce2 = ChainIdSchema.transform((val) => val.toString());
-var UseConvertPriceToUSDArgsSchema = z8.object({
+var UseConvertPriceToUSDArgsSchema = z7.object({
   chainId: ChainIdCoerce2,
   currencyAddress: AddressSchema,
-  amountRaw: z8.string(),
+  amountRaw: z7.string(),
   query: QueryArgSchema
 });
 var convertPriceToUSD = async (args, config) => {
@@ -1134,7 +1064,7 @@ var convertPriceToUSD = async (args, config) => {
   };
 };
 var convertPriceToUSDOptions = (args, config) => {
-  return queryOptions8({
+  return queryOptions6({
     ...args.query,
     queryKey: [
       ...currencyKeys.conversion,
@@ -1152,13 +1082,13 @@ var useConvertPriceToUSD = (args) => {
 
 // src/react/hooks/useComparePrices.tsx
 var ChainIdCoerce3 = ChainIdSchema.transform((val) => val.toString());
-var UseComparePricesArgsSchema = z9.object({
+var UseComparePricesArgsSchema = z8.object({
   chainId: ChainIdCoerce3,
   // First price details
-  priceAmountRaw: z9.string(),
+  priceAmountRaw: z8.string(),
   priceCurrencyAddress: AddressSchema,
   // Second price details (to compare against)
-  compareToPriceAmountRaw: z9.string(),
+  compareToPriceAmountRaw: z8.string(),
   compareToPriceCurrencyAddress: AddressSchema,
   query: QueryArgSchema
 });
@@ -1198,7 +1128,7 @@ var comparePrices = async (args, config) => {
   };
 };
 var comparePricesOptions = (args, config) => {
-  return queryOptions9({
+  return queryOptions7({
     ...args.query,
     queryKey: [...currencyKeys.conversion, "compare", args],
     queryFn: () => comparePrices(args, config)
@@ -1210,10 +1140,10 @@ var useComparePrices = (args) => {
 };
 
 // src/react/hooks/useCurrency.tsx
-import { queryOptions as queryOptions10, useQuery as useQuery10 } from "@tanstack/react-query";
-import { z as z10 } from "zod";
+import { queryOptions as queryOptions8, useQuery as useQuery10 } from "@tanstack/react-query";
+import { z as z9 } from "zod";
 var ChainIdCoerce4 = ChainIdSchema.transform((val) => val.toString());
-var UseCurrencyArgsSchema = z10.object({
+var UseCurrencyArgsSchema = z9.object({
   chainId: ChainIdCoerce4,
   currencyAddress: AddressSchema,
   query: QueryArgSchema
@@ -1238,7 +1168,7 @@ var fetchCurrency = async (chainId, currencyAddress, config) => {
   return currency;
 };
 var currencyOptions = (args, config) => {
-  return queryOptions10({
+  return queryOptions8({
     ...args.query,
     queryKey: [...currencyKeys.details, args.chainId, args.currencyAddress],
     queryFn: () => fetchCurrency(args.chainId, args.currencyAddress, config)
@@ -1250,12 +1180,12 @@ var useCurrency = (args) => {
 };
 
 // src/react/hooks/useFilters.tsx
-import { queryOptions as queryOptions11, useQuery as useQuery11 } from "@tanstack/react-query";
-import { z as z11 } from "zod";
-var UseFiltersSchema = z11.object({
-  chainId: ChainIdSchema.pipe(z11.coerce.string()),
+import { queryOptions as queryOptions9, useQuery as useQuery11 } from "@tanstack/react-query";
+import { z as z10 } from "zod";
+var UseFiltersSchema = z10.object({
+  chainId: ChainIdSchema.pipe(z10.coerce.string()),
   collectionAddress: AddressSchema,
-  showAllFilters: z11.boolean().default(false).optional(),
+  showAllFilters: z10.boolean().default(false).optional(),
   query: QueryArgSchema
 });
 var fetchFilters = async (args, config) => {
@@ -1304,7 +1234,7 @@ var fetchFilters = async (args, config) => {
   return filteredResults;
 };
 var filtersOptions = (args, config) => {
-  return queryOptions11({
+  return queryOptions9({
     ...args.query,
     queryKey: [...collectableKeys.filter, args, config],
     queryFn: () => fetchFilters(args, config)
@@ -1316,10 +1246,10 @@ var useFilters = (args) => {
 };
 
 // src/react/hooks/useFloorOrder.tsx
-import { queryOptions as queryOptions12, useQuery as useQuery12 } from "@tanstack/react-query";
-import { z as z12 } from "zod";
-var UseFloorOrderSchema = z12.object({
-  chainId: ChainIdSchema.pipe(z12.coerce.string()),
+import { queryOptions as queryOptions10, useQuery as useQuery12 } from "@tanstack/react-query";
+import { z as z11 } from "zod";
+var UseFloorOrderSchema = z11.object({
+  chainId: ChainIdSchema.pipe(z11.coerce.string()),
   collectionAddress: AddressSchema,
   query: QueryArgSchema
 });
@@ -1328,7 +1258,7 @@ var fetchFloorOrder = async (args, config) => {
   return marketplaceClient.getFloorOrder({ contractAddress: args.collectionAddress }).then((data) => data.collectible);
 };
 var floorOrderOptions = (args, config) => {
-  return queryOptions12({
+  return queryOptions10({
     queryKey: [...collectableKeys.floorOrders, args, config],
     queryFn: () => fetchFloorOrder(args, config)
   });
@@ -1339,13 +1269,13 @@ var useFloorOrder = (args) => {
 };
 
 // src/react/hooks/useHighestOffer.tsx
-import { queryOptions as queryOptions13, useQuery as useQuery13 } from "@tanstack/react-query";
-import { z as z13 } from "zod";
+import { queryOptions as queryOptions11, useQuery as useQuery13 } from "@tanstack/react-query";
+import { z as z12 } from "zod";
 var UseHighestOfferArgsSchema = getCollectibleHighestOfferArgsSchema.omit({
   contractAddress: true
 }).extend({
   collectionAddress: AddressSchema,
-  chainId: ChainIdSchema.pipe(z13.coerce.string()),
+  chainId: ChainIdSchema.pipe(z12.coerce.string()),
   query: QueryArgSchema
 });
 var fetchHighestOffer = async (args, config) => {
@@ -1357,7 +1287,7 @@ var fetchHighestOffer = async (args, config) => {
   });
 };
 var highestOfferOptions = (args, config) => {
-  return queryOptions13({
+  return queryOptions11({
     ...args.query,
     queryKey: [...collectableKeys.highestOffers, args, config],
     queryFn: () => fetchHighestOffer(args, config)
@@ -1371,34 +1301,34 @@ var useHighestOffer = (args) => {
 // src/react/hooks/useListBalances.tsx
 import { SortOrder as SortOrder2 } from "@0xsequence/indexer";
 import { infiniteQueryOptions, useInfiniteQuery } from "@tanstack/react-query";
-import { z as z14 } from "zod";
-var metadataOptionsSchema = z14.object({
-  verifiedOnly: z14.boolean().optional(),
-  unverifiedOnly: z14.boolean().optional(),
-  includeContracts: z14.array(z14.string()).optional()
-});
-var sortOrderSchema2 = z14.nativeEnum(SortOrder2);
-var sortBySchema2 = z14.object({
-  column: z14.string(),
+import { z as z13 } from "zod";
+var metadataOptionsSchema = z13.object({
+  verifiedOnly: z13.boolean().optional(),
+  unverifiedOnly: z13.boolean().optional(),
+  includeContracts: z13.array(z13.string()).optional()
+});
+var sortOrderSchema2 = z13.nativeEnum(SortOrder2);
+var sortBySchema2 = z13.object({
+  column: z13.string(),
   order: sortOrderSchema2
 });
-var pageSchema2 = z14.object({
-  page: z14.number().optional(),
-  column: z14.string().optional(),
-  before: z14.any().optional(),
-  after: z14.any().optional(),
-  sort: z14.array(sortBySchema2).optional(),
-  pageSize: z14.number().optional(),
-  more: z14.boolean().optional()
-});
-var useListBalancesArgsSchema = z14.object({
-  chainId: ChainIdSchema.pipe(z14.coerce.number()),
+var pageSchema2 = z13.object({
+  page: z13.number().optional(),
+  column: z13.string().optional(),
+  before: z13.any().optional(),
+  after: z13.any().optional(),
+  sort: z13.array(sortBySchema2).optional(),
+  pageSize: z13.number().optional(),
+  more: z13.boolean().optional()
+});
+var useListBalancesArgsSchema = z13.object({
+  chainId: ChainIdSchema.pipe(z13.coerce.number()),
   accountAddress: AddressSchema.optional(),
   contractAddress: AddressSchema.optional(),
-  tokenId: z14.string().optional(),
-  includeMetadata: z14.boolean().optional(),
+  tokenId: z13.string().optional(),
+  includeMetadata: z13.boolean().optional(),
   metadataOptions: metadataOptionsSchema.optional(),
-  includeCollectionTokens: z14.boolean().optional(),
+  includeCollectionTokens: z13.boolean().optional(),
   page: pageSchema2.optional(),
   query: QueryArgSchema
 });
@@ -1426,7 +1356,7 @@ var useListBalances = (args) => {
 };
 
 // src/react/hooks/useListCollectibleActivities.tsx
-import { queryOptions as queryOptions14, useQuery as useQuery14 } from "@tanstack/react-query";
+import { queryOptions as queryOptions12, useQuery as useQuery14 } from "@tanstack/react-query";
 var fetchCollectibleActivities = async (args, config) => {
   const marketplaceClient = getMarketplaceClient(args.chainId, config);
   return marketplaceClient.listCollectibleActivities({
@@ -1443,7 +1373,7 @@ var fetchCollectibleActivities = async (args, config) => {
   }));
 };
 var listCollectibleActivitiesOptions = (args, config) => {
-  return queryOptions14({
+  return queryOptions12({
     queryKey: [...collectableKeys.collectibleActivities, args, config],
     queryFn: () => fetchCollectibleActivities(args, config),
     enabled: args.query?.enabled ?? true
@@ -1456,12 +1386,12 @@ var useListCollectibleActivities = (args) => {
 
 // src/react/hooks/useListCollectibles.tsx
 import { infiniteQueryOptions as infiniteQueryOptions2, useInfiniteQuery as useInfiniteQuery2 } from "@tanstack/react-query";
-import { z as z15 } from "zod";
+import { z as z14 } from "zod";
 var UseListCollectiblesArgsSchema = listCollectiblesArgsSchema.omit({
   contractAddress: true
 }).extend({
   collectionAddress: AddressSchema,
-  chainId: ChainIdSchema.pipe(z15.coerce.string()),
+  chainId: ChainIdSchema.pipe(z14.coerce.string()),
   query: QueryArgSchema
 });
 var fetchCollectibles = async (args, marketplaceClient, page) => {
@@ -1489,17 +1419,17 @@ var useListCollectibles = (args) => {
 };
 
 // src/react/hooks/useListCollectiblesPaginated.tsx
-import { queryOptions as queryOptions15, useQuery as useQuery15 } from "@tanstack/react-query";
-import { z as z16 } from "zod";
+import { queryOptions as queryOptions13, useQuery as useQuery15 } from "@tanstack/react-query";
+import { z as z15 } from "zod";
 var UseListCollectiblesPaginatedArgsSchema = listCollectiblesArgsSchema.omit({
   contractAddress: true
 }).extend({
   collectionAddress: AddressSchema,
-  chainId: ChainIdSchema.pipe(z16.coerce.string()),
-  query: z16.object({
-    enabled: z16.boolean().optional(),
-    page: z16.number().optional().default(1),
-    pageSize: z16.number().optional().default(30)
+  chainId: ChainIdSchema.pipe(z15.coerce.string()),
+  query: z15.object({
+    enabled: z15.boolean().optional(),
+    page: z15.number().optional().default(1),
+    pageSize: z15.number().optional().default(30)
   }).optional().default({})
 });
 var fetchCollectiblesPaginated = async (args, marketplaceClient) => {
@@ -1520,7 +1450,7 @@ var listCollectiblesPaginatedOptions = (args, config) => {
     args.chainId,
     config
   );
-  return queryOptions15({
+  return queryOptions13({
     queryKey: [...collectableKeys.lists, "paginated", args],
     queryFn: () => fetchCollectiblesPaginated(args, marketplaceClient),
     enabled: args.query?.enabled ?? true
@@ -1532,7 +1462,7 @@ var useListCollectiblesPaginated = (args) => {
 };
 
 // src/react/hooks/useListCollectionActivities.tsx
-import { queryOptions as queryOptions16, useQuery as useQuery16 } from "@tanstack/react-query";
+import { queryOptions as queryOptions14, useQuery as useQuery16 } from "@tanstack/react-query";
 var fetchListCollectionActivities = async (args, config) => {
   const marketplaceClient = getMarketplaceClient(args.chainId, config);
   return marketplaceClient.listCollectionActivities({
@@ -1548,7 +1478,7 @@ var fetchListCollectionActivities = async (args, config) => {
   }));
 };
 var listCollectionActivitiesOptions = (args, config) => {
-  return queryOptions16({
+  return queryOptions14({
     queryKey: [...collectionKeys.collectionActivities, args, config],
     queryFn: () => fetchListCollectionActivities(args, config),
     enabled: args.query?.enabled ?? true
@@ -1560,12 +1490,12 @@ var useListCollectionActivities = (args) => {
 };
 
 // src/react/hooks/useListOffersForCollectible.tsx
-import { queryOptions as queryOptions17, useQuery as useQuery17 } from "@tanstack/react-query";
-import { z as z17 } from "zod";
+import { queryOptions as queryOptions15, useQuery as useQuery17 } from "@tanstack/react-query";
+import { z as z16 } from "zod";
 var UseListOffersForCollectibleArgsSchema = listOffersForCollectibleArgsSchema.extend({
-  chainId: ChainIdSchema.pipe(z17.coerce.string()),
-  collectionAddress: z17.string(),
-  collectibleId: z17.string()
+  chainId: ChainIdSchema.pipe(z16.coerce.string()),
+  collectionAddress: z16.string(),
+  collectibleId: z16.string()
 }).omit({ contractAddress: true, tokenId: true });
 var fetchListOffersForCollectible = async (config, args) => {
   const arg = {
@@ -1578,7 +1508,7 @@ var fetchListOffersForCollectible = async (config, args) => {
   return marketplaceClient.listCollectibleOffers(arg);
 };
 var listOffersForCollectibleOptions = (args, config) => {
-  return queryOptions17({
+  return queryOptions15({
     queryKey: [...collectableKeys.offers, args, config],
     queryFn: () => fetchListOffersForCollectible(config, args)
   });
@@ -1589,15 +1519,15 @@ var useListOffersForCollectible = (args) => {
 };
 
 // src/react/hooks/useCountOffersForCollectible.tsx
-import { queryOptions as queryOptions18, useQuery as useQuery18 } from "@tanstack/react-query";
-import { z as z18 } from "zod";
+import { queryOptions as queryOptions16, useQuery as useQuery18 } from "@tanstack/react-query";
+import { z as z17 } from "zod";
 var UseCountOffersForCollectibleArgsSchema = countOffersForCollectibleArgsSchema.omit({
   contractAddress: true,
   tokenId: true
 }).extend({
   collectionAddress: AddressSchema,
-  collectibleId: z18.string(),
-  chainId: ChainIdSchema.pipe(z18.coerce.string()),
+  collectibleId: z17.string(),
+  chainId: ChainIdSchema.pipe(z17.coerce.string()),
   query: QueryArgSchema
 });
 var fetchCountOffersForCollectible = async (args, config) => {
@@ -1610,7 +1540,7 @@ var fetchCountOffersForCollectible = async (args, config) => {
   });
 };
 var countOffersForCollectibleOptions = (args, config) => {
-  return queryOptions18({
+  return queryOptions16({
     ...args.query,
     queryKey: [...collectableKeys.offersCount, args, config],
     queryFn: () => fetchCountOffersForCollectible(args, config)
@@ -1622,12 +1552,12 @@ var useCountOffersForCollectible = (args) => {
 };
 
 // src/react/hooks/useListListingsForCollectible.tsx
-import { queryOptions as queryOptions19, useQuery as useQuery19 } from "@tanstack/react-query";
-import { z as z19 } from "zod";
+import { queryOptions as queryOptions17, useQuery as useQuery19 } from "@tanstack/react-query";
+import { z as z18 } from "zod";
 var UseListListingsForCollectibleArgsSchema = listListingsForCollectibleArgsSchema.extend({
-  chainId: ChainIdSchema.pipe(z19.coerce.string()),
-  collectionAddress: z19.string(),
-  collectibleId: z19.string()
+  chainId: ChainIdSchema.pipe(z18.coerce.string()),
+  collectionAddress: z18.string(),
+  collectibleId: z18.string()
 }).omit({ contractAddress: true, tokenId: true });
 var fetchListListingsForCollectible = async (config, args) => {
   const arg = {
@@ -1640,7 +1570,7 @@ var fetchListListingsForCollectible = async (config, args) => {
   return marketplaceClient.listCollectibleListings(arg);
 };
 var listListingsForCollectibleOptions = (args, config) => {
-  return queryOptions19({
+  return queryOptions17({
     queryKey: [...collectableKeys.listings, args, config],
     queryFn: () => fetchListListingsForCollectible(config, args)
   });
@@ -1651,15 +1581,15 @@ var useListListingsForCollectible = (args) => {
 };
 
 // src/react/hooks/useCountListingsForCollectible.tsx
-import { queryOptions as queryOptions20, useQuery as useQuery20 } from "@tanstack/react-query";
-import { z as z20 } from "zod";
+import { queryOptions as queryOptions18, useQuery as useQuery20 } from "@tanstack/react-query";
+import { z as z19 } from "zod";
 var UseCountListingsForCollectibleArgsSchema = countListingsForCollectibleArgsSchema.omit({
   contractAddress: true,
   tokenId: true
 }).extend({
   collectionAddress: AddressSchema,
-  collectibleId: z20.string(),
-  chainId: ChainIdSchema.pipe(z20.coerce.string()),
+  collectibleId: z19.string(),
+  chainId: ChainIdSchema.pipe(z19.coerce.string()),
   query: QueryArgSchema
 });
 var fetchCountListingsForCollectible = async (args, config) => {
@@ -1672,7 +1602,7 @@ var fetchCountListingsForCollectible = async (args, config) => {
   });
 };
 var countListingsForCollectibleOptions = (args, config) => {
-  return queryOptions20({
+  return queryOptions18({
     ...args.query,
     queryKey: [...collectableKeys.listingsCount, args, config],
     queryFn: () => fetchCountListingsForCollectible(args, config)
@@ -1684,13 +1614,13 @@ var useCountListingsForCollectible = (args) => {
 };
 
 // src/react/hooks/useLowestListing.tsx
-import { queryOptions as queryOptions21, useQuery as useQuery21 } from "@tanstack/react-query";
-import { z as z21 } from "zod";
+import { queryOptions as queryOptions19, useQuery as useQuery21 } from "@tanstack/react-query";
+import { z as z20 } from "zod";
 var UseLowestListingSchema = getCollectibleLowestListingArgsSchema.omit({
   contractAddress: true
 }).extend({
   collectionAddress: AddressSchema,
-  chainId: ChainIdSchema.pipe(z21.coerce.string()),
+  chainId: ChainIdSchema.pipe(z20.coerce.string()),
   query: QueryArgSchema
 });
 var fetchLowestListing = async (args, config) => {
@@ -1702,7 +1632,7 @@ var fetchLowestListing = async (args, config) => {
   });
 };
 var lowestListingOptions = (args, config) => {
-  return queryOptions21({
+  return queryOptions19({
     ...args.query,
     queryKey: [...collectableKeys.lowestListings, args, config],
     queryFn: () => fetchLowestListing(args, config)
@@ -1714,14 +1644,14 @@ var useLowestListing = (args) => {
 };
 
 // src/react/hooks/useRoyaltyPercentage.tsx
-import { queryOptions as queryOptions22, skipToken as skipToken2, useQuery as useQuery22 } from "@tanstack/react-query";
+import { queryOptions as queryOptions20, skipToken as skipToken2, useQuery as useQuery22 } from "@tanstack/react-query";
 import { getContract } from "viem";
 import { usePublicClient } from "wagmi";
-import { z as z22 } from "zod";
-var UseRoyaletyPercentageSchema = z22.object({
-  chainId: ChainIdSchema.pipe(z22.coerce.string()),
+import { z as z21 } from "zod";
+var UseRoyaletyPercentageSchema = z21.object({
+  chainId: ChainIdSchema.pipe(z21.coerce.string()),
   collectionAddress: AddressSchema,
-  collectibleId: z22.string(),
+  collectibleId: z21.string(),
   query: QueryArgSchema
 });
 var fetchRoyaletyPercentage = async (args, publicClient) => {
@@ -1741,7 +1671,7 @@ var fetchRoyaletyPercentage = async (args, publicClient) => {
     return 0n;
   }
 };
-var royaletyPercentageOptions = (args, publicClient) => queryOptions22({
+var royaletyPercentageOptions = (args, publicClient) => queryOptions20({
   ...args.query,
   queryKey: [...collectableKeys.royaltyPercentage, args],
   queryFn: publicClient ? () => fetchRoyaletyPercentage(args, publicClient) : skipToken2
@@ -1807,13 +1737,13 @@ var useGenerateOfferTransaction = (params) => {
 
 // src/react/hooks/useGenerateSellTransaction.tsx
 import { useMutation as useMutation3 } from "@tanstack/react-query";
-import { z as z23 } from "zod";
-var UserGeneratSellTransactionArgsSchema = z23.object({
-  chainId: ChainIdSchema.pipe(z23.coerce.string()),
-  onSuccess: z23.function().args(stepSchema.array().optional()).optional()
+import { z as z22 } from "zod";
+var UserGeneratSellTransactionArgsSchema = z22.object({
+  chainId: ChainIdSchema.pipe(z22.coerce.string()),
+  onSuccess: z22.function().args(stepSchema.array().optional()).optional()
 });
 var generateSellTransaction = async (args, config, chainId) => {
-  const parsedChainId = ChainIdSchema.pipe(z23.coerce.string()).parse(chainId);
+  const parsedChainId = ChainIdSchema.pipe(z22.coerce.string()).parse(chainId);
   const marketplaceClient = getMarketplaceClient(parsedChainId, config);
   return marketplaceClient.generateSellTransaction(args).then((data) => data.steps);
 };
@@ -1832,13 +1762,13 @@ var useGenerateSellTransaction = (params) => {
 
 // src/react/hooks/useGenerateCancelTransaction.tsx
 import { useMutation as useMutation4 } from "@tanstack/react-query";
-import { z as z24 } from "zod";
-var UserGenerateCancelTransactionArgsSchema = z24.object({
-  chainId: ChainIdSchema.pipe(z24.coerce.string()),
-  onSuccess: z24.function().args(stepSchema.array().optional()).optional()
+import { z as z23 } from "zod";
+var UserGenerateCancelTransactionArgsSchema = z23.object({
+  chainId: ChainIdSchema.pipe(z23.coerce.string()),
+  onSuccess: z23.function().args(stepSchema.array().optional()).optional()
 });
 var generateCancelTransaction = async (args, config, chainId) => {
-  const parsedChainId = ChainIdSchema.pipe(z24.coerce.string()).parse(chainId);
+  const parsedChainId = ChainIdSchema.pipe(z23.coerce.string()).parse(chainId);
   const marketplaceClient = getMarketplaceClient(parsedChainId, config);
   return marketplaceClient.generateCancelTransaction(args).then((data) => data.steps);
 };
@@ -1911,16 +1841,16 @@ var useTransferTokens = () => {
 };
 
 // src/react/hooks/useCheckoutOptions.tsx
-import { queryOptions as queryOptions23, useQuery as useQuery23 } from "@tanstack/react-query";
+import { queryOptions as queryOptions21, useQuery as useQuery23 } from "@tanstack/react-query";
 import { useAccount as useAccount3 } from "wagmi";
-import { z as z25 } from "zod";
-var UseCheckoutOptionsSchema = z25.object({
-  chainId: ChainIdSchema.pipe(z25.coerce.string()),
-  orders: z25.array(
-    z25.object({
+import { z as z24 } from "zod";
+var UseCheckoutOptionsSchema = z24.object({
+  chainId: ChainIdSchema.pipe(z24.coerce.string()),
+  orders: z24.array(
+    z24.object({
       collectionAddress: AddressSchema,
-      orderId: z25.string(),
-      marketplace: z25.nativeEnum(MarketplaceKind)
+      orderId: z24.string(),
+      marketplace: z24.nativeEnum(MarketplaceKind)
     })
   ),
   query: QueryArgSchema
@@ -1939,7 +1869,7 @@ var fetchCheckoutOptions = async (args, config) => {
   });
 };
 var checkoutOptionsOptions = (args, config) => {
-  return queryOptions23({
+  return queryOptions21({
     queryKey: ["checkoutOptions", args],
     queryFn: () => fetchCheckoutOptions(args, config)
   });
@@ -1954,9 +1884,9 @@ var useCheckoutOptions = (args) => {
 };
 
 // src/react/hooks/useListCollections.tsx
-import { queryOptions as queryOptions24, useQuery as useQuery24 } from "@tanstack/react-query";
-import { z as z26 } from "zod";
-var UseListCollectionsSchema = z26.object({
+import { queryOptions as queryOptions22, useQuery as useQuery24 } from "@tanstack/react-query";
+import { z as z25 } from "zod";
+var UseListCollectionsSchema = z25.object({
   query: QueryArgSchema.optional().default({})
 });
 var fetchListCollections = async ({ marketplaceConfig }, config) => {
@@ -1982,7 +1912,7 @@ var fetchListCollections = async ({ marketplaceConfig }, config) => {
   return results.flat();
 };
 var listCollectionsOptions = (args, config) => {
-  return queryOptions24({
+  return queryOptions22({
     ...args.query,
     queryKey: [...collectionKeys.list],
     queryFn: () => fetchListCollections(args, config)
@@ -2002,21 +1932,21 @@ var useListCollections = (args = {}) => {
 };
 
 // src/react/hooks/useGenerateBuyTransaction.tsx
-import { queryOptions as queryOptions25, skipToken as skipToken3, useQuery as useQuery25 } from "@tanstack/react-query";
+import { queryOptions as queryOptions23, skipToken as skipToken3, useQuery as useQuery25 } from "@tanstack/react-query";
 import { useAccount as useAccount4 } from "wagmi";
-import { z as z27 } from "zod";
-var UseGenerateBuyTransactionArgsSchema = z27.object({
-  chainId: ChainIdSchema.pipe(z27.coerce.string()),
+import { z as z26 } from "zod";
+var UseGenerateBuyTransactionArgsSchema = z26.object({
+  chainId: ChainIdSchema.pipe(z26.coerce.string()),
   collectionAddress: AddressSchema,
-  marketplace: z27.nativeEnum(MarketplaceKind),
-  ordersData: z27.array(
-    z27.object({
-      orderId: z27.string(),
-      quantity: z27.string(),
-      marketplace: z27.string()
+  marketplace: z26.nativeEnum(MarketplaceKind),
+  ordersData: z26.array(
+    z26.object({
+      orderId: z26.string(),
+      quantity: z26.string(),
+      marketplace: z26.string()
     })
   ),
-  walletType: z27.nativeEnum(WalletKind).optional(),
+  walletType: z26.nativeEnum(WalletKind).optional(),
   query: QueryArgSchema
 });
 var fetchGenerateBuyTransaction = async (args, config) => {
@@ -2030,7 +1960,7 @@ var fetchGenerateBuyTransaction = async (args, config) => {
   }).then((data) => data.steps);
 };
 var generateBuyTransactionOptions = (args, config) => {
-  return queryOptions25({
+  return queryOptions23({
     queryKey: ["generateBuyTransaction", args],
     queryFn: () => fetchGenerateBuyTransaction(args, config),
     ...args.query
@@ -2051,7 +1981,8 @@ var useGenerateBuyTransaction = (args) => {
 };
 
 // src/react/hooks/useCancelOrder.tsx
-import { useState, useEffect } from "react";
+import { useWaasFeeOptions } from "@0xsequence/kit";
+import { useEffect, useState } from "react";
 
 // src/react/_internal/wallet/useWallet.ts
 import { skipToken as skipToken4, useQuery as useQuery26 } from "@tanstack/react-query";
@@ -2125,6 +2056,7 @@ var TransactionLogger = class {
 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,
@@ -2136,7 +2068,7 @@ var wallet = ({
   const walletInstance = {
     transport: custom(wallet2.transport),
     isWaaS: connector.id.endsWith("waas"),
-    walletKind: connector.id === "sequence" ? "sequence" /* sequence */ : "unknown" /* unknown */,
+    walletKind: isSequenceWallet(connector) ? "sequence" /* sequence */ : "unknown" /* unknown */,
     getChainId: wallet2.getChainId,
     address: async () => {
       let address = wallet2.account?.address;
@@ -2640,7 +2572,6 @@ var useCancelTransactionSteps = ({
 };
 
 // src/react/hooks/useCancelOrder.tsx
-import { useWaasFeeOptions } from "@0xsequence/kit";
 var useCancelOrder = ({
   collectionAddress,
   chainId,
@@ -2714,7 +2645,7 @@ var useCancelOrder = ({
 };
 
 // src/react/hooks/useCollectionDetails.tsx
-import { queryOptions as queryOptions26, useQuery as useQuery27 } from "@tanstack/react-query";
+import { queryOptions as queryOptions24, useQuery as useQuery27 } from "@tanstack/react-query";
 var fetchCollectionDetails = async (args, marketplaceClient) => {
   const { collection } = await marketplaceClient.getCollectionDetail({
     contractAddress: args.collectionAddress
@@ -2723,7 +2654,7 @@ var fetchCollectionDetails = async (args, marketplaceClient) => {
 };
 var collectionDetailsOptions = (args, config) => {
   const marketplaceClient = getMarketplaceClient(args.chainId, config);
-  return queryOptions26({
+  return queryOptions24({
     queryKey: ["collectionDetails", args],
     queryFn: () => fetchCollectionDetails(args, marketplaceClient)
   });
@@ -2734,7 +2665,7 @@ var useCollectionDetails = (args) => {
 };
 
 // src/react/hooks/useCollectionDetailsPolling.tsx
-import { queryOptions as queryOptions27, useQuery as useQuery28 } from "@tanstack/react-query";
+import { queryOptions as queryOptions25, useQuery as useQuery28 } from "@tanstack/react-query";
 var INITIAL_POLLING_INTERVAL = 2e3;
 var MAX_POLLING_INTERVAL = 3e4;
 var MAX_ATTEMPTS = 30;
@@ -2747,7 +2678,7 @@ var isTerminalState = (status) => {
   ].includes(status);
 };
 var collectionDetailsPollingOptions = (args, config) => {
-  return queryOptions27({
+  return queryOptions25({
     ...collectionDetailsOptions(args, config),
     refetchInterval: (query) => {
       const data = query.state.data;
@@ -2787,9 +2718,7 @@ export {
   useCountOfCollectables,
   collectibleOptions,
   useCollectible,
-  collectionOptions,
   useCollection,
-  marketplaceConfigOptions,
   useMarketplaceConfig,
   currenciesOptions,
   useCurrencies,
@@ -2858,4 +2787,4 @@ export {
   collectionDetailsPollingOptions,
   useCollectionDetailsPolling
 };
-//# sourceMappingURL=chunk-YA3DWLDC.js.map
+//# sourceMappingURL=chunk-A5ICXOCZ.js.map