@0xsequence/marketplace-sdk 0.8.3 → 0.8.5

package/dist/{chunk-DFI52A2E.js → chunk-KCLMSSPS.js}

@@ -2,7 +2,7 @@
 
 import {
   collectionOptions
-} from "./chunk-XUNDLCEH.js";
+} from "./chunk-LDZZUYG7.js";
 import {
   InfoIcon_default
 } from "./chunk-SJU6QZHM.js";
@@ -23,10 +23,11 @@ import {
 import {
   balanceOfCollectibleOptions,
   highestOfferOptions,
+  inventoryOptions,
   listBalancesOptions,
   listCollectiblesOptions,
   lowestListingOptions
-} from "./chunk-FSJKN4YN.js";
+} from "./chunk-ZSCZLHKX.js";
 import {
   marketplaceConfigOptions
 } from "./chunk-HGKWWZWY.js";
@@ -35,7 +36,7 @@ import {
   CollectableIdSchema,
   PROVIDER_ID,
   QueryArgSchema
-} from "./chunk-25CAMYCG.js";
+} from "./chunk-BB2PTJHI.js";
 import {
   BaseError,
   ChainSwitchError,
@@ -76,7 +77,7 @@ import {
 // src/react/hooks/useAutoSelectFeeOption.tsx
 import { zeroAddress } from "viem";
 import { useChain } from "@0xsequence/connect";
-import { useCallback } from "react";
+import { useCallback, useEffect } from "react";
 import { useAccount } from "wagmi";
 
 // src/react/hooks/useCollectionBalanceDetails.tsx
@@ -194,7 +195,8 @@ var useCollectionBalanceDetails = (args) => {
 
 // src/react/hooks/useAutoSelectFeeOption.tsx
 function useAutoSelectFeeOption({
-  pendingFeeOptionConfirmation
+  pendingFeeOptionConfirmation,
+  enabled
 }) {
   const { address: userAddress } = useAccount();
   const contractWhitelist = pendingFeeOptionConfirmation.options?.map(
@@ -212,7 +214,7 @@ function useAutoSelectFeeOption({
       omitNativeBalances: false
     },
     query: {
-      enabled: !!pendingFeeOptionConfirmation.options && !!userAddress
+      enabled: !!pendingFeeOptionConfirmation.options && !!userAddress && enabled
     }
   });
   const chain = useChain(pendingFeeOptionConfirmation.chainId);
@@ -230,7 +232,11 @@ function useAutoSelectFeeOption({
       contractAddress: b.contractAddress
     }))
   ];
-  console.debug("currency balances", combinedBalances);
+  useEffect(() => {
+    if (combinedBalances) {
+      console.debug("currency balances", combinedBalances);
+    }
+  }, [combinedBalances]);
   const autoSelectedOption = useCallback(async () => {
     if (!userAddress) {
       return {
@@ -1233,8 +1239,19 @@ function useHighestOffer(args) {
   return useQuery13(highestOfferOptions(args, config));
 }
 
-// src/react/hooks/useListBalances.tsx
+// src/react/hooks/useInventory.tsx
 import { useInfiniteQuery } from "@tanstack/react-query";
+function useInventory(args) {
+  const config = useConfig();
+  const marketplaceConfig = useMarketplaceConfig();
+  const isLaos721 = marketplaceConfig.data?.collections.find(
+    (c) => c.address === args.collectionAddress
+  )?.isLAOSERC721 ?? false;
+  return useInfiniteQuery(inventoryOptions({ ...args, isLaos721 }, config));
+}
+
+// src/react/hooks/useListBalances.tsx
+import { useInfiniteQuery as useInfiniteQuery2 } from "@tanstack/react-query";
 function useListBalances(args) {
   const config = useConfig();
   const { data: marketplaceConfig } = useMarketplaceConfig();
@@ -1244,7 +1261,7 @@ function useListBalances(args) {
   if (isLaos721) {
     args.isLaos721 = true;
   }
-  return useInfiniteQuery(listBalancesOptions(args, config));
+  return useInfiniteQuery2(listBalancesOptions(args, config));
 }
 
 // src/react/hooks/useListCollectibleActivities.tsx
@@ -1277,7 +1294,7 @@ var useListCollectibleActivities = (args) => {
 };
 
 // src/react/hooks/useListCollectibles.tsx
-import { useInfiniteQuery as useInfiniteQuery2 } from "@tanstack/react-query";
+import { useInfiniteQuery as useInfiniteQuery3 } from "@tanstack/react-query";
 function useListCollectibles(args) {
   const config = useConfig();
   const { data: marketplaceConfig } = useMarketplaceConfig();
@@ -1287,7 +1304,7 @@ function useListCollectibles(args) {
   if (isLaos721) {
     args.isLaos721 = true;
   }
-  return useInfiniteQuery2(listCollectiblesOptions(args, config));
+  return useInfiniteQuery3(listCollectiblesOptions(args, config));
 }
 
 // src/react/hooks/useListCollectiblesPaginated.tsx
@@ -1554,229 +1571,11 @@ var useGenerateListingTransaction = (params) => {
 
 // src/react/hooks/useGenerateOfferTransaction.tsx
 import { useMutation as useMutation2 } from "@tanstack/react-query";
-var generateOfferTransaction = async (params, config, chainId) => {
-  const args = {
-    ...params,
-    offer: { ...params.offer, expiry: dateToUnixTime(params.offer.expiry) }
-  };
-  const marketplaceClient = getMarketplaceClient(chainId, config);
-  return (await marketplaceClient.generateOfferTransaction(args)).steps;
-};
-var useGenerateOfferTransaction = (params) => {
-  const config = useConfig();
-  const { mutate, mutateAsync, ...result } = useMutation2({
-    onSuccess: params.onSuccess,
-    mutationFn: (args) => generateOfferTransaction(args, config, params.chainId)
-  });
-  return {
-    ...result,
-    generateOfferTransaction: mutate,
-    generateOfferTransactionAsync: mutateAsync
-  };
-};
-
-// src/react/hooks/useGenerateSellTransaction.tsx
-import { useMutation as useMutation3 } from "@tanstack/react-query";
-import { z as z17 } from "zod";
-var UserGeneratSellTransactionArgsSchema = z17.object({
-  chainId: z17.number(),
-  onSuccess: z17.function().args(stepSchema.array().optional()).optional()
-});
-var generateSellTransaction = async (args, config, chainId) => {
-  const marketplaceClient = getMarketplaceClient(chainId, config);
-  return marketplaceClient.generateSellTransaction(args).then((data) => data.steps);
-};
-var useGenerateSellTransaction = (params) => {
-  const config = useConfig();
-  const { mutate, mutateAsync, ...result } = useMutation3({
-    onSuccess: params.onSuccess,
-    mutationFn: (args) => generateSellTransaction(args, config, params.chainId)
-  });
-  return {
-    ...result,
-    generateSellTransaction: mutate,
-    generateSellTransactionAsync: mutateAsync
-  };
-};
-
-// src/react/hooks/useGenerateCancelTransaction.tsx
-import { useMutation as useMutation4 } from "@tanstack/react-query";
-import { z as z18 } from "zod";
-var UserGenerateCancelTransactionArgsSchema = z18.object({
-  chainId: z18.number(),
-  onSuccess: z18.function().args(stepSchema.array().optional()).optional()
-});
-var generateCancelTransaction = async (args, config, chainId) => {
-  const marketplaceClient = getMarketplaceClient(chainId, config);
-  return marketplaceClient.generateCancelTransaction(args).then((data) => data.steps);
-};
-var useGenerateCancelTransaction = (params) => {
-  const config = useConfig();
-  const { mutate, mutateAsync, ...result } = useMutation4({
-    onSuccess: params.onSuccess,
-    mutationFn: (args) => generateCancelTransaction(args, config, params.chainId)
-  });
-  return {
-    ...result,
-    generateCancelTransaction: mutate,
-    generateCancelTransactionAsync: mutateAsync
-  };
-};
-
-// src/react/hooks/useTransferTokens.tsx
-import { erc721Abi } from "viem";
-import { useAccount as useAccount2, useWriteContract } from "wagmi";
-var prepareTransferConfig = (params, accountAddress) => {
-  if (params.contractType === "ERC721") {
-    return {
-      abi: erc721Abi,
-      address: params.collectionAddress,
-      functionName: "safeTransferFrom",
-      args: [
-        accountAddress,
-        params.receiverAddress,
-        BigInt(params.tokenId)
-      ]
-    };
-  }
-  return {
-    abi: ERC1155_ABI,
-    address: params.collectionAddress,
-    functionName: "safeTransferFrom",
-    args: [
-      accountAddress,
-      params.receiverAddress,
-      BigInt(params.tokenId),
-      params.quantity,
-      "0x"
-      // data
-    ]
-  };
-};
-var useTransferTokens = () => {
-  const { address: accountAddress } = useAccount2();
-  const {
-    writeContractAsync,
-    data: hash,
-    isPending,
-    isError,
-    isSuccess
-  } = useWriteContract();
-  const transferTokensAsync = async (params) => {
-    if (!accountAddress) {
-      throw new NoWalletConnectedError();
-    }
-    const config = prepareTransferConfig(params, accountAddress);
-    return await writeContractAsync(config);
-  };
-  return {
-    transferTokensAsync,
-    hash,
-    transferring: isPending,
-    transferFailed: isError,
-    transferSuccess: isSuccess
-  };
-};
-
-// src/react/hooks/useCheckoutOptions.tsx
-import { queryOptions as queryOptions17, useQuery as useQuery22 } from "@tanstack/react-query";
-import { useAccount as useAccount3 } from "wagmi";
-import { z as z19 } from "zod";
-var UseCheckoutOptionsSchema = z19.object({
-  chainId: z19.number(),
-  orders: z19.array(
-    z19.object({
-      collectionAddress: AddressSchema,
-      orderId: z19.string(),
-      marketplace: z19.nativeEnum(MarketplaceKind)
-    })
-  ),
-  query: QueryArgSchema
-});
-var fetchCheckoutOptions = async (args, config) => {
-  const marketplaceClient = getMarketplaceClient(args.chainId, config);
-  return marketplaceClient.checkoutOptionsMarketplace({
-    wallet: args.walletAddress,
-    orders: args.orders.map((order) => ({
-      contractAddress: order.collectionAddress,
-      orderId: order.orderId,
-      marketplace: order.marketplace
-    })),
-    additionalFee: 0
-    //TODO: add additional fee
-  });
-};
-var checkoutOptionsOptions = (args, config) => {
-  return queryOptions17({
-    queryKey: ["checkoutOptions", args],
-    queryFn: () => fetchCheckoutOptions(args, config)
-  });
-};
-var useCheckoutOptions = (args) => {
-  const { address } = useAccount3();
-  const config = useConfig();
-  return useQuery22(
-    // biome-ignore lint/style/noNonNullAssertion: <explanation>
-    checkoutOptionsOptions({ walletAddress: address, ...args }, config)
-  );
-};
-
-// src/react/hooks/useListCollections.tsx
-import { queryOptions as queryOptions18, useQuery as useQuery23 } from "@tanstack/react-query";
-import { z as z20 } from "zod";
-var UseListCollectionsSchema = z20.object({
-  query: QueryArgSchema.optional().default({})
-});
-var fetchListCollections = async ({ marketplaceConfig }, config) => {
-  const metadataClient = getMetadataClient(config);
-  if (!marketplaceConfig?.collections?.length) {
-    return [];
-  }
-  const collectionsByChain = marketplaceConfig.collections.reduce((acc, curr) => {
-    const { chainId, address } = curr;
-    if (!acc[chainId]) {
-      acc[chainId] = [];
-    }
-    acc[chainId].push(address);
-    return acc;
-  }, {});
-  const promises = Object.entries(collectionsByChain).map(
-    ([chainId, addresses]) => metadataClient.getContractInfoBatch({
-      chainID: chainId,
-      contractAddresses: addresses
-    }).then((resp) => Object.values(resp.contractInfoMap))
-  );
-  const results = await Promise.all(promises);
-  return results.flat();
-};
-var listCollectionsOptions = (args, config) => {
-  return queryOptions18({
-    ...args.query,
-    queryKey: [...collectionKeys.list],
-    queryFn: () => fetchListCollections(args, config)
-  });
-};
-var useListCollections = (args = {}) => {
-  const config = useConfig();
-  const { data: marketplaceConfig, isLoading: isLoadingConfig } = useMarketplaceConfig();
-  return useQuery23({
-    ...listCollectionsOptions(
-      // biome-ignore lint/style/noNonNullAssertion: <explanation>
-      { marketplaceConfig, query: args.query },
-      config
-    ),
-    enabled: !isLoadingConfig && !!marketplaceConfig
-  });
-};
-
-// src/react/hooks/useCancelOrder.tsx
-import { useWaasFeeOptions } from "@0xsequence/connect";
-import { useEffect, useState } from "react";
 
 // src/react/_internal/wallet/useWallet.ts
-import { skipToken as skipToken2, useQuery as useQuery24 } from "@tanstack/react-query";
+import { skipToken as skipToken2, useQuery as useQuery22 } from "@tanstack/react-query";
 import {
-  useAccount as useAccount4,
+  useAccount as useAccount2,
   useChainId,
   usePublicClient,
   useSwitchChain,
@@ -1789,7 +1588,7 @@ import {
   WaitForTransactionReceiptTimeoutError,
   custom,
   erc20Abi,
-  erc721Abi as erc721Abi2,
+  erc721Abi,
   hexToBigInt,
   isHex
 } from "viem";
@@ -1982,7 +1781,7 @@ var wallet = ({
         case "ERC721":
           return await publicClient.readContract({
             address: contractAddress,
-            abi: erc721Abi2,
+            abi: erc721Abi,
             functionName: "isApprovedForAll",
             args: [walletAddress, spenderAddress]
           });
@@ -2043,11 +1842,11 @@ var useWallet = () => {
     isLoading: wagmiWalletIsLoading,
     isError: wagmiWalletIsError
   } = useWalletClient();
-  const { connector, isConnected, isConnecting } = useAccount4();
+  const { connector, isConnected, isConnecting } = useAccount2();
   const sdkConfig = useConfig();
   const chainId = useChainId();
   const publicClient = usePublicClient();
-  const { data, isLoading, isError } = useQuery24({
+  const { data, isLoading, isError } = useQuery22({
     queryKey: ["wallet", chainId, connector?.uid],
     queryFn: walletClient && connector && isConnected && publicClient ? () => {
       return wallet({
@@ -2067,6 +1866,233 @@ var useWallet = () => {
   };
 };
 
+// src/react/hooks/useGenerateOfferTransaction.tsx
+var generateOfferTransaction = async (params, config, chainId, walletKind) => {
+  const args = {
+    ...params,
+    offer: { ...params.offer, expiry: dateToUnixTime(params.offer.expiry) },
+    walletType: walletKind
+  };
+  const marketplaceClient = getMarketplaceClient(chainId, config);
+  return (await marketplaceClient.generateOfferTransaction(args)).steps;
+};
+var useGenerateOfferTransaction = (params) => {
+  const config = useConfig();
+  const { wallet: wallet2 } = useWallet();
+  const { mutate, mutateAsync, ...result } = useMutation2({
+    onSuccess: params.onSuccess,
+    mutationFn: (args) => generateOfferTransaction(
+      args,
+      config,
+      params.chainId,
+      wallet2?.walletKind
+    )
+  });
+  return {
+    ...result,
+    generateOfferTransaction: mutate,
+    generateOfferTransactionAsync: mutateAsync
+  };
+};
+
+// src/react/hooks/useGenerateSellTransaction.tsx
+import { useMutation as useMutation3 } from "@tanstack/react-query";
+import { z as z17 } from "zod";
+var UserGeneratSellTransactionArgsSchema = z17.object({
+  chainId: z17.number(),
+  onSuccess: z17.function().args(stepSchema.array().optional()).optional()
+});
+var generateSellTransaction = async (args, config, chainId) => {
+  const marketplaceClient = getMarketplaceClient(chainId, config);
+  return marketplaceClient.generateSellTransaction(args).then((data) => data.steps);
+};
+var useGenerateSellTransaction = (params) => {
+  const config = useConfig();
+  const { mutate, mutateAsync, ...result } = useMutation3({
+    onSuccess: params.onSuccess,
+    mutationFn: (args) => generateSellTransaction(args, config, params.chainId)
+  });
+  return {
+    ...result,
+    generateSellTransaction: mutate,
+    generateSellTransactionAsync: mutateAsync
+  };
+};
+
+// src/react/hooks/useGenerateCancelTransaction.tsx
+import { useMutation as useMutation4 } from "@tanstack/react-query";
+import { z as z18 } from "zod";
+var UserGenerateCancelTransactionArgsSchema = z18.object({
+  chainId: z18.number(),
+  onSuccess: z18.function().args(stepSchema.array().optional()).optional()
+});
+var generateCancelTransaction = async (args, config, chainId) => {
+  const marketplaceClient = getMarketplaceClient(chainId, config);
+  return marketplaceClient.generateCancelTransaction(args).then((data) => data.steps);
+};
+var useGenerateCancelTransaction = (params) => {
+  const config = useConfig();
+  const { mutate, mutateAsync, ...result } = useMutation4({
+    onSuccess: params.onSuccess,
+    mutationFn: (args) => generateCancelTransaction(args, config, params.chainId)
+  });
+  return {
+    ...result,
+    generateCancelTransaction: mutate,
+    generateCancelTransactionAsync: mutateAsync
+  };
+};
+
+// src/react/hooks/useTransferTokens.tsx
+import { erc721Abi as erc721Abi2 } from "viem";
+import { useAccount as useAccount3, useWriteContract } from "wagmi";
+var prepareTransferConfig = (params, accountAddress) => {
+  if (params.contractType === "ERC721") {
+    return {
+      abi: erc721Abi2,
+      address: params.collectionAddress,
+      functionName: "safeTransferFrom",
+      args: [
+        accountAddress,
+        params.receiverAddress,
+        BigInt(params.tokenId)
+      ]
+    };
+  }
+  return {
+    abi: ERC1155_ABI,
+    address: params.collectionAddress,
+    functionName: "safeTransferFrom",
+    args: [
+      accountAddress,
+      params.receiverAddress,
+      BigInt(params.tokenId),
+      params.quantity,
+      "0x"
+      // data
+    ]
+  };
+};
+var useTransferTokens = () => {
+  const { address: accountAddress } = useAccount3();
+  const {
+    writeContractAsync,
+    data: hash,
+    isPending,
+    isError,
+    isSuccess
+  } = useWriteContract();
+  const transferTokensAsync = async (params) => {
+    if (!accountAddress) {
+      throw new NoWalletConnectedError();
+    }
+    const config = prepareTransferConfig(params, accountAddress);
+    return await writeContractAsync(config);
+  };
+  return {
+    transferTokensAsync,
+    hash,
+    transferring: isPending,
+    transferFailed: isError,
+    transferSuccess: isSuccess
+  };
+};
+
+// src/react/hooks/useCheckoutOptions.tsx
+import { queryOptions as queryOptions17, useQuery as useQuery23 } from "@tanstack/react-query";
+import { useAccount as useAccount4 } from "wagmi";
+import { z as z19 } from "zod";
+var UseCheckoutOptionsSchema = z19.object({
+  chainId: z19.number(),
+  orders: z19.array(
+    z19.object({
+      collectionAddress: AddressSchema,
+      orderId: z19.string(),
+      marketplace: z19.nativeEnum(MarketplaceKind)
+    })
+  ),
+  query: QueryArgSchema
+});
+var fetchCheckoutOptions = async (args, config) => {
+  const marketplaceClient = getMarketplaceClient(args.chainId, config);
+  return marketplaceClient.checkoutOptionsMarketplace({
+    wallet: args.walletAddress,
+    orders: args.orders.map((order) => ({
+      contractAddress: order.collectionAddress,
+      orderId: order.orderId,
+      marketplace: order.marketplace
+    })),
+    additionalFee: 0
+    //TODO: add additional fee
+  });
+};
+var checkoutOptionsOptions = (args, config) => {
+  return queryOptions17({
+    queryKey: ["checkoutOptions", args],
+    queryFn: () => fetchCheckoutOptions(args, config)
+  });
+};
+var useCheckoutOptions = (args) => {
+  const { address } = useAccount4();
+  const config = useConfig();
+  return useQuery23(
+    // biome-ignore lint/style/noNonNullAssertion: <explanation>
+    checkoutOptionsOptions({ walletAddress: address, ...args }, config)
+  );
+};
+
+// src/react/hooks/useListCollections.tsx
+import { queryOptions as queryOptions18, useQuery as useQuery24 } from "@tanstack/react-query";
+import { z as z20 } from "zod";
+var UseListCollectionsSchema = z20.object({
+  query: QueryArgSchema.optional().default({})
+});
+var fetchListCollections = async ({ marketplaceConfig }, config) => {
+  const metadataClient = getMetadataClient(config);
+  if (!marketplaceConfig?.collections?.length) {
+    return [];
+  }
+  const collectionsByChain = marketplaceConfig.collections.reduce((acc, curr) => {
+    const { chainId, address } = curr;
+    if (!acc[chainId]) {
+      acc[chainId] = [];
+    }
+    acc[chainId].push(address);
+    return acc;
+  }, {});
+  const promises = Object.entries(collectionsByChain).map(
+    ([chainId, addresses]) => metadataClient.getContractInfoBatch({
+      chainID: chainId,
+      contractAddresses: addresses
+    }).then((resp) => Object.values(resp.contractInfoMap))
+  );
+  const results = await Promise.all(promises);
+  return results.flat();
+};
+var listCollectionsOptions = (args, config) => {
+  return queryOptions18({
+    ...args.query,
+    queryKey: [...collectionKeys.list],
+    queryFn: () => fetchListCollections(args, config)
+  });
+};
+var useListCollections = (args = {}) => {
+  const config = useConfig();
+  const { data: marketplaceConfig, isLoading: isLoadingConfig } = useMarketplaceConfig();
+  return useQuery24({
+    ...listCollectionsOptions(
+      // biome-ignore lint/style/noNonNullAssertion: <explanation>
+      { marketplaceConfig, query: args.query },
+      config
+    ),
+    enabled: !isLoadingConfig && !!marketplaceConfig
+  });
+};
+
+// src/react/hooks/useCancelOrder.tsx
+import { useWaasFeeOptions } from "@0xsequence/connect";
+import { useEffect as useEffect2, useState } from "react";
+
 // src/react/ui/modals/_internal/components/switchChainModal/index.tsx
 import { Button, Modal, Spinner, Text as Text2 } from "@0xsequence/design-system";
 import { observer } from "@legendapp/state/react";
@@ -2149,7 +2175,7 @@ var SwitchChainModal = observer(() => {
     try {
       if (!chainIdToSwitchTo) return;
       await switchChainAsync({ chainId: Number(chainIdToSwitchTo) });
-      if (switchChainModal$.state.onSuccess && typeof switchChainModal$.state.onSuccess === "function") {
+      if (switchChainModal$.state.onSuccess.get() && typeof switchChainModal$.state.onSuccess.get() === "function") {
         switchChainModal$.state.onSuccess();
       }
       switchChainModal$.delete();
@@ -2206,6 +2232,91 @@ var SwitchChainModal = observer(() => {
 });
 var switchChainModal_default = SwitchChainModal;
 
+// src/react/hooks/util/optimisticCancelUpdates.ts
+var SECOND = 1e3;
+var updateQueriesOnCancel = ({
+  orderId,
+  queryClient
+}) => {
+  queryClient.setQueriesData(
+    { queryKey: collectableKeys.offersCount, exact: false },
+    (oldData) => {
+      if (!oldData) return { count: 0 };
+      return { count: Math.max(0, oldData.count - 1) };
+    }
+  );
+  console.log("query client ", queryClient, "orderId", orderId);
+  queryClient.setQueriesData(
+    { queryKey: collectableKeys.offers, exact: false },
+    (oldData) => {
+      if (!oldData || !oldData.offers) return oldData;
+      return {
+        ...oldData,
+        offers: oldData.offers.filter((offer) => offer.orderId !== orderId)
+      };
+    }
+  );
+  setTimeout(() => {
+    queryClient.invalidateQueries({
+      queryKey: collectableKeys.highestOffers,
+      exact: false
+    });
+  }, 2 * SECOND);
+  queryClient.setQueriesData(
+    { queryKey: collectableKeys.listingsCount, exact: false },
+    (oldData) => {
+      if (!oldData) return { count: 0 };
+      return { count: Math.max(0, oldData.count - 1) };
+    }
+  );
+  queryClient.setQueriesData(
+    { queryKey: collectableKeys.listings, exact: false },
+    (oldData) => {
+      if (!oldData || !oldData.listings) return oldData;
+      return {
+        ...oldData,
+        listings: oldData.listings.filter(
+          (listing) => listing.orderId !== orderId
+        )
+      };
+    }
+  );
+  setTimeout(() => {
+    queryClient.invalidateQueries({
+      queryKey: collectableKeys.lowestListings,
+      exact: false
+    });
+  }, 2 * SECOND);
+};
+var invalidateQueriesOnCancel = ({
+  queryClient
+}) => {
+  queryClient.invalidateQueries({
+    queryKey: collectableKeys.offers,
+    exact: false
+  });
+  queryClient.invalidateQueries({
+    queryKey: collectableKeys.offersCount,
+    exact: false
+  });
+  queryClient.invalidateQueries({
+    queryKey: collectableKeys.listings,
+    exact: false
+  });
+  queryClient.invalidateQueries({
+    queryKey: collectableKeys.listingsCount,
+    exact: false
+  });
+  queryClient.invalidateQueries({
+    queryKey: collectableKeys.highestOffers,
+    exact: false
+  });
+  queryClient.invalidateQueries({
+    queryKey: collectableKeys.lowestListings,
+    exact: false
+  });
+};
+
 // src/react/hooks/useCancelTransactionSteps.tsx
 var useCancelTransactionSteps = ({
   collectionAddress,
@@ -2311,8 +2422,11 @@ var useCancelTransactionSteps = ({
           await wallet2.handleConfirmTransactionStep(hash, Number(chainId));
           if (onSuccess && typeof onSuccess === "function") {
             onSuccess({ hash });
+            updateQueriesOnCancel({
+              orderId,
+              queryClient
+            });
           }
-          queryClient.invalidateQueries();
           setSteps((prev) => ({
             ...prev,
             isExecuting: false
@@ -2323,14 +2437,20 @@ var useCancelTransactionSteps = ({
         reservoirOrderId = await executeSignature({ signatureStep });
         if (onSuccess && typeof onSuccess === "function") {
           onSuccess({ orderId: reservoirOrderId });
+          updateQueriesOnCancel({
+            orderId: reservoirOrderId,
+            queryClient
+          });
         }
-        queryClient.invalidateQueries();
         setSteps((prev) => ({
           ...prev,
           isExecuting: false
         }));
       }
     } catch (error) {
+      invalidateQueriesOnCancel({
+        queryClient
+      });
       setSteps((prev) => ({
         ...prev,
         isExecuting: false
@@ -2401,9 +2521,10 @@ var useCancelOrder = ({
       id: "",
       options: void 0,
       chainId
-    }
+    },
+    enabled: !!pendingFeeOptionConfirmation
   });
-  useEffect(() => {
+  useEffect2(() => {
     autoSelectOptionPromise.then((res) => {
       if (pendingFeeOptionConfirmation?.id && res.selectedOption) {
         confirmPendingFeeOption(
@@ -2531,6 +2652,7 @@ export {
   floorOrderOptions,
   useFloorOrder,
   useHighestOffer,
+  useInventory,
   useListBalances,
   listCollectibleActivitiesOptions,
   useListCollectibleActivities,
@@ -2552,6 +2674,7 @@ export {
   dateToUnixTime,
   generateListingTransaction,
   useGenerateListingTransaction,
+  useWallet,
   generateOfferTransaction,
   useGenerateOfferTransaction,
   generateSellTransaction,
@@ -2563,7 +2686,6 @@ export {
   useCheckoutOptions,
   listCollectionsOptions,
   useListCollections,
-  useWallet,
   AlertMessage,
   MODAL_OVERLAY_PROPS,
   MODAL_CONTENT_PROPS,
@@ -2575,4 +2697,4 @@ export {
   collectionDetailsPollingOptions,
   useCollectionDetailsPolling
 };
-//# sourceMappingURL=chunk-DFI52A2E.js.map
+//# sourceMappingURL=chunk-KCLMSSPS.js.map