@0xsequence/marketplace-sdk 0.4.8 → 0.5.0

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

@@ -1,9 +1,21 @@
 "use client"
 import {
-  useSwitchChainModal,
-  useWallet
-} from "./chunk-FWN2MCLI.js";
+  InfoIcon_default
+} from "./chunk-QTJF5GDQ.js";
+import {
+  SEQUENCE_MARKET_V1_ADDRESS,
+  SEQUENCE_MARKET_V2_ADDRESS
+} from "./chunk-Y75XGZOB.js";
+import {
+  alertMessageBox,
+  alertMessageBoxVariants,
+  closeButton,
+  dialogOverlay,
+  switchChainCta,
+  switchChainModalContent
+} from "./chunk-FI723DGL.js";
 import {
+  getPresentableChainName,
   getPublicRpcClient
 } from "./chunk-XP3WY5AX.js";
 import {
@@ -17,7 +29,8 @@ import {
   ChainIdSchema,
   CollectableIdSchema,
   PROVIDER_ID,
-  QueryArgSchema
+  QueryArgSchema,
+  getProviderEl
 } from "./chunk-YOKGP2EQ.js";
 import {
   CollectibleStatus,
@@ -48,16 +61,91 @@ import {
   getMarketplaceClient,
   getMetadataClient,
   getQueryClient
-} from "./chunk-6R4G7J6Q.js";
+} from "./chunk-WSCUPAGR.js";
 import {
   BaseError,
+  ChainSwitchError,
   ChainSwitchUserRejectedError,
   MarketplaceConfigFetchError,
   NoWalletConnectedError,
   ProjectNotFoundError,
+  TransactionConfirmationError,
+  TransactionExecutionError,
+  TransactionSignatureError,
+  UserRejectedRequestError,
   WalletInstanceNotFoundError
 } from "./chunk-WM4RGBFQ.js";
 
+// src/react/hooks/useAutoSelectFeeOption.tsx
+import { useAccount, useConfig } from "wagmi";
+import { getBalance } from "wagmi/actions";
+import { useCallback } from "react";
+function useAutoSelectFeeOption({
+  pendingFeeOptionConfirmation
+}) {
+  const { address: userAddress } = useAccount();
+  const config = useConfig();
+  const findAffordableOption = useCallback(async () => {
+    if (!userAddress) {
+      return {
+        selectedOption: null,
+        error: "User not connected",
+        isLoading: false
+      };
+    }
+    if (!pendingFeeOptionConfirmation.options) {
+      return {
+        selectedOption: null,
+        error: "No options provided",
+        isLoading: false
+      };
+    }
+    try {
+      for (const option of pendingFeeOptionConfirmation.options) {
+        if (!option.token.contractAddress) continue;
+        try {
+          const balance = await getBalance(config, {
+            address: userAddress,
+            token: option.token.contractAddress,
+            chainId: pendingFeeOptionConfirmation.chainId
+          });
+          const optionValue = BigInt(option.value);
+          if (balance.value >= optionValue) {
+            return {
+              selectedOption: option,
+              error: null,
+              isLoading: false
+            };
+          }
+        } catch (error) {
+          console.error(
+            "Error fetching balance for currency:",
+            option.token.contractAddress,
+            error
+          );
+        }
+      }
+      return {
+        selectedOption: null,
+        error: "Insufficient balance for any fee option",
+        isLoading: false
+      };
+    } catch (error) {
+      return {
+        selectedOption: null,
+        error: "Failed to check balances",
+        isLoading: false
+      };
+    }
+  }, [
+    pendingFeeOptionConfirmation.options,
+    pendingFeeOptionConfirmation.chainId,
+    userAddress,
+    config
+  ]);
+  return findAffordableOption();
+}
+
 // src/react/hooks/useBalanceOfCollectible.tsx
 import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
 import { z } from "zod";
@@ -109,7 +197,7 @@ function MarketplaceProvider({
 }
 
 // src/react/hooks/useConfig.tsx
-function useConfig() {
+function useConfig2() {
   const context = useContext(MarketplaceSdkContext);
   if (!context) {
     throw new MarketplaceSdkProviderNotFoundError();
@@ -155,7 +243,7 @@ var balanceOfCollectibleOptions = (args, config) => {
   });
 };
 var useBalanceOfCollectible = (args) => {
-  const config = useConfig();
+  const config = useConfig2();
   return useQuery(balanceOfCollectibleOptions(args, config));
 };
 
@@ -749,7 +837,7 @@ var countOfCollectablesOptions = (args, config) => {
   });
 };
 var useCountOfCollectables = (args) => {
-  const config = useConfig();
+  const config = useConfig2();
   return useQuery2(countOfCollectablesOptions(args, config));
 };
 
@@ -779,7 +867,7 @@ var collectibleOptions = (args, config) => {
   });
 };
 var useCollectible = (args) => {
-  const config = useConfig();
+  const config = useConfig2();
   return useQuery3(collectibleOptions(args, config));
 };
 
@@ -807,19 +895,76 @@ var collectionOptions = (args, config) => {
   });
 };
 var useCollection = (args) => {
-  const config = useConfig();
+  const config = useConfig2();
   return useQuery4(collectionOptions(args, config));
 };
 
-// src/react/hooks/useCurrencies.tsx
+// src/react/hooks/useCollectionBalanceDetails.tsx
+import { z as z6 } from "zod";
 import { queryOptions as queryOptions5, useQuery as useQuery5 } from "@tanstack/react-query";
