@getpara/react-sdk-lite 2.10.0 → 2.11.0

package/dist/modal/components/ErrorBoundary.js

@@ -0,0 +1,27 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+import { Component } from "react";
+class ErrorBoundary extends Component {
+  constructor(props) {
+    super(props);
+    this.state = { hasError: false };
+  }
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  componentDidCatch(error, errorInfo) {
+    var _a, _b;
+    console.error("[ErrorBoundary] Caught error:", error, errorInfo);
+    (_b = (_a = this.props).onError) == null ? void 0 : _b.call(_a, error, errorInfo);
+  }
+  render() {
+    var _a;
+    if (this.state.hasError) {
+      return (_a = this.props.fallback) != null ? _a : null;
+    }
+    return this.props.children;
+  }
+}
+export {
+  ErrorBoundary
+};

package/dist/modal/components/OnRampComponents/OnRampProviderButton.js

@@ -16,10 +16,10 @@ const OnRampProviderButton = ({ config, index, onClick: _onClick }) => {
   return /* @__PURE__ */ jsx(StyledButton, { variant: "tertiary", fullWidth: true, onClick, children: /* @__PURE__ */ jsxs(Container, { children: [
     /* @__PURE__ */ jsx(IconContainer, { children: /* @__PURE__ */ jsx(CpslIcon, { icon, color: backgroundColors[0] }) }),
     /* @__PURE__ */ jsxs(ProviderInfoContainer, { children: [
-      /* @__PURE__ */ jsx(Text, { variant: "bodyL", weight: "medium", children: name }),
+      /* @__PURE__ */ jsx(CpslText, { variant: "bodyL", weight: "medium", children: name }),
       /* @__PURE__ */ jsxs(ProviderInfoInnerContainer, { children: [
-        /* @__PURE__ */ jsx(Text, { variant: "bodyXS", weight: "medium", children: methods.join(", ") }),
-        /* @__PURE__ */ jsx(Text, { variant: "bodyXS", weight: "medium", children: feeString })
+        /* @__PURE__ */ jsx(CpslText, { variant: "bodyXS", weight: "medium", children: methods.join(", ") }),
+        /* @__PURE__ */ jsx(CpslText, { variant: "bodyXS", weight: "medium", children: feeString })
       ] })
     ] })
   ] }) });
@@ -57,11 +57,6 @@ const IconContainer = safeStyled.span`
   width: 48px;
   flex-shrink: 0;
 `;
-const Text = safeStyled(CpslText)`
-  &::part(text-element) {
-    color: #fff;
-  }
-`;
 export {
   OnRampProviderButton
 };

package/dist/modal/components/common.d.ts

@@ -1,6 +1,6 @@
 import { CpslInput, CpslText, CpslTileButton } from '@getpara/react-components';
 import { TLinkedAccountType, TNetwork, TOnRampAsset } from '@getpara/web-sdk';
-import { ComponentProps, PropsWithChildren } from 'react';
+import { ComponentProps, PropsWithChildren, ReactNode } from 'react';
 export declare const SpinnerContainer: import("styled-components/dist/types.js").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export declare const QRContainer: import("styled-components/dist/types.js").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 export declare const InfoBoxContent: import("styled-components/dist/types.js").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
@@ -59,6 +59,10 @@ export declare function GradientScroll({ height, gap, children }: PropsWithChild
 export declare const HeroGenericIcon: ({ accountType }: {
     accountType: "EMAIL" | "PHONE";
 }) => import("react/jsx-runtime").JSX.Element;
+export declare const ExplorerLink: ({ href, text }: {
+    href: string;
+    text: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
 export * from './SearchableButtonList.js';
 export * from './QuantityInput.js';
 export { AnimatedHeightWrapper } from './Body/AnimatedHeightWrapper.js';

package/dist/modal/components/common.js

@@ -4,7 +4,7 @@ import {
   __spreadProps,
   __spreadValues
 } from "../../chunk-MMUBH76A.js";
-import { jsx } from "react/jsx-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
 import { CpslIcon, CpslInput, CpslSelect, CpslSelectItem, CpslText, CpslTileButton } from "@getpara/react-components";
 import { ACCOUNT_TYPES, safeStyled, MOBILE_SIZE, NETWORKS, ON_RAMP_ASSETS } from "@getpara/react-common";
 import { useStore } from "../../provider/stores/useStore.js";
@@ -276,6 +276,31 @@ const Avatar = safeStyled.div`
   justify-content: center;
   background-color: var(--cpsl-color-background-8);
 `;
+const ExplorerLinkBase = safeStyled.a`
+  font-family: var(--cpsl-font-family);
+  font-size: 14px;
+  position: relative;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+  background: transparent;
+  border: none;
+  cursor: pointer;
+  color: var(--cpsl-color-text-primary);
+  --icon-color: var(--cpsl-color-text-primary);
+
+  &:hover {
+    color: var(--cpsl-color-text-contrast);
+    --icon-color: var(--cpsl-color-text-contrast);
+  }
+`;
+const ExplorerLink = ({ href, text }) => {
+  return /* @__PURE__ */ jsxs(ExplorerLinkBase, { target: "_blank", href, rel: "noopener noreferrer", children: [
+    /* @__PURE__ */ jsx("span", { children: text }),
+    /* @__PURE__ */ jsx(CpslIcon, { icon: "externalLink", size: "16px", style: { marginLeft: "6px" } })
+  ] });
+};
 export * from "./SearchableButtonList.js";
 export * from "./QuantityInput.js";
 import { AnimatedHeightWrapper } from "./Body/AnimatedHeightWrapper.js";
@@ -286,6 +311,7 @@ export {
   CenteredText,
   ErrorContainer,
   ErrorIcon,
+  ExplorerLink,
   FilledDisabledInput,
   FullWidthFilledDisabledInput,
   GradientScroll,

package/dist/modal/hooks/index.d.ts

@@ -1,4 +1,5 @@
 export * from './useDebounce.js';
 export * from './useFarcasterLogin.js';
 export * from './useGoBack.js';
+export * from './useSendMutations.js';
 export * from './useTelegramLogin.js';

package/dist/modal/hooks/index.js

@@ -2,4 +2,5 @@
 export * from "./useDebounce.js";
 export * from "./useFarcasterLogin.js";
 export * from "./useGoBack.js";
+export * from "./useSendMutations.js";
 export * from "./useTelegramLogin.js";

package/dist/modal/hooks/useSendMutations.d.ts

@@ -0,0 +1,51 @@
+import { BroadcastTransactionResult, EstimateTransactionResult } from '@getpara/web-sdk';
+import { EstimateTransactionOpts, NetworkDefinition, RpcMetadata, TransactionType } from '@getpara/shared';
+type BroadcastOpts = Omit<NetworkDefinition, 'type'> & {
+    userId: string;
+    walletId: string;
+    walletAddress: string;
+    walletType: TransactionType;
+    txSerialized: string;
+    message?: string;
+    txUrlFormat?: string;
+    rpc?: RpcMetadata;
+    simulateFailure?: boolean;
+};
+export declare function useSendMutations({ estimateOnSuccess, estimateOnError, broadcastOnSuccess, broadcastOnError, }: {
+    estimateOnSuccess: (data: EstimateTransactionResult) => void;
+    estimateOnError: (error: Error) => void;
+    broadcastOnSuccess?: (data: BroadcastTransactionResult) => void;
+    broadcastOnError: (error: Error) => void;
+}): {
+    estimateMutate: import("@tanstack/react-query").UseMutateFunction<Partial<{
+        result: Pick<import("@getpara/shared").CreateTransactionSuccess, "txSerialized" | "message">;
+        error: import("@getpara/shared").TransactionError;
+        feeAmount: string;
+        feeValue: string;
+        transferAmount: string;
+        transferValue: string;
+    }> | null, Error, {
+        userId: string;
+        walletId: string;
+        opts: EstimateTransactionOpts;
+    }, unknown>;
+    estimateMutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<Partial<{
+        result: Pick<import("@getpara/shared").CreateTransactionSuccess, "txSerialized" | "message">;
+        error: import("@getpara/shared").TransactionError;
+        feeAmount: string;
+        feeValue: string;
+        transferAmount: string;
+        transferValue: string;
+    }> | null, Error, {
+        userId: string;
+        walletId: string;
+        opts: EstimateTransactionOpts;
+    }, unknown>;
+    broadcastMutate: import("@tanstack/react-query").UseMutateFunction<BroadcastTransactionResult | null, Error, BroadcastOpts, unknown>;
+    broadcastMutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<BroadcastTransactionResult | null, Error, BroadcastOpts, unknown>;
+    estimateIsPending: boolean;
+    estimateIsError: boolean;
+    broadcastIsPending: boolean;
+    broadcastIsError: boolean;
+};
+export {};

package/dist/modal/hooks/useSendMutations.js

@@ -0,0 +1,170 @@
+"use client";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "../../chunk-MMUBH76A.js";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useInternalClient } from "../../provider/hooks/utils/useInternalClient.js";
+import { useModalStore, useModalSessionStore } from "../stores/index.js";
+import { useSignMessage, useSignTransaction, useWalletState } from "../../provider/index.js";
+import {
+  hexStringToBase64
+} from "@getpara/web-sdk";
+import { useMemo, useCallback } from "react";
+import { ModalStep } from "../utils/steps.js";
+import { useStore } from "../../provider/stores/useStore.js";
+function useSendMutations({
+  estimateOnSuccess,
+  estimateOnError,
+  broadcastOnSuccess,
+  broadcastOnError
+}) {
+  const para = useInternalClient();
+  const setStep = useModalStore((state) => state.setStep);
+  const setSendTx = useModalSessionStore((state) => state.setSendTx);
+  const { signTransactionAsync } = useSignTransaction();
+  const { signMessageAsync } = useSignMessage();
+  const { selectedWallet } = useWalletState();
+  const queryClient = useQueryClient();
+  const refs = useStore((state) => state.refs);
+  const defaultBroadcastOnSuccess = useCallback(
+    (data) => {
+      if (!!(data == null ? void 0 : data.error)) {
+        return;
+      } else if (!!data) {
+        const currentSendTx = useModalSessionStore.getState().sendTx;
+        if (currentSendTx) {
+          setSendTx(__spreadProps(__spreadValues({}, currentSendTx), { result: data }));
+        }
+        setStep(ModalStep.ACCOUNT_MAIN);
+        refs.balancesInvalidationTime.current = Date.now();
+        queryClient.invalidateQueries({
+          queryKey: ["useProfileBalance"],
+          refetchType: "active"
+        });
+      }
+    },
+    [setSendTx, setStep, queryClient, refs]
+  );
+  const handleBroadcastSuccess = useCallback(
+    (data) => {
+      defaultBroadcastOnSuccess(data);
+      broadcastOnSuccess == null ? void 0 : broadcastOnSuccess(data);
+    },
+    [defaultBroadcastOnSuccess, broadcastOnSuccess]
+  );
+  const {
+    mutate: estimateMutate,
+    mutateAsync: estimateMutateAsync,
+    isPending: estimateIsPending,
+    isError: estimateIsError
+  } = useMutation({
+    mutationKey: ["estimate-tx"],
+    mutationFn: (_0) => __async(this, [_0], function* ({ userId, walletId, opts }) {
+      if (!para.userId || !selectedWallet.id) {
+        return null;
+      }
+      const result = yield para.ctx.client.estimateSendTransaction({
+        userId,
+        walletId,
+        opts
+      });
+      return result;
+    }),
+    onSuccess: (data, variables) => {
+      setSendTx(__spreadValues({}, variables));
+      estimateOnSuccess(data);
+    },
+    onError: estimateOnError
+  });
+  const {
+    mutate: broadcastMutate,
+    mutateAsync: broadcastMutateAsync,
+    isPending: broadcastIsPending,
+    isError: broadcastIsError
+  } = useMutation({
+    mutationKey: ["broadcast-tx"],
+    mutationFn: (_0) => __async(this, [_0], function* ({
+      userId,
+      walletId,
+      walletAddress,
+      walletType,
+      txSerialized,
+      message,
+      evmChainId,
+      isDevnet,
+      txUrlFormat,
+      rpc,
+      simulateFailure
+    }) {
+      var _a, _b;
+      if (!para.userId || !selectedWallet.id) {
+        return null;
+      }
+      let signature;
+      switch (walletType) {
+        case "SOLANA":
+          signature = (_a = yield signMessageAsync({
+            walletId,
+            messageBase64: message
+          })) == null ? void 0 : _a.signature;
+          break;
+        case "EVM":
+        default:
+          signature = (_b = yield signTransactionAsync({
+            walletId,
+            rlpEncodedTxBase64: hexStringToBase64(txSerialized),
+            chainId: evmChainId
+          })) == null ? void 0 : _b.signature;
+          if (!!signature) {
+            signature = `0x${signature}`;
+          }
+          break;
+      }
+      const result = yield para.ctx.client.broadcastSendTransaction({
+        userId,
+        walletId,
+        opts: {
+          type: walletType,
+          evmChainId,
+          isDevnet,
+          tx: txSerialized,
+          signature,
+          sourceAddress: walletAddress,
+          txUrlFormat,
+          rpc,
+          simulateFailure
+        }
+      });
+      return result;
+    }),
+    onSuccess: handleBroadcastSuccess,
+    onError: broadcastOnError
+  });
+  return useMemo(
+    () => ({
+      estimateMutate,
+      estimateMutateAsync,
+      broadcastMutate,
+      broadcastMutateAsync,
+      estimateIsPending,
+      estimateIsError,
+      broadcastIsPending,
+      broadcastIsError
+    }),
+    [
+      estimateMutate,
+      estimateMutateAsync,
+      broadcastMutate,
+      broadcastMutateAsync,
+      estimateIsPending,
+      estimateIsError,
+      broadcastIsPending,
+      broadcastIsError
+    ]
+  );
+}
+export {
+  useSendMutations
+};

package/dist/modal/hooks/useTransactionMonitoring.d.ts

@@ -0,0 +1 @@
+export declare function useTransactionMonitoring(): void;

package/dist/modal/hooks/useTransactionMonitoring.js

@@ -0,0 +1,175 @@
+"use client";
+import {
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "../../chunk-MMUBH76A.js";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { useInternalClient } from "../../provider/hooks/utils/useInternalClient.js";
+import { useModalStore, useModalSessionStore } from "../stores/index.js";
+import { getBaseUrl } from "@getpara/web-sdk";
+import { useAccount } from "../../provider/index.js";
+import { ModalStep } from "../utils/steps.js";
+import { SESSION_COOKIE_HEADER_NAME } from "@getpara/user-management-client";
+const TRANSACTION_CLEANUP_DELAY_MS = 3e4;
+function useTransactionMonitoring() {
+  var _a, _b, _c, _d, _e, _f;
+  const sendTx = useModalSessionStore((state) => state.sendTx);
+  const setSendTx = useModalSessionStore((state) => state.setSendTx);
+  const currentStep = useModalStore((state) => state.step);
+  const para = useInternalClient();
+  const socketRef = useRef(null);
+  const subscribedDataRef = useRef(null);
+  const socketIoModuleRef = useRef(null);
+  const [isLoadingSocketIo, setIsLoadingSocketIo] = useState(false);
+  const {
+    embedded: { userId },
+    isConnected
+  } = useAccount();
+  const socketUrl = useMemo(() => {
+    var _a2;
+    if (!((_a2 = para.ctx) == null ? void 0 : _a2.env)) return null;
+    return getBaseUrl(para.ctx.env, "ws");
+  }, [(_a = para.ctx) == null ? void 0 : _a.env]);
+  useEffect(() => {
+    var _a2, _b2, _c2, _d2;
+    if (typeof window === "undefined") {
+      return;
+    }
+    const shouldMonitor = isConnected && userId && userId === (sendTx == null ? void 0 : sendTx.userId) && ((_a2 = sendTx == null ? void 0 : sendTx.result) == null ? void 0 : _a2.status) && ((_b2 = sendTx == null ? void 0 : sendTx.result) == null ? void 0 : _b2.txHash) && ((_c2 = sendTx == null ? void 0 : sendTx.result) == null ? void 0 : _c2.network) && socketUrl;
+    if (!shouldMonitor) {
+      if (socketRef.current) {
+        if (subscribedDataRef.current) {
+          socketRef.current.emit("tx:unsubscribe", subscribedDataRef.current);
+          subscribedDataRef.current = null;
+        }
+        socketRef.current.disconnect();
+        socketRef.current = null;
+      }
+      if (sendTx && (!isConnected || !userId || userId !== sendTx.userId)) {
+        setSendTx(null);
+      }
+      return;
+    }
+    const subscribeData = __spreadValues({
+      txHash: sendTx.result.txHash
+    }, sendTx.result.network);
+    if (!socketRef.current && !isLoadingSocketIo) {
+      setIsLoadingSocketIo(true);
+      import("socket.io-client").then((socketIoModule) => {
+        var _a3, _b3;
+        socketIoModuleRef.current = socketIoModule;
+        const { io } = socketIoModule;
+        const sessionCookie = (_a3 = para == null ? void 0 : para.retrieveSessionCookie) == null ? void 0 : _a3.call(para);
+        if (!sessionCookie) {
+          setIsLoadingSocketIo(false);
+          return;
+        }
+        socketRef.current = io(socketUrl, {
+          transports: ["polling", "websocket"],
+          reconnection: true,
+          reconnectionAttempts: 5,
+          reconnectionDelay: 1e3,
+          upgrade: true,
+          extraHeaders: {
+            [SESSION_COOKIE_HEADER_NAME]: sessionCookie
+          }
+        });
+        socketRef.current.on("connect_error", () => {
+          var _a4;
+          const sendTx2 = useModalSessionStore.getState().sendTx;
+          if ((_a4 = sendTx2 == null ? void 0 : sendTx2.result) == null ? void 0 : _a4.explorerUrl) {
+            const _b4 = sendTx2.result, { status: _status } = _b4, rest = __objRest(_b4, ["status"]);
+            setSendTx(__spreadProps(__spreadValues({}, sendTx2), {
+              result: __spreadValues({}, rest)
+            }));
+          }
+          return;
+        });
+        socketRef.current.on("tx:error", (error) => {
+          console.error("Transaction monitoring error:", error);
+        });
+        if (((_b3 = subscribedDataRef.current) == null ? void 0 : _b3.txHash) !== subscribeData.txHash) {
+          socketRef.current.emit("tx:subscribe", subscribeData);
+          subscribedDataRef.current = subscribeData;
+        }
+        socketRef.current.on("tx:status", (status) => {
+          if (!status || typeof status !== "object") {
+            return;
+          }
+          if (!status.status || !["PENDING", "CONFIRMED", "FAILED"].includes(status.status)) {
+            return;
+          }
+          if (status.confirmations !== void 0 && (typeof status.confirmations !== "number" || status.confirmations < 0)) {
+            return;
+          }
+          if (status.blockNumber !== void 0 && (typeof status.blockNumber !== "number" || status.blockNumber < 0)) {
+            return;
+          }
+          const currentSendTx = useModalSessionStore.getState().sendTx;
+          if (currentSendTx && currentSendTx.userId === para.userId) {
+            const updatedSendTx = __spreadProps(__spreadValues({}, currentSendTx), {
+              result: __spreadProps(__spreadValues({}, currentSendTx.result), {
+                status: __spreadValues({}, status)
+              })
+            });
+            setSendTx(updatedSendTx);
+          }
+        });
+        setIsLoadingSocketIo(false);
+      }).catch((err) => {
+        console.error("[useTransactionMonitoring] Failed to load socket.io-client:", err);
+        setIsLoadingSocketIo(false);
+      });
+    }
+    if (((_d2 = subscribedDataRef.current) == null ? void 0 : _d2.txHash) !== subscribeData.txHash && socketRef.current) {
+      socketRef.current.emit("tx:subscribe", subscribeData);
+      subscribedDataRef.current = subscribeData;
+    }
+    return () => {
+      var _a3, _b3;
+      if (socketRef.current && ((_a3 = subscribedDataRef.current) == null ? void 0 : _a3.txHash) === subscribeData.txHash) {
+        socketRef.current.emit("tx:unsubscribe", subscribedDataRef.current);
+        subscribedDataRef.current = null;
+        if (!((_b3 = sendTx == null ? void 0 : sendTx.result) == null ? void 0 : _b3.status) || !isConnected) {
+          socketRef.current.disconnect();
+          socketRef.current = null;
+        }
+      }
+    };
+  }, [(_b = sendTx == null ? void 0 : sendTx.result) == null ? void 0 : _b.txHash, (_c = sendTx == null ? void 0 : sendTx.result) == null ? void 0 : _c.network, socketUrl, setSendTx, isConnected, userId, isLoadingSocketIo, para]);
+  useEffect(() => {
+    return () => {
+      if (socketRef.current) {
+        socketRef.current.disconnect();
+        socketRef.current = null;
+      }
+    };
+  }, []);
+  useEffect(() => {
+    var _a2, _b2, _c2;
+    if (typeof window === "undefined") return;
+    const status = (_b2 = (_a2 = sendTx == null ? void 0 : sendTx.result) == null ? void 0 : _a2.status) == null ? void 0 : _b2.status;
+    const isCompleted = status === "CONFIRMED" || status === "FAILED";
+    const isOnAccountOrMonitor = currentStep === ModalStep.ACCOUNT_MAIN || currentStep === ModalStep.ACCOUNT_MONITOR_TX;
+    if (isCompleted && sendTx && !isOnAccountOrMonitor) {
+      setSendTx(null);
+      return;
+    }
+    if (isCompleted && currentStep === ModalStep.ACCOUNT_MAIN && ((_c2 = sendTx == null ? void 0 : sendTx.result) == null ? void 0 : _c2.txHash)) {
+      const txHash = sendTx.result.txHash;
+      const timeoutId = setTimeout(() => {
+        var _a3, _b3;
+        const sessionState = useModalSessionStore.getState();
+        const modalState = useModalStore.getState();
+        if (((_b3 = (_a3 = sessionState.sendTx) == null ? void 0 : _a3.result) == null ? void 0 : _b3.txHash) === txHash && modalState.step === ModalStep.ACCOUNT_MAIN) {
+          setSendTx(null);
+        }
+      }, TRANSACTION_CLEANUP_DELAY_MS);
+      return () => clearTimeout(timeoutId);
+    }
+  }, [(_e = (_d = sendTx == null ? void 0 : sendTx.result) == null ? void 0 : _d.status) == null ? void 0 : _e.status, (_f = sendTx == null ? void 0 : sendTx.result) == null ? void 0 : _f.txHash, currentStep, setSendTx]);
+}
+export {
+  useTransactionMonitoring
+};

package/dist/modal/index.d.ts

@@ -5,4 +5,4 @@ export { AuthLayout } from './types/modalProps.js';
 export * from './utils/openPopup.js';
 export { ON_RAMP_PROVIDERS, ON_RAMP_ASSETS, NETWORKS, getAssetIcon, getAssetCode, getNetworkIcon, getNetworkName, } from '@getpara/react-common';
 export { SaveRecoverySecret } from './components/RecoverySecretStep/RecoverySecretStep.js';
-export * from './utils/validateOnRampConfig.js';
+export * from './utils/onramps.js';

package/dist/modal/index.js

@@ -14,7 +14,7 @@ import {
   getNetworkName
 } from "@getpara/react-common";
 import { SaveRecoverySecret } from "./components/RecoverySecretStep/RecoverySecretStep.js";
-export * from "./utils/validateOnRampConfig.js";
+export * from "./utils/onramps.js";
 export {
   AuthLayout,
   ModalStep,

package/dist/modal/stores/index.d.ts

@@ -1 +1,2 @@
 export * from './modal/useModalStore.js';
+export * from './modal/useModalSessionStore.js';

package/dist/modal/stores/index.js

@@ -1,2 +1,3 @@
 "use client";
 export * from "./modal/useModalStore.js";
+export * from "./modal/useModalSessionStore.js";

package/dist/modal/stores/modal/actions.js

@@ -139,7 +139,6 @@ const getActions = (set, get) => ({
   setIsPasskeySupported: (isPasskeySupported) => set({ isPasskeySupported }),
   setAccountLinkOptions: (accountLinkOptions) => set({ accountLinkOptions }),
   setProfileWallet: (profileWallet) => set({ profileWallet }),
-  setSendTx: (sendTx) => set({ sendTx }),
   setIsTestModeAlertDismissed: (isTestModeAlertDismissed) => set({ isTestModeAlertDismissed })
 });
 export {

package/dist/modal/stores/modal/useModalSessionStore.d.ts

@@ -0,0 +1,28 @@
+import { BroadcastTransactionResult } from '@getpara/web-sdk';
+import { CreateTransactionOpts } from '@getpara/shared';
+export type SendTx = {
+    userId: string;
+    walletId: string;
+    opts: CreateTransactionOpts;
+    transferAmount?: string;
+    result?: BroadcastTransactionResult;
+};
+interface ModalSessionState {
+    sendTx: SendTx | null;
+}
+interface ModalSessionActions {
+    setSendTx: (_: SendTx | null) => void;
+}
+export type ModalSessionStore = ModalSessionState & ModalSessionActions;
+export declare const useModalSessionStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<ModalSessionStore>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<ModalSessionStore, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: ModalSessionStore) => void) => () => void;
+        onFinishHydration: (fn: (state: ModalSessionStore) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<ModalSessionStore, unknown>>;
+    };
+}>;
+export {};

package/dist/modal/stores/modal/useModalSessionStore.js

@@ -0,0 +1,26 @@
+"use client";
+import {
+  __spreadProps,
+  __spreadValues
+} from "../../../chunk-MMUBH76A.js";
+import { create } from "zustand";
+import { persist, createJSONStorage } from "zustand/middleware";
+import { PARA_STORAGE_PREFIX } from "@getpara/core-sdk";
+const DEFAULT_SESSION_STATE = {
+  sendTx: null
+};
+const useModalSessionStore = create()(
+  persist(
+    (set) => __spreadProps(__spreadValues({}, DEFAULT_SESSION_STATE), {
+      setSendTx: (sendTx) => set({ sendTx })
+    }),
+    {
+      version: 1,
+      name: `${PARA_STORAGE_PREFIX}modalSessionState`,
+      storage: createJSONStorage(() => sessionStorage)
+    }
+  )
+);
+export {
+  useModalSessionStore
+};

package/dist/modal/stores/modal/useModalStore.d.ts

@@ -1,6 +1,6 @@
 import { AvailableWallet } from '@getpara/core-sdk';
 import { ModalStep } from '../../utils/steps.js';
-import { AuthStateLogin, AuthStateSignup, AuthState, AuthStateVerify, OnRampConfig as OnRampConfigBase, OnRampPurchase, TWalletType, Setup2faResponse, SupportedAccountLinks, BroadcastTransactionResult } from '@getpara/web-sdk';
+import { AuthStateLogin, AuthStateSignup, AuthState, AuthStateVerify, OnRampConfig as OnRampConfigBase, OnRampPurchase, TWalletType, Setup2faResponse, SupportedAccountLinks } from '@getpara/web-sdk';
 import { Tab as AddFundsTabType } from '../../components/AddFunds/AddFundsContext.js';
 import { TAuthLayout } from '../../types/modalProps.js';
 import { MutableRefObject } from 'react';
@@ -61,7 +61,6 @@ interface ModalState {
     isPasskeySupported: boolean;
     accountLinkOptions: SupportedAccountLinks;
     profileWallet?: AvailableWallet;
-    sendTx: BroadcastTransactionResult | null;
     isTestModeAlertDismissed: boolean;
 }
 export interface ModalActions {
@@ -102,7 +101,6 @@ export interface ModalActions {
     setIsPasskeySupported: (_: boolean) => void;
     setAccountLinkOptions: (_: SupportedAccountLinks) => void;
     setProfileWallet: (_?: AvailableWallet) => void;
-    setSendTx: (_: BroadcastTransactionResult | null) => void;
     setIsTestModeAlertDismissed: (_: boolean) => void;
 }
 export type ModalStore = ModalState & ModalActions;

package/dist/modal/stores/modal/useModalStore.js

@@ -50,7 +50,6 @@ const DEFAULT_MODAL_STATE = {
   isPasskeySupported: true,
   accountLinkOptions: [...LINKED_ACCOUNT_TYPES],
   profileWallet: void 0,
-  sendTx: null,
   isTestModeAlertDismissed: false
 };
 const useModalStore = create()(