@0xsequence/marketplace-sdk 0.4.2 → 0.4.4

package/dist/{chunk-WBJKZOQ7.js → chunk-GLOIEUWC.js}

@@ -1,19 +1,12 @@
 "use client"
 import {
-  InfoIcon_default
-} from "./chunk-XXML5K3X.js";
-import {
-  alertMessageBox,
-  alertMessageBoxVariants,
-  closeButton,
-  dialogOverlay,
-  switchChainCta,
-  switchChainModalContent
-} from "./chunk-FI723DGL.js";
+  createLogger,
+  useSwitchChainModal,
+  useWallet
+} from "./chunk-LHN6EBLM.js";
 import {
-  getPresentableChainName,
   getPublicRpcClient
-} from "./chunk-ZWIRTV7A.js";
+} from "./chunk-4VS5NKDD.js";
 import {
   EIP2981_ABI
 } from "./chunk-3OHM45R3.js";
@@ -26,7 +19,7 @@ import {
   CollectableIdSchema,
   PROVIDER_ID,
   QueryArgSchema
-} from "./chunk-Q2BVDQ3G.js";
+} from "./chunk-ZEKRTFBU.js";
 import {
   CollectibleStatus,
   CollectionStatus,
@@ -57,10 +50,11 @@ import {
   getMarketplaceClient,
   getMetadataClient,
   getQueryClient
-} from "./chunk-S5IPE7TH.js";
+} from "./chunk-URX7ZHX4.js";
 import {
   BaseError,
   ChainSwitchError,
+  ChainSwitchUserRejectedError,
   CheckoutOptionsError,
   InvalidCurrencyOptionsError,
   MarketplaceConfigFetchError,
@@ -77,15 +71,12 @@ import {
   ProjectNotFoundError,
   StepExecutionError,
   StepGenerationError,
-  TransactionConfirmationError,
   TransactionError,
-  TransactionExecutionError,
   TransactionReceiptError,
-  TransactionSignatureError,
   UnexpectedStepsError,
   UnknownTransactionTypeError,
-  UserRejectedRequestError
-} from "./chunk-OPMDGQFB.js";
+  WalletInstanceNotFoundError
+} from "./chunk-DNDPYQKV.js";
 
 // src/react/hooks/useBalanceOfCollectible.tsx
 import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
@@ -1603,64 +1594,219 @@ var useGenerateBuyTransaction = (args) => {
   );
 };
 
-// src/react/_internal/transaction-machine/execute-transaction.ts
-import { avalanche, optimism } from "viem/chains";
+// src/react/hooks/useCancelOrder.tsx
+import { useState } from "react";
 