+var filterSchema2 = z6.object({
+  accountAddresses: z6.array(AddressSchema),
+  contractWhitelist: z6.array(AddressSchema).optional(),
+  omitNativeBalances: z6.boolean()
+});
+var useCollectionBalanceDetailsArgsSchema = z6.object({
+  chainId: ChainIdSchema.pipe(z6.coerce.number()),
+  filter: filterSchema2,
+  query: QueryArgSchema.optional()
+});
+var fetchCollectionBalanceDetails = async (args, indexerClient) => {
+  const promises = args.filter.accountAddresses.map(
+    (accountAddress) => indexerClient.getTokenBalancesDetails({
+      filter: {
+        accountAddresses: [accountAddress],
+        contractWhitelist: args.filter.contractWhitelist,
+        omitNativeBalances: args.filter.omitNativeBalances
+      }
+    })
+  );
+  const responses = await Promise.all(promises);
+  const mergedResponse = responses.reduce(
+    (acc, curr) => {
+      if (!curr) return acc;
+      return {
+        page: curr.page,
+        nativeBalances: [
+          ...acc.nativeBalances || [],
+          ...curr.nativeBalances || []
+        ],
+        balances: [...acc.balances || [], ...curr.balances || []]
+      };
+    },
+    { page: {}, nativeBalances: [], balances: [] }
+  );
+  if (!mergedResponse) {
+    throw new Error("Failed to fetch collection balance details");
+  }
+  return mergedResponse;
+};
+var collectionBalanceDetailsOptions = (args, config) => {
+  const parsedArgs = useCollectionBalanceDetailsArgsSchema.parse(args);
+  const indexerClient = getIndexerClient(parsedArgs.chainId, config);
+  return queryOptions5({
+    queryKey: [...balanceQueries.collectionBalanceDetails, args, config],
+    queryFn: () => fetchCollectionBalanceDetails(parsedArgs, indexerClient),
+    ...args.query
+  });
+};
+var useCollectionBalanceDetails = (args) => {
+  const config = useConfig2();
+  return useQuery5(collectionBalanceDetailsOptions(args, config));
+};
+
+// src/react/hooks/useCurrencies.tsx
+import { queryOptions as queryOptions6, useQuery as useQuery6 } from "@tanstack/react-query";
 import { zeroAddress } from "viem";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var ChainIdCoerce = ChainIdSchema.transform((val) => val.toString());
