@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

package/dist/hooks/useFormValidation.js

@@ -0,0 +1,62 @@
+import { isValidAddress } from '../lib/address/validator';
+export function resolveFormValidation({ values, maxAllowedAmount, minAllowedAmount, sourceAddress, sameAccountNetwork, quoteError }) {
+    let amount = values.amount ? Number(values.amount) : undefined;
+    if (!values.from && !values.fromExchange) {
+        return { message: 'Select source' };
+    }
+    if (values.fromExchange && values.toAsset && values.toAsset?.status === 'inactive') {
+        return { message: 'Route unavailable' };
+    }
+    if (!values.to) {
+        return { message: 'Select destination' };
+    }
+    if (!values.fromAsset) {
+        return { message: 'Select source asset' };
+    }
+    if (!values.toAsset) {
+        return { message: 'Select destination asset' };
+    }
+    if (!amount) {
+        return { message: 'Enter an amount' };
+    }
+    if (!/^[0-9]*[.,]?[0-9]*$/i.test(amount.toString())) {
+        return { message: 'Invalid amount' };
+    }
+    if (amount < 0) {
+        return { message: "Can't be negative" };
+    }
+    if (maxAllowedAmount != undefined && amount > maxAllowedAmount) {
+        return { message: `Max amount is ${maxAllowedAmount}` };
+    }
+    if (minAllowedAmount != undefined && amount < minAllowedAmount) {
+        return { message: `Min amount is ${minAllowedAmount}` };
+    }
+    if (values.to) {
+        if (values.destination_address && !isValidAddress(values.destination_address, values.to)) {
+            return { message: `Enter a valid ${values.to?.display_name} address` };
+        }
+    }
+    if (values.fromAsset?.status === 'not_found' ||
+        values.toAsset?.status === 'not_found') {
+        return { message: `Route unavailable` };
+    }
+    if (values.fromAsset?.status === 'inactive' ||
+        values.toAsset?.status === 'inactive') {
+        return { message: `Route unavailable` };
+    }
+    if (values.from?.name.toLowerCase() === sameAccountNetwork?.toLowerCase() ||
+        values.to?.name.toLowerCase() === sameAccountNetwork?.toLowerCase()) {
+        if (sourceAddress &&
+            values.destination_address &&
+            sourceAddress.toLowerCase() !== values.destination_address.toLowerCase()) {
+            return { message: `Address update required` };
+        }
+        if (values.depositMethod === "deposit_address") {
+            return { message: 'Manual Transfer is not supported' };
+        }
+    }
+    if (quoteError) {
+        return { message: quoteError.response?.data?.error?.message || 'Unable to retrieve quote' };
+    }
+    return { message: '' };
+}

package/dist/hooks/useRouteValidation.d.ts

@@ -0,0 +1,11 @@
+import { QuoteError } from './useFee';
+interface ValidationDetails {
+    title?: string;
+    type?: string;
+    icon?: React.ReactNode;
+}
+export declare function resolveRouteValidation(quoteError?: QuoteError): {
+    message: string;
+    details: ValidationDetails;
+};
+export {};

