@0xsequence/marketplace-sdk 0.3.2 → 0.3.4

package/dist/{chunk-O7UQGT43.js → chunk-6LQST3KZ.js}

@@ -13,7 +13,7 @@ import {
 import {
   getPresentableChainName,
   getPublicRpcClient
-} from "./chunk-SPW24Y7I.js";
+} from "./chunk-OUZ42I6B.js";
 import {
   EIP2981_ABI
 } from "./chunk-3OHM45R3.js";
@@ -46,6 +46,7 @@ import {
   TransactionOnRampProvider,
   TransactionSwapProvider,
   WalletKind,
+  WebrpcError,
   balanceQueries,
   builderMarketplaceApi,
   collectableKeys,
@@ -56,7 +57,34 @@ import {
   getMarketplaceClient,
   getMetadataClient,
   getQueryClient
-} from "./chunk-GZG2QO64.js";
+} from "./chunk-D3HRXVYJ.js";
+import {
+  BaseError,
+  ChainIdUnavailableError,
+  ChainSwitchError,
+  CheckoutOptionsError,
+  CollectionNotFoundError,
+  InvalidSignatureStepError,
+  MarketplaceConfigFetchError,
+  MissingPostStepError,
+  MissingSignatureDataError,
+  MissingStepDataError,
+  NoExecutionStepError,
+  NoMarketplaceConfigError,
+  NoStepsFoundError,
+  NoWalletConnectedError,
+  OrderNotFoundError,
+  OrdersFetchError,
+  PaymentModalError,
+  PaymentModalTransactionError,
+  ProjectNotFoundError,
+  StepExecutionError,
+  StepGenerationError,
+  TransactionError,
+  TransactionReceiptError,
+  UnexpectedStepsError,
+  UnknownTransactionTypeError
+} from "./chunk-T2AMWIKD.js";
 
 // src/react/hooks/useBalanceOfCollectible.tsx
 import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
@@ -65,6 +93,14 @@ import { z } from "zod";
 // src/react/hooks/useConfig.tsx
 import { useContext } from "react";
 
+// src/utils/_internal/error/context.ts
+var MarketplaceSdkProviderNotFoundError = class extends BaseError {
+  name = "MarketplaceSDKProviderNotFoundError";
+  constructor() {
+    super("`useConfig` must be used within `MarketplaceSdkProvider`.");
+  }
+};
+
 // src/react/provider.tsx
 import { createContext } from "react";
 import "@0xsequence/design-system/styles.css";
