@0xsequence/marketplace-sdk 0.4.4 → 0.4.6

package/dist/{chunk-GLOIEUWC.js → chunk-36NGHJH5.js}

@@ -1,12 +1,11 @@
 "use client"
 import {
-  createLogger,
   useSwitchChainModal,
   useWallet
-} from "./chunk-LHN6EBLM.js";
+} from "./chunk-3C2MT5TM.js";
 import {
   getPublicRpcClient
-} from "./chunk-4VS5NKDD.js";
+} from "./chunk-LTHX6RXH.js";
 import {
   EIP2981_ABI
 } from "./chunk-3OHM45R3.js";
@@ -19,7 +18,7 @@ import {
   CollectableIdSchema,
   PROVIDER_ID,
   QueryArgSchema
-} from "./chunk-ZEKRTFBU.js";
+} from "./chunk-DNVERQ5J.js";
 import {
   CollectibleStatus,
   CollectionStatus,
@@ -39,7 +38,6 @@ import {
   TransactionOnRampProvider,
   TransactionSwapProvider,
   WalletKind,
-  WebrpcError,
   balanceQueries,
   builderMarketplaceApi,
   collectableKeys,
@@ -50,33 +48,15 @@ import {
   getMarketplaceClient,
   getMetadataClient,
   getQueryClient
-} from "./chunk-URX7ZHX4.js";
+} from "./chunk-QVOUL555.js";
 import {
   BaseError,
-  ChainSwitchError,
   ChainSwitchUserRejectedError,
-  CheckoutOptionsError,
-  InvalidCurrencyOptionsError,
   MarketplaceConfigFetchError,
-  MissingSignatureDataError,
-  MissingStepDataError,
-  NoExecutionStepError,
-  NoMarketplaceConfigError,
-  NoStepsFoundError,
   NoWalletConnectedError,
-  OrderNotFoundError,
-  OrdersFetchError,
-  PaymentModalError,
-  PaymentModalTransactionError,
   ProjectNotFoundError,
-  StepExecutionError,
-  StepGenerationError,
-  TransactionError,
-  TransactionReceiptError,
-  UnexpectedStepsError,
-  UnknownTransactionTypeError,
   WalletInstanceNotFoundError
-} from "./chunk-DNDPYQKV.js";
+} from "./chunk-WM4RGBFQ.js";
 
 // src/react/hooks/useBalanceOfCollectible.tsx
 import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
@@ -94,15 +74,22 @@ var MarketplaceSdkProviderNotFoundError = class extends BaseError {
 };
 
 // src/react/provider.tsx
+import { QueryClientProvider } from "@tanstack/react-query";
 import { createContext } from "react";
 import "@0xsequence/design-system/styles.css";
 import { jsx } from "react/jsx-runtime";
 var MarketplaceSdkContext = createContext({});
+function MarketplaceQueryClientProvider({
+  children
+}) {
+  const queryClient = getQueryClient();
+  return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children });
+}
 function MarketplaceProvider({
   config,
   children
 }) {
-  return /* @__PURE__ */ jsx(MarketplaceSdkContext.Provider, { value: config, children: /* @__PURE__ */ jsx("div", { id: PROVIDER_ID, children }) });
+  return /* @__PURE__ */ jsx(MarketplaceQueryClientProvider, { children: /* @__PURE__ */ jsx(MarketplaceSdkContext.Provider, { value: config, children: /* @__PURE__ */ jsx("div", { id: PROVIDER_ID, children }) }) });
 }
 
 // src/react/hooks/useConfig.tsx