package/dist/hooks/useRouteValidation.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Info, RouteOff } from 'lucide-react';
+import { useMemo } from 'react';
+import { useSettingsState } from '../context/settings';
+import { useInitialSettings } from '../context/settings';
+import { useFormikContext } from 'formik';
+import useWallet from './useWallet';
+import { useSelectedAccount } from '../context/balanceAccounts';
+const ICON_CLASSES_WARNING = 'w-5 h-5 text-warning-foreground';
+export function resolveRouteValidation(quoteError) {
+    const { values } = useFormikContext();
+    const { destinationRoutes: allDestinations, sourceRoutes: allSources } = useSettingsState();
+    const { to, from, fromAsset: fromCurrency, toAsset: toCurrency, fromExchange, validatingSource, validatingDestination, destination_address } = values;
+    const { provider } = useWallet(from, "withdrawal");
+    const selectedSourceAccount = useSelectedAccount("from", provider?.name);
+    const initialSettings = useInitialSettings();
+    const fromDisplayName = fromExchange ? fromExchange.display_name : from?.display_name;
+    const toDisplayName = to?.display_name;
+    const quoteMessage = quoteError?.response?.data?.error?.message || quoteError?.message;
+    let validationMessage = '';
+    let validationDetails = {};
+    if (initialSettings?.lockToAsset) {
+        if (fromCurrency?.status === 'not_found') {
+            validationMessage = `Transfers from ${fromDisplayName} ${fromCurrency?.symbol || fromCurrency?.symbol} to this token are not supported`;
+            validationDetails = { title: 'Route Unavailable', type: 'warning', icon: _jsx(RouteOff, { className: ICON_CLASSES_WARNING }) };
+        }
+        else if (fromCurrency?.status === 'inactive') {
+            validationMessage = `Sorry, transfers of ${fromCurrency?.symbol} from ${fromDisplayName} are not available at the moment. Please try later.`;
+            validationDetails = { title: 'Temporarily unavailable.', type: 'warning', icon: _jsx(Info, { className: ICON_CLASSES_WARNING }) };
+        }
+        else if (!toCurrency) {
+            validationMessage = `Sorry, transfers of ${initialSettings?.toAsset} to ${toDisplayName || initialSettings.to} are not available at the moment. Please try later.`;
+            validationDetails = { title: 'Temporarily unavailable.', type: 'warning', icon: _jsx(Info, { className: ICON_CLASSES_WARNING }) };
+        }
+    }
+    else if (initialSettings?.lockFromAsset) {
+        if (toCurrency?.status === 'not_found') {
+            validationMessage = `Transfers to ${toDisplayName} ${toCurrency?.symbol} from this token are not supported`;
+            validationDetails = { title: 'Route Unavailable', type: 'warning', icon: _jsx(RouteOff, { className: ICON_CLASSES_WARNING }) };
+        }
+        else if (toCurrency?.status === 'inactive') {
+            validationMessage = `Sorry, transfers of ${toCurrency?.symbol} to ${toDisplayName} are not available at the moment. Please try later.`;
+            validationDetails = { title: 'Temporarily unavailable.', type: 'warning', icon: _jsx(Info, { className: ICON_CLASSES_WARNING }) };
+        }
+        else if (!fromCurrency) {
+            validationMessage = `Sorry, transfers of ${initialSettings?.fromAsset} from ${fromDisplayName || initialSettings.from} are not available at the moment. Please try later.`;
+            validationDetails = { title: 'Temporarily unavailable.', type: 'warning', icon: _jsx(Info, { className: ICON_CLASSES_WARNING }) };
+        }
+    }
+    else if (toCurrency?.status === 'inactive' || fromCurrency?.status === 'inactive') {
+        const unfilteredDestinationRoute = allDestinations?.find(r => r.name === to?.name);
+        const unfilteredDestinationCurrency = unfilteredDestinationRoute?.tokens?.find(t => t.symbol === toCurrency?.symbol);
+        const unfilteredSourceRoute = allSources?.find(r => r.name === from?.name);
+        const unfilteredSourceCurrency = unfilteredSourceRoute?.tokens?.find(t => t.symbol === fromCurrency?.symbol);
+        if (unfilteredDestinationCurrency?.status === 'inactive') {
+            validationMessage = `Sorry, transfers of ${toCurrency?.symbol} to ${toDisplayName} are not available at the moment. Please try later.`;
+            validationDetails = { title: 'Temporarily unavailable.', type: 'warning', icon: _jsx(Info, { className: ICON_CLASSES_WARNING }) };
+        }
+        else if (unfilteredSourceCurrency?.status === 'inactive') {
+            validationMessage = `Sorry, transfers of ${fromCurrency?.symbol} from ${fromDisplayName} are not available at the moment. Please try later.`;
+            validationDetails = { title: 'Temporarily unavailable.', type: 'warning', icon: _jsx(Info, { className: ICON_CLASSES_WARNING }) };
+        }
+        else {
+            validationMessage = `Please change one of the selected tokens or try later.`;
+            validationDetails = { title: 'Temporarily unavailable.', type: 'warning', icon: _jsx(Info, { className: ICON_CLASSES_WARNING }) };
+        }
+    }
+    else if (!validatingSource && !validatingDestination && (toCurrency?.status === 'not_found' || fromCurrency?.status === 'not_found')) {
+        validationMessage = 'Please change one of the selected tokens';
+        validationDetails = { title: 'Route Unavailable', type: 'warning', icon: _jsx(RouteOff, { className: ICON_CLASSES_WARNING }) };
+    }
+    if (((from?.name && from?.name.toLowerCase() === initialSettings.sameAccountNetwork?.toLowerCase()) || (to?.name && to?.name.toLowerCase() === initialSettings.sameAccountNetwork?.toLowerCase()))) {
+        const network = from?.name.toLowerCase() === initialSettings.sameAccountNetwork?.toLowerCase() ? from : to;
+        if ((selectedSourceAccount && destination_address && selectedSourceAccount?.address?.toLowerCase() !== destination_address?.toLowerCase())) {
+            validationMessage = `Transfers between ${network?.display_name} and other chains are only allowed within the same account. Please make sure you're using the same address on both source and destination.`;
+            validationDetails = { title: 'Action Needed', type: 'warning', icon: _jsx(RouteOff, { className: ICON_CLASSES_WARNING }) };
+        }
+        if (values.depositMethod === "deposit_address") {
+            validationMessage = `Manually transferring between ${from?.display_name} and ${to?.display_name} networks is not supported.`;
+            validationDetails = { title: 'Manual Transfer is not supported', type: 'warning', icon: _jsx(RouteOff, { className: ICON_CLASSES_WARNING }) };
+        }
+    }
+    if (quoteError) {
+        validationMessage = '';
+        validationDetails = { title: quoteMessage || 'Unable to retrieve quote', type: 'warning', icon: _jsx(RouteOff, { className: ICON_CLASSES_WARNING }) };
+    }
+    const value = useMemo(() => ({
+        message: validationMessage,
+        details: validationDetails
+    }), [validationMessage, validationDetails]);
+    return value;
+}

