@getpara/react-sdk-lite 2.9.0 → 2.11.0

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()(

package/dist/modal/types/modalProps.d.ts

@@ -74,7 +74,9 @@ export interface ParaModalProps {
      */
     logo?: string;
     /**
-     * Whether or not to run configured on-ramp providers in test mode.
+     * Whether to run configured on-ramp providers in test mode in the PROD environment.
+     *
+     * On-ramp and off-ramp widgets will always run in test mode outside of PROD.
      */
     onRampTestMode?: boolean;
     /**

package/dist/modal/utils/onramps.d.ts

@@ -0,0 +1,61 @@
+import { OnRampConfig, OnRampProvider, OnRampPurchaseType, TNetwork, TOnRampAsset, TWalletType } from '@getpara/web-sdk';
+export declare class OnRampConfigError extends Error {
+    constructor(message: string);
+}
+/**
+ * Provider-specific transaction amount limits (in USD).
+ * These limits are enforced client-side to prevent users from selecting
+ * providers that don't support their desired transaction amount.
+ *
+ * Last verified: February 2025
+ * Sources:
+ * - MoonPay: https://support.moonpay.com/customers/docs/moonpay-transaction-limits
+ * - Stripe: https://docs.stripe.com/crypto/using-the-dashboard#onramp-minimums-and-maximums
+ * - Ramp: https://support.ramp.network/en/articles/471-transaction-limits
+ */
+export declare const PROVIDER_LIMITS: Record<OnRampProvider, Record<OnRampPurchaseType, {
+    min: number | null;
+    max: number | null;
+}>>;
+export declare function validateOnRampConfig(obj?: OnRampConfig): obj is OnRampConfig;
+/**
+ * Gets a default asset and network combination that are guaranteed to work together.
+ *
+ * When preferredAsset is provided:
+ * - Locks in that asset and finds the best compatible network
+ * - Returns { asset: preferredAsset, network: <compatible network> }
+ *
+ * When preferredAsset is not provided:
+ * - Finds the best asset+network combination
+ * - Priority order:
+ *   1. Partner's defaults (if both are valid together)
+ *   2. Wallet-type-specific combo (COSMOS→ATOM on COSMOS, SOLANA→SOL on SOLANA, etc.)
+ *   3. First valid asset+network combination from available lists
+ *
+ * @param params - Configuration object
+ * @param params.walletType - The wallet type (EVM, SOLANA, COSMOS)
+ * @param params.onRampConfig - OnRamp configuration
+ * @param params.networks - Available networks (from getOnRampNetworks)
+ * @param params.assets - Available assets (from assets calculation)
+ * @param params.preferredAsset - Optional asset to lock in (will only find compatible network)
+ * @returns Object with asset and network, both null if no valid combination exists
+ */
+export declare function getDefaultAssetAndNetwork({ walletType, onRampConfig, networks, assets, preferredAsset, }: {
+    walletType: TWalletType | undefined;
+    onRampConfig: OnRampConfig | undefined;
+    networks: TNetwork[];
+    assets: TOnRampAsset[];
+    preferredAsset?: TOnRampAsset | null;
+}): {
+    asset: TOnRampAsset | null;
+    network: TNetwork | null;
+};
+/**
+ * Checks if an amount falls within the provider's limits for a given operation type.
+ * @param amount - The amount to check (can be undefined for invalid inputs)
+ * @param provider - The provider to check limits for
+ * @param type - The transaction type (BUY or SELL)
+ * @param limits - Optional provider limits object (defaults to PROVIDER_LIMITS)
+ * @returns true if the amount is within limits, false otherwise
+ */
+export declare function isAmountWithinProviderLimits(amount: number | undefined, provider: OnRampProvider, type: OnRampPurchaseType, limits?: typeof PROVIDER_LIMITS): boolean;

package/dist/modal/utils/onramps.js

@@ -0,0 +1,112 @@
+"use client";
+import "../../chunk-MMUBH76A.js";
+import { OnRampProvider, OnRampPurchaseType } from "@getpara/web-sdk";
+class OnRampConfigError extends Error {
+  constructor(message) {
+    super(`On-ramp configuration error: ${message}.`);
+    this.name = "OnRampConfigError";
+  }
+}
+const PROVIDER_LIMITS = {
+  [OnRampProvider.MOONPAY]: {
+    [OnRampPurchaseType.BUY]: { min: 20, max: 3e4 },
+    [OnRampPurchaseType.SELL]: { min: 20, max: 1e4 }
+  },
+  [OnRampProvider.STRIPE]: {
+    [OnRampPurchaseType.BUY]: { min: 0.5, max: null },
+    [OnRampPurchaseType.SELL]: { min: 0.5, max: null }
+  },
+  [OnRampProvider.RAMP]: {
+    [OnRampPurchaseType.BUY]: { min: null, max: null },
+    [OnRampPurchaseType.SELL]: { min: null, max: null }
+  }
+};
+function checkHasProviders({ providers }) {
+  if (!providers || providers.length < 1) {
+    throw new OnRampConfigError("No providers are configured");
+  }
+}
+function checkDuplicateProviders({ providers }) {
+  if (!providers) return;
+  providers.forEach((id, index) => {
+    if (providers.findIndex((p) => p === id) !== index) {
+      throw new OnRampConfigError(`Provider ${id} is configured more than once`);
+    }
+  });
+}
+function validateOnRampConfig(obj) {
+  if (!obj) {
+    return false;
+  }
+  checkHasProviders(obj);
+  checkDuplicateProviders(obj);
+  return true;
+}
+function getDefaultAssetAndNetwork({
+  walletType,
+  onRampConfig,
+  networks,
+  assets,
+  preferredAsset
+}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+  if (!walletType || !onRampConfig || networks.length === 0 || assets.length === 0) {
+    return { asset: null, network: null };
+  }
+  if (preferredAsset && assets.includes(preferredAsset)) {
+    if (onRampConfig.defaultOnRampNetwork && networks.includes(onRampConfig.defaultOnRampNetwork) && ((_c = (_b = (_a = onRampConfig.assetInfo) == null ? void 0 : _a[walletType]) == null ? void 0 : _b[onRampConfig.defaultOnRampNetwork]) == null ? void 0 : _c[preferredAsset])) {
+      return { asset: preferredAsset, network: onRampConfig.defaultOnRampNetwork };
+    }
+    const preferredNetwork = walletType === "COSMOS" ? "COSMOS" : walletType === "SOLANA" ? "SOLANA" : "ETHEREUM";
+    if (networks.includes(preferredNetwork) && ((_f = (_e = (_d = onRampConfig.assetInfo) == null ? void 0 : _d[walletType]) == null ? void 0 : _e[preferredNetwork]) == null ? void 0 : _f[preferredAsset])) {
+      return { asset: preferredAsset, network: preferredNetwork };
+    }
+    const supportedNetwork = networks.find((network) => {
+      var _a2, _b2, _c2;
+      return !!((_c2 = (_b2 = (_a2 = onRampConfig.assetInfo) == null ? void 0 : _a2[walletType]) == null ? void 0 : _b2[network]) == null ? void 0 : _c2[preferredAsset]);
+    });
+    if (supportedNetwork) {
+      return { asset: preferredAsset, network: supportedNetwork };
+    }
+    return { asset: preferredAsset, network: null };
+  }
+  const partnerAsset = onRampConfig.defaultOnRampAsset;
+  const partnerNetwork = onRampConfig.defaultOnRampNetwork;
+  if (partnerAsset && partnerNetwork && assets.includes(partnerAsset) && networks.includes(partnerNetwork) && ((_i = (_h = (_g = onRampConfig.assetInfo) == null ? void 0 : _g[walletType]) == null ? void 0 : _h[partnerNetwork]) == null ? void 0 : _i[partnerAsset])) {
+    return { asset: partnerAsset, network: partnerNetwork };
+  }
+  const walletTypeAsset = walletType === "COSMOS" ? "ATOM" : walletType === "SOLANA" ? "SOLANA" : "ETHEREUM";
+  const walletTypeNetwork = walletType === "COSMOS" ? "COSMOS" : walletType === "SOLANA" ? "SOLANA" : "ETHEREUM";
+  if (assets.includes(walletTypeAsset) && networks.includes(walletTypeNetwork) && ((_l = (_k = (_j = onRampConfig.assetInfo) == null ? void 0 : _j[walletType]) == null ? void 0 : _k[walletTypeNetwork]) == null ? void 0 : _l[walletTypeAsset])) {
+    return { asset: walletTypeAsset, network: walletTypeNetwork };
+  }
+  for (const testAsset of assets) {
+    if (networks.includes(walletTypeNetwork) && ((_o = (_n = (_m = onRampConfig.assetInfo) == null ? void 0 : _m[walletType]) == null ? void 0 : _n[walletTypeNetwork]) == null ? void 0 : _o[testAsset])) {
+      return { asset: testAsset, network: walletTypeNetwork };
+    }
+    const validNetwork = networks.find((network) => {
+      var _a2, _b2, _c2;
+      return !!((_c2 = (_b2 = (_a2 = onRampConfig.assetInfo) == null ? void 0 : _a2[walletType]) == null ? void 0 : _b2[network]) == null ? void 0 : _c2[testAsset]);
+    });
+    if (validNetwork) {
+      return { asset: testAsset, network: validNetwork };
+    }
+  }
+  return { asset: null, network: null };
+}
+function isAmountWithinProviderLimits(amount, provider, type, limits = PROVIDER_LIMITS) {
+  if (typeof amount !== "number" || isNaN(amount)) {
+    return false;
+  }
+  const { min, max } = limits[provider][type];
+  if (min !== null && amount < min) return false;
+  if (max !== null && amount > max) return false;
+  return true;
+}
+export {
+  OnRampConfigError,
+  PROVIDER_LIMITS,
+  getDefaultAssetAndNetwork,
+  isAmountWithinProviderLimits,
+  validateOnRampConfig
+};

package/dist/modal/utils/steps.d.ts

@@ -50,7 +50,8 @@ export declare enum ModalStep {
     LINK_EX_WALLET_NETWORK_SELECT = "LINK_EX_WALLET_NETWORK_SELECT",
     ACCOUNT_SEND = "ACCOUNT_SEND",
     ACCOUNT_SEND_ASSET = "ACCOUNT_SEND_ASSET",
-    ACCOUNT_SEND_NETWORK = "ACCOUNT_SEND_NETWORK"
+    ACCOUNT_SEND_NETWORK = "ACCOUNT_SEND_NETWORK",
+    ACCOUNT_MONITOR_TX = "ACCOUNT_MONITOR_TX"
 }
 export type ModalStepPropU = keyof typeof ModalStep | ModalStep;
 export type ModalStepPropL = Lowercase<ModalStepPropU>;
@@ -79,7 +80,8 @@ declare enum AccountStep {
     LINK_EX_WALLET_NETWORK_SELECT = "LINK_EX_WALLET_NETWORK_SELECT",
     ACCOUNT_SEND = "ACCOUNT_SEND",
     ACCOUNT_SEND_ASSET = "ACCOUNT_SEND_ASSET",
-    ACCOUNT_SEND_NETWORK = "ACCOUNT_SEND_NETWORK"
+    ACCOUNT_SEND_NETWORK = "ACCOUNT_SEND_NETWORK",
+    ACCOUNT_MONITOR_TX = "ACCOUNT_MONITOR_TX"
 }
 export declare const RESET_TO_AUTH_STEPS: ModalStep[];
 export declare const RESET_TO_ACCOUNT_STEPS: ModalStep[];

package/dist/modal/utils/steps.js

@@ -52,6 +52,7 @@ var ModalStep = /* @__PURE__ */ ((ModalStep2) => {
   ModalStep2["ACCOUNT_SEND"] = "ACCOUNT_SEND";
   ModalStep2["ACCOUNT_SEND_ASSET"] = "ACCOUNT_SEND_ASSET";
   ModalStep2["ACCOUNT_SEND_NETWORK"] = "ACCOUNT_SEND_NETWORK";
+  ModalStep2["ACCOUNT_MONITOR_TX"] = "ACCOUNT_MONITOR_TX";
   return ModalStep2;
 })(ModalStep || {});
 var AccountStep = /* @__PURE__ */ ((AccountStep2) => {
@@ -79,6 +80,7 @@ var AccountStep = /* @__PURE__ */ ((AccountStep2) => {
   AccountStep2["ACCOUNT_SEND"] = "ACCOUNT_SEND";
   AccountStep2["ACCOUNT_SEND_ASSET"] = "ACCOUNT_SEND_ASSET";
   AccountStep2["ACCOUNT_SEND_NETWORK"] = "ACCOUNT_SEND_NETWORK";
+  AccountStep2["ACCOUNT_MONITOR_TX"] = "ACCOUNT_MONITOR_TX";
   return AccountStep2;
 })(AccountStep || {});
 const RESET_TO_AUTH_STEPS = [
@@ -129,7 +131,8 @@ const RESET_TO_ACCOUNT_STEPS = [
   "ADD_EX_WALLET_SELECTED" /* ADD_EX_WALLET_SELECTED */,
   "ADD_EX_WALLET_NETWORK_SELECT" /* ADD_EX_WALLET_NETWORK_SELECT */,
   "LINK_EX_WALLET_NETWORK_SELECT" /* LINK_EX_WALLET_NETWORK_SELECT */,
-  "EXTERNAL_WALLET_VERIFICATION" /* EXTERNAL_WALLET_VERIFICATION */
+  "EXTERNAL_WALLET_VERIFICATION" /* EXTERNAL_WALLET_VERIFICATION */,
+  "ACCOUNT_MONITOR_TX" /* ACCOUNT_MONITOR_TX */
 ];
 const AccountPreviousStep = {
   ["ACCOUNT_MAIN" /* ACCOUNT_MAIN */]: void 0,
@@ -155,7 +158,8 @@ const AccountPreviousStep = {
   ["LINK_EX_WALLET_NETWORK_SELECT" /* LINK_EX_WALLET_NETWORK_SELECT */]: "ACCOUNT_PROFILE_LIST" /* ACCOUNT_PROFILE_LIST */,
   ["ACCOUNT_SEND" /* ACCOUNT_SEND */]: "ACCOUNT_MAIN" /* ACCOUNT_MAIN */,
   ["ACCOUNT_SEND_ASSET" /* ACCOUNT_SEND_ASSET */]: "ACCOUNT_SEND" /* ACCOUNT_SEND */,
-  ["ACCOUNT_SEND_NETWORK" /* ACCOUNT_SEND_NETWORK */]: "ACCOUNT_SEND_ASSET" /* ACCOUNT_SEND_ASSET */
+  ["ACCOUNT_SEND_NETWORK" /* ACCOUNT_SEND_NETWORK */]: "ACCOUNT_SEND_ASSET" /* ACCOUNT_SEND_ASSET */,
+  ["ACCOUNT_MONITOR_TX" /* ACCOUNT_MONITOR_TX */]: "ACCOUNT_MAIN" /* ACCOUNT_MAIN */
 };
 var SignUpModalStep = /* @__PURE__ */ ((SignUpModalStep2) => {
   SignUpModalStep2["AUTH_MAIN"] = "AUTH_MAIN";

package/dist/provider/hooks/queries/useProfileBalance.js

@@ -1,13 +1,15 @@
 "use client";
 import {
-  __async
+  __async,
+  __spreadProps,
+  __spreadValues
 } from "../../../chunk-MMUBH76A.js";
 import { useQuery } from "@tanstack/react-query";
-import { useRef, useEffect } from "react";
+import { useRef, useEffect, useMemo } from "react";
 import { useStore } from "../../stores/useStore.js";
 import { useInternalClient } from "../utils/useInternalClient.js";
 import { useIsFullyLoggedIn } from "./useIsFullyLoggedIn.js";
-import { filterProfileBalance } from "@getpara/shared";
+import { filterProfileBalance, formatCurrency } from "@getpara/shared";
 const useProfileBalance = (options) => {
   var _a, _b, _c;
   const client = useInternalClient();
@@ -17,6 +19,7 @@ const useProfileBalance = (options) => {
     return (_a2 = state.modalConfig) == null ? void 0 : _a2.balances;
   });
   const refs = useStore((state) => state.refs);
+  const balanceOverrides = useStore((state) => state.balanceOverrides);
   const isComprehensive = (_a = options == null ? void 0 : options.isComprehensive) != null ? _a : false;
   const previousTriggerRef = useRef(options == null ? void 0 : options.refetchTrigger);
   const shouldRefetchRef = useRef(false);
@@ -28,8 +31,10 @@ const useProfileBalance = (options) => {
       previousTriggerRef.current = options == null ? void 0 : options.refetchTrigger;
     }
   }, [options == null ? void 0 : options.refetchTrigger]);
-  return useQuery({
-    enabled: isSuccess && !!client,
+  const requiresOverrides = (config == null ? void 0 : config.useBalanceOverrides) && (config == null ? void 0 : config.displayType) === "AGGREGATED";
+  const shouldUseOverrides = requiresOverrides && !!balanceOverrides;
+  const query = useQuery({
+    enabled: isSuccess && !!client && (!requiresOverrides || !!balanceOverrides),
     queryKey: [
       "useProfileBalance",
       isFullyLoggedIn != null ? isFullyLoggedIn : null,
@@ -56,9 +61,31 @@ const useProfileBalance = (options) => {
       isInitialLoadRef.current = false;
       return isComprehensive ? profileBalance : filterProfileBalance(profileBalance, config || { displayType: "AGGREGATED" });
     }),
-    // We handle refetch manually
     refetchOnWindowFocus: false
   });
+  const data = useMemo(() => {
+    var _a2;
+    const raw = query.data;
+    if (!raw || !shouldUseOverrides) return raw;
+    const overrides = balanceOverrides.value;
+    const result = structuredClone(raw);
+    for (const [walletAddress, override] of Object.entries(overrides)) {
+      const wallet = result.wallets.find((w) => w.address === walletAddress);
+      if (((_a2 = wallet == null ? void 0 : wallet.value) == null ? void 0 : _a2.value) === void 0) continue;
+      if (typeof override !== "number" || !Number.isFinite(override)) continue;
+      wallet.value.value = override;
+      wallet.formattedValue = formatCurrency(wallet.value);
+    }
+    if (result.value) {
+      result.value.value = result.wallets.reduce((sum, wallet) => {
+        var _a3, _b2;
+        return sum + ((_b2 = (_a3 = wallet.value) == null ? void 0 : _a3.value) != null ? _b2 : 0);
+      }, 0);
+      result.formattedValue = formatCurrency(result.value);
+    }
+    return result;
+  }, [query.data, shouldUseOverrides, balanceOverrides == null ? void 0 : balanceOverrides.version]);
+  return __spreadProps(__spreadValues({}, query), { data: data != null ? data : void 0 });
 };
 export {
   useProfileBalance

package/dist/provider/hooks/utils/index.d.ts

@@ -1,3 +1,4 @@
 export { useClient } from './useClient.js';
 export { useModal } from './useModal.js';
 export { useWalletState } from './useWalletState.js';
+export { useSetBalanceOverrides } from './useSetBalanceOverrides.js';

package/dist/provider/hooks/utils/index.js

@@ -3,8 +3,10 @@ import "../../../chunk-MMUBH76A.js";
 import { useClient } from "./useClient.js";
 import { useModal } from "./useModal.js";
 import { useWalletState } from "./useWalletState.js";
+import { useSetBalanceOverrides } from "./useSetBalanceOverrides.js";
 export {
   useClient,
   useModal,
+  useSetBalanceOverrides,
   useWalletState
 };

package/dist/provider/hooks/utils/useEventListeners.js

@@ -11,7 +11,7 @@ import { ACCOUNT_BASE_KEY } from "../queries/useAccount.js";
 import { WALLET_BASE_KEY } from "../queries/useWallet.js";
 import { WALLET_BALANCE_BASE_KEY } from "../queries/useWalletBalance.js";
 import { IS_FULLY_LOGGED_IN_BASE_KEY } from "../queries/useIsFullyLoggedIn.js";
-import { useModalStore } from "../../../modal/stores/index.js";
+import { useModalSessionStore } from "../../../modal/stores/index.js";
 const useEventListeners = ({
   onLogin,
   onLogout,
@@ -29,7 +29,7 @@ const useEventListeners = ({
   const refs = useStore((state) => state.refs);
   const clearSelectedWallet = useStore((state) => state.clearSelectedWallet);
   const { updateSelectedWallet } = useWalletState();
-  const setSendTx = useModalStore((state) => state.setSendTx);
+  const setSendTx = useModalSessionStore((state) => state.setSendTx);
   const loginOrSetupListener = useCallback(() => {
     queryClient.refetchQueries({ queryKey: [IS_FULLY_LOGGED_IN_BASE_KEY] });
     queryClient.refetchQueries({ queryKey: [ACCOUNT_BASE_KEY] });