@silentswap/react 0.0.51 → 0.0.52

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.52",
   "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.52",
+    "@silentswap/ui-kit": "0.0.52",
     "@solana/codecs-strings": "^5.1.0",
     "@solana/kit": "^5.1.0",
     "@solana/rpc": "^5.1.0",