package/dist/hooks/useSwapHistoryData.d.ts

@@ -0,0 +1,30 @@
+import { SwapResponse } from '../lib/apiClients/layerSwapApiClient';
+import { ApiResponse } from '../Models/ApiResponse';
+export declare function useSwapHistoryData(addresses?: string[]): {
+    pendingDeposit: {
+        pages: ApiResponse<SwapResponse[]>[];
+        swaps: SwapResponse[];
+        size: number;
+        setSize: (size: number | ((_size: number) => number)) => Promise<ApiResponse<SwapResponse[]>[] | undefined>;
+        loadMore: () => Promise<ApiResponse<SwapResponse[]>[] | undefined>;
+        isLoading: boolean;
+        isValidating: boolean;
+        hasMore: boolean;
+        error: any;
+        mutate: import("swr/dist/infinite").SWRInfiniteKeyedMutator<ApiResponse<SwapResponse[]>[]>;
+    };
+    completed: {
+        pages: ApiResponse<SwapResponse[]>[];
+        swaps: SwapResponse[];
+        size: number;
+        setSize: (size: number | ((_size: number) => number)) => Promise<ApiResponse<SwapResponse[]>[] | undefined>;
+        loadMore: () => Promise<ApiResponse<SwapResponse[]>[] | undefined>;
+        isLoading: boolean;
+        isValidating: boolean;
+        hasMore: boolean;
+        error: any;
+        mutate: import("swr/dist/infinite").SWRInfiniteKeyedMutator<ApiResponse<SwapResponse[]>[]>;
+    };
+    isLoadingAny: boolean;
+    isValidatingAny: boolean;
+};

package/dist/hooks/useSwapHistoryData.js