@@ -787,7 +774,7 @@ var useCollection = (args) => {
 
 // src/react/hooks/useCurrencies.tsx
 import { queryOptions as queryOptions5, useQuery as useQuery5 } from "@tanstack/react-query";
-import { toHex, zeroAddress } from "viem";
+import { zeroAddress } from "viem";
 import { z as z6 } from "zod";
 var ChainIdCoerce = ChainIdSchema.transform((val) => val.toString());
 var UseCurrenciesArgsSchema = z6.object({
@@ -809,19 +796,21 @@ var fetchCurrencies = async (chainId, config) => {
 };
 var selectCurrencies = (data, args) => {
   const argsParsed = UseCurrenciesArgsSchema.parse(args);
+  let filteredData = data;
+  if (!argsParsed.includeNativeCurrency) {
+    filteredData = filteredData.filter((currency) => !currency.nativeCurrency);
+  }
   if (argsParsed.currencyOptions) {
-    if (!argsParsed.currencyOptions) {
-      throw new InvalidCurrencyOptionsError(argsParsed.currencyOptions);
-    }
-    return data.filter(
-      (currency) => argsParsed.currencyOptions?.includes(toHex(currency.contractAddress)) || // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
-      currency.nativeCurrency == argsParsed.includeNativeCurrency || currency.defaultChainCurrency
+    const lowerCaseCurrencyOptions = argsParsed.currencyOptions.map(
+      (option) => option.toLowerCase()
+    );
+    filteredData = filteredData.filter(
+      (currency) => lowerCaseCurrencyOptions.includes(
+        currency.contractAddress.toLowerCase()
+      )
     );
   }
-  if (argsParsed.includeNativeCurrency) {
-    return data;
-  }
-  return data.filter((currency) => !currency.nativeCurrency);
+  return filteredData;
 };
 var currenciesOptions = (args, config) => {
   return queryOptions5({
@@ -1597,28 +1586,6 @@ var useGenerateBuyTransaction = (args) => {
 // src/react/hooks/useCancelOrder.tsx
 import { useState } from "react";
 
-// src/react/hooks/useGetReceiptFromHash.tsx
-import { usePublicClient } from "wagmi";
-import { useCallback } from "react";
-var useGetReceiptFromHash = () => {
-  const publicClient = usePublicClient();
-  const waitForReceipt = useCallback(
-    async (transactionHash) => {
-      if (!publicClient) {
-        throw new Error("Public client not found");
-      }
-      const receipt = await publicClient.waitForTransactionReceipt({
-        hash: transactionHash
-      });
-      return receipt;
-    },
-    [publicClient]
-  );
-  return {
-    waitForReceipt
-  };
-};
-
 // src/react/hooks/useCancelTransactionSteps.tsx
 var useCancelTransactionSteps = ({
   collectionAddress,
@@ -1633,7 +1600,6 @@ var useCancelTransactionSteps = ({
   const walletIsInitialized = wallet && !isLoading && !isError;
   const sdkConfig = useConfig();
   const marketplaceClient = getMarketplaceClient(chainId, sdkConfig);
-  const { waitForReceipt } = useGetReceiptFromHash();
   const { generateCancelTransactionAsync } = useGenerateCancelTransaction({
     chainId
   });
@@ -1683,13 +1649,13 @@ var useCancelTransactionSteps = ({
       } else {
         console.debug("onError callback not provided:", error);
       }
-      throw error;
     }
   };
   const cancelOrder = async ({
     orderId,
     marketplace
   }) => {
+    const queryClient = getQueryClient();
     if (!walletIsInitialized) {
       throw new WalletInstanceNotFoundError();
     }
@@ -1718,10 +1684,11 @@ var useCancelTransactionSteps = ({
       if (transactionStep && wallet) {
         hash = await executeTransaction({ transactionStep });
         if (hash) {
-          await waitForReceipt(hash);
+          await wallet.handleConfirmTransactionStep(hash, Number(chainId));
           if (onSuccess && typeof onSuccess === "function") {
             onSuccess({ hash });
           }
+          queryClient.invalidateQueries();
           setSteps((prev) => ({
             ...prev,
             isExecuting: false
@@ -1733,6 +1700,7 @@ var useCancelTransactionSteps = ({
         if (onSuccess && typeof onSuccess === "function") {
           onSuccess({ orderId: reservoirOrderId });
         }
+        queryClient.invalidateQueries();
         setSteps((prev) => ({
           ...prev,
           isExecuting: false
@@ -1746,7 +1714,6 @@ var useCancelTransactionSteps = ({
       if (onError && typeof onError === "function") {
         onError(error);
       }
-      throw error;
     }
   };
   const executeTransaction = async ({
@@ -1788,561 +1755,36 @@ var useCancelOrder = ({
     isExecuting: false,
     execute: () => Promise.resolve()
   });
-  const { cancelOrder } = useCancelTransactionSteps({
+  const [cancellingOrderId, setCancellingOrderId] = useState(
+    null
+  );
+  const { cancelOrder: cancelOrderBase } = useCancelTransactionSteps({
     collectionAddress,
     chainId,
-    onSuccess,
-    onError,
-    setSteps
-  });
-  return {
-    cancelOrder,
-    isExecuting: steps.isExecuting
-  };
-};
-
-// src/react/_internal/transaction-machine/execute-transaction.ts
-import { avalanche, optimism } from "viem/chains";
-var TransactionMachine = class {
-  constructor(config, wallet, openSelectPaymentModal, switchChainFn, onPaymentModalLoaded) {
-    this.config = config;
-    this.wallet = wallet;
-    this.openSelectPaymentModal = openSelectPaymentModal;
-    this.switchChainFn = switchChainFn;
-    this.onPaymentModalLoaded = onPaymentModalLoaded;
-    this.currentState = "IDLE" /* IDLE */;
-    this.logger = createLogger("TransactionMachine");
-    this.marketplaceClient = getMarketplaceClient(
-      config.config.chainId,
-      config.config.sdkConfig
-    );
-    this.onPaymentModalLoaded = onPaymentModalLoaded;
-  }
-  currentState;
-  logger;
-  marketplaceClient;
-  memoizedSteps = null;
-  lastProps = null;
-  getMarketplaceFee(collectionAddress) {
-    const defaultFee = 2.5;
-    const defaultPlatformFeeRecipient = "0x858dB1cbF6D09D447C96A11603189b49B2D1C219";
-    const avalancheAndOptimismPlatformFeeRecipient = "0x400cdab4676c17aec07e8ec748a5fc3b674bca41";
-    const chainId = Number(this.config.config.chainId);
-    const collection = this.config.config.marketplaceConfig.collections.find(
-      (collection2) => collection2.collectionAddress.toLowerCase() === collectionAddress.toLowerCase() && chainId === Number(collection2.chainId)
-    );
-    const avalancheOrOptimism = chainId === avalanche.id || chainId === optimism.id;
-    const receiver = avalancheOrOptimism ? avalancheAndOptimismPlatformFeeRecipient : defaultPlatformFeeRecipient;
-    const percentageToBPS = (percentage) => Number(percentage) * 1e4 / 100;
-    return {
-      amount: percentageToBPS(
-        collection?.marketplaceFeePercentage || defaultFee
-      ).toString(),
-      receiver
-    };
-  }
-  async generateSteps({
-    type,
-    props
-  }) {
-    this.logger.debug("Generating steps", { type, props });
-    const { collectionAddress } = this.config.config;
-    const address = await this.wallet.address();
-    try {
-      switch (type) {
-        case "BUY" /* BUY */:
-          return await this.marketplaceClient.generateBuyTransaction({
-            collectionAddress,
-            buyer: address,
-            walletType: this.wallet.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.wallet.walletKind,
-            marketplace: props.marketplace,
-            ordersData: [
-              {
-                orderId: props.orderId,
-                quantity: props.quantity || "1"
-              }
-            ],
-            additionalFees: [this.getMarketplaceFee(collectionAddress)]
-          }).then((resp) => resp.steps);
-        case "LISTING" /* LISTING */:
-          if (!this.config.config.orderbookKind) {
-            this.config.config.orderbookKind = "sequence_marketplace_v2" /* sequence_marketplace_v2 */;
-          }
-          return await this.marketplaceClient.generateListingTransaction({
-            collectionAddress,
-            owner: address,
-            walletType: this.wallet.walletKind,
-            contractType: props.contractType,
-            orderbook: this.config.config.orderbookKind,
-            listing: props.listing
-          }).then((resp) => resp.steps);
-        case "OFFER" /* OFFER */:
-          if (!this.config.config.orderbookKind) {
-            this.config.config.orderbookKind = "sequence_marketplace_v2" /* sequence_marketplace_v2 */;
-          }
-          return await this.marketplaceClient.generateOfferTransaction({
-            collectionAddress,
-            maker: address,
-            walletType: this.wallet.walletKind,
-            contractType: props.contractType,
-            orderbook: this.config.config.orderbookKind,
-            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() {
-    this.logger.debug("Clearing memoized steps");
-    this.memoizedSteps = null;
-    this.lastProps = null;
-  }
-  async transition(newState) {
-    this.logger.state(this.currentState, newState);
-    this.currentState = newState;
-    this.clearMemoizedSteps();
-  }
-  async switchChain() {
-    this.logger.debug("Checking chain", {
-      currentChain: await this.wallet.getChainId(),
-      targetChain: Number(this.config.config.chainId)
-    });
-    const correctChain = await this.isOnCorrectChain();
-    if (!correctChain) {
-      const currentChain = await this.wallet.getChainId();
-      const targetChain = Number(this.config.config.chainId);
-      await this.transition("SWITCH_CHAIN" /* SWITCH_CHAIN */);
-      try {
-        if (this.wallet.isWaaS) {
-          await this.wallet.switchChain(targetChain);
-        } else {
-          await this.switchChainFn(this.config.config.chainId);
-        }
-        if (!this.isOnCorrectChain()) {
-          throw new Error("Chain switch verification failed");
-        }
-        this.logger.debug("Switched chain successfully");
-      } catch (error) {
-        this.logger.debug("Chain switch failed", error);
-        throw new ChainSwitchError(currentChain, targetChain);
-      }
-    }
-  }
-  async isOnCorrectChain() {
-    return await this.wallet.getChainId() === Number(this.config.config.chainId);
-  }
-  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, isApproval, orderId) {
-    if (!hash) {
-      await this.transition("SUCCESS" /* SUCCESS */);
-      this.config.onTransactionSent?.(void 0, orderId);
-      return;
-    }
-    await this.transition("CONFIRMING" /* CONFIRMING */);
-    if (!isApproval) {
-      this.config.onTransactionSent?.(hash);
-    }
-    try {
-      const receipt = await this.wallet.handleConfirmTransactionStep(
-        hash,
-        await this.wallet.getChainId()
-      );
-      this.logger.debug("Transaction confirmed", receipt);
-      await this.transition("SUCCESS" /* SUCCESS */);
-      if (isApproval) {
-        this.config.onApprovalSuccess?.(hash);
-      } else {
-        console.log("onSuccess", hash);
-        this.config.onSuccess?.(hash);
-      }
-    } catch (error) {
-      throw new TransactionReceiptError(hash, error);
-    }
-  }
-  async executeTransaction(step) {
-    try {
-      await this.switchChain();
-      if (step.id === "tokenApproval" /* tokenApproval */) {
-        await this.transition("TOKEN_APPROVAL" /* TOKEN_APPROVAL */);
-      }
-      this.logger.debug("Executing transaction", step);
-      const hash = await this.wallet.handleSendTransactionStep(
-        Number(this.config.config.chainId),
-        step
-      );
-      this.logger.debug("Transaction submitted", { hash });
-      await this.handleTransactionSuccess(
-        hash,
-        step.id === "tokenApproval" /* tokenApproval */
-      );
-      return hash;
-    } catch (error) {
-      throw new StepExecutionError(step.id, error);
-    }
-  }
-  async executeSignature(step) {
-    await this.switchChain();
-    if (!step.signature) {
-      throw new MissingSignatureDataError();
-    }
-    try {
-      const signature = await this.wallet.handleSignMessageStep(
-        step
-      );
-      const result = await this.marketplaceClient.execute({
-        signature,
-        executeType: "order" /* order */,
-        body: step.post?.body
-      });
-      await this.handleTransactionSuccess(void 0, false, result.orderId);
-    } catch (error) {
-      this.logger.error("Signature execution failed", { error });
-      throw new StepExecutionError(step.id, error);
-    }
-  }
-  openPaymentModalWithPromise(settings) {
-    return new Promise((resolve, reject) => {
-      this.openSelectPaymentModal({
-        ...settings,
-        onSuccess: async (hash) => {
-          try {
-            await this.handleTransactionSuccess(hash);
-            resolve();
-          } catch (error) {
-            reject(error);
-          }
-        },
-        onError: (error) => {
-          reject(new PaymentModalError(error));
-        }
-      });
-    });
-  }
-  async executeBuyStep({
-    step,
-    props
-  }) {
-    try {
-      await this.transition("EXECUTING_TRANSACTION" /* EXECUTING_TRANSACTION */);
-      try {
-        const [checkoutOptions, orders] = await Promise.all([
-          this.marketplaceClient.checkoutOptionsMarketplace({
-            wallet: await this.wallet.address(),
-            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);
-        }
-        const paymentModalProps = {
-          chain: this.config.config.chainId,
-          collectibles: [
-            {
-              tokenId: order.tokenId,
-              quantity: props.quantity,
-              decimals: props.collectableDecimals
-            }
-          ],
-          currencyAddress: order.priceCurrencyAddress,
-          price: step.value,
-          targetContractAddress: step.to,
-          txData: step.data,
-          collectionAddress: this.config.config.collectionAddress,
-          recipientAddress: await this.wallet.address(),
-          enableMainCurrencyPayment: true,
-          enableSwapPayments: !!checkoutOptions.options?.swap?.includes(
-            "zerox" /* zerox */
-          ),
-          creditCardProviders: checkoutOptions?.options.nftCheckout || []
-        };
-        this.logger.debug("Opening payment modal", paymentModalProps);
-        this.onPaymentModalLoaded?.();
-        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
-  }) {
-    try {
-      this.logger.debug("Executing step", { stepId: step.id });
-      if (!step.to && !step.signature) {
-        throw new MissingStepDataError();
-      }
-      if (step.id === "buy" /* buy */) {
-        await this.executeBuyStep({ step, props });
-        return;
-      }
-      if (step.signature) {
-        await this.executeSignature(step);
-        return;
-      }
-      const hash = await this.executeTransaction(step);
-      return { hash };
-    } catch (error) {
-      if (error instanceof TransactionError) {
-        throw error;
-      }
-      throw new StepExecutionError(step.id, error);
-    }
-  }
-  async getTransactionSteps(props) {
-    this.logger.debug("Getting transaction steps", props);
-    if (this.memoizedSteps && this.lastProps && JSON.stringify(props) === JSON.stringify(this.lastProps)) {
-      this.logger.debug("Returning memoized steps");
-      return this.memoizedSteps;
-    }
-    const type = this.config.config.type;
-    const steps = await this.generateSteps({
-      type,
-      props
-    });
-    const executionStep = steps.pop();
-    if (!executionStep) {
-      throw new NoStepsFoundError();
-    }
-    if (executionStep.id === "tokenApproval" /* tokenApproval */) {
-      throw new NoExecutionStepError();
-    }
-    const approvalStep = steps.pop();
-    if (steps.length > 0) {
-      throw new UnexpectedStepsError();
-    }
-    this.lastProps = props;
-    this.memoizedSteps = {
-      switchChain: {
-        isPending: !this.isOnCorrectChain(),
-        isExecuting: this.currentState === "SWITCH_CHAIN" /* SWITCH_CHAIN */,
-        execute: () => this.switchChain()
-      },
-      approval: {
-        isPending: Boolean(approvalStep),
-        isExecuting: this.currentState === "TOKEN_APPROVAL" /* TOKEN_APPROVAL */,
-        execute: () => approvalStep && this.executeStep({ step: approvalStep, props })
-      },
-      transaction: {
-        isPending: Boolean(executionStep),
-        isExecuting: this.currentState === "EXECUTING_TRANSACTION" /* EXECUTING_TRANSACTION */,
-        execute: () => this.executeStep({ step: executionStep, props })
-      }
-    };
-    this.logger.debug("Generated new transaction steps", this.memoizedSteps);
-    return this.memoizedSteps;
-  }
-};
-
-// src/react/_internal/transaction-machine/useTransactionMachine.ts
-import { useSelectPaymentModal } from "@0xsequence/kit-checkout";
-import { useAccount as useAccount4, useSwitchChain } from "wagmi";
-var useTransactionMachine = ({
-  config,
-  enabled,
-  onSuccess,
-  onError,
-  onTransactionSent,
-  onApprovalSuccess,
-  onPaymentModalLoaded
-}) => {
-  const { show: showSwitchChainModal } = useSwitchChainModal();
-  const sdkConfig = useConfig();
-  const {
-    data: marketplaceConfig,
-    error: marketplaceError,
-    isLoading: marketplaceConfigIsLoading
-  } = useMarketplaceConfig();
-  const { openSelectPaymentModal } = useSelectPaymentModal();
-  const { chains } = useSwitchChain();
-  const { isConnected } = useAccount4();
-  const {
-    wallet: walletInstance,
-    isLoading: walletClientIsLoading,
-    isError: walletClientIsError
-  } = useWallet();
-  if (!enabled) return { machine: null, error: null, isLoading: false };
-  if (!isConnected) {
-    return { machine: null, error: null, isLoading: false };
-  }
-  if (walletClientIsLoading || marketplaceConfigIsLoading) {
-    return { machine: null, error: null, isLoading: true };
-  }
-  if (marketplaceError) {
-    const error = new TransactionError("Marketplace config error", {
-      cause: marketplaceError
-    });
-    onError?.(error);
-    return { machine: null, error };
-  }
-  if (walletClientIsError) {
-    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,
-        chains,
-        ...config
-      },
-      onSuccess,
-      onTransactionSent,
-      onApprovalSuccess
+    onSuccess: (result) => {
+      setCancellingOrderId(null);
+      onSuccess?.(result);
     },
-    walletInstance,
-    openSelectPaymentModal,
-    async () => new Promise((resolve, reject) => {
-      showSwitchChainModal({
-        chainIdToSwitchTo: Number(config.chainId),
-        onSuccess: resolve,
-        onError: reject,
-        onClose: reject
-      });
-    }),
-    onPaymentModalLoaded
-  );
-  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);
-        }
-      }
+    onError: (error) => {
+      setCancellingOrderId(null);
+      onError?.(error);
     },
-    error: null,
-    isLoading: false
-  };
-};
-
-// src/react/hooks/useBuyCollectable.tsx
-import { useCallback as useCallback2 } from "react";
-var useBuyCollectable = ({
-  onSuccess,
-  onError,
-  onTransactionSent,
-  setPaymentLoadingModalOpen,
-  onPaymentModalLoaded,
-  enabled,
-  ...config
-}) => {
-  const machineConfig = {
-    ...config,
-    type: "BUY" /* BUY */
-  };
-  const { machine, error, isLoading } = useTransactionMachine({
-    config: machineConfig,
-    enabled,
-    onSuccess,
-    onError,
-    onTransactionSent,
-    onPaymentModalLoaded
+    setSteps
   });
-  const buy = useCallback2(
-    (props) => {
-      if (!machine || isLoading) return;
-      setPaymentLoadingModalOpen(true);
-      machine.start(props);
-    },
-    [setPaymentLoadingModalOpen, machine]
-  );
+  const cancelOrder = async (params) => {
+    setCancellingOrderId(params.orderId);
+    return cancelOrderBase(params);
+  };
   return {
-    buy,
-    isLoading,
-    error
+    cancelOrder,
+    isExecuting: steps.isExecuting,
+    cancellingOrderId
   };
 };
 
 export {
   MarketplaceSdkContext,
+  MarketplaceQueryClientProvider,
   MarketplaceProvider,
   useConfig,
   balanceOfCollectibleOptions,
@@ -2402,8 +1844,6 @@ export {
   fetchGenerateBuyTransaction,
   generateBuyTransactionOptions,
   useGenerateBuyTransaction,
-  useGetReceiptFromHash,
-  useCancelOrder,
-  useBuyCollectable
+  useCancelOrder
 };
-//# sourceMappingURL=chunk-GLOIEUWC.js.map
+//# sourceMappingURL=chunk-36NGHJH5.js.map