@@ -81,9 +117,7 @@ function MarketplaceProvider({
 function useConfig() {
   const context = useContext(MarketplaceSdkContext);
   if (!context) {
-    throw new Error(
-      "Marketplace SDK must be used within a MarketplaceSdkProvider"
-    );
+    throw new MarketplaceSdkProviderNotFoundError();
   }
   return context;
 }
@@ -411,6 +445,22 @@ var checkoutOptionsSalesContractArgsSchema = z2.object({
 var checkoutOptionsSalesContractReturnSchema = z2.object({
   options: checkoutOptionsSchema
 });
+var countListingsForCollectibleArgsSchema = z2.object({
+  contractAddress: z2.string(),
+  tokenId: z2.string(),
+  filter: orderFilterSchema.optional()
+});
+var countListingsForCollectibleReturnSchema = z2.object({
+  count: z2.number()
+});
+var countOffersForCollectibleArgsSchema = z2.object({
+  contractAddress: z2.string(),
+  tokenId: z2.string(),
+  filter: orderFilterSchema.optional()
+});
+var countOffersForCollectibleReturnSchema = z2.object({
+  count: z2.number()
+});
 var tokenMetadataSchema = z2.object({
   tokenId: z2.string(),
   name: z2.string(),
@@ -769,7 +819,7 @@ var selectCurrencies = (data, args) => {
       (collection2) => collection2.collectionAddress === argsParsed.collectionAddress
     );
     if (!collection) {
-      throw new Error("Collection doesn't exist");
+      throw new CollectionNotFoundError(argsParsed.collectionAddress);
     }
     return data.filter(
       (currency) => collection.currencyOptions?.includes(currency.contractAddress) || // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
@@ -1028,13 +1078,46 @@ var useListOffersForCollectible = (args) => {
   return useQuery10(listOffersForCollectibleOptions(args, config));
 };
 
-// src/react/hooks/useListListingsForCollectible.tsx
+// src/react/hooks/useCountOffersForCollectible.tsx
 import { queryOptions as queryOptions11, useQuery as useQuery11 } from "@tanstack/react-query";
 import { z as z14 } from "zod";
-var UseListListingsForCollectibleArgsSchema = listListingsForCollectibleArgsSchema.extend({
+var UseCountOffersForCollectibleArgsSchema = countOffersForCollectibleArgsSchema.omit({
+  contractAddress: true,
+  tokenId: true
+}).extend({
+  collectionAddress: AddressSchema,
+  collectibleId: z14.string(),
   chainId: ChainIdSchema.pipe(z14.coerce.string()),
-  collectionAddress: z14.string(),
-  collectibleId: z14.string()
+  query: QueryArgSchema
+});
+var fetchCountOffersForCollectible = async (args, config) => {
+  const parsedArgs = UseCountOffersForCollectibleArgsSchema.parse(args);
+  const marketplaceClient = getMarketplaceClient(parsedArgs.chainId, config);
+  return marketplaceClient.getCountOfOffersForCollectible({
+    ...parsedArgs,
+    contractAddress: parsedArgs.collectionAddress,
+    tokenId: parsedArgs.collectibleId
+  });
+};
+var countOffersForCollectibleOptions = (args, config) => {
+  return queryOptions11({
+    ...args.query,
+    queryKey: [...collectableKeys.offersCount, args, config],
+    queryFn: () => fetchCountOffersForCollectible(args, config)
+  });
+};
+var useCountOffersForCollectible = (args) => {
+  const config = useConfig();
+  return useQuery11(countOffersForCollectibleOptions(args, config));
+};
+
+// src/react/hooks/useListListingsForCollectible.tsx
+import { queryOptions as queryOptions12, useQuery as useQuery12 } from "@tanstack/react-query";
+import { z as z15 } from "zod";
+var UseListListingsForCollectibleArgsSchema = listListingsForCollectibleArgsSchema.extend({
+  chainId: ChainIdSchema.pipe(z15.coerce.string()),
+  collectionAddress: z15.string(),
+  collectibleId: z15.string()
 }).omit({ contractAddress: true, tokenId: true });
 var fetchListListingsForCollectible = async (config, args) => {
   const arg = {
@@ -1047,24 +1130,57 @@ var fetchListListingsForCollectible = async (config, args) => {
   return marketplaceClient.listCollectibleListings(arg);
 };
 var listListingsForCollectibleOptions = (args, config) => {
-  return queryOptions11({
+  return queryOptions12({
     queryKey: [...collectableKeys.listings, args, config],
     queryFn: () => fetchListListingsForCollectible(config, args)
   });
 };
 var useListListingsForCollectible = (args) => {
   const config = useConfig();
-  return useQuery11(listListingsForCollectibleOptions(args, config));
+  return useQuery12(listListingsForCollectibleOptions(args, config));
+};
+
+// src/react/hooks/useCountListingsForCollectible.tsx
+import { queryOptions as queryOptions13, useQuery as useQuery13 } from "@tanstack/react-query";
+import { z as z16 } from "zod";
+var UseCountListingsForCollectibleArgsSchema = countListingsForCollectibleArgsSchema.omit({
+  contractAddress: true,
+  tokenId: true
+}).extend({
+  collectionAddress: AddressSchema,
+  collectibleId: z16.string(),
+  chainId: ChainIdSchema.pipe(z16.coerce.string()),
+  query: QueryArgSchema
+});
+var fetchCountListingsForCollectible = async (args, config) => {
+  const parsedArgs = UseCountListingsForCollectibleArgsSchema.parse(args);
+  const marketplaceClient = getMarketplaceClient(parsedArgs.chainId, config);
+  return marketplaceClient.getCountOfListingsForCollectible({
+    ...parsedArgs,
+    contractAddress: parsedArgs.collectionAddress,
+    tokenId: parsedArgs.collectibleId
+  });
+};
+var countListingsForCollectibleOptions = (args, config) => {
+  return queryOptions13({
+    ...args.query,
+    queryKey: [...collectableKeys.listingsCount, args, config],
+    queryFn: () => fetchCountListingsForCollectible(args, config)
+  });
+};
+var useCountListingsForCollectible = (args) => {
+  const config = useConfig();
+  return useQuery13(countListingsForCollectibleOptions(args, config));
 };
 
 // src/react/hooks/useLowestListing.tsx
-import { queryOptions as queryOptions12, useQuery as useQuery12 } from "@tanstack/react-query";
-import { z as z15 } from "zod";
+import { queryOptions as queryOptions14, useQuery as useQuery14 } from "@tanstack/react-query";
+import { z as z17 } from "zod";
 var UseLowestListingSchema = getCollectibleLowestListingArgsSchema.omit({
   contractAddress: true
 }).extend({
   collectionAddress: AddressSchema,
-  chainId: ChainIdSchema.pipe(z15.coerce.string()),
+  chainId: ChainIdSchema.pipe(z17.coerce.string()),
   query: QueryArgSchema
 });
 var fetchLowestListing = async (args, config) => {
@@ -1076,7 +1192,7 @@ var fetchLowestListing = async (args, config) => {
   });
 };
 var lowestListingOptions = (args, config) => {
-  return queryOptions12({
+  return queryOptions14({
     ...args.query,
     queryKey: [...collectableKeys.lowestListings, args, config],
     queryFn: () => fetchLowestListing(args, config)
@@ -1084,14 +1200,14 @@ var lowestListingOptions = (args, config) => {
 };
 var useLowestListing = (args) => {
   const config = useConfig();
-  return useQuery12(lowestListingOptions(args, config));
+  return useQuery14(lowestListingOptions(args, config));
 };
 
 // src/react/hooks/useMarketplaceConfig.tsx
-import { useQuery as useQuery13 } from "@tanstack/react-query";
+import { useQuery as useQuery15 } from "@tanstack/react-query";
 
 // src/react/hooks/options/marketplaceConfigOptions.ts
-import { queryOptions as queryOptions13 } from "@tanstack/react-query";
+import { queryOptions as queryOptions15 } from "@tanstack/react-query";
 var fetchBuilderConfig = async (projectId, env) => {
   const url = `${builderMarketplaceApi(projectId, env)}`;
   const response = await fetch(`${url}/config.json`);
@@ -1100,9 +1216,9 @@ var fetchBuilderConfig = async (projectId, env) => {
     console.error("Failed to fetch marketplace config:", response.status, json);
     switch (json.code) {
       case 3e3:
-        throw new Error(`Project id: ${projectId} not found, ${url}`);
+        throw new ProjectNotFoundError(projectId, url);
       default:
-        throw new Error(`Failed to fetch marketplace config: ${json.msg}`);
+        throw new MarketplaceConfigFetchError(json.msg);
     }
   }
   return json;
@@ -1131,7 +1247,7 @@ var marketplaceConfigOptions = (config) => {
     env = config._internal.builderEnv ?? env;
   }
   const projectId = config.projectId;
-  return queryOptions13({
+  return queryOptions15({
     queryKey: [...configKeys.marketplace, env, projectId],
     queryFn: () => fetchMarketplaceConfig(env, projectId)
   });
@@ -1140,17 +1256,17 @@ var marketplaceConfigOptions = (config) => {
 // src/react/hooks/useMarketplaceConfig.tsx
 var useMarketplaceConfig = () => {
   const config = useConfig();
-  return useQuery13(marketplaceConfigOptions(config));
+  return useQuery15(marketplaceConfigOptions(config));
 };
 
 // src/react/hooks/useRoyaltyPercentage.tsx
-import { queryOptions as queryOptions14, useQuery as useQuery14 } from "@tanstack/react-query";
+import { queryOptions as queryOptions16, useQuery as useQuery16 } from "@tanstack/react-query";
 import { getContract } from "viem";
-import { z as z16 } from "zod";
-var UseRoyaletyPercentageSchema = z16.object({
-  chainId: ChainIdSchema.pipe(z16.coerce.string()),
+import { z as z18 } from "zod";
+var UseRoyaletyPercentageSchema = z18.object({
+  chainId: ChainIdSchema.pipe(z18.coerce.string()),
   collectionAddress: AddressSchema,
-  collectibleId: z16.string(),
+  collectibleId: z18.string(),
   query: QueryArgSchema
 });
 var fetchRoyaletyPercentage = async (args) => {
@@ -1171,13 +1287,13 @@ var fetchRoyaletyPercentage = async (args) => {
     return 0n;
   }
 };
-var royaletyPercentageOptions = (args) => queryOptions14({
+var royaletyPercentageOptions = (args) => queryOptions16({
   ...args.query,
   queryKey: [...collectableKeys.royaltyPercentage, args],
   queryFn: () => fetchRoyaletyPercentage(args)
 });
 var useRoyaltyPercentage = (args) => {
-  return useQuery14(royaletyPercentageOptions(args));
+  return useQuery16(royaletyPercentageOptions(args));
 };
 
 // src/react/hooks/useGenerateListingTransaction.tsx
@@ -1233,13 +1349,13 @@ var useGenerateOfferTransaction = (params) => {
 
 // src/react/hooks/useGenerateSellTransaction.tsx
 import { useMutation as useMutation3 } from "@tanstack/react-query";
-import { z as z17 } from "zod";
-var UserGeneratSellTransactionArgsSchema = z17.object({
-  chainId: ChainIdSchema.pipe(z17.coerce.string()),
-  onSuccess: z17.function().args(stepSchema.array().optional()).optional()
+import { z as z19 } from "zod";
+var UserGeneratSellTransactionArgsSchema = z19.object({
+  chainId: ChainIdSchema.pipe(z19.coerce.string()),
+  onSuccess: z19.function().args(stepSchema.array().optional()).optional()
 });
 var generateSellTransaction = async (args, config, chainId) => {
-  const parsedChainId = ChainIdSchema.pipe(z17.coerce.string()).parse(chainId);
+  const parsedChainId = ChainIdSchema.pipe(z19.coerce.string()).parse(chainId);
   const marketplaceClient = getMarketplaceClient(parsedChainId, config);
   return marketplaceClient.generateSellTransaction(args).then((data) => data.steps);
 };
@@ -1258,13 +1374,13 @@ var useGenerateSellTransaction = (params) => {
 
 // src/react/hooks/useGenerateCancelTransaction.tsx
 import { useMutation as useMutation4 } from "@tanstack/react-query";
-import { z as z18 } from "zod";
-var UserGenerateCancelTransactionArgsSchema = z18.object({
-  chainId: ChainIdSchema.pipe(z18.coerce.string()),
-  onSuccess: z18.function().args(stepSchema.array().optional()).optional()
+import { z as z20 } from "zod";
+var UserGenerateCancelTransactionArgsSchema = z20.object({
+  chainId: ChainIdSchema.pipe(z20.coerce.string()),
+  onSuccess: z20.function().args(stepSchema.array().optional()).optional()
 });
 var generateCancelTransaction = async (args, config, chainId) => {
-  const parsedChainId = ChainIdSchema.pipe(z18.coerce.string()).parse(chainId);
+  const parsedChainId = ChainIdSchema.pipe(z20.coerce.string()).parse(chainId);
   const marketplaceClient = getMarketplaceClient(parsedChainId, config);
   return marketplaceClient.generateCancelTransaction(args).then((data) => data.steps);
 };
@@ -1322,7 +1438,7 @@ var useTransferTokens = () => {
   } = useWriteContract();
   const transferTokensAsync = async (params) => {
     if (!accountAddress) {
-      throw new Error("No wallet connected");
+      throw new NoWalletConnectedError();
     }
     const config = prepareTransferConfig(params, accountAddress);
     return await writeContractAsync(config);
@@ -1337,16 +1453,16 @@ var useTransferTokens = () => {
 };
 
 // src/react/hooks/useCheckoutOptions.tsx
-import { queryOptions as queryOptions15, useQuery as useQuery15 } from "@tanstack/react-query";
-import { z as z19 } from "zod";
+import { queryOptions as queryOptions17, useQuery as useQuery17 } from "@tanstack/react-query";
 import { useAccount as useAccount2 } from "wagmi";
-var UseCheckoutOptionsSchema = z19.object({
-  chainId: ChainIdSchema.pipe(z19.coerce.string()),
-  orders: z19.array(
-    z19.object({
+import { z as z21 } from "zod";
+var UseCheckoutOptionsSchema = z21.object({
+  chainId: ChainIdSchema.pipe(z21.coerce.string()),
+  orders: z21.array(
+    z21.object({
       collectionAddress: AddressSchema,
-      orderId: z19.string(),
-      marketplace: z19.nativeEnum(MarketplaceKind)
+      orderId: z21.string(),
+      marketplace: z21.nativeEnum(MarketplaceKind)
     })
   ),
   query: QueryArgSchema
@@ -1365,7 +1481,7 @@ var fetchCheckoutOptions = async (args, config) => {
   });
 };
 var checkoutOptionsOptions = (args, config) => {
-  return queryOptions15({
+  return queryOptions17({
     queryKey: ["checkoutOptions", args],
     queryFn: () => fetchCheckoutOptions(args, config)
   });
@@ -1373,16 +1489,16 @@ var checkoutOptionsOptions = (args, config) => {
 var useCheckoutOptions = (args) => {
   const { address } = useAccount2();
   const config = useConfig();
-  return useQuery15(
+  return useQuery17(
     // biome-ignore lint/style/noNonNullAssertion: <explanation>
     checkoutOptionsOptions({ walletAddress: address, ...args }, config)
   );
 };
 
 // src/react/hooks/useListCollections.tsx
-import { queryOptions as queryOptions16, useQuery as useQuery16 } from "@tanstack/react-query";
-import { z as z20 } from "zod";
-var UseListCollectionsSchema = z20.object({
+import { queryOptions as queryOptions18, useQuery as useQuery18 } from "@tanstack/react-query";
+import { z as z22 } from "zod";
+var UseListCollectionsSchema = z22.object({
   query: QueryArgSchema.optional().default({})
 });
 var fetchListCollections = async ({ marketplaceConfig }, config) => {
@@ -1408,7 +1524,7 @@ var fetchListCollections = async ({ marketplaceConfig }, config) => {
   return results.flat();
 };
 var listCollectionsOptions = (args, config) => {
-  return queryOptions16({
+  return queryOptions18({
     ...args.query,
     queryKey: [...collectionKeys.list],
     queryFn: () => fetchListCollections(args, config)
@@ -1417,7 +1533,7 @@ var listCollectionsOptions = (args, config) => {
 var useListCollections = (args = {}) => {
   const config = useConfig();
   const { data: marketplaceConfig, isLoading: isLoadingConfig } = useMarketplaceConfig();
-  return useQuery16({
+  return useQuery18({
     ...listCollectionsOptions(
       // biome-ignore lint/style/noNonNullAssertion: <explanation>
       { marketplaceConfig, query: args.query },
@@ -1428,21 +1544,21 @@ var useListCollections = (args = {}) => {
 };
 
 // src/react/hooks/useGenerateBuyTransaction.tsx
-import { queryOptions as queryOptions17, useQuery as useQuery17 } from "@tanstack/react-query";
-import { z as z21 } from "zod";
+import { queryOptions as queryOptions19, useQuery as useQuery19 } from "@tanstack/react-query";
 import { useAccount as useAccount3 } from "wagmi";
-var UseGenerateBuyTransactionArgsSchema = z21.object({
-  chainId: ChainIdSchema.pipe(z21.coerce.string()),
+import { z as z23 } from "zod";
+var UseGenerateBuyTransactionArgsSchema = z23.object({
+  chainId: ChainIdSchema.pipe(z23.coerce.string()),
   collectionAddress: AddressSchema,
-  marketplace: z21.nativeEnum(MarketplaceKind),
-  ordersData: z21.array(
-    z21.object({
-      orderId: z21.string(),
-      quantity: z21.string(),
-      marketplace: z21.string()
+  marketplace: z23.nativeEnum(MarketplaceKind),
+  ordersData: z23.array(
+    z23.object({
+      orderId: z23.string(),
+      quantity: z23.string(),
+      marketplace: z23.string()
     })
   ),
-  walletType: z21.nativeEnum(WalletKind).optional(),
+  walletType: z23.nativeEnum(WalletKind).optional(),
   query: QueryArgSchema
 });
 var fetchGenerateBuyTransaction = async (args, config) => {
@@ -1456,7 +1572,7 @@ var fetchGenerateBuyTransaction = async (args, config) => {
   }).then((data) => data.steps);
 };
 var generateBuyTransactionOptions = (args, config) => {
-  return queryOptions17({
+  return queryOptions19({
     queryKey: ["generateBuyTransaction", args],
     queryFn: () => fetchGenerateBuyTransaction(args, config),
     ...args.query
@@ -1465,17 +1581,66 @@ var generateBuyTransactionOptions = (args, config) => {
 var useGenerateBuyTransaction = (args) => {
   const { address } = useAccount3();
   const config = useConfig();
-  return useQuery17(
+  return useQuery19(
     // biome-ignore lint/style/noNonNullAssertion: <explanation>
     generateBuyTransactionOptions({ buyer: address, ...args }, config)
   );
 };
 
 // src/react/_internal/transaction-machine/execute-transaction.ts
-import { avalanche } from "viem/chains";
-var debug = (message, data) => {
-  console.debug(`[TransactionMachine] ${message}`, data || "");
+import { avalanche, optimism } from "viem/chains";
+
+// src/react/_internal/transaction-machine/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/transaction-machine/execute-transaction.ts
 var TransactionMachine = class {
   constructor(config, walletClient, publicClient, openSelectPaymentModal, switchChainFn) {
     this.config = config;
@@ -1484,19 +1649,21 @@ var TransactionMachine = class {
     this.openSelectPaymentModal = openSelectPaymentModal;
     this.switchChainFn = switchChainFn;
     this.currentState = "IDLE" /* IDLE */;
+    this.logger = createLogger("TransactionMachine");
     this.marketplaceClient = getMarketplaceClient(
       config.config.chainId,
       config.config.sdkConfig
     );
   }
   currentState;
+  logger;
   marketplaceClient;
   memoizedSteps = null;
   lastProps = null;
   getAccount() {
     const account = this.walletClient.account;
     if (!account) {
-      throw new Error("Account not connected");
+      throw new NoWalletConnectedError();
     }
     return account;
   }
@@ -1507,7 +1674,8 @@ var TransactionMachine = class {
     const collection = this.config.config.marketplaceConfig.collections.find(
       (collection2) => collection2.collectionAddress.toLowerCase() === collectionAddress.toLowerCase() && this.getChainId() === Number(collection2.chainId)
     );
-    const receiver = this.getChainId() === avalanche.id ? avalancheAndOptimismPlatformFeeRecipient : defaultPlatformFeeRecipient;
+    const avalancheOrOptimism = this.getChainId() === avalanche.id || this.getChainId() === optimism.id;
+    const receiver = avalancheOrOptimism ? avalancheAndOptimismPlatformFeeRecipient : defaultPlatformFeeRecipient;
     const percentageToBPS = (percentage) => Number(percentage) * 1e4 / 100;
     return {
       amount: percentageToBPS(
@@ -1523,79 +1691,90 @@ var TransactionMachine = class {
     type,
     props
   }) {
-    debug("Generating steps", { type, props });
+    this.logger.debug("Generating steps", { type, props });
     const { collectionAddress } = this.config.config;
     const address = this.getAccountAddress();
-    switch (type) {
-      case "BUY" /* BUY */:
-        return this.marketplaceClient.generateBuyTransaction({
-          collectionAddress,
-          buyer: address,
-          walletType: this.config.config.walletKind,
-          marketplace: props.marketplace,
-          ordersData: [
-            {
-              orderId: props.orderId,
-              quantity: props.quantity || "1"
-            }
-          ],
-          additionalFees: [this.getMarketplaceFee(collectionAddress)]
-        }).then((resp) => resp.steps);
-      case "SELL" /* SELL */:
-        return this.marketplaceClient.generateSellTransaction({
-          collectionAddress,
-          seller: address,
-          walletType: this.config.config.walletKind,
-          marketplace: props.marketplace,
-          ordersData: [
-            {
-              orderId: props.orderId,
-              quantity: props.quantity || "1"
-            }
-          ],
-          additionalFees: []
-        }).then((resp) => resp.steps);
-      case "LISTING" /* LISTING */:
-        return this.marketplaceClient.generateListingTransaction({
-          collectionAddress,
-          owner: address,
-          walletType: this.config.config.walletKind,
-          contractType: props.contractType,
-          orderbook: "sequence_marketplace_v2" /* sequence_marketplace_v2 */,
-          listing: props.listing
-        }).then((resp) => resp.steps);
-      case "OFFER" /* OFFER */:
-        return this.marketplaceClient.generateOfferTransaction({
-          collectionAddress,
-          maker: address,
-          walletType: this.config.config.walletKind,
-          contractType: props.contractType,
-          orderbook: "sequence_marketplace_v2" /* sequence_marketplace_v2 */,
-          offer: props.offer
-        }).then((resp) => resp.steps);
-      case "CANCEL" /* CANCEL */:
-        return this.marketplaceClient.generateCancelTransaction({
-          collectionAddress,
-          maker: address,
-          marketplace: props.marketplace,
-          orderId: props.orderId
-        }).then((resp) => resp.steps);
-      default:
-        throw new Error(`Unknown transaction type: ${type}`);
+    try {
+      switch (type) {
+        case "BUY" /* BUY */:
+          return await this.marketplaceClient.generateBuyTransaction({
+            collectionAddress,
+            buyer: address,
+            walletType: this.config.config.walletKind,
+            marketplace: props.marketplace,
+            ordersData: [
+              {
+                orderId: props.orderId,
+                quantity: props.quantity || "1"
+              }
+            ],
+            additionalFees: [this.getMarketplaceFee(collectionAddress)]
+          }).then((resp) => resp.steps);
+        case "SELL" /* SELL */:
+          return await this.marketplaceClient.generateSellTransaction({
+            collectionAddress,
+            seller: address,
+            walletType: this.config.config.walletKind,
+            marketplace: props.marketplace,
+            ordersData: [
+              {
+                orderId: props.orderId,
+                quantity: props.quantity || "1"
+              }
+            ],
+            additionalFees: []
+          }).then((resp) => resp.steps);
+        case "LISTING" /* LISTING */:
+          return await this.marketplaceClient.generateListingTransaction({
+            collectionAddress,
+            owner: address,
+            walletType: this.config.config.walletKind,
+            contractType: props.contractType,
+            orderbook: "sequence_marketplace_v2" /* sequence_marketplace_v2 */,
+            listing: props.listing
+          }).then((resp) => resp.steps);
+        case "OFFER" /* OFFER */:
+          return await this.marketplaceClient.generateOfferTransaction({
+            collectionAddress,
+            maker: address,
+            walletType: this.config.config.walletKind,
+            contractType: props.contractType,
+            orderbook: "sequence_marketplace_v2" /* sequence_marketplace_v2 */,
+            offer: props.offer
+          }).then((resp) => resp.steps);
+        case "CANCEL" /* CANCEL */:
+          return await this.marketplaceClient.generateCancelTransaction({
+            collectionAddress,
+            maker: address,
+            marketplace: props.marketplace,
+            orderId: props.orderId
+          }).then((resp) => resp.steps);
+        default:
+          throw new UnknownTransactionTypeError(type);
+      }
+    } catch (error) {
+      if (error instanceof WebrpcError) {
+        throw new StepGenerationError(type, error);
+      }
+      throw error;
     }
   }
   clearMemoizedSteps() {
-    debug("Clearing memoized steps");
+    this.logger.debug("Clearing memoized steps");
     this.memoizedSteps = null;
     this.lastProps = null;
   }
   async transition(newState) {
-    debug(`State transition: ${this.currentState} -> ${newState}`);
+    this.logger.state(this.currentState, newState);
     this.currentState = newState;
     this.clearMemoizedSteps();
   }
   getChainId() {
-    return this.walletClient.chain?.id;
+    const chainId = this.walletClient.chain?.id;
+    if (!chainId) {
+      throw new ChainIdUnavailableError();
+    }
+    return chainId;
   }
   getChainForTransaction() {
     const chainId = this.config.config.chainId;
@@ -1607,38 +1786,37 @@ var TransactionMachine = class {
     return this.getChainId() === Number(this.config.config.chainId);
   }
   async switchChain() {
+    this.logger.debug("Checking chain", {
+      currentChain: this.getChainId(),
+      targetChain: Number(this.config.config.chainId)
+    });
     if (!this.isOnCorrectChain()) {
+      const currentChain = this.getChainId();
+      const targetChain = Number(this.config.config.chainId);
       await this.transition("SWITCH_CHAIN" /* SWITCH_CHAIN */);
-      await this.switchChainFn(this.config.config.chainId);
-      await this.walletClient.switchChain({
-        id: Number(this.config.config.chainId)
-      });
-      debug("Switched chain");
+      try {
+        await this.switchChainFn(this.config.config.chainId);
+        await this.walletClient.switchChain({
+          id: Number(this.config.config.chainId)
+        });
+        this.logger.debug("Switched chain");
+      } catch (error) {
+        throw new ChainSwitchError(currentChain, targetChain);
+      }
     }
   }
-  async start({ props }) {
-    debug("Starting transaction", props);
-    try {
-      await this.transition("CHECKING_STEPS" /* CHECKING_STEPS */);
-      const { type } = this.config.config;
-      const steps = await this.generateSteps({
-        type,
-        props
-      });
-      for (const step of steps) {
-        try {
-          await this.executeStep({ step, props });
-        } catch (error) {
-          await this.transition("ERROR" /* ERROR */);
-          throw error;
-        }
-      }
-      await this.transition("SUCCESS" /* SUCCESS */);
-    } catch (error) {
-      debug("Transaction failed", error);
-      await this.transition("ERROR" /* ERROR */);
-      throw error;
+  async start(props) {
+    this.logger.debug("Starting transaction", props);
+    await this.transition("CHECKING_STEPS" /* CHECKING_STEPS */);
+    const { type } = this.config.config;
+    const steps = await this.generateSteps({
+      type,
+      props
+    });
+    for (const step of steps) {
+      await this.executeStep({ step, props });
     }
+    await this.transition("SUCCESS" /* SUCCESS */);
   }
   async handleTransactionSuccess(hash) {
     if (!hash) {
@@ -1647,36 +1825,46 @@ var TransactionMachine = class {
     }
     await this.transition("CONFIRMING" /* CONFIRMING */);
     this.config.onTransactionSent?.(hash);
-    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
-    debug("Transaction confirmed", receipt);
-    await this.transition("SUCCESS" /* SUCCESS */);
-    this.config.onSuccess?.(hash);
+    try {
+      const receipt = await this.publicClient.waitForTransactionReceipt({
+        hash
+      });
+      this.logger.debug("Transaction confirmed", receipt);
+      await this.transition("SUCCESS" /* SUCCESS */);
+      this.config.onSuccess?.(hash);
+    } catch (error) {
+      throw new TransactionReceiptError(hash, error);
+    }
   }
   async executeTransaction(step) {
-    const transactionData = {
-      account: this.getAccount(),
-      chain: this.getChainForTransaction(),
-      to: step.to,
-      data: step.data,
-      value: BigInt(step.value || "0")
-    };
-    debug("Executing transaction", transactionData);
-    const hash = await this.walletClient.sendTransaction(transactionData);
-    debug("Transaction submitted", { hash });
-    await this.handleTransactionSuccess(hash);
-    return hash;
+    try {
+      const transactionData = {
+        account: this.getAccount(),
+        chain: this.getChainForTransaction(),
+        to: step.to,
+        data: step.data,
+        value: BigInt(step.value || "0")
+      };
+      this.logger.debug("Executing transaction", transactionData);
+      const hash = await this.walletClient.sendTransaction(transactionData);
+      this.logger.debug("Transaction submitted", { hash });
+      await this.handleTransactionSuccess(hash);
+      return hash;
+    } catch (error) {
+      throw new StepExecutionError(step.id, error);
+    }
   }
   async executeSignature(step) {
-    debug("Executing signature", { stepId: step.id });
-    let signature;
+    this.logger.debug("Executing signature", { stepId: step.id });
     if (!step.post) {
-      throw new Error("Missing post step");
+      throw new MissingPostStepError();
+    }
+    let signature;
+    if (!step.signature) {
+      throw new MissingSignatureDataError();
     }
     switch (step.id) {
       case "signEIP712" /* signEIP712 */:
-        if (!step.signature) {
-          throw new Error("Missing signature data");
-        }
         signature = await this.walletClient.signTypedData({
           domain: step.signature.domain,
           types: step.signature.types,
@@ -1692,7 +1880,7 @@ var TransactionMachine = class {
         });
         break;
       default:
-        throw new Error(`Invalid signature step: ${step.id}`);
+        throw new InvalidSignatureStepError(step.id);
     }
     await this.marketplaceClient.execute({
       signature,
@@ -1706,12 +1894,15 @@ var TransactionMachine = class {
       this.openSelectPaymentModal({
         ...settings,
         onSuccess: async (hash) => {
-          await this.handleTransactionSuccess(hash);
-          resolve();
+          try {
+            await this.handleTransactionSuccess(hash);
+            resolve();
+          } catch (error) {
+            reject(error);
+          }
         },
         onError: (error) => {
-          this.config.onError?.(error);
-          reject(error);
+          reject(new PaymentModalError(error));
         }
       });
     });
@@ -1720,86 +1911,111 @@ var TransactionMachine = class {
     step,
     props
   }) {
-    this.transition("EXECUTING_TRANSACTION" /* EXECUTING_TRANSACTION */);
-    const [checkoutOptions, orders] = await Promise.all([
-      this.marketplaceClient.checkoutOptionsMarketplace({
-        wallet: this.getAccountAddress(),
-        orders: [
-          {
-            contractAddress: this.config.config.collectionAddress,
-            orderId: props.orderId,
-            marketplace: props.marketplace
-          }
-        ],
-        additionalFee: Number(
-          this.getMarketplaceFee(this.config.config.collectionAddress).amount
-        )
-      }),
-      this.marketplaceClient.getOrders({
-        input: [
-          {
-            orderId: props.orderId,
-            marketplace: props.marketplace,
-            contractAddress: this.config.config.collectionAddress
-          }
-        ]
-      })
-    ]);
-    const order = orders.orders[0];
-    await this.openPaymentModalWithPromise({
-      // biome-ignore lint/style/noNonNullAssertion: <explanation>
-      chain: this.getChainId(),
-      collectibles: [
-        {
-          tokenId: order.tokenId,
-          quantity: props.quantity,
-          decimals: props.collectableDecimals
+    try {
+      await this.transition("EXECUTING_TRANSACTION" /* EXECUTING_TRANSACTION */);
+      try {
+        const [checkoutOptions, orders] = await Promise.all([
+          this.marketplaceClient.checkoutOptionsMarketplace({
+            wallet: this.getAccountAddress(),
+            orders: [
+              {
+                contractAddress: this.config.config.collectionAddress,
+                orderId: props.orderId,
+                marketplace: props.marketplace
+              }
+            ],
+            additionalFee: Number(
+              this.getMarketplaceFee(this.config.config.collectionAddress).amount
+            )
+          }).catch((error) => {
+            throw new CheckoutOptionsError(error);
+          }),
+          this.marketplaceClient.getOrders({
+            input: [
+              {
+                orderId: props.orderId,
+                marketplace: props.marketplace,
+                contractAddress: this.config.config.collectionAddress
+              }
+            ]
+          }).catch((error) => {
+            throw new OrdersFetchError(props.orderId, error);
+          })
+        ]);
+        const order = orders.orders[0];
+        if (!order) {
+          throw new OrderNotFoundError(props.orderId);
         }
-      ],
-      currencyAddress: order.priceCurrencyAddress,
-      price: order.priceAmount,
-      targetContractAddress: step.to,
-      txData: step.data,
-      collectionAddress: this.config.config.collectionAddress,
-      recipientAddress: this.getAccountAddress(),
-      enableMainCurrencyPayment: true,
-      enableSwapPayments: !!checkoutOptions.options?.swap?.includes(
-        "zerox" /* zerox */
-      ),
-      creditCardProviders: checkoutOptions?.options.nftCheckout || []
-    });
+        const paymentModalProps = {
+          chain: this.getChainId(),
+          collectibles: [
+            {
+              tokenId: order.tokenId,
+              quantity: props.quantity,
+              decimals: props.collectableDecimals
+            }
+          ],
+          currencyAddress: order.priceCurrencyAddress,
+          price: order.priceAmount,
+          targetContractAddress: step.to,
+          txData: step.data,
+          collectionAddress: this.config.config.collectionAddress,
+          recipientAddress: this.getAccountAddress(),
+          enableMainCurrencyPayment: true,
+          enableSwapPayments: !!checkoutOptions.options?.swap?.includes(
+            "zerox" /* zerox */
+          ),
+          creditCardProviders: checkoutOptions?.options.nftCheckout || []
+        };
+        this.logger.debug("Opening payment modal", paymentModalProps);
+        await this.openPaymentModalWithPromise(paymentModalProps);
+      } catch (error) {
+        if (error instanceof TransactionError) {
+          throw error;
+        }
+        throw new PaymentModalTransactionError(step.id, error);
+      }
+    } catch (error) {
+      if (error instanceof TransactionError) {
+        throw error;
+      }
+      throw new StepExecutionError(step.id, error);
+    }
   }
   async executeStep({
     step,
     props
   }) {
-    debug("Executing step", { stepId: step.id });
-    if (!step.to && !step.signature) {
-      throw new Error("Invalid step data");
-    }
     try {
+      this.logger.debug("Executing step", { stepId: step.id });
+      if (!step.to && !step.signature) {
+        throw new MissingStepDataError();
+      }
       await this.switchChain();
       if (step.id === "buy" /* buy */) {
         await this.executeBuyStep({ step, props });
-      } else if (step.signature) {
+        return;
+      }
+      if (step.signature) {
         await this.executeSignature(step);
-      } else if (step.id === "tokenApproval" /* tokenApproval */) {
-        const hash = await this.executeTransaction(step);
-        return { hash };
-      } else {
-        const hash = await this.executeTransaction(step);
+        return;
+      }
+      const hash = await this.executeTransaction(step);
+      if (step.id !== "tokenApproval" /* tokenApproval */) {
         this.config.onSuccess?.(hash);
-        return { hash };
       }
+      return { hash };
     } catch (error) {
-      this.config.onError?.(error);
-      throw error;
+      if (error instanceof TransactionError) {
+        throw error;
+      }
+      throw new StepExecutionError(step.id, error);
     }
   }
   async getTransactionSteps(props) {
-    debug("Getting transaction steps", props);
+    this.logger.debug("Getting transaction steps", props);
     if (this.memoizedSteps && this.lastProps && JSON.stringify(props) === JSON.stringify(this.lastProps)) {
-      debug("Returning memoized steps");
+      this.logger.debug("Returning memoized steps");
       return this.memoizedSteps;
     }
     const type = this.config.config.type;
@@ -1809,14 +2025,14 @@ var TransactionMachine = class {
     });
     const executionStep = steps.pop();
     if (!executionStep) {
-      throw new Error("No steps found");
+      throw new NoStepsFoundError();
     }
     if (executionStep.id === "tokenApproval" /* tokenApproval */) {
-      throw new Error("No execution step found, only approval step");
+      throw new NoExecutionStepError();
     }
     const approvalStep = steps.pop();
     if (steps.length > 0) {
-      throw new Error("Unexpected steps found");
+      throw new UnexpectedStepsError();
     }
     this.lastProps = props;
     this.memoizedSteps = {
@@ -1836,7 +2052,7 @@ var TransactionMachine = class {
         execute: () => this.executeStep({ step: executionStep, props })
       }
     };
-    debug("Generated new transaction steps", this.memoizedSteps);
+    this.logger.debug("Generated new transaction steps", this.memoizedSteps);
     return this.memoizedSteps;
   }
 };
@@ -1862,7 +2078,16 @@ 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", children: message }),
+    /* @__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" })
   ] });
@@ -1965,42 +2190,80 @@ var switchChainModal_default = SwitchChainModal;
 
 // src/react/_internal/transaction-machine/useTransactionMachine.ts
 var useTransactionMachine = (config, onSuccess, onError, onTransactionSent) => {
-  const { data: walletClient } = useWalletClient();
+  const { data: walletClient, isLoading: walletClientIsLoading } = useWalletClient();
   const { show: showSwitchChainModal } = useSwitchChainModal();
   const sdkConfig = useConfig();
-  const { data: marketplaceConfig, error: marketplaceError } = useMarketplaceConfig();
+  const {
+    data: marketplaceConfig,
+    error: marketplaceError,
+    isLoading: marketplaceConfigIsLoading
+  } = useMarketplaceConfig();
   const { openSelectPaymentModal } = useSelectPaymentModal();
   const { chains } = useSwitchChain2();
-  const { connector } = useAccount4();
+  const { connector, isConnected } = useAccount4();
   const walletKind = connector?.id === "sequence" ? "sequence" /* sequence */ : "unknown" /* unknown */;
+  if (!isConnected) {
+    return { machine: null, error: null, isLoading: false };
+  }
+  if (walletClientIsLoading || marketplaceConfigIsLoading) {
+    return { machine: null, error: null, isLoading: true };
+  }
   if (marketplaceError) {
-    throw marketplaceError;
+    const error = new TransactionError("Marketplace config error", {
+      cause: marketplaceError
+    });
+    onError?.(error);
+    return { machine: null, error };
   }
-  if (!walletClient || !marketplaceConfig) return null;
-  return new TransactionMachine(
+  if (!walletClient) {
+    const error = new NoWalletConnectedError();
+    onError?.(error);
+    return { machine: null, error };
+  }
+  if (!marketplaceConfig) {
+    const error = new NoMarketplaceConfigError();
+    onError?.(error);
+    return { machine: null, error };
+  }
+  const machine = new TransactionMachine(
     {
       config: { sdkConfig, marketplaceConfig, walletKind, chains, ...config },
       onSuccess,
-      onError,
       onTransactionSent
     },
     walletClient,
     getPublicRpcClient(config.chainId),
     openSelectPaymentModal,
-    async (chainId) => {
-      return new Promise((resolve, reject) => {
-        showSwitchChainModal({
-          chainIdToSwitchTo: Number(chainId),
-          onSuccess: () => {
-            resolve();
-          },
-          onError: (error) => {
-            reject(error);
-          }
-        });
+    async (chainId) => new Promise((resolve, reject) => {
+      showSwitchChainModal({
+        chainIdToSwitchTo: Number(chainId),
+        onSuccess: resolve,
+        onError: reject
       });
-    }
+    })
   );
+  return {
+    machine: {
+      getTransactionSteps: async (props) => {
+        try {
+          return await machine.getTransactionSteps(props);
+        } catch (e) {
+          const error = e;
+          onError?.(error);
+        }
+      },
+      start: async (props) => {
+        try {
+          await machine.start(props);
+        } catch (e) {
+          const error = e;
+          onError?.(error);
+        }
+      }
+    },
+    error: null,
+    isLoading: false
+  };
 };
 
 // src/react/hooks/useCancelOrder.tsx
@@ -2010,7 +2273,7 @@ var useCancelOrder = ({
   onTransactionSent,
   ...config
 }) => {
-  const machine = useTransactionMachine(
+  const { machine, isLoading } = useTransactionMachine(
     {
       ...config,
       type: "CANCEL" /* CANCEL */
@@ -2020,10 +2283,11 @@ var useCancelOrder = ({
     onTransactionSent
   );
   return {
-    cancel: (props) => machine?.start({ props }),
+    cancel: (props) => machine?.start(props),
     onError,
     onSuccess,
-    onTransactionSent
+    onTransactionSent,
+    isLoading
   };
 };
 
@@ -2034,7 +2298,7 @@ var useBuyCollectable = ({
   onTransactionSent,
   ...config
 }) => {
-  const machine = useTransactionMachine(
+  const { machine, error, isLoading } = useTransactionMachine(
     {
       ...config,
       type: "BUY" /* BUY */
@@ -2044,10 +2308,12 @@ var useBuyCollectable = ({
     onTransactionSent
   );
   return {
-    buy: (props) => machine?.start({ props }),
-    onError,
-    onSuccess,
-    onTransactionSent
+    buy: (props) => {
+      if (!machine || isLoading) return;
+      machine.start(props);
+    },
+    isLoading,
+    error
   };
 };
 
@@ -2081,8 +2347,12 @@ export {
   useListCollectibles,
   listOffersForCollectibleOptions,
   useListOffersForCollectible,
+  countOffersForCollectibleOptions,
+  useCountOffersForCollectible,
   listListingsForCollectibleOptions,
   useListListingsForCollectible,
+  countListingsForCollectibleOptions,
+  useCountListingsForCollectible,
   lowestListingOptions,
   useLowestListing,
   marketplaceConfigOptions,
@@ -2113,4 +2383,4 @@ export {
   useCancelOrder,
   useBuyCollectable
 };
-//# sourceMappingURL=chunk-O7UQGT43.js.map
+//# sourceMappingURL=chunk-6LQST3KZ.js.map