@@ -0,0 +1,37 @@
+import { useState } from 'react';
+import { useSwrSwaps } from './useSwrSwaps';
+import { SwapStatus } from '../Models/SwapStatus';
+export function useSwapHistoryData(addresses) {
+    const [revalidateAll, setRevalidateAll] = useState(false);
+    const pendingDeposit = useSwrSwaps({
+        statuses: ['PendingDeposit'],
+        addresses,
+        refreshInterval: (data) => {
+            const hasAny = !!data?.some((p) => (p?.data?.length ?? 0) > 0);
+            if (!hasAny)
+                return 30000;
+            setRevalidateAll(true);
+            return 2000;
+        },
+        revalidateAll: true,
+        revalidateFirstPage: true,
+    });
+    const completed = useSwrSwaps({
+        statuses: ['Completed', 'Refunded', 'PendingWithdrawal', 'PendingRefund'],
+        addresses,
+        refreshInterval: (data) => {
+            const hasAnyInProgress = !!data?.some((p) => (p?.data?.some(s => s.swap.status === SwapStatus.PendingRefund || s.swap.status === SwapStatus.LsTransferPending)));
+            if (!hasAnyInProgress)
+                return 0;
+            return 2000;
+        },
+        revalidateAll,
+        revalidateFirstPage: true,
+    });
+    return {
+        pendingDeposit,
+        completed,
+        isLoadingAny: pendingDeposit.isLoading || completed.isLoading,
+        isValidatingAny: pendingDeposit.isValidating || completed.isValidating,
+    };
+}

package/dist/hooks/useSwrSwaps.d.ts

@@ -0,0 +1,22 @@
+import { SwapResponse } from '../lib/apiClients/layerSwapApiClient';
+import { ApiResponse } from '../Models/ApiResponse';
+export type UseSwrSwapsArgs = {
+    statuses: string[];
+    addresses?: string[];
+    refreshInterval: number | ((data?: ApiResponse<SwapResponse[]>[] | undefined) => number);
+    autoLoadAllInitially?: boolean;
+    revalidateAll?: boolean;
+    revalidateFirstPage?: boolean;
+};
+export declare function useSwrSwaps({ statuses, addresses, refreshInterval, autoLoadAllInitially, revalidateAll, revalidateFirstPage }: UseSwrSwapsArgs): {
+    pages: ApiResponse<SwapResponse[]>[];
+    swaps: SwapResponse[];
+    size: number;
+    setSize: (size: number | ((_size: number) => number)) => Promise<ApiResponse<SwapResponse[]>[] | undefined>;
+    loadMore: () => Promise<ApiResponse<SwapResponse[]>[] | undefined>;
+    isLoading: boolean;
+    isValidating: boolean;
+    hasMore: boolean;
+    error: any;
+    mutate: import("swr/infinite").SWRInfiniteKeyedMutator<ApiResponse<SwapResponse[]>[]>;
+};

package/dist/hooks/useSwrSwaps.js

@@ -0,0 +1,53 @@
+import useSWRInfinite from 'swr/infinite';
+import { useEffect } from 'react';
+import LayerSwapApiClient from '../lib/apiClients/layerSwapApiClient';
+import { EmptyApiResponse } from '../Models/ApiResponse';
+const PAGE_SIZE = 20;
+const getSwapsKey = (index, statuses, addresses) => {
+    const addressesParams = addresses?.map(a => `&addresses=${a}`).join('') || '';
+    const statusesParams = statuses.map(s => `&statuses=${s}`).join('') || '';
+    return `/internal/swaps?page=${index + 1}${statusesParams}${addressesParams}`;
+};
+export function useSwrSwaps({ statuses, addresses, refreshInterval, autoLoadAllInitially, revalidateAll, revalidateFirstPage }) {
+    const apiClient = new LayerSwapApiClient();
+    const getKey = (pageIndex, previous) => {
+        if (previous instanceof EmptyApiResponse)
+            return null;
+        if (previous && 'data' in previous && !(previous?.data?.length))
+            return null;
+        return getSwapsKey(pageIndex, statuses, addresses);
+    };
+    const { data, size, setSize, isLoading, isValidating, mutate, error } = useSWRInfinite(getKey, apiClient.fetcher, {
+        revalidateAll,
+        revalidateFirstPage,
+        dedupingInterval: 3000,
+        refreshInterval,
+    });
+    const pages = data ?? [];
+    const swaps = pages.flatMap(p => (p?.data ?? []));
+    const isEmpty = !isLoading && swaps.length === 0;
+    const hasMore = !(isEmpty || (pages.length && ((pages[pages.length - 1]?.data?.length ?? 0) < PAGE_SIZE)));
+    // Auto-load all pages on initial mount for small datasets (like in-progress)
+    useEffect(() => {
+        if (!autoLoadAllInitially)
+            return;
+        if (!pages.length)
+            return;
+        const lastPageLen = (pages[pages.length - 1]?.data?.length ?? 0);
+        if (lastPageLen === PAGE_SIZE && !isValidating) {
+            setSize(size + 1);
+        }
+    }, [autoLoadAllInitially, pages, isValidating, setSize, size]);
+    return {
+        pages,
+        swaps,
+        size,
+        setSize,
+        loadMore: () => setSize(size + 1),
+        isLoading,
+        isValidating,
+        hasMore,
+        error,
+        mutate,
+    };
+}