-// 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)
-      };
+// 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,
+  chainId,
+  callbacks,
+  setSteps,
+  onSuccess,
+  onError
+}) => {
+  const { show: showSwitchChainModal } = useSwitchChainModal();
+  const { wallet, isLoading, isError } = useWallet();
+  const walletIsInitialized = wallet && !isLoading && !isError;
+  const sdkConfig = useConfig();
+  const marketplaceClient = getMarketplaceClient(chainId, sdkConfig);
+  const { waitForReceipt } = useGetReceiptFromHash();
+  const { generateCancelTransactionAsync } = useGenerateCancelTransaction({
+    chainId
+  });
+  const getWalletChainId = async () => {
+    return await wallet.getChainId();
+  };
+  const switchChain = async () => {
+    await wallet.switchChain(Number(chainId));
+  };
+  const checkAndSwitchChain = async () => {
+    const walletChainId = await getWalletChainId();
+    const isWaaS = wallet?.isWaaS;
+    const chainIdMismatch = walletChainId !== Number(chainId);
+    return new Promise((resolve, reject) => {
+      if (chainIdMismatch) {
+        if (isWaaS) {
+          switchChain().then(resolve).catch(reject);
+        } else {
+          showSwitchChainModal({
+            chainIdToSwitchTo: chainId,
+            onSuccess: () => resolve({ chainId }),
+            onError: (error) => reject(error),
+            onClose: () => reject(new ChainSwitchUserRejectedError())
+          });
+        }
+      } else {
+        resolve({ chainId });
+      }
+    });
+  };
+  const getCancelSteps = async ({
+    orderId,
+    marketplace
+  }) => {
+    try {
+      const address = await wallet.address();
+      const steps = await generateCancelTransactionAsync({
+        collectionAddress,
+        maker: address,
+        marketplace,
+        orderId
+      });
+      return steps;
+    } catch (error) {
+      if (callbacks?.onError) {
+        callbacks.onError(error);
+      } else {
+        console.debug("onError callback not provided:", error);
+      }
+      throw error;
     }
-    if (Array.isArray(data)) {
-      return data.map((item) => this.formatData(item));
+  };
+  const cancelOrder = async ({
+    orderId,
+    marketplace
+  }) => {
+    if (!walletIsInitialized) {
+      throw new WalletInstanceNotFoundError();
     }
-    if (typeof data === "object" && data !== null) {
-      return Object.fromEntries(
-        Object.entries(data).map(([key, value]) => [
-          key,
-          this.formatData(value)
-        ])
+    try {
+      await checkAndSwitchChain();
+      setSteps((prev) => ({
+        ...prev,
+        isExecuting: true
+      }));
+      const cancelSteps = await getCancelSteps({
+        orderId,
+        marketplace
+      });
+      const transactionStep = cancelSteps?.find(
+        (step) => step.id === "cancel" /* cancel */
+      );
+      const signatureStep = cancelSteps?.find(
+        (step) => step.id === "signEIP712" /* signEIP712 */
       );
+      console.debug("transactionStep", transactionStep);
+      console.debug("signatureStep", signatureStep);
+      if (!transactionStep && !signatureStep) {
+        throw new Error("No transaction or signature step found");
+      }
+      let hash, reservoirOrderId;
+      if (transactionStep && wallet) {
+        hash = await executeTransaction({ transactionStep });
+        if (hash) {
+          await waitForReceipt(hash);
+          if (onSuccess && typeof onSuccess === "function") {
+            onSuccess({ hash });
+          }
+          setSteps((prev) => ({
+            ...prev,
+            isExecuting: false
+          }));
+        }
+      }
+      if (signatureStep) {
+        reservoirOrderId = await executeSignature({ signatureStep });
+        if (onSuccess && typeof onSuccess === "function") {
+          onSuccess({ orderId: reservoirOrderId });
+        }
+        setSteps((prev) => ({
+          ...prev,
+          isExecuting: false
+        }));
+      }
+    } catch (error) {
+      setSteps((prev) => ({
+        ...prev,
+        isExecuting: false
+      }));
+      if (onError && typeof onError === "function") {
+        onError(error);
+      }
+      throw error;
     }
-    return data;
-  }
-  log(level, message, data) {
-    if (!this.enabled) return;
-    console[level](
-      `[${this.context}] ${message}`,
-      data ? this.formatData(data) : ""
+  };
+  const executeTransaction = async ({
+    transactionStep
+  }) => {
+    const hash = await wallet.handleSendTransactionStep(
+      Number(chainId),
+      transactionStep
     );
-  }
-  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}`);
-  }
+    return hash;
+  };
+  const executeSignature = async ({
+    signatureStep
+  }) => {
+    const signature = await wallet.handleSignMessageStep(
+      signatureStep
+    );
+    const result = await marketplaceClient.execute({
+      signature,
+      executeType: "order" /* order */,
+      body: signatureStep.post?.body
+    });
+    return result.orderId;
+  };
+  return {
+    cancelOrder
+  };
+};
+
+// src/react/hooks/useCancelOrder.tsx
+var useCancelOrder = ({
+  collectionAddress,
+  chainId,
+  onSuccess,
+  onError
+}) => {
+  const [steps, setSteps] = useState({
+    exist: false,
+    isExecuting: false,
+    execute: () => Promise.resolve()
+  });
+  const { cancelOrder } = useCancelTransactionSteps({
+    collectionAddress,
+    chainId,
+    onSuccess,
+    onError,
+    setSteps
+  });
+  return {
+    cancelOrder,
+    isExecuting: steps.isExecuting
+  };
 };
-var createLogger = (context, enabled = true) => new TransactionLogger(context, enabled);
 
 // src/react/_internal/transaction-machine/execute-transaction.ts
+import { avalanche, optimism } from "viem/chains";
 var TransactionMachine = class {
-  constructor(config, wallet2, openSelectPaymentModal, switchChainFn, onPaymentModalLoaded) {
+  constructor(config, wallet, openSelectPaymentModal, switchChainFn, onPaymentModalLoaded) {
     this.config = config;
-    this.wallet = wallet2;
+    this.wallet = wallet;
     this.openSelectPaymentModal = openSelectPaymentModal;
     this.switchChainFn = switchChainFn;
     this.onPaymentModalLoaded = onPaymentModalLoaded;
@@ -2060,260 +2206,7 @@ var TransactionMachine = class {
 
 // src/react/_internal/transaction-machine/useTransactionMachine.ts
 import { useSelectPaymentModal } from "@0xsequence/kit-checkout";
-import { useAccount as useAccount4, useSwitchChain as useSwitchChain2, useWalletClient } from "wagmi";
-
-// src/react/ui/modals/_internal/components/switchChainModal/index.tsx
-import {
-  Button,
-  CloseIcon,
-  IconButton,
-  Spinner,
-  Text as Text2
-} from "@0xsequence/design-system";
-import { observer } from "@legendapp/state/react";
-import { Close, Content, Overlay, Portal, Root } from "@radix-ui/react-dialog";
-import { useSwitchChain } from "wagmi";
-
-// src/react/ui/modals/_internal/components/alertMessage/index.tsx
-import { Box, Text, WarningIcon } from "@0xsequence/design-system";
-import { jsx as jsx2, jsxs } from "react/jsx-runtime";
-function AlertMessage({ message, type }) {
-  return /* @__PURE__ */ jsxs(Box, { className: `${alertMessageBox} ${alertMessageBoxVariants[type]}`, children: [
-    /* @__PURE__ */ jsx2(
-      Text,
-      {
-        color: "white",
-        fontSize: "normal",
-        fontWeight: "medium",
-        fontFamily: "body",
-        children: message
-      }
-    ),
-    type === "warning" && /* @__PURE__ */ jsx2(WarningIcon, { size: "sm", color: "white" }),
-    type === "info" && /* @__PURE__ */ jsx2(InfoIcon_default, { size: "sm", color: "white" })
-  ] });
-}
-
-// src/react/ui/modals/_internal/components/switchChainModal/store.ts
-import { observable } from "@legendapp/state";
-var initialState = {
-  isOpen: false,
-  open: ({ chainIdToSwitchTo, onError, onSuccess, onClose }) => {
-    switchChainModal$.state.set({
-      ...switchChainModal$.state.get(),
-      chainIdToSwitchTo,
-      onError,
-      onSuccess,
-      onClose
-    });
-    switchChainModal$.isOpen.set(true);
-  },
-  close: () => {
-    switchChainModal$.isOpen.set(false);
-  },
-  state: {
-    chainIdToSwitchTo: void 0,
-    onError: void 0,
-    onSuccess: void 0,
-    onClose: void 0,
-    isSwitching: false
-  }
-};
-var switchChainModal$ = observable(initialState);
-
-// src/react/ui/modals/_internal/components/switchChainModal/index.tsx
-import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
-var useSwitchChainModal = () => {
-  return {
-    show: (args) => switchChainModal$.open(args),
-    close: () => switchChainModal$.delete(),
-    isSwitching$: switchChainModal$.state.isSwitching
-  };
-};
-var SwitchChainModal = observer(() => {
-  const chainIdToSwitchTo = switchChainModal$.state.chainIdToSwitchTo.get();
-  const isSwitching$ = switchChainModal$.state.isSwitching;
-  const chainName = chainIdToSwitchTo ? getPresentableChainName(chainIdToSwitchTo) : "";
-  const { switchChainAsync } = useSwitchChain();
-  async function handleSwitchChain() {
-    isSwitching$.set(true);
-    try {
-      if (!chainIdToSwitchTo) return;
-      await switchChainAsync({ chainId: Number(chainIdToSwitchTo) });
-      switchChainModal$.state.onSuccess?.();
-      switchChainModal$.delete();
-    } catch (error) {
-      switchChainModal$.state.onError?.(error);
-    } finally {
-      isSwitching$.set(false);
-    }
-  }
-  return /* @__PURE__ */ jsx3(Root, { open: switchChainModal$.isOpen.get(), children: /* @__PURE__ */ jsxs2(Portal, { children: [
-    /* @__PURE__ */ jsx3(Overlay, { className: dialogOverlay }),
-    /* @__PURE__ */ jsxs2(Content, { className: switchChainModalContent, children: [
-      /* @__PURE__ */ jsx3(Text2, { fontSize: "large", fontWeight: "bold", color: "text100", children: "Wrong network" }),
-      /* @__PURE__ */ jsx3(
-        AlertMessage,
-        {
-          type: "warning",
-          message: `You need to switch to ${chainName} network before completing the transaction`
-        }
-      ),
-      /* @__PURE__ */ jsx3(
-        Button,
-        {
-          name: "switch-chain",
-          size: "sm",
-          label: isSwitching$.get() ? /* @__PURE__ */ jsx3(Spinner, {}) : "Switch Network",
-          variant: "primary",
-          pending: isSwitching$.get(),
-          shape: "square",
-          className: isSwitching$.get() ? switchChainCta.pending : switchChainCta.default,
-          justifySelf: "flex-end",
-          onClick: handleSwitchChain
-        }
-      ),
-      /* @__PURE__ */ jsx3(
-        Close,
-        {
-          onClick: () => {
-            switchChainModal$.state.onClose?.();
-            switchChainModal$.delete();
-          },
-          className: closeButton,
-          asChild: true,
-          children: /* @__PURE__ */ jsx3(IconButton, { size: "xs", "aria-label": "Close modal", icon: CloseIcon })
-        }
-      )
-    ] })
-  ] }) });
-});
-var switchChainModal_default = SwitchChainModal;
-
-// src/react/_internal/transaction-machine/wallet.ts
-import {
-  custom,
-  hexToBigInt,
-  isHex
-} from "viem";
-var wallet = ({
-  wallet: wallet2,
-  chains,
-  connector
-}) => {
-  const logger = createLogger("Wallet");
-  return {
-    transport: custom(wallet2.transport),
-    isWaaS: connector.id.endsWith("waas"),
-    walletKind: connector.id === "sequence" ? "sequence" /* sequence */ : "unknown" /* unknown */,
-    getChainId: wallet2.getChainId,
-    address: async () => {
-      let address = wallet2.account?.address;
-      if (!address) {
-        [address] = await wallet2.getAddresses();
-      }
-      return address;
-    },
-    switchChain: async (chainId) => {
-      logger.debug("Switching chain", { targetChainId: chainId });
-      try {
-        await wallet2.switchChain({
-          id: chainId
-        });
-        logger.info("Chain switch successful", { chainId });
-        return;
-      } catch (e) {
-        const error = e;
-        logger.error("Chain switch failed", error);
-        switch (error.name) {
-          case "SwitchChainNotSupportedError":
-            throw new ChainSwitchError(await wallet2.getChainId(), chainId);
-          case "UserRejectedRequestError":
-            throw new UserRejectedRequestError();
-          case "ChainNotConfiguredError":
-            return;
-          default:
-            throw new ChainSwitchError(await wallet2.getChainId(), chainId);
-        }
-      }
-    },
-    handleSignMessageStep: async (stepItem) => {
-      try {
-        if (stepItem.id === "signEIP191" /* signEIP191 */) {
-          logger.debug("Signing with EIP-191", { data: stepItem.data });
-          const message = isHex(stepItem.data) ? { raw: stepItem.data } : stepItem.data;
-          return await wallet2.signMessage({
-            account: wallet2.account,
-            message
-          });
-        } else if (stepItem.id === "signEIP712" /* signEIP712 */) {
-          logger.debug("Signing with EIP-712", {
-            domain: stepItem.domain,
-            types: stepItem.signature?.types
-          });
-          return await wallet2.signTypedData({
-            account: wallet2.account,
-            domain: stepItem.signature.domain,
-            // biome-ignore lint/style/noNonNullAssertion: <explanation>
-            types: stepItem.signature.types,
-            // biome-ignore lint/style/noNonNullAssertion: <explanation>
-            primaryType: stepItem.signature.primaryType,
-            // biome-ignore lint/style/noNonNullAssertion: <explanation>
-            message: stepItem.signature.value
-          });
-        }
-      } catch (error) {
-        logger.error("Signature failed", error);
-        throw new TransactionSignatureError(stepItem.id, error);
-      }
-    },
-    handleSendTransactionStep: async (chainId, stepItem) => {
-      logger.debug("Sending transaction", {
-        chainId,
-        to: stepItem.to,
-        value: stepItem.value
-      });
-      const chain = chains.find((chain2) => chain2.id === chainId);
-      try {
-        return await wallet2.sendTransaction({
-          chain,
-          data: stepItem.data,
-          account: wallet2.account,
-          to: stepItem.to,
-          value: hexToBigInt(stepItem.value || "0x0"),
-          ...stepItem.maxFeePerGas && {
-            maxFeePerGas: hexToBigInt(stepItem.maxFeePerGas)
-          },
-          ...stepItem.maxPriorityFeePerGas && {
-            maxPriorityFeePerGas: hexToBigInt(stepItem.maxPriorityFeePerGas)
-          },
-          ...stepItem.gas && {
-            gas: hexToBigInt(stepItem.gas)
-          }
-        });
-      } catch (error) {
-        logger.error("Transaction failed", error);
-        throw new TransactionExecutionError(stepItem.id, error);
-      }
-    },
-    handleConfirmTransactionStep: async (txHash, chainId) => {
-      logger.debug("Confirming transaction", { txHash, chainId });
-      try {
-        const publicClient = getPublicRpcClient(chainId);
-        const receipt = await publicClient.waitForTransactionReceipt({
-          hash: txHash
-        });
-        logger.info("Transaction confirmed", { txHash, receipt });
-        return receipt;
-      } catch (error) {
-        logger.error("Transaction confirmation failed", error);
-        throw new TransactionConfirmationError(txHash, error);
-      }
-    }
-  };
-};
-
-// src/react/_internal/transaction-machine/useTransactionMachine.ts
+import { useAccount as useAccount4, useSwitchChain } from "wagmi";
 var useTransactionMachine = ({
   config,
   enabled,
@@ -2323,7 +2216,6 @@ var useTransactionMachine = ({
   onApprovalSuccess,
   onPaymentModalLoaded
 }) => {
-  const { data: walletClient, isLoading: walletClientIsLoading } = useWalletClient();
   const { show: showSwitchChainModal } = useSwitchChainModal();
   const sdkConfig = useConfig();
   const {
@@ -2332,8 +2224,13 @@ var useTransactionMachine = ({
     isLoading: marketplaceConfigIsLoading
   } = useMarketplaceConfig();
   const { openSelectPaymentModal } = useSelectPaymentModal();
-  const { chains } = useSwitchChain2();
-  const { connector, isConnected } = useAccount4();
+  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 };
@@ -2348,7 +2245,7 @@ var useTransactionMachine = ({
     onError?.(error);
     return { machine: null, error };
   }
-  if (!walletClient) {
+  if (walletClientIsError) {
     const error = new NoWalletConnectedError();
     onError?.(error);
     return { machine: null, error };
@@ -2358,11 +2255,6 @@ var useTransactionMachine = ({
     onError?.(error);
     return { machine: null, error };
   }
-  const walletInstance = wallet({
-    wallet: walletClient,
-    chains,
-    connector
-  });
   const machine = new TransactionMachine(
     {
       config: {
@@ -2411,36 +2303,8 @@ var useTransactionMachine = ({
   };
 };
 
-// src/react/hooks/useCancelOrder.tsx
-var useCancelOrder = ({
-  onSuccess,
-  onError,
-  onTransactionSent,
-  enabled,
-  ...config
-}) => {
-  const machineConfig = {
-    ...config,
-    type: "CANCEL" /* CANCEL */
-  };
-  const { machine, isLoading } = useTransactionMachine({
-    config: machineConfig,
-    enabled,
-    onSuccess,
-    onError,
-    onTransactionSent
-  });
-  return {
-    cancel: (props) => machine?.start(props),
-    onError,
-    onSuccess,
-    onTransactionSent,
-    isLoading
-  };
-};
-
 // src/react/hooks/useBuyCollectable.tsx
-import { useCallback } from "react";
+import { useCallback as useCallback2 } from "react";
 var useBuyCollectable = ({
   onSuccess,
   onError,
@@ -2462,7 +2326,7 @@ var useBuyCollectable = ({
     onTransactionSent,
     onPaymentModalLoaded
   });
-  const buy = useCallback(
+  const buy = useCallback2(
     (props) => {
       if (!machine || isLoading) return;
       setPaymentLoadingModalOpen(true);
@@ -2538,11 +2402,8 @@ export {
   fetchGenerateBuyTransaction,
   generateBuyTransactionOptions,
   useGenerateBuyTransaction,
-  AlertMessage,
-  useSwitchChainModal,
-  switchChainModal_default,
-  useTransactionMachine,
+  useGetReceiptFromHash,
   useCancelOrder,
   useBuyCollectable
 };
-//# sourceMappingURL=chunk-WBJKZOQ7.js.map
+//# sourceMappingURL=chunk-GLOIEUWC.js.map