-var UseCurrenciesArgsSchema = z6.object({
+var UseCurrenciesArgsSchema = z7.object({
   chainId: ChainIdCoerce,
-  includeNativeCurrency: z6.boolean().optional().default(true),
-  currencyOptions: z6.array(AddressSchema).optional(),
+  includeNativeCurrency: z7.boolean().optional().default(true),
+  currencyOptions: z7.array(AddressSchema).optional(),
   query: QueryArgSchema
 });
 var fetchCurrencies = async (chainId, config) => {
@@ -850,7 +995,7 @@ var selectCurrencies = (data, args) => {
   return filteredData;
 };
 var currenciesOptions = (args, config) => {
-  return queryOptions5({
+  return queryOptions6({
     ...args.query,
     queryKey: [...currencyKeys.lists, args.chainId],
     queryFn: () => fetchCurrencies(args.chainId, config),
@@ -859,15 +1004,15 @@ var currenciesOptions = (args, config) => {
   });
 };
 var useCurrencies = (args) => {
-  const config = useConfig();
-  return useQuery5(currenciesOptions(args, config));
+  const config = useConfig2();
+  return useQuery6(currenciesOptions(args, config));
 };
 
 // src/react/hooks/useMarketplaceConfig.tsx
-import { useQuery as useQuery6 } from "@tanstack/react-query";
+import { useQuery as useQuery7 } from "@tanstack/react-query";
 
 // src/react/hooks/options/marketplaceConfigOptions.ts
-import { queryOptions as queryOptions6 } from "@tanstack/react-query";
+import { queryOptions as queryOptions7 } from "@tanstack/react-query";
 var fetchBuilderConfig = async (projectId, env) => {
   const url = `${builderMarketplaceApi(projectId, env)}`;
   const response = await fetch(`${url}/config.json`);
@@ -907,7 +1052,7 @@ var marketplaceConfigOptions = (config) => {
     env = config._internal.builderEnv ?? env;
   }
   const projectId = config.projectId;
-  return queryOptions6({
+  return queryOptions7({
     queryKey: [...configKeys.marketplace, env, projectId],
     queryFn: () => fetchMarketplaceConfig(env, projectId)
   });
@@ -915,8 +1060,8 @@ var marketplaceConfigOptions = (config) => {
 
 // src/react/hooks/useMarketplaceConfig.tsx
 var useMarketplaceConfig = () => {
-  const config = useConfig();
-  return useQuery6(marketplaceConfigOptions(config));
+  const config = useConfig2();
+  return useQuery7(marketplaceConfigOptions(config));
 };
 
 // src/react/hooks/useCurrencyOptions.tsx
@@ -932,10 +1077,10 @@ var useCurrencyOptions = ({
 };
 
 // src/react/hooks/useCurrency.tsx
-import { queryOptions as queryOptions7, useQuery as useQuery7 } from "@tanstack/react-query";
-import { z as z7 } from "zod";
+import { queryOptions as queryOptions8, useQuery as useQuery8 } from "@tanstack/react-query";
+import { z as z8 } from "zod";
 var ChainIdCoerce2 = ChainIdSchema.transform((val) => val.toString());
-var UseCurrencyArgsSchema = z7.object({
+var UseCurrencyArgsSchema = z8.object({
   chainId: ChainIdCoerce2,
   currencyAddress: AddressSchema,
   query: QueryArgSchema
@@ -960,22 +1105,22 @@ var fetchCurrency = async (chainId, currencyAddress, config) => {
   return currency;
 };
 var currencyOptions = (args, config) => {
-  return queryOptions7({
+  return queryOptions8({
     ...args.query,
     queryKey: [...currencyKeys.details, args.chainId, args.currencyAddress],
     queryFn: () => fetchCurrency(args.chainId, args.currencyAddress, config)
   });
 };
 var useCurrency = (args) => {
-  const config = useConfig();
-  return useQuery7(currencyOptions(args, config));
+  const config = useConfig2();
+  return useQuery8(currencyOptions(args, config));
 };
 
 // src/react/hooks/useFilters.tsx
-import { queryOptions as queryOptions8, useQuery as useQuery8 } from "@tanstack/react-query";
-import { z as z8 } from "zod";
-var UseFiltersSchema = z8.object({
-  chainId: ChainIdSchema.pipe(z8.coerce.string()),
+import { queryOptions as queryOptions9, useQuery as useQuery9 } from "@tanstack/react-query";
+import { z as z9 } from "zod";
+var UseFiltersSchema = z9.object({
+  chainId: ChainIdSchema.pipe(z9.coerce.string()),
   collectionAddress: AddressSchema,
   query: QueryArgSchema
 });
@@ -988,22 +1133,22 @@ var fetchFilters = async (args, config) => {
   }).then((resp) => resp.filters);
 };
 var filtersOptions = (args, config) => {
-  return queryOptions8({
+  return queryOptions9({
     ...args.query,
     queryKey: [...collectableKeys.filter, args, config],
     queryFn: () => fetchFilters(args, config)
   });
 };
 var useFilters = (args) => {
-  const config = useConfig();
-  return useQuery8(filtersOptions(args, config));
+  const config = useConfig2();
+  return useQuery9(filtersOptions(args, config));
 };
 
 // src/react/hooks/useFloorOrder.tsx
-import { queryOptions as queryOptions9, useQuery as useQuery9 } from "@tanstack/react-query";
-import { z as z9 } from "zod";
-var UseFloorOrderSchema = z9.object({
-  chainId: ChainIdSchema.pipe(z9.coerce.string()),
+import { queryOptions as queryOptions10, useQuery as useQuery10 } from "@tanstack/react-query";
+import { z as z10 } from "zod";
+var UseFloorOrderSchema = z10.object({
+  chainId: ChainIdSchema.pipe(z10.coerce.string()),
   collectionAddress: AddressSchema,
   query: QueryArgSchema
 });
@@ -1012,24 +1157,24 @@ var fetchFloorOrder = async (args, config) => {
   return marketplaceClient.getFloorOrder({ contractAddress: args.collectionAddress }).then((data) => data.collectible);
 };
 var floorOrderOptions = (args, config) => {
-  return queryOptions9({
+  return queryOptions10({
     queryKey: [...collectableKeys.floorOrders, args, config],
     queryFn: () => fetchFloorOrder(args, config)
   });
 };
 var useFloorOrder = (args) => {
-  const config = useConfig();
-  return useQuery9(floorOrderOptions(args, config));
+  const config = useConfig2();
+  return useQuery10(floorOrderOptions(args, config));
 };
 
 // src/react/hooks/useHighestOffer.tsx
-import { queryOptions as queryOptions10, useQuery as useQuery10 } from "@tanstack/react-query";
-import { z as z10 } from "zod";
+import { queryOptions as queryOptions11, useQuery as useQuery11 } from "@tanstack/react-query";
+import { z as z11 } from "zod";
 var UseHighestOfferArgsSchema = getCollectibleHighestOfferArgsSchema.omit({
   contractAddress: true
 }).extend({
   collectionAddress: AddressSchema,
-  chainId: ChainIdSchema.pipe(z10.coerce.string()),
+  chainId: ChainIdSchema.pipe(z11.coerce.string()),
   query: QueryArgSchema
 });
 var fetchHighestOffer = async (args, config) => {
@@ -1041,48 +1186,48 @@ var fetchHighestOffer = async (args, config) => {
   });
 };
 var highestOfferOptions = (args, config) => {
-  return queryOptions10({
+  return queryOptions11({
     ...args.query,
     queryKey: [...collectableKeys.highestOffers, args, config],
     queryFn: () => fetchHighestOffer(args, config)
   });
 };
 var useHighestOffer = (args) => {
-  const config = useConfig();
-  return useQuery10(highestOfferOptions(args, config));
+  const config = useConfig2();
+  return useQuery11(highestOfferOptions(args, config));
 };
 
 // src/react/hooks/useListBalances.tsx
 import { SortOrder as SortOrder2 } from "@0xsequence/indexer";
 import { infiniteQueryOptions, useInfiniteQuery } from "@tanstack/react-query";
-import { z as z11 } from "zod";
-var metadataOptionsSchema = z11.object({
-  verifiedOnly: z11.boolean().optional(),
-  unverifiedOnly: z11.boolean().optional(),
-  includeContracts: z11.array(z11.string()).optional()
-});
-var sortOrderSchema2 = z11.nativeEnum(SortOrder2);
-var sortBySchema2 = z11.object({
-  column: z11.string(),
+import { z as z12 } from "zod";
+var metadataOptionsSchema = z12.object({
+  verifiedOnly: z12.boolean().optional(),
+  unverifiedOnly: z12.boolean().optional(),
+  includeContracts: z12.array(z12.string()).optional()
+});
+var sortOrderSchema2 = z12.nativeEnum(SortOrder2);
+var sortBySchema2 = z12.object({
+  column: z12.string(),
   order: sortOrderSchema2
 });
-var pageSchema2 = z11.object({
-  page: z11.number().optional(),
-  column: z11.string().optional(),
-  before: z11.any().optional(),
-  after: z11.any().optional(),
-  sort: z11.array(sortBySchema2).optional(),
-  pageSize: z11.number().optional(),
-  more: z11.boolean().optional()
-});
-var useListBalancesArgsSchema = z11.object({
-  chainId: ChainIdSchema.pipe(z11.coerce.number()),
+var pageSchema2 = z12.object({
+  page: z12.number().optional(),
+  column: z12.string().optional(),
+  before: z12.any().optional(),
+  after: z12.any().optional(),
+  sort: z12.array(sortBySchema2).optional(),
+  pageSize: z12.number().optional(),
+  more: z12.boolean().optional()
+});
+var useListBalancesArgsSchema = z12.object({
+  chainId: ChainIdSchema.pipe(z12.coerce.number()),
   accountAddress: AddressSchema.optional(),
   contractAddress: AddressSchema.optional(),
-  tokenId: z11.string().optional(),
-  includeMetadata: z11.boolean().optional(),
+  tokenId: z12.string().optional(),
+  includeMetadata: z12.boolean().optional(),
   metadataOptions: metadataOptionsSchema.optional(),
-  includeCollectionTokens: z11.boolean().optional(),
+  includeCollectionTokens: z12.boolean().optional(),
   page: pageSchema2.optional(),
   query: QueryArgSchema
 });
@@ -1105,12 +1250,12 @@ var listBalancesOptions = (args, config) => {
   });
 };
 var useListBalances = (args) => {
-  const config = useConfig();
+  const config = useConfig2();
   return useInfiniteQuery(listBalancesOptions(args, config));
 };
 
 // src/react/hooks/useListCollectibleActivities.tsx
-import { queryOptions as queryOptions11, useQuery as useQuery11 } from "@tanstack/react-query";
+import { queryOptions as queryOptions12, useQuery as useQuery12 } from "@tanstack/react-query";
 var fetchCollectibleActivities = async (args, config) => {
   const marketplaceClient = getMarketplaceClient(args.chainId, config);
   return marketplaceClient.listCollectibleActivities({
@@ -1127,24 +1272,24 @@ var fetchCollectibleActivities = async (args, config) => {
   }));
 };
 var listCollectibleActivitiesOptions = (args, config) => {
-  return queryOptions11({
+  return queryOptions12({
     queryKey: [...collectableKeys.collectibleActivities, args, config],
     queryFn: () => fetchCollectibleActivities(args, config)
   });
 };
 var useListCollectibleActivities = (args) => {
-  const config = useConfig();
-  return useQuery11(listCollectibleActivitiesOptions(args, config));
+  const config = useConfig2();
+  return useQuery12(listCollectibleActivitiesOptions(args, config));
 };
 
 // src/react/hooks/useListCollectibles.tsx
 import { infiniteQueryOptions as infiniteQueryOptions2, useInfiniteQuery as useInfiniteQuery2 } from "@tanstack/react-query";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var UseListCollectiblesArgsSchema = listCollectiblesArgsSchema.omit({
   contractAddress: true
 }).extend({
   collectionAddress: AddressSchema,
-  chainId: ChainIdSchema.pipe(z12.coerce.string()),
+  chainId: ChainIdSchema.pipe(z13.coerce.string()),
   query: QueryArgSchema
 });
 var fetchCollectibles = async (args, marketplaceClient, page) => {
@@ -1166,12 +1311,12 @@ var listCollectiblesOptions = (args, config) => {
   });
 };
 var useListCollectibles = (args) => {
-  const config = useConfig();
+  const config = useConfig2();
   return useInfiniteQuery2(listCollectiblesOptions(args, config));
 };
 
 // src/react/hooks/useListCollectionActivities.tsx
-import { queryOptions as queryOptions12, useQuery as useQuery12 } from "@tanstack/react-query";
+import { queryOptions as queryOptions13, useQuery as useQuery13 } from "@tanstack/react-query";
 var fetchListCollectionActivities = async (args, config) => {
   const marketplaceClient = getMarketplaceClient(args.chainId, config);
   return marketplaceClient.listCollectionActivities({
@@ -1187,23 +1332,23 @@ var fetchListCollectionActivities = async (args, config) => {
   }));
 };
 var listCollectionActivitiesOptions = (args, config) => {
-  return queryOptions12({
+  return queryOptions13({
     queryKey: [...collectionKeys.collectionActivities, args, config],
     queryFn: () => fetchListCollectionActivities(args, config)
   });
 };
 var useListCollectionActivities = (args) => {
-  const config = useConfig();
-  return useQuery12(listCollectionActivitiesOptions(args, config));
+  const config = useConfig2();
+  return useQuery13(listCollectionActivitiesOptions(args, config));
 };
 
 // src/react/hooks/useListOffersForCollectible.tsx
-import { queryOptions as queryOptions13, useQuery as useQuery13 } from "@tanstack/react-query";
-import { z as z13 } from "zod";
+import { queryOptions as queryOptions14, useQuery as useQuery14 } from "@tanstack/react-query";
+import { z as z14 } from "zod";
 var UseListOffersForCollectibleArgsSchema = listOffersForCollectibleArgsSchema.extend({
-  chainId: ChainIdSchema.pipe(z13.coerce.string()),
-  collectionAddress: z13.string(),
-  collectibleId: z13.string()
+  chainId: ChainIdSchema.pipe(z14.coerce.string()),
+  collectionAddress: z14.string(),
+  collectibleId: z14.string()
 }).omit({ contractAddress: true, tokenId: true });
 var fetchListOffersForCollectible = async (config, args) => {
   const arg = {
@@ -1216,26 +1361,26 @@ var fetchListOffersForCollectible = async (config, args) => {
   return marketplaceClient.listCollectibleOffers(arg);
 };
 var listOffersForCollectibleOptions = (args, config) => {
-  return queryOptions13({
+  return queryOptions14({
     queryKey: [...collectableKeys.offers, args, config],
     queryFn: () => fetchListOffersForCollectible(config, args)
   });
 };
 var useListOffersForCollectible = (args) => {
-  const config = useConfig();
-  return useQuery13(listOffersForCollectibleOptions(args, config));
+  const config = useConfig2();
+  return useQuery14(listOffersForCollectibleOptions(args, config));
 };
 
 // src/react/hooks/useCountOffersForCollectible.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 UseCountOffersForCollectibleArgsSchema = countOffersForCollectibleArgsSchema.omit({
   contractAddress: true,
   tokenId: true
 }).extend({
   collectionAddress: AddressSchema,
-  collectibleId: z14.string(),
-  chainId: ChainIdSchema.pipe(z14.coerce.string()),
+  collectibleId: z15.string(),
+  chainId: ChainIdSchema.pipe(z15.coerce.string()),
   query: QueryArgSchema
 });
 var fetchCountOffersForCollectible = async (args, config) => {
@@ -1248,24 +1393,24 @@ var fetchCountOffersForCollectible = async (args, config) => {
   });
 };
 var countOffersForCollectibleOptions = (args, config) => {
-  return queryOptions14({
+  return queryOptions15({
     ...args.query,
     queryKey: [...collectableKeys.offersCount, args, config],
     queryFn: () => fetchCountOffersForCollectible(args, config)
   });
 };
 var useCountOffersForCollectible = (args) => {
-  const config = useConfig();
-  return useQuery14(countOffersForCollectibleOptions(args, config));
+  const config = useConfig2();
+  return useQuery15(countOffersForCollectibleOptions(args, config));
 };
 
 // src/react/hooks/useListListingsForCollectible.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 UseListListingsForCollectibleArgsSchema = listListingsForCollectibleArgsSchema.extend({
-  chainId: ChainIdSchema.pipe(z15.coerce.string()),
-  collectionAddress: z15.string(),
-  collectibleId: z15.string()
+  chainId: ChainIdSchema.pipe(z16.coerce.string()),
+  collectionAddress: z16.string(),
+  collectibleId: z16.string()
 }).omit({ contractAddress: true, tokenId: true });
 var fetchListListingsForCollectible = async (config, args) => {
   const arg = {
@@ -1278,26 +1423,26 @@ var fetchListListingsForCollectible = async (config, args) => {
   return marketplaceClient.listCollectibleListings(arg);
 };
 var listListingsForCollectibleOptions = (args, config) => {
-  return queryOptions15({
+  return queryOptions16({
     queryKey: [...collectableKeys.listings, args, config],
     queryFn: () => fetchListListingsForCollectible(config, args)
   });
 };
 var useListListingsForCollectible = (args) => {
-  const config = useConfig();
-  return useQuery15(listListingsForCollectibleOptions(args, config));
+  const config = useConfig2();
+  return useQuery16(listListingsForCollectibleOptions(args, config));
 };
 
 // src/react/hooks/useCountListingsForCollectible.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 UseCountListingsForCollectibleArgsSchema = countListingsForCollectibleArgsSchema.omit({
   contractAddress: true,
   tokenId: true
 }).extend({
   collectionAddress: AddressSchema,
-  collectibleId: z16.string(),
-  chainId: ChainIdSchema.pipe(z16.coerce.string()),
+  collectibleId: z17.string(),
+  chainId: ChainIdSchema.pipe(z17.coerce.string()),
   query: QueryArgSchema
 });
 var fetchCountListingsForCollectible = async (args, config) => {
@@ -1310,25 +1455,25 @@ var fetchCountListingsForCollectible = async (args, config) => {
   });
 };
 var countListingsForCollectibleOptions = (args, config) => {
-  return queryOptions16({
+  return queryOptions17({
     ...args.query,
     queryKey: [...collectableKeys.listingsCount, args, config],
     queryFn: () => fetchCountListingsForCollectible(args, config)
   });
 };
 var useCountListingsForCollectible = (args) => {
-  const config = useConfig();
-  return useQuery16(countListingsForCollectibleOptions(args, config));
+  const config = useConfig2();
+  return useQuery17(countListingsForCollectibleOptions(args, config));
 };
 
 // src/react/hooks/useLowestListing.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 UseLowestListingSchema = getCollectibleLowestListingArgsSchema.omit({
   contractAddress: true
 }).extend({
   collectionAddress: AddressSchema,
-  chainId: ChainIdSchema.pipe(z17.coerce.string()),
+  chainId: ChainIdSchema.pipe(z18.coerce.string()),
   query: QueryArgSchema
 });
 var fetchLowestListing = async (args, config) => {
@@ -1340,25 +1485,25 @@ var fetchLowestListing = async (args, config) => {
   });
 };
 var lowestListingOptions = (args, config) => {
-  return queryOptions17({
+  return queryOptions18({
     ...args.query,
     queryKey: [...collectableKeys.lowestListings, args, config],
     queryFn: () => fetchLowestListing(args, config)
   });
 };
 var useLowestListing = (args) => {
-  const config = useConfig();
-  return useQuery17(lowestListingOptions(args, config));
+  const config = useConfig2();
+  return useQuery18(lowestListingOptions(args, config));
 };
 
 // src/react/hooks/useRoyaltyPercentage.tsx
-import { queryOptions as queryOptions18, useQuery as useQuery18 } from "@tanstack/react-query";
+import { queryOptions as queryOptions19, useQuery as useQuery19 } from "@tanstack/react-query";
 import { getContract } from "viem";
-import { z as z18 } from "zod";
-var UseRoyaletyPercentageSchema = z18.object({
-  chainId: ChainIdSchema.pipe(z18.coerce.string()),
+import { z as z19 } from "zod";
+var UseRoyaletyPercentageSchema = z19.object({
+  chainId: ChainIdSchema.pipe(z19.coerce.string()),
   collectionAddress: AddressSchema,
-  collectibleId: z18.string(),
+  collectibleId: z19.string(),
   query: QueryArgSchema
 });
 var fetchRoyaletyPercentage = async (args) => {
@@ -1379,13 +1524,13 @@ var fetchRoyaletyPercentage = async (args) => {
     return 0n;
   }
 };
-var royaletyPercentageOptions = (args) => queryOptions18({
+var royaletyPercentageOptions = (args) => queryOptions19({
   ...args.query,
   queryKey: [...collectableKeys.royaltyPercentage, args],
   queryFn: () => fetchRoyaletyPercentage(args)
 });
 var useRoyaltyPercentage = (args) => {
-  return useQuery18(royaletyPercentageOptions(args));
+  return useQuery19(royaletyPercentageOptions(args));
 };
 
 // src/react/hooks/useGenerateListingTransaction.tsx
@@ -1407,7 +1552,7 @@ var generateListingTransaction = async (params, config, chainId) => {
   return (await marketplaceClient.generateListingTransaction(args)).steps;
 };
 var useGenerateListingTransaction = (params) => {
-  const config = useConfig();
+  const config = useConfig2();
   const { mutate, mutateAsync, ...result } = useMutation({
     onSuccess: params.onSuccess,
     mutationFn: (args) => generateListingTransaction(args, config, params.chainId)
@@ -1430,7 +1575,7 @@ var generateOfferTransaction = async (params, config, chainId) => {
   return (await marketplaceClient.generateOfferTransaction(args)).steps;
 };
 var useGenerateOfferTransaction = (params) => {
-  const config = useConfig();
+  const config = useConfig2();
   const { mutate, mutateAsync, ...result } = useMutation2({
     onSuccess: params.onSuccess,
     mutationFn: (args) => generateOfferTransaction(args, config, params.chainId)
@@ -1444,18 +1589,18 @@ var useGenerateOfferTransaction = (params) => {
 
 // src/react/hooks/useGenerateSellTransaction.tsx
 import { useMutation as useMutation3 } from "@tanstack/react-query";
-import { z as z19 } from "zod";
-var UserGeneratSellTransactionArgsSchema = z19.object({
-  chainId: ChainIdSchema.pipe(z19.coerce.string()),
-  onSuccess: z19.function().args(stepSchema.array().optional()).optional()
+import { z as z20 } from "zod";
+var UserGeneratSellTransactionArgsSchema = z20.object({
+  chainId: ChainIdSchema.pipe(z20.coerce.string()),
+  onSuccess: z20.function().args(stepSchema.array().optional()).optional()
 });
 var generateSellTransaction = async (args, config, chainId) => {
-  const parsedChainId = ChainIdSchema.pipe(z19.coerce.string()).parse(chainId);
+  const parsedChainId = ChainIdSchema.pipe(z20.coerce.string()).parse(chainId);
   const marketplaceClient = getMarketplaceClient(parsedChainId, config);
   return marketplaceClient.generateSellTransaction(args).then((data) => data.steps);
 };
 var useGenerateSellTransaction = (params) => {
-  const config = useConfig();
+  const config = useConfig2();
   const { mutate, mutateAsync, ...result } = useMutation3({
     onSuccess: params.onSuccess,
     mutationFn: (args) => generateSellTransaction(args, config, params.chainId)
@@ -1469,18 +1614,18 @@ var useGenerateSellTransaction = (params) => {
 
 // src/react/hooks/useGenerateCancelTransaction.tsx
 import { useMutation as useMutation4 } from "@tanstack/react-query";
-import { z as z20 } from "zod";
-var UserGenerateCancelTransactionArgsSchema = z20.object({
-  chainId: ChainIdSchema.pipe(z20.coerce.string()),
-  onSuccess: z20.function().args(stepSchema.array().optional()).optional()
+import { z as z21 } from "zod";
+var UserGenerateCancelTransactionArgsSchema = z21.object({
+  chainId: ChainIdSchema.pipe(z21.coerce.string()),
+  onSuccess: z21.function().args(stepSchema.array().optional()).optional()
 });
 var generateCancelTransaction = 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.generateCancelTransaction(args).then((data) => data.steps);
 };
 var useGenerateCancelTransaction = (params) => {
-  const config = useConfig();
+  const config = useConfig2();
   const { mutate, mutateAsync, ...result } = useMutation4({
     onSuccess: params.onSuccess,
     mutationFn: (args) => generateCancelTransaction(args, config, params.chainId)
@@ -1494,7 +1639,7 @@ var useGenerateCancelTransaction = (params) => {
 
 // src/react/hooks/useTransferTokens.tsx
 import { erc721Abi } from "viem";
-import { useAccount, useWriteContract } from "wagmi";
+import { useAccount as useAccount2, useWriteContract } from "wagmi";
 var prepareTransferConfig = (params, accountAddress) => {
   if (params.contractType === "ERC721") {
     return {
@@ -1523,7 +1668,7 @@ var prepareTransferConfig = (params, accountAddress) => {
   };
 };
 var useTransferTokens = () => {
-  const { address: accountAddress } = useAccount();
+  const { address: accountAddress } = useAccount2();
   const {
     writeContractAsync,
     data: hash,
@@ -1548,16 +1693,16 @@ var useTransferTokens = () => {
 };
 
 // src/react/hooks/useCheckoutOptions.tsx
-import { queryOptions as queryOptions19, useQuery as useQuery19 } from "@tanstack/react-query";
-import { useAccount as useAccount2 } from "wagmi";
-import { z as z21 } from "zod";
-var UseCheckoutOptionsSchema = z21.object({
-  chainId: ChainIdSchema.pipe(z21.coerce.string()),
-  orders: z21.array(
-    z21.object({
+import { queryOptions as queryOptions20, useQuery as useQuery20 } 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({
       collectionAddress: AddressSchema,
-      orderId: z21.string(),
-      marketplace: z21.nativeEnum(MarketplaceKind)
+      orderId: z22.string(),
+      marketplace: z22.nativeEnum(MarketplaceKind)
     })
   ),
   query: QueryArgSchema
@@ -1576,24 +1721,24 @@ var fetchCheckoutOptions = async (args, config) => {
   });
 };
 var checkoutOptionsOptions = (args, config) => {
-  return queryOptions19({
+  return queryOptions20({
     queryKey: ["checkoutOptions", args],
     queryFn: () => fetchCheckoutOptions(args, config)
   });
 };
 var useCheckoutOptions = (args) => {
-  const { address } = useAccount2();
-  const config = useConfig();
-  return useQuery19(
+  const { address } = useAccount3();
+  const config = useConfig2();
+  return useQuery20(
     // biome-ignore lint/style/noNonNullAssertion: <explanation>
     checkoutOptionsOptions({ walletAddress: address, ...args }, config)
   );
 };
 
 // src/react/hooks/useListCollections.tsx
-import { queryOptions as queryOptions20, useQuery as useQuery20 } from "@tanstack/react-query";
-import { z as z22 } from "zod";
-var UseListCollectionsSchema = z22.object({
+import { queryOptions as queryOptions21, useQuery as useQuery21 } from "@tanstack/react-query";
+import { z as z23 } from "zod";
+var UseListCollectionsSchema = z23.object({
   query: QueryArgSchema.optional().default({})
 });
 var fetchListCollections = async ({ marketplaceConfig }, config) => {
@@ -1619,16 +1764,16 @@ var fetchListCollections = async ({ marketplaceConfig }, config) => {
   return results.flat();
 };
 var listCollectionsOptions = (args, config) => {
-  return queryOptions20({
+  return queryOptions21({
     ...args.query,
     queryKey: [...collectionKeys.list],
     queryFn: () => fetchListCollections(args, config)
   });
 };
 var useListCollections = (args = {}) => {
-  const config = useConfig();
+  const config = useConfig2();
   const { data: marketplaceConfig, isLoading: isLoadingConfig } = useMarketplaceConfig();
-  return useQuery20({
+  return useQuery21({
     ...listCollectionsOptions(
       // biome-ignore lint/style/noNonNullAssertion: <explanation>
       { marketplaceConfig, query: args.query },
@@ -1639,21 +1784,21 @@ var useListCollections = (args = {}) => {
 };
 
 // src/react/hooks/useGenerateBuyTransaction.tsx
-import { queryOptions as queryOptions21, useQuery as useQuery21 } from "@tanstack/react-query";
-import { useAccount as useAccount3 } from "wagmi";
-import { z as z23 } from "zod";
-var UseGenerateBuyTransactionArgsSchema = z23.object({
-  chainId: ChainIdSchema.pipe(z23.coerce.string()),
+import { queryOptions as queryOptions22, useQuery as useQuery22 } 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()),
   collectionAddress: AddressSchema,
-  marketplace: z23.nativeEnum(MarketplaceKind),
-  ordersData: z23.array(
-    z23.object({
-      orderId: z23.string(),
-      quantity: z23.string(),
-      marketplace: z23.string()
+  marketplace: z24.nativeEnum(MarketplaceKind),
+  ordersData: z24.array(
+    z24.object({
+      orderId: z24.string(),
+      quantity: z24.string(),
+      marketplace: z24.string()
     })
   ),
-  walletType: z23.nativeEnum(WalletKind).optional(),
+  walletType: z24.nativeEnum(WalletKind).optional(),
   query: QueryArgSchema
 });
 var fetchGenerateBuyTransaction = async (args, config) => {
@@ -1667,23 +1812,443 @@ var fetchGenerateBuyTransaction = async (args, config) => {
   }).then((data) => data.steps);
 };
 var generateBuyTransactionOptions = (args, config) => {
-  return queryOptions21({
+  return queryOptions22({
     queryKey: ["generateBuyTransaction", args],
     queryFn: () => fetchGenerateBuyTransaction(args, config),
     ...args.query
   });
 };
 var useGenerateBuyTransaction = (args) => {
-  const { address } = useAccount3();
-  const config = useConfig();
-  return useQuery21(
+  const { address } = useAccount4();
+  const config = useConfig2();
+  return useQuery22(
     // biome-ignore lint/style/noNonNullAssertion: <explanation>
     generateBuyTransactionOptions({ buyer: address, ...args }, config)
   );
 };
 
 // src/react/hooks/useCancelOrder.tsx
-import { useState } from "react";
+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";
+
+// src/react/_internal/wallet/wallet.ts
+import {
+  TransactionReceiptNotFoundError,
+  WaitForTransactionReceiptTimeoutError,
+  custom,
+  erc20Abi,
+  erc721Abi as erc721Abi2,
+  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 wallet = ({
+  wallet: wallet2,
+  chains,
+  connector,
+  sdkConfig
+}) => {
+  const logger = createLogger("Wallet");
+  const walletInstance = {
+    transport: custom(wallet2.transport),
+    isWaaS: connector.id.endsWith("waas"),
+    walletKind: connector.id === "sequence" ? "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,
+            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 (error) {
+        logger.error("Signature failed", error);
+        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 (error) {
+        logger.error("Transaction failed", error);
+        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 publicClient = getPublicRpcClient(await wallet2.getChainId());
+      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: erc721Abi2,
+            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");
+      }
+    }
+  };
+  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 } = useWalletClient();
+  const { connector, isConnected, isConnecting } = useAccount5();
+  const sdkConfig = useConfig2();
+  const chainId = useChainId();
+  const { data, isLoading, isError } = useQuery23({
+    queryKey: ["wallet", chainId, connector?.uid],
+    queryFn: () => {
+      if (!walletClient || !connector || !isConnected) {
+        return null;
+      }
+      return wallet({
+        wallet: walletClient,
+        chains,
+        connector,
+        sdkConfig
+      });
+    },
+    staleTime: Number.POSITIVE_INFINITY,
+    enabled: Boolean(walletClient && connector && isConnected)
+  });
+  return {
+    wallet: data,
+    isLoading: isLoading || isConnecting || wagmiWalletIsLoading,
+    isError
+  };
+};
+
+// src/react/ui/modals/_internal/components/switchChainModal/index.tsx
+import {
+  Button,
+  CloseIcon,
+  IconButton,
+  Spinner,
+  Text as Text2
+} from "@0xsequence/design-system";
+import { observer } from "@legendapp/state/react";
+import { Close, Content, Overlay, Portal, Root } from "@radix-ui/react-dialog";
+import { useSwitchChain as useSwitchChain2 } from "wagmi";
+
+// src/react/ui/modals/_internal/components/alertMessage/index.tsx
+import { Box, Text, WarningIcon } from "@0xsequence/design-system";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function AlertMessage({ message, type }) {
+  return /* @__PURE__ */ jsxs(Box, { className: `${alertMessageBox} ${alertMessageBoxVariants[type]}`, children: [
+    /* @__PURE__ */ jsx2(
+      Text,
+      {
+        color: "white",
+        fontSize: "normal",
+        fontWeight: "medium",
+        fontFamily: "body",
+        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/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 && typeof switchChainModal$.state.onSuccess === "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);
+    }
+  }
+  return /* @__PURE__ */ jsx3(Root, { open: switchChainModal$.isOpen.get(), children: /* @__PURE__ */ jsxs2(Portal, { container: getProviderEl(), children: [
+    /* @__PURE__ */ jsx3(Overlay, { className: dialogOverlay }),
+    /* @__PURE__ */ jsxs2(Content, { className: switchChainModalContent, children: [
+      /* @__PURE__ */ jsx3(Text2, { fontSize: "large", 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,
+        {
+          name: "switch-chain",
+          id: "switch-chain-button",
+          size: "sm",
+          label: isSwitching$.get() ? /* @__PURE__ */ jsx3(Spinner, { "data-testid": "switch-chain-spinner" }) : "Switch Network",
+          variant: "primary",
+          pending: isSwitching$.get(),
+          shape: "square",
+          className: isSwitching$.get() ? switchChainCta.pending : switchChainCta.default,
+          justifySelf: "flex-end",
+          onClick: handleSwitchChain
+        }
+      ),
+      /* @__PURE__ */ jsx3(
+        Close,
+        {
+          "data-testid": "switch-chain-modal-close-button",
+          onClick: () => {
+            if (switchChainModal$.state.onClose && typeof switchChainModal$.state.onClose === "function") {
+              switchChainModal$.state.onClose();
+            }
+            switchChainModal$.delete();
+          },
+          className: closeButton,
+          asChild: true,
+          children: /* @__PURE__ */ jsx3(IconButton, { size: "xs", "aria-label": "Close modal", icon: CloseIcon })
+        }
+      )
+    ] })
+  ] }) });
+});
+var switchChainModal_default = SwitchChainModal;
 
 // src/react/hooks/useCancelTransactionSteps.tsx
 var useCancelTransactionSteps = ({
@@ -1695,22 +2260,22 @@ var useCancelTransactionSteps = ({
   onError
 }) => {
   const { show: showSwitchChainModal } = useSwitchChainModal();
-  const { wallet, isLoading, isError } = useWallet();
-  const walletIsInitialized = wallet && !isLoading && !isError;
-  const sdkConfig = useConfig();
+  const { wallet: wallet2, isLoading, isError } = useWallet();
+  const walletIsInitialized = wallet2 && !isLoading && !isError;
+  const sdkConfig = useConfig2();
   const marketplaceClient = getMarketplaceClient(chainId, sdkConfig);
   const { generateCancelTransactionAsync } = useGenerateCancelTransaction({
     chainId
   });
   const getWalletChainId = async () => {
-    return await wallet.getChainId();
+    return await wallet2.getChainId();
   };
   const switchChain = async () => {
-    await wallet.switchChain(Number(chainId));
+    await wallet2.switchChain(Number(chainId));
   };
   const checkAndSwitchChain = async () => {
     const walletChainId = await getWalletChainId();
-    const isWaaS = wallet?.isWaaS;
+    const isWaaS = wallet2?.isWaaS;
     const chainIdMismatch = walletChainId !== Number(chainId);
     return new Promise((resolve, reject) => {
       if (chainIdMismatch) {
@@ -1734,7 +2299,7 @@ var useCancelTransactionSteps = ({
     marketplace
   }) => {
     try {
-      const address = await wallet.address();
+      const address = await wallet2.address();
       const steps = await generateCancelTransactionAsync({
         collectionAddress,
         maker: address,
@@ -1780,10 +2345,10 @@ var useCancelTransactionSteps = ({
         throw new Error("No transaction or signature step found");
       }
       let hash, reservoirOrderId;
-      if (transactionStep && wallet) {
+      if (transactionStep && wallet2) {
         hash = await executeTransaction({ transactionStep });
         if (hash) {
-          await wallet.handleConfirmTransactionStep(hash, Number(chainId));
+          await wallet2.handleConfirmTransactionStep(hash, Number(chainId));
           if (onSuccess && typeof onSuccess === "function") {
             onSuccess({ hash });
           }
@@ -1818,7 +2383,7 @@ var useCancelTransactionSteps = ({
   const executeTransaction = async ({
     transactionStep
   }) => {
-    const hash = await wallet.handleSendTransactionStep(
+    const hash = await wallet2.handleSendTransactionStep(
       Number(chainId),
       transactionStep
     );
@@ -1827,7 +2392,7 @@ var useCancelTransactionSteps = ({
   const executeSignature = async ({
     signatureStep
   }) => {
-    const signature = await wallet.handleSignMessageStep(
+    const signature = await wallet2.handleSignMessageStep(
       signatureStep
     );
     const result = await marketplaceClient.execute({
@@ -1843,6 +2408,7 @@ var useCancelTransactionSteps = ({
 };
 
 // src/react/hooks/useCancelOrder.tsx
+import { useWaasFeeOptions } from "@0xsequence/kit";
 var useCancelOrder = ({
   collectionAddress,
   chainId,
@@ -1857,6 +2423,49 @@ var useCancelOrder = ({
   const [cancellingOrderId, setCancellingOrderId] = useState(
     null
   );
+  const [pendingFeeOptionConfirmation, confirmPendingFeeOption] = useWaasFeeOptions();
+  const autoSelectFeeOptionResult = 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: Number(chainId)
+    } : {
+      id: "",
+      options: void 0,
+      chainId: Number(chainId)
+    }
+  });
+  useEffect(() => {
+    const handleFeeOptionSelection = async () => {
+      if (!pendingFeeOptionConfirmation) return;
+      const { selectedOption, error } = await autoSelectFeeOptionResult;
+      if (error) {
+        console.error("Error selecting fee option:", error);
+        onError?.(new Error(`Failed to select fee option: ${error}`));
+        return;
+      }
+      if (selectedOption?.token.contractAddress && pendingFeeOptionConfirmation.id) {
+        confirmPendingFeeOption(
+          pendingFeeOptionConfirmation.id,
+          selectedOption.token.contractAddress
+        );
+      }
+    };
+    handleFeeOptionSelection();
+  }, [
+    pendingFeeOptionConfirmation,
+    autoSelectFeeOptionResult,
+    confirmPendingFeeOption,
+    onError
+  ]);
   const { cancelOrder: cancelOrderBase } = useCancelTransactionSteps({
     collectionAddress,
     chainId,
@@ -1881,11 +2490,72 @@ var useCancelOrder = ({
   };
 };
 
+// src/react/hooks/useCollectionDetails.tsx
+import { queryOptions as queryOptions23, useQuery as useQuery24 } 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 queryOptions23({
+    queryKey: ["collectionDetails", args],
+    queryFn: () => fetchCollectionDetails(args, marketplaceClient)
+  });
+};
+var useCollectionDetails = (args) => {
+  const config = useConfig2();
+  return useQuery24(collectionDetailsOptions(args, config));
+};
+
+// src/react/hooks/useCollectionDetailsPolling.tsx
+import { queryOptions as queryOptions24, useQuery as useQuery25 } 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 queryOptions24({
+    ...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 * Math.pow(1.5, currentAttempt),
+        MAX_POLLING_INTERVAL
+      );
+      return interval;
+    },
+    refetchOnWindowFocus: false,
+    retry: false
+  });
+};
+var useCollectionDetailsPolling = (args) => {
+  const config = useConfig2();
+  return useQuery25(collectionDetailsPollingOptions(args, config));
+};
+
 export {
   MarketplaceSdkContext,
   MarketplaceQueryClientProvider,
   MarketplaceProvider,
-  useConfig,
+  useAutoSelectFeeOption,
+  useConfig2 as useConfig,
   balanceOfCollectibleOptions,
   useBalanceOfCollectible,
   countOfCollectablesOptions,
@@ -1894,6 +2564,8 @@ export {
   useCollectible,
   collectionOptions,
   useCollection,
+  collectionBalanceDetailsOptions,
+  useCollectionBalanceDetails,
   currenciesOptions,
   useCurrencies,
   marketplaceConfigOptions,
@@ -1947,6 +2619,14 @@ export {
   fetchGenerateBuyTransaction,
   generateBuyTransactionOptions,
   useGenerateBuyTransaction,
-  useCancelOrder
-};
-//# sourceMappingURL=chunk-WRMJ5FZM.js.map
+  useWallet,
+  AlertMessage,
+  useSwitchChainModal,
+  switchChainModal_default,
+  useCancelOrder,
+  collectionDetailsOptions,
+  useCollectionDetails,
+  collectionDetailsPollingOptions,
+  useCollectionDetailsPolling
+};
+//# sourceMappingURL=chunk-HV2X2VZN.js.map