package/dist/hooks/useWallet.js

@@ -1,51 +1,64 @@
-'use client';
-import useEVM from "../lib/wallets/evm/useEVM";
-// import useTron from "../lib/wallets/tron/useTron";
-import { useMemo } from "react";
-// import useParadex from "../lib/wallets/paradex/useParadex";
-import { useSettingsState } from "../context/settings";
-import { useWalletProviderOverrides } from "../context/walletHooksProvider";
+import { useCallback, useMemo } from "react";
+import { useWalletProviders } from "../context/walletProviders";
 export default function useWallet(network, purpose) {
-    const { networks } = useSettingsState();
-    const overrides = useWalletProviderOverrides();
-    const walletProviders = [
-        overrides?.evm ?? useEVM({ network }),
-        // useStarknet(),
-        // useImtblX(),
-        // useSVM({ network }),
-        // useTON(),
-        // useFuel(),
-        // useTron(),
-        // useParadex({ network })
-    ].filter(provider => networks.some(obj => provider?.autofillSupportedNetworks?.includes(obj.name) || provider?.withdrawalSupportedNetworks?.includes(obj.name) || provider?.asSourceSupportedNetworks?.includes(obj.name)));
-    const provider = network && resolveProvider(network, walletProviders, purpose);
+    const walletProviders = useWalletProviders();
+    const provider = useMemo(() => network && resolveProvider(network, walletProviders, purpose), [network, purpose, walletProviders]);
     const wallets = useMemo(() => {
         let connectedWallets = [];
-        walletProviders.forEach((wallet) => {
-            const w = wallet.connectedWallets;
+        walletProviders.forEach((provider) => {
+            const w = provider.connectedWallets?.map(wallet => {
+                return {
+                    ...wallet,
+                    isNotAvailable: (provider.isNotAvailableCondition && network?.name && wallet.internalId) ? provider.isNotAvailableCondition(wallet.internalId, network?.name) : false,
+                };
+            });
             connectedWallets = w ? [...connectedWallets, ...w] : [...connectedWallets];
         });
         return connectedWallets;
-    }, [walletProviders]);
-    const getProvider = (network, purpose) => {
+    }, [walletProviders, network]);
+    const getProvider = useCallback((network, purpose) => {
         return network && resolveProvider(network, walletProviders, purpose);
-    };
-    return {
+    }, [walletProviders, purpose]);
+    const res = useMemo(() => ({
         wallets,
         provider,
         providers: walletProviders,
         getProvider
-    };
+    }), [wallets, provider, walletProviders, getProvider]);
+    return res;
 }
 const resolveProvider = (network, walletProviders, purpose) => {
     if (!purpose || !network)
         return;
+    let provider = undefined;
     switch (purpose) {
         case "withdrawal":
-            return walletProviders.find(provider => provider.withdrawalSupportedNetworks?.includes(network.name));
+            provider = walletProviders.find(provider => provider.withdrawalSupportedNetworks?.includes(network.name));
+            break;
         case "autofil":
-            return walletProviders.find(provider => provider.autofillSupportedNetworks?.includes(network.name));
+            provider = walletProviders.find(provider => provider.autofillSupportedNetworks?.includes(network.name));
+            break;
         case "asSource":
-            return walletProviders.find(provider => provider.asSourceSupportedNetworks?.includes(network.name));
+            provider = walletProviders.find(provider => provider.asSourceSupportedNetworks?.includes(network.name));
+            break;
     }
+    if (provider?.isNotAvailableCondition) {
+        const availableWalletsForConnect = provider.availableWalletsForConnect?.filter(connector => (provider.isNotAvailableCondition && network?.name) ? !provider.isNotAvailableCondition(connector.id, network?.name) : true);
+        const resolvedProvider = {
+            ...provider,
+            connectedWallets: provider.connectedWallets?.map(wallet => {
+                return {
+                    ...wallet,
+                    isNotAvailable: (provider.isNotAvailableCondition && network?.name && wallet.internalId) ? provider.isNotAvailableCondition(wallet.internalId, network?.name) : false,
+                };
+            }),
+            activeWallet: provider.activeWallet ? {
+                ...provider.activeWallet,
+                isNotAvailable: (network?.name) ? provider.isNotAvailableCondition(provider.activeWallet.id, network?.name) : false,
+            } : undefined,
+            availableWalletsForConnect
+        };
+        return resolvedProvider;
+    }
+    return provider;
 };

