@silentswap/react 0.0.51 → 0.0.53

package/dist/contexts/SilentSwapContext.js

@@ -72,7 +72,7 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, sol
         autoAuthenticate: true,
     });
     // Wallet management hook
-    const { wallet, generateWallet, refreshWallet, isLoading: walletLoading, } = useWallet({
+    const { wallet, generateWallet, refreshWallet, isLoading: walletLoading, error: walletError, } = useWallet({
         client,
         address: evmAddress,
         auth: auth || undefined,
@@ -121,6 +121,8 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, sol
         setDestinations,
         wallet,
         walletLoading,
+        walletError,
+        generateWallet,
         walletClient,
         connector,
         solanaConnector,

package/dist/hooks/silent/useSilentQuote.d.ts

@@ -40,6 +40,10 @@ export interface useSilentQuoteOptions {
     wallet: SilentSwapWallet | null;
     /** Whether wallet is currently being generated (to prevent swap execution before wallet is ready) */
     walletLoading?: boolean;
+    /** Wallet generation error (if previous generation failed) */
+    walletError?: Error | null;
+    /** Function to generate wallet (for retry on swap execution) */
+    generateWallet?: () => Promise<void>;
     /** Facilitator group for the swap, or a function that resolves it */
     /** Status update callback */
     onStatus?: (status: string) => void;
@@ -87,4 +91,4 @@ export interface ExecuteSwapParams {
     /** Optional integrator ID for tracking */
     integratorId?: string;
 }
-export declare function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, wallet, walletLoading, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, getPrice, setDestinations, }: useSilentQuoteOptions): useSilentQuoteReturn;
+export declare function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, wallet, walletLoading, walletError, generateWallet, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, getPrice, setDestinations, }: useSilentQuoteOptions): useSilentQuoteReturn;

package/dist/hooks/silent/useSilentQuote.js

@@ -1,4 +1,4 @@
-import { useCallback, useMemo, useState } from 'react';
+import { useCallback, useMemo, useState, useRef, useEffect } from 'react';
 import { hexToBase58, isSolanaAsset, parseEvmCaip19, S_CAIP19_USDC_AVALANCHE, NI_CHAIN_ID_AVALANCHE, getAssetByCaip19, } from '@silentswap/sdk';
 import { getAddress } from 'viem';
 import { BigNumber } from 'bignumber.js';
@@ -7,7 +7,7 @@ import { useOrderSigning } from './useOrderSigning.js';
 import { useBridgeExecution } from './useBridgeExecution.js';
 import { useTransaction } from '../useTransaction.js';
 import { useQuoteCalculation } from './useQuoteCalculation.js';
-export function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, wallet, walletLoading = false, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, getPrice, setDestinations, }) {
+export function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, wallet, walletLoading = false, walletError = null, generateWallet, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, getPrice, setDestinations, }) {
     const [isLoading, setIsLoading] = useState(false);
     const [currentStep, setCurrentStep] = useState('');
     const [quote, setQuote] = useState(null);
@@ -15,6 +15,18 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
     const [orderId, setOrderId] = useState(null);
     const [viewingAuth, setViewingAuth] = useState(null);
     const [isSwapping, setIsSwapping] = useState(false);
+    // Use refs to track current wallet state (to avoid stale closure values)
+    const walletRef = useRef(wallet);
+    const walletLoadingRef = useRef(walletLoading);
+    const walletErrorRef = useRef(walletError);
+    const generateWalletRef = useRef(generateWallet);
+    // Update refs when wallet state changes
+    useEffect(() => {
+        walletRef.current = wallet;
+        walletLoadingRef.current = walletLoading;
+        walletErrorRef.current = walletError;
+        generateWalletRef.current = generateWallet;
+    }, [wallet, walletLoading, walletError, generateWallet]);
     // Normalize address - only normalize EVM addresses
     // Note: For Solana swaps, we still need an EVM address for facilitator operations
     // The address parameter should be EVM for facilitator operations, but can be Solana for quote requests
@@ -93,9 +105,49 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
         if (!walletClient) {
             throw new Error('Wallet client required for swap execution');
         }
-        // Check if wallet is being generated - wait a bit and check again
-        if (walletLoading) {
-            throw new Error('Wallet is being generated. Please wait for wallet generation to complete before executing swap.');
+        // Check if wallet generation previously failed - retry if so
+        if (!walletRef.current && walletErrorRef.current && generateWalletRef.current && !walletLoadingRef.current) {
+            setCurrentStep('Retrying wallet generation...');
+            onStatus?.('Retrying wallet generation...');
+            try {
+                await generateWalletRef.current();
+                // Wait for wallet to be ready after retry (with timeout)
+                const maxWaitTime = 30000; // 30 seconds
+                const checkInterval = 100; // Check every 100ms
+                const startTime = Date.now();
+                while (!walletRef.current && Date.now() - startTime < maxWaitTime) {
+                    await new Promise((resolve) => setTimeout(resolve, checkInterval));
+                }
+                // If wallet is still not ready after retry, throw error
+                if (!walletRef.current) {
+                    throw new Error('Wallet generation retry completed but wallet is still not available. Please try again.');
+                }
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error('Failed to generate wallet');
+                throw new Error(`Wallet generation failed: ${error.message}. Please try again or ensure wallet is connected and authenticated.`);
+            }
+        }
+        // Wait for wallet to be ready if it's being generated
+        // Use refs to check current state (avoid stale closure values)
+        if (!walletRef.current && walletLoadingRef.current) {
+            setCurrentStep('Waiting for wallet generation...');
+            onStatus?.('Waiting for wallet generation...');
+            // Wait for wallet generation to complete (with timeout)
+            const maxWaitTime = 30000; // 30 seconds
+            const checkInterval = 100; // Check every 100ms
+            const startTime = Date.now();
+            while (!walletRef.current && walletLoadingRef.current && Date.now() - startTime < maxWaitTime) {
+                await new Promise((resolve) => setTimeout(resolve, checkInterval));
+            }
+            // If wallet is still not ready after waiting, throw error
+            if (!walletRef.current) {
+                throw new Error('Wallet is being generated. Please wait for wallet generation to complete before executing swap.');
+            }
+        }
+        // Final check: wallet must exist for swap execution
+        if (!walletRef.current) {
+            throw new Error('Wallet is required for swap execution. Please ensure wallet is connected and authenticated.');
         }
         setIsLoading(true);
         setError(null);
@@ -233,6 +285,8 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
         evmAddress,
         walletClient,
         walletLoading,
+        walletError,
+        generateWallet,
         solanaConnector,
         signAuthorizations,
         createOrder,

package/dist/hooks/usePlatformHealth.d.ts

@@ -0,0 +1,45 @@
+import React from 'react';
+export type PlatformHealthStatus = 'ON' | 'ONLINE' | 'PAUSED' | 'DEPOSITS_PAUSED' | 'OFF' | 'MAINTENANCE' | 'UNKNOWN';
+export type PlatformHealthContextType = {
+    platformHealth: PlatformHealthStatus | null;
+    maximumDepositUusdc: string | undefined;
+    minimumDepositUusdc: string | undefined;
+    outputLimit: number | undefined;
+    serviceFeeRate: number | undefined;
+    overheadUsd: number | undefined;
+    formDisabled: boolean;
+    trackingDisabled: boolean;
+    validateDepositAmount: (usdAmount: string | number) => {
+        valid: boolean;
+        error?: string;
+    };
+    validateOutputCount: (count: number) => {
+        valid: boolean;
+        error?: string;
+    };
+    getMinimumDepositUsd: () => number | null;
+    getMaximumDepositUsd: () => number | null;
+    getServiceFeeRate: () => number | null;
+};
+export type PlatformHealthProviderProps = {
+    children: React.ReactNode;
+    /**
+     * Optional callback to update form disabled state in app state
+     * If not provided, formDisabled will always be false in the context
+     */
+    onFormDisabledChange?: (disabled: boolean) => void;
+    /**
+     * Optional callback to update tracking disabled state in app state
+     * If not provided, trackingDisabled will always be false in the context
+     */
+    onTrackingDisabledChange?: (disabled: boolean) => void;
+};
+/**
+ * Provider that monitors platform health from status API and provides validation functions
+ * for deposit amounts, output limits, and service fee rates
+ */
+export declare function PlatformHealthProvider({ children, onFormDisabledChange, onTrackingDisabledChange, }: PlatformHealthProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access platform health context
+ */
+export declare function usePlatformHealthContext(): PlatformHealthContextType;

package/dist/hooks/usePlatformHealth.js

@@ -0,0 +1,172 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { createContext, useContext, useEffect, useMemo, useCallback } from 'react';
+import { useStatus } from '../hooks/useStatus.js';
+import { BigNumber } from 'bignumber.js';
+const PlatformHealthContext = createContext(undefined);
+/**
+ * Provider that monitors platform health from status API and provides validation functions
+ * for deposit amounts, output limits, and service fee rates
+ */
+export function PlatformHealthProvider({ children, onFormDisabledChange, onTrackingDisabledChange, }) {
+    const { platformHealth: statusPlatformHealth, maximumDepositUusdc, minimumDepositUusdc, outputLimit, serviceFeeRate, overheadUsd, } = useStatus();
+    // Normalize platform health status
+    const platformHealth = useMemo(() => {
+        if (!statusPlatformHealth)
+            return null;
+        return statusPlatformHealth;
+    }, [statusPlatformHealth]);
+    // Track disabled states locally for context value
+    const [formDisabled, setFormDisabled] = React.useState(false);
+    const [trackingDisabled, setTrackingDisabled] = React.useState(false);
+    // Update app state based on platform health
+    useEffect(() => {
+        if (!platformHealth) {
+            // Default to enabled if no platform health info
+            const newFormDisabled = false;
+            const newTrackingDisabled = false;
+            setFormDisabled(newFormDisabled);
+            setTrackingDisabled(newTrackingDisabled);
+            onFormDisabledChange?.(newFormDisabled);
+            onTrackingDisabledChange?.(newTrackingDisabled);
+            return;
+        }
+        // Update app state based on platform health (matching Svelte fees.ts logic)
+        let newFormDisabled = false;
+        let newTrackingDisabled = false;
+        switch (platformHealth) {
+            case 'ON':
+            case 'ONLINE':
+                // Everything enabled
+                newFormDisabled = false;
+                newTrackingDisabled = false;
+                break;
+            case 'PAUSED':
+            case 'DEPOSITS_PAUSED':
+                // Form disabled, tracking still enabled
+                newFormDisabled = true;
+                newTrackingDisabled = false;
+                break;
+            case 'OFF':
+            case 'MAINTENANCE':
+            case 'UNKNOWN':
+            default:
+                // Both form and tracking disabled
+                newFormDisabled = true;
+                newTrackingDisabled = true;
+                break;
+        }
+        setFormDisabled(newFormDisabled);
+        setTrackingDisabled(newTrackingDisabled);
+        onFormDisabledChange?.(newFormDisabled);
+        onTrackingDisabledChange?.(newTrackingDisabled);
+    }, [platformHealth, onFormDisabledChange, onTrackingDisabledChange]);
+    // Convert uusdc (micro-USDC) to USDC: 1 USDC = 1,000,000 uusdc
+    const getMinimumDepositUsd = useCallback(() => {
+        if (!minimumDepositUusdc)
+            return null;
+        try {
+            const uusdc = BigNumber(minimumDepositUusdc);
+            // Convert from micro-USDC to USDC (divide by 1e6)
+            return uusdc.dividedBy(1000000).toNumber();
+        }
+        catch {
+            return null;
+        }
+    }, [minimumDepositUusdc]);
+    const getMaximumDepositUsd = useCallback(() => {
+        if (!maximumDepositUusdc)
+            return null;
+        try {
+            const uusdc = BigNumber(maximumDepositUusdc);
+            // Convert from micro-USDC to USDC (divide by 1e6)
+            return uusdc.dividedBy(1000000).toNumber();
+        }
+        catch {
+            return null;
+        }
+    }, [maximumDepositUusdc]);
+    const getServiceFeeRate = useCallback(() => {
+        if (!serviceFeeRate)
+            return null;
+        try {
+            return +serviceFeeRate;
+        }
+        catch {
+            return null;
+        }
+    }, [serviceFeeRate]);
+    // Validate deposit amount against min/max limits
+    const validateDepositAmount = useCallback((usdAmount) => {
+        const amount = typeof usdAmount === 'string' ? parseFloat(usdAmount) : usdAmount;
+        if (isNaN(amount) || amount <= 0) {
+            return { valid: false, error: 'Amount must be greater than zero' };
+        }
+        const minUsd = getMinimumDepositUsd();
+        const maxUsd = getMaximumDepositUsd();
+        if (minUsd !== null && amount < minUsd) {
+            return { valid: false, error: `Minimum deposit is $${minUsd.toFixed(2)}` };
+        }
+        if (maxUsd !== null && amount > maxUsd) {
+            return { valid: false, error: `Maximum deposit is $${maxUsd.toFixed(2)}` };
+        }
+        return { valid: true };
+    }, [getMinimumDepositUsd, getMaximumDepositUsd]);
+    // Validate output count against limit
+    const validateOutputCount = useCallback((count) => {
+        if (outputLimit === null || outputLimit === undefined) {
+            // No limit set, allow any count
+            return { valid: true };
+        }
+        if (count < 1) {
+            return { valid: false, error: 'At least one output destination is required' };
+        }
+        if (count > outputLimit) {
+            return {
+                valid: false,
+                error: `Maximum ${outputLimit} output destination${outputLimit === 1 ? '' : 's'} allowed`,
+            };
+        }
+        return { valid: true };
+    }, [outputLimit]);
+    const value = useMemo(() => ({
+        platformHealth,
+        maximumDepositUusdc,
+        minimumDepositUusdc,
+        outputLimit: outputLimit ?? undefined,
+        serviceFeeRate: serviceFeeRate ?? undefined,
+        overheadUsd: overheadUsd ?? undefined,
+        formDisabled,
+        trackingDisabled,
+        validateDepositAmount,
+        validateOutputCount,
+        getMinimumDepositUsd,
+        getMaximumDepositUsd,
+        getServiceFeeRate,
+    }), [
+        platformHealth,
+        maximumDepositUusdc,
+        minimumDepositUusdc,
+        outputLimit,
+        serviceFeeRate,
+        overheadUsd,
+        formDisabled,
+        trackingDisabled,
+        validateDepositAmount,
+        validateOutputCount,
+        getMinimumDepositUsd,
+        getMaximumDepositUsd,
+        getServiceFeeRate,
+    ]);
+    return _jsx(PlatformHealthContext.Provider, { value: value, children: children });
+}
+/**
+ * Hook to access platform health context
+ */
+export function usePlatformHealthContext() {
+    const context = useContext(PlatformHealthContext);
+    if (context === undefined) {
+        throw new Error('usePlatformHealthContext must be used within a PlatformHealthProvider');
+    }
+    return context;
+}

package/dist/hooks/usePlatformHealthMonitor.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+export type PlatformHealthMonitorProps = {
+    /**
+     * Component to render when maintenance mode is active
+     * Receives `enabled` prop indicating if maintenance mode is active
+     */
+    MaintenanceComponent: React.ComponentType<{
+        enabled: boolean;
+    }>;
+};
+/**
+ * Hook that determines if platform is in maintenance mode
+ * Returns the maintenance status based on platform health
+ */
+export declare function usePlatformHealthMonitor(): {
+    isMaintenanceMode: boolean;
+    platformHealth: import("./usePlatformHealth.js").PlatformHealthStatus | null;
+};
+/**
+ * Component that renders MaintenanceComponent when platform is down for maintenance
+ * Should be mounted at the root level to ensure it runs on every page
+ * The actual platform health monitoring is done in PlatformHealthProvider
+ */
+export declare function PlatformHealthMonitor({ MaintenanceComponent }: PlatformHealthMonitorProps): import("react/jsx-runtime").JSX.Element;

package/dist/hooks/usePlatformHealthMonitor.js

@@ -0,0 +1,25 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { usePlatformHealthContext } from './usePlatformHealth.js';
+/**
+ * Hook that determines if platform is in maintenance mode
+ * Returns the maintenance status based on platform health
+ */
+export function usePlatformHealthMonitor() {
+    const { platformHealth } = usePlatformHealthContext();
+    // Show maintenance modal when status is 'OFF' or 'MAINTENANCE'
+    const isMaintenanceMode = platformHealth === 'OFF' || platformHealth === 'MAINTENANCE' || platformHealth === 'UNKNOWN';
+    return {
+        isMaintenanceMode,
+        platformHealth,
+    };
+}
+/**
+ * Component that renders MaintenanceComponent when platform is down for maintenance
+ * Should be mounted at the root level to ensure it runs on every page
+ * The actual platform health monitoring is done in PlatformHealthProvider
+ */
+export function PlatformHealthMonitor({ MaintenanceComponent }) {
+    const { isMaintenanceMode } = usePlatformHealthMonitor();
+    return _jsx(MaintenanceComponent, { enabled: isMaintenanceMode });
+}

package/dist/index.d.ts

@@ -25,6 +25,10 @@ export { useEgressEstimates } from './hooks/useEgressEstimates.js';
 export type { UseEgressEstimatesOptions } from './hooks/useEgressEstimates.js';
 export { useStatus } from './hooks/useStatus.js';
 export type { StatusResponse } from './hooks/useStatus.js';
+export { PlatformHealthProvider, usePlatformHealthContext } from './hooks/usePlatformHealth.js';
+export type { PlatformHealthStatus, PlatformHealthContextType, PlatformHealthProviderProps, } from './hooks/usePlatformHealth.js';
+export { PlatformHealthMonitor, usePlatformHealthMonitor, } from './hooks/usePlatformHealthMonitor.js';
+export type { PlatformHealthMonitorProps } from './hooks/usePlatformHealthMonitor.js';
 export { useHiddenSwapFees } from './hooks/useHiddenSwapFees.js';
 export type { HiddenSwapFees, UseHiddenSwapFeesOptions } from './hooks/useHiddenSwapFees.js';
 export { useSlippageUsd } from './hooks/useSlippageUsd.js';

package/dist/index.js

@@ -17,6 +17,8 @@ export { usePrices } from './hooks/usePrices.js';
 export { useSwap, getSourceAssetCaip19, X_RANGE_SLIDER_MIN_GAP, OUTPUT_LIMIT, DEFAULT_SOURCE_ASSET, DEFAULT_DEST_ASSET, } from './hooks/useSwap.js';
 export { useEgressEstimates } from './hooks/useEgressEstimates.js';
 export { useStatus } from './hooks/useStatus.js';
+export { PlatformHealthProvider, usePlatformHealthContext } from './hooks/usePlatformHealth.js';
+export { PlatformHealthMonitor, usePlatformHealthMonitor, } from './hooks/usePlatformHealthMonitor.js';
 export { useHiddenSwapFees } from './hooks/useHiddenSwapFees.js';
 export { useSlippageUsd } from './hooks/useSlippageUsd.js';
 export { useResetSwapForm } from './hooks/useResetSwapForm.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@silentswap/react",
   "type": "module",
-  "version": "0.0.51",
+  "version": "0.0.53",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,8 +23,8 @@
   },
   "dependencies": {
     "@ensdomains/ensjs": "^4.2.0",
-    "@silentswap/sdk": "0.0.51",
-    "@silentswap/ui-kit": "0.0.51",
+    "@silentswap/sdk": "0.0.53",
+    "@silentswap/ui-kit": "0.0.53",
     "@solana/codecs-strings": "^5.1.0",
     "@solana/kit": "^5.1.0",
     "@solana/rpc": "^5.1.0",