package/dist/hooks/useWalletTransferOptions.js

@@ -6,32 +6,32 @@ import { useContractWalletsStore } from "../stores/contractWalletsStore";
 import resolveChain from "../lib/resolveChain";
 import { createPublicClient, http } from "viem";
 import { useSettingsState } from "../context/settings";
+import { useSelectedAccount } from "../context/balanceAccounts";
 export default function useWalletTransferOptions() {
-    const { swapResponse } = useSwapDataState();
+    const { swapBasicData } = useSwapDataState();
     const { networks } = useSettingsState();
-    const { swap } = swapResponse || {};
-    const { source_network } = swap || {};
+    const { source_network } = swapBasicData || {};
     const { addContractWallet, getContractWallet, updateContractWallet } = useContractWalletsStore();
     const { provider } = useWallet(source_network, 'withdrawal');
-    const wallet = provider?.activeWallet;
+    const selectedSourceAccount = useSelectedAccount("from", provider?.name);
     useEffect(() => {
-        if (wallet?.address == undefined || source_network == undefined)
+        if (selectedSourceAccount?.address == undefined || source_network == undefined)
             return;
-        let contractWallet = getContractWallet(wallet.address, source_network.name);
+        let contractWallet = getContractWallet(selectedSourceAccount.address, source_network.name);
         if (!contractWallet) {
             // add before checking to check only once
-            addContractWallet(wallet.address, source_network.name);
+            addContractWallet(selectedSourceAccount.address, source_network.name);
             const sourceNetworkFromSettings = networks.find(n => n.name === source_network.name);
-            checkContractWallet(wallet.address, sourceNetworkFromSettings).then(result => {
-                updateContractWallet(wallet.address, sourceNetworkFromSettings?.name, result);
+            checkContractWallet(selectedSourceAccount.address, sourceNetworkFromSettings).then(result => {
+                updateContractWallet(selectedSourceAccount.address, sourceNetworkFromSettings?.name, result);
             });
         }
-    }, [wallet?.address]);
-    const walletAddressType = getContractWallet(wallet?.address, source_network?.name);
+    }, [selectedSourceAccount?.address]);
+    const walletAddressType = getContractWallet(selectedSourceAccount?.address, source_network?.name);
     const canDoSweepless = source_network && ((source_network.type == NetworkType.EVM
         && (walletAddressType?.ready && !walletAddressType?.isContract))
         || source_network.type == NetworkType.Starknet || source_network.type == NetworkType.ZkSyncLite)
-        || wallet?.address?.toLowerCase() === swap?.destination_address.toLowerCase();
+        || selectedSourceAccount?.address?.toLowerCase() === swapBasicData?.destination_address.toLowerCase();
     return { canDoSweepless, isContractWallet: walletAddressType };
 }
 let checkContractWallet = async (address, network) => {