@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

package/dist/context/swap.js

@@ -1,53 +1,110 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useCallback, useEffect, useState, createContext, useContext } from 'react';
-import LayerSwapApiClient from '../lib/layerSwapApiClient';
+import { useCallback, useEffect, useState, createContext, useContext, useMemo } from 'react';
+import LayerSwapApiClient, { TransactionType } from '../lib/apiClients/layerSwapApiClient';
 import useSWR from 'swr';
 import { ResolvePollingInterval } from '../components/utils/SwapStatus';
 import useWallet from '../hooks/useWallet';
+import { useSettingsState } from './settings';
+import { transformSwapDataToQuoteArgs, useQuoteData } from '../hooks/useFee';
+import { useRecentNetworksStore } from '../stores/recentRoutesStore';
+import { useSelectedAccount } from './balanceAccounts';
+import { useSwapIdChangeCallback } from './callbackProvider';
+import { useInitialSettings } from './settings';
 export const SwapDataStateContext = createContext({
-    codeRequested: false,
-    swapResponse: undefined,
     depositAddressIsFromAccount: false,
     withdrawType: undefined,
     swapTransaction: undefined,
     depositActionsResponse: undefined,
+    swapApiError: undefined,
+    quote: undefined,
+    refuel: undefined,
+    swapBasicData: undefined,
+    swapDetails: undefined,
+    quoteIsLoading: false,
+    swapId: undefined,
+    swapModalOpen: false
 });
 export const SwapDataUpdateContext = createContext(null);
 export function SwapDataProvider({ children }) {
-    const [codeRequested, setCodeRequested] = useState(false);
+    const [quoteIsLoading, setQuoteLoading] = useState(false);
     const [withdrawType, setWithdrawType] = useState();
     const [depositAddressIsFromAccount, setDepositAddressIsFromAccount] = useState();
-    const { providers } = useWallet();
-    const [swapId, setSwapId] = useState();
+    const initialSettings = useInitialSettings();
+    const [swapId, setSwapId] = useState(initialSettings.swapId?.toString());
+    const [swapTransaction, setSwapTransaction] = useState();
+    const { sourceRoutes, destinationRoutes } = useSettingsState();
+    const [swapBasicFormData, setSwapBasicFormData] = useState();
+    const updateRecentTokens = useRecentNetworksStore(state => state.updateRecentNetworks);
+    const [swapModalOpen, setSwapModalOpen] = useState(false);
+    const { providers, provider } = useWallet(swapBasicFormData?.source_network, 'asSource');
+    const selectedSourceAccount = useSelectedAccount("from", provider?.name);
+    const selectedWallet = selectedSourceAccount?.wallet;
+    const quoteArgs = useMemo(() => transformSwapDataToQuoteArgs(swapBasicFormData, !!swapBasicFormData?.refuel), [swapBasicFormData]);
+    const { quote: formDataQuote } = useQuoteData(swapId ? undefined : quoteArgs);
+    const triggerSwapIdChangeCallback = useSwapIdChangeCallback();
+    const handleUpdateSwapid = (value) => {
+        setSwapId(value);
+        triggerSwapIdChangeCallback(value);
+    };
+    const setSubmitedFormValues = useCallback((values) => {
+        const from = sourceRoutes.find(n => n.name === values.from?.name);
+        const to = destinationRoutes.find(n => n.name === values.to?.name);
+        const fromCurrency = from?.tokens.find(t => t.symbol === values.fromAsset?.symbol);
+        const toCurrency = to?.tokens.find(t => t.symbol === values.toAsset?.symbol);
+        if (!from || !to || !fromCurrency || !toCurrency || !values.amount || !values.destination_address)
+            return;
+        setSwapBasicFormData({
+            source_network: from,
+            destination_network: to,
+            source_token: fromCurrency,
+            destination_token: toCurrency,
+            requested_amount: Number(values.amount),
+            destination_address: values.destination_address,
+            use_deposit_address: values.depositMethod === 'deposit_address',
+            refuel: !!values.refuel,
+            source_exchange: values.fromExchange,
+        });
+    }, [sourceRoutes, destinationRoutes]);
     const layerswapApiClient = new LayerSwapApiClient();
     const swap_details_endpoint = `/swaps/${swapId}?exclude_deposit_actions=true`;
     const [interval, setInterval] = useState(0);
-    const { data: swapData, mutate, error } = useSWR(swapId ? swap_details_endpoint : null, layerswapApiClient.fetcher, { refreshInterval: interval });
-    const [selectedSourceAccount, setSelectedSourceAccount] = useState();
-    const handleChangeSelectedSourceAccount = (props) => {
-        if (!props) {
-            setSelectedSourceAccount(undefined);
-            return;
+    const { data, mutate, error } = useSWR(swapId ? swap_details_endpoint : null, layerswapApiClient.fetcher, { refreshInterval: interval });
+    const swapBasicData = useMemo(() => {
+        if (swapId && data?.data) {
+            return data?.data?.swap ? {
+                ...data.data.swap,
+                refuel: !!data.data.refuel
+            } : undefined;
         }
-        const { wallet, address } = props || {};
-        const provider = providers?.find(p => p.name === wallet.providerName);
-        if (provider?.activeWallet?.address.toLowerCase() !== address.toLowerCase()) {
-            provider?.switchAccount && provider?.switchAccount(wallet, address);
+        return swapBasicFormData;
+    }, [data, swapBasicFormData, swapId]);
+    const swapDetails = useMemo(() => {
+        if (swapId)
+            return data?.data?.swap;
+    }, [data, swapId]);
+    const quote = useMemo(() => {
+        if (swapId && data?.data) {
+            return data?.data?.quote;
         }
-        setSelectedSourceAccount({ wallet, address });
-    };
-    const swapResponse = swapData?.data;
-    const sourceIsSupported = swapResponse && WalletIsSupportedForSource({
+        return formDataQuote?.quote;
+    }, [formDataQuote, data, swapId]);
+    const refuel = useMemo(() => {
+        if (swapId) {
+            return data?.data?.refuel;
+        }
+        return formDataQuote?.refuel;
+    }, [formDataQuote, data, swapId]);
+    const sourceIsSupported = swapBasicData && WalletIsSupportedForSource({
         providers: providers,
-        sourceNetwork: swapResponse.swap.source_network,
-        sourceWallet: selectedSourceAccount?.wallet
+        sourceNetwork: swapBasicData.source_network,
+        sourceWallet: selectedWallet
     });
-    const use_deposit_address = swapData?.data?.swap?.use_deposit_address;
-    const deposit_actions_endpoint = `/swaps/${swapId}/deposit_actions${(use_deposit_address || !selectedSourceAccount || !sourceIsSupported) ? "" : `?source_address=${selectedSourceAccount?.address}`}`;
-    const { data: depositActions } = useSWR(swapData ? deposit_actions_endpoint : null, layerswapApiClient.fetcher);
+    const use_deposit_address = swapBasicData?.use_deposit_address;
+    const deposit_actions_endpoint = swapId ? `/swaps/${swapId}/deposit_actions${(use_deposit_address || !selectedSourceAccount || !sourceIsSupported) ? "" : `?source_address=${selectedSourceAccount?.address}`}` : null;
+    const inputTransfer = swapDetails?.transactions.find(t => t.type === TransactionType.Input);
+    const { data: depositActions } = useSWR(!inputTransfer ? deposit_actions_endpoint : null, layerswapApiClient.fetcher);
     const depositActionsResponse = depositActions?.data;
-    const [swapTransaction, setSwapTransaction] = useState();
-    const swapStatus = swapResponse?.swap.status;
+    const swapStatus = data?.data?.swap.status;
     useEffect(() => {
         if (swapStatus)
             setInterval(ResolvePollingInterval(swapStatus));
@@ -65,24 +122,21 @@ export function SwapDataProvider({ children }) {
     const createSwap = useCallback(async (values, query, partner) => {
         if (!values)
             throw new Error("No swap data");
-        const { to, fromCurrency, toCurrency, from, refuel, fromExchange, toExchange, depositMethod, amount, destination_address } = values;
+        const { to, fromAsset: fromCurrency, toAsset: toCurrency, from, refuel, fromExchange, depositMethod, amount, destination_address } = values;
         if (!to || !fromCurrency || !toCurrency || !from || !amount || !destination_address || !depositMethod)
             throw new Error("Form data is missing");
-        const sourceLayer = from;
-        const destinationLayer = to;
         const sourceIsSupported = WalletIsSupportedForSource({
             providers: providers,
-            sourceNetwork: sourceLayer,
-            sourceWallet: selectedSourceAccount?.wallet
+            sourceNetwork: from,
+            sourceWallet: selectedWallet
         });
         const data = {
             amount: amount,
-            source_network: sourceLayer?.name,
-            destination_network: destinationLayer?.name,
+            source_network: from.name,
+            destination_network: to.name,
             source_token: fromCurrency.symbol,
             destination_token: toCurrency.symbol,
             source_exchange: fromExchange?.name,
-            destination_exchange: toExchange?.name,
             destination_address: destination_address,
             reference_id: query.externalId,
             refuel: !!refuel,
@@ -93,30 +147,39 @@ export function SwapDataProvider({ children }) {
         if (swapResponse?.error) {
             throw swapResponse?.error;
         }
-        const swapId = swapResponse?.data?.swap.id;
-        if (!swapId)
+        const swap = swapResponse?.data;
+        if (!swap?.swap.id)
             throw new Error("Could not create swap");
-        return swapId;
-    }, [selectedSourceAccount]);
+        updateRecentTokens({
+            from: !fromExchange ? { network: from.name, token: fromCurrency.symbol } : undefined,
+            to: { network: to.name, token: toCurrency.symbol }
+        });
+        return swap;
+    }, [selectedSourceAccount, formDataQuote]);
     const updateFns = {
-        createSwap: createSwap,
-        setCodeRequested: setCodeRequested,
-        setInterval: setInterval,
+        createSwap,
+        setInterval,
         mutateSwap: mutate,
-        setDepositAddressIsFromAccount: setDepositAddressIsFromAccount,
+        setDepositAddressIsFromAccount,
         setWithdrawType,
-        setSwapId,
-        setSelectedSourceAccount: handleChangeSelectedSourceAccount
+        setSwapId: handleUpdateSwapid,
+        setSubmitedFormValues,
+        setQuoteLoading,
+        setSwapModalOpen
     };
     return (_jsx(SwapDataStateContext.Provider, { value: {
             withdrawType,
-            codeRequested,
             swapTransaction,
             depositAddressIsFromAccount: !!depositAddressIsFromAccount,
-            swapResponse: swapResponse,
             swapApiError: error,
             depositActionsResponse,
-            selectedSourceAccount
+            quote,
+            refuel,
+            swapBasicData,
+            swapDetails,
+            quoteIsLoading,
+            swapId,
+            swapModalOpen
         }, children: _jsx(SwapDataUpdateContext.Provider, { value: updateFns, children: children }) }));
 }
 export function useSwapDataState() {

package/dist/context/{validationErrorContext.d.ts → validationContext.d.ts}

@@ -1,13 +1,17 @@
-import React from 'react';
-import { ReactNode } from 'react';
+import React, { ReactNode } from 'react';
 interface ValidationDetails {
     title?: string;
     type?: string;
     icon?: React.ReactNode;
 }
 interface ValidationContextType {
-    validationMessage: string;
-    validationDetails: ValidationDetails;
+    formValidation: {
+        message: string;
+    };
+    routeValidation: {
+        message: string;
+        details: ValidationDetails;
+    };
 }
 export declare const ValidationProvider: React.FC<{
     children: ReactNode;

package/dist/context/validationContext.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { createContext, useMemo } from 'react';
+import { useFormikContext } from 'formik';
+import { useInitialSettings } from './settings';
+import { transformFormValuesToQuoteArgs, useQuoteData } from '../hooks/useFee';
+import { resolveFormValidation } from '../hooks/useFormValidation';
+import { resolveRouteValidation } from '../hooks/useRouteValidation';
+import useWallet from '../hooks/useWallet';
+import { useSwapDataState } from './swap';
+import { useSelectedAccount } from './balanceAccounts';
+const defaultContext = {
+    formValidation: { message: '' },
+    routeValidation: { message: '', details: {} },
+};
+const ValidationContext = createContext(defaultContext);
+export const ValidationProvider = ({ children }) => {
+    const { values } = useFormikContext();
+    const initialSettings = useInitialSettings();
+    const { sameAccountNetwork } = initialSettings;
+    const { swapId } = useSwapDataState();
+    const { provider } = useWallet(values.from, "withdrawal");
+    const selectedSourceAccount = useSelectedAccount("from", provider?.name);
+    const quoteArgs = useMemo(() => transformFormValuesToQuoteArgs(values), [values]);
+    const quoteRefreshInterval = !!swapId ? 0 : undefined;
+    const { minAllowedAmount, maxAllowedAmount, quoteError } = useQuoteData(quoteArgs, quoteRefreshInterval);
+    const routeValidation = resolveRouteValidation(quoteError);
+    const formValidation = resolveFormValidation({
+        values,
+        maxAllowedAmount,
+        minAllowedAmount,
+        sourceAddress: selectedSourceAccount?.address,
+        sameAccountNetwork,
+        quoteError
+    });
+    const value = useMemo(() => ({
+        formValidation,
+        routeValidation,
+    }), [formValidation, routeValidation]);
+    return _jsx(ValidationContext.Provider, { value: value, children: children });
+};
+export const useValidationContext = () => React.useContext(ValidationContext);

package/dist/context/walletProviders.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { WalletProvider } from "../Models/WalletProvider";
+export declare const WalletProvidersProvider: React.FC<React.PropsWithChildren>;
+export declare const useWalletProviders: () => WalletProvider[];

package/dist/context/walletProviders.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from "react";
+import { useSettingsState } from "./settings";
+import VaulDrawer from "../components/Modal/vaulModal";
+import IconButton from "../components/Buttons/iconButton";
+import { ChevronLeft } from "lucide-react";
+import ConnectorsList from "../components/Wallet/WalletModal/ConnectorsList";
+import { useConnectModal } from "../components/Wallet/WalletModal";
+import useEVM from "../lib/wallets/evm/useEVM";
+import useStarknet from "../lib/wallets/starknet/useStarknet";
+import useImtblX from "../lib/wallets/imtblX/useImtblX";
+import useTON from "../lib/wallets/ton/useTON";
+import useFuel from "../lib/wallets/fuel/useFuel";
+import useTron from "../lib/wallets/tron/useTron";
+import useParadex from "../lib/wallets/paradex/useParadex";
+import useSVM from "../lib/wallets/solana/useSVM";
+import useBitcoin from "../lib/wallets/bitcoin/useBitcoin";
+import { isMobile } from "../lib/wallets/connectors/utils/isMobile";
+const WalletProvidersContext = createContext([]);
+export const WalletProvidersProvider = ({ children }) => {
+    const { networks } = useSettingsState();
+    const isMobilePlatform = isMobile();
+    const { goBack, onFinish, open, setOpen, selectedConnector, selectedMultiChainConnector } = useConnectModal();
+    const bitcoin = useBitcoin();
+    const evm = useEVM();
+    const starknet = useStarknet();
+    const imtblX = useImtblX();
+    const svm = useSVM();
+    const ton = useTON();
+    const fuel = useFuel();
+    const tron = useTron();
+    const paradex = useParadex();
+    const providers = useMemo(() => {
+        const allProviders = [
+            bitcoin, evm, starknet, svm, ton, fuel, tron, paradex, imtblX
+        ];
+        const filteredProviders = allProviders.filter(provider => isMobilePlatform ? !provider.unsupportedPlatforms?.includes('mobile') : !provider.unsupportedPlatforms?.includes('desktop'));
+        return filteredProviders.filter(provider => networks.some(net => provider.autofillSupportedNetworks?.includes(net.name) ||
+            provider.withdrawalSupportedNetworks?.includes(net.name) ||
+            provider.asSourceSupportedNetworks?.includes(net.name)));
+    }, [networks, bitcoin, evm, starknet, svm, ton, fuel, tron, paradex, imtblX, isMobilePlatform]);
+    return (_jsxs(WalletProvidersContext.Provider, { value: providers, children: [children, _jsx(VaulDrawer, { show: open, setShow: setOpen, onClose: onFinish, modalId: "connectNewWallet", header: _jsxs("div", { className: "flex items-center gap-1", children: [(selectedConnector || selectedMultiChainConnector) &&
+                            _jsx("div", { className: '-ml-2', children: _jsx(IconButton, { onClick: goBack, icon: _jsx(ChevronLeft, { className: "h-6 w-6" }) }) }), _jsx("p", { children: (selectedMultiChainConnector && !selectedConnector) ? "Select ecosystem" : "Connect wallet" })] }), children: _jsx(VaulDrawer.Snap, { id: 'item-1', children: _jsx(ConnectorsList, { onFinish: onFinish }) }) })] }));
+};
+export const useWalletProviders = () => useContext(WalletProvidersContext);

package/dist/context/withdrawalContext.d.ts

@@ -0,0 +1,10 @@
+import React, { FC } from 'react';
+type WalletWithdrawalContextValue = {
+    onWalletWithdrawalSuccess?: () => void;
+};
+export declare const WithdrawalProvider: FC<{
+    onWalletWithdrawalSuccess?: () => void;
+    children?: React.ReactNode;
+}>;
+export declare function useWalletWithdrawalState(): WalletWithdrawalContextValue;
+export {};

package/dist/context/withdrawalContext.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+const WalletWithdrawalContext = React.createContext(null);
+export const WithdrawalProvider = ({ onWalletWithdrawalSuccess, children }) => {
+    return (_jsx(WalletWithdrawalContext.Provider, { value: { onWalletWithdrawalSuccess }, children: children }));
+};
+export function useWalletWithdrawalState() {
+    const data = React.useContext(WalletWithdrawalContext);
+    if (data === null) {
+        throw new Error('useWalletWithdrawalState must be used within a WithdrawalProvider');
+    }
+    return data;
+}

package/dist/helpers/accountSelectHelper.d.ts

@@ -0,0 +1,2 @@
+import { SelectAccountProps, WalletProvider } from "../Models/WalletProvider";
+export declare function SwitchWalletAccount(props: SelectAccountProps, provider: WalletProvider | undefined): void;

package/dist/helpers/accountSelectHelper.js

@@ -0,0 +1,16 @@
+export function SwitchWalletAccount(props, provider) {
+    const { walletId, address, providerName } = props;
+    if (!provider || !provider.connectedWallets) {
+        throw new Error("Provider or connected wallets not available.");
+    }
+    const wallet = provider.connectedWallets.find(c => c.id === walletId);
+    if (!wallet) {
+        throw new Error(`Wallet with id ${walletId} not found in connected wallets.`);
+    }
+    if (provider.switchAccount) {
+        provider.switchAccount(wallet, address);
+    }
+    else {
+        throw new Error(`Switch account method not implemented for provider ${providerName}.`);
+    }
+}

package/dist/helpers/getSettings.d.ts

@@ -1,7 +1,6 @@
 export declare function getSettings(): Promise<{
     networks: import("..").NetworkWithTokens[];
     sourceExchanges: import("../Models/Exchange").Exchange[];
-    destinationExchanges: import("../Models/Exchange").Exchange[];
     sourceRoutes: import("..").NetworkWithTokens[];
     destinationRoutes: import("..").NetworkWithTokens[];
 } | undefined>;

package/dist/helpers/getSettings.js

@@ -1,9 +1,8 @@
-import LayerSwapApiClient from "../lib/layerSwapApiClient";
+import LayerSwapApiClient from "../lib/apiClients/layerSwapApiClient";
 export async function getSettings() {
     const apiClient = new LayerSwapApiClient();
     const { data: networkData } = await apiClient.GetLSNetworksAsync();
     const { data: sourceExchangesData } = await apiClient.GetSourceExchangesAsync();
-    const { data: destinationExchangesData } = await apiClient.GetDestinationExchangesAsync();
     const { data: sourceRoutes } = await apiClient.GetRoutesAsync('sources');
     const { data: destinationRoutes } = await apiClient.GetRoutesAsync('destinations');
     if (!networkData)
@@ -11,7 +10,6 @@ export async function getSettings() {
     const settings = {
         networks: networkData,
         sourceExchanges: sourceExchangesData || [],
-        destinationExchanges: destinationExchangesData || [],
         sourceRoutes: sourceRoutes || [],
         destinationRoutes: destinationRoutes || []
     };

package/dist/helpers/querryHelper.js

@@ -1,4 +1,4 @@
-import { PersistantQueryParams } from "../Models/QueryParams";
+import { PersistantQueryParams } from "../Models/InitialSettings";
 export const resolvePersistantQueryParams = (query) => {
     if (!query)
         return null;

package/dist/helpers/routes.d.ts

@@ -1,15 +1,22 @@
-import { ExchangeToken } from "../Models/Exchange";
-import { SwapDirection, SwapFormValues } from "../components/Pages/SwapPages/Form/SwapFormValues";
-export declare const resolveExchangesURLForSelectedToken: (direction: SwapDirection, values: SwapFormValues) => string;
+import { SwapDirection, SwapFormValues } from "../components/Pages/Swap/Form/SwapFormValues";
+export declare const resolveExchangesURLForSelectedToken: (values: SwapFormValues) => string;
+export declare const resolveExchangeHistoricalNetworksURL: (direction: SwapDirection, { fromExchange, to, toAsset }: {
+    fromExchange?: string | undefined;
+    to?: string | undefined;
+    toAsset?: string | undefined;
+}) => string | null;
 export declare const resolveNetworkRoutesURL: (direction: SwapDirection, values: SwapFormValues, networkTypes?: string[]) => string;
-export declare const resolveRoutesURLForSelectedToken: ({ direction, network, token, includes, networkTypes }: {
+type IncludeOptions = {
+    unavailable: boolean;
+    unmatched: boolean;
+    swaps: boolean;
+};
+type ResolveRoutesURLForSelectedTokenProps = {
     direction: SwapDirection;
     network: string | undefined;
     token: string | undefined;
-    includes: {
-        unavailable: boolean;
-        unmatched: boolean;
-    };
+    includes: IncludeOptions;
     networkTypes?: string[];
-}) => string;
-export declare const resolveRoutesURLForSelectedAssetGroup: (direction: SwapDirection, currencyGroup: ExchangeToken, networkTypes?: string[]) => string;
+};
+export declare const resolveRoutesURLForSelectedToken: ({ direction, network, token, includes, networkTypes }: ResolveRoutesURLForSelectedTokenProps) => string;
+export {};

package/dist/helpers/routes.js

@@ -1,44 +1,49 @@
-export const resolveExchangesURLForSelectedToken = (direction, values) => {
+export const resolveExchangesURLForSelectedToken = (values) => {
     const include_unmatched = 'true';
-    const include_swaps = 'true';
+    const include_swaps = 'false';
     const include_unavailable = 'true';
-    const { from, to, fromCurrency, toCurrency } = values;
-    const network = direction === "from" ? to?.name : from?.name;
-    const token = direction === "from" ? toCurrency?.symbol : fromCurrency?.symbol;
+    const { from, fromAsset: fromCurrency } = values;
     const params = new URLSearchParams({
         include_unmatched,
         include_swaps,
         include_unavailable,
-        ...(network && token ?
+        ...(from?.name && fromCurrency?.symbol ?
             {
-                [direction === 'to' ? 'source_network' : 'destination_network']: network,
-                [direction === 'to' ? 'source_token' : 'destination_token']: token,
+                ['source_network']: from?.name,
+                ['source_token']: fromCurrency?.symbol,
             }
             : {})
     });
     const sourcesURL = `/source_exchanges?${params.toString()}`;
-    const destinationsURL = `/destination_exchanges?${params.toString()}`;
-    const result = direction === "from" ? sourcesURL : destinationsURL;
-    return result;
+    return sourcesURL;
 };
-export const resolveNetworkRoutesURL = (direction, values, networkTypes) => {
-    const { from, to, fromCurrency, toCurrency, fromExchange, toExchange, currencyGroup } = values;
-    const selectedExchange = direction === 'from' ? toExchange : fromExchange;
-    if (selectedExchange) {
-        return currencyGroup ?
-            resolveRoutesURLForSelectedAssetGroup(direction, currencyGroup, networkTypes)
-            :
-                resolveRoutesURLForSelectedToken({ direction, network: undefined, token: undefined, includes: { unavailable: true, unmatched: true }, networkTypes });
-    }
-    else {
-        const selectednetwork = direction === "from" ? to : from;
-        const selectedToken = direction === "from" ? toCurrency?.symbol : fromCurrency?.symbol;
-        return resolveRoutesURLForSelectedToken({ direction, network: selectednetwork?.name, token: selectedToken, includes: { unmatched: true, unavailable: true }, networkTypes });
+export const resolveExchangeHistoricalNetworksURL = (direction, { fromExchange, to, toAsset }) => {
+    if (direction === "from" && fromExchange && to && toAsset) {
+        const params = new URLSearchParams({
+            source_exchange: fromExchange,
+            destination_network: to,
+            destination_token: toAsset,
+        });
+        return `/exchange_withdrawal_networks?${params.toString()}`;
     }
+    return null;
+};
+export const resolveNetworkRoutesURL = (direction, values, networkTypes) => {
+    const { from, to, fromAsset: fromCurrency, toAsset: toCurrency, fromExchange, toExchange } = values;
+    const selectednetwork = direction === "from" ? to : from;
+    const selectedToken = direction === "from" ? toCurrency?.symbol : fromCurrency?.symbol;
+    const isCEX = fromExchange || toExchange;
+    return resolveRoutesURLForSelectedToken({
+        direction,
+        network: isCEX ? undefined : selectednetwork?.name,
+        token: isCEX ? undefined : selectedToken,
+        includes: { unmatched: true, unavailable: true, swaps: !isCEX },
+        networkTypes
+    });
 };
 export const resolveRoutesURLForSelectedToken = ({ direction, network, token, includes, networkTypes }) => {
     const include_unmatched = includes.unmatched ? 'true' : 'false';
-    const include_swaps = 'true';
+    const include_swaps = includes.swaps ? 'true' : 'false';
     const include_unavailable = includes.unavailable ? 'true' : 'false';
     const params = new URLSearchParams({
         include_unmatched,
@@ -62,17 +67,3 @@ export const resolveRoutesURLForSelectedToken = ({ direction, network, token, in
     const result = direction === "from" ? sourceRoutesURL : destinationRoutesURL;
     return result;
 };
-export const resolveRoutesURLForSelectedAssetGroup = (direction, currencyGroup, networkTypes) => {
-    const include_unmatched = 'true';
-    const include_swaps = 'true';
-    const include_unavailable = 'true';
-    const parrams = new URLSearchParams({
-        include_unmatched,
-        include_swaps,
-        include_unavailable,
-        ...(networkTypes ? { network_types: networkTypes?.join(',') } : {}),
-        [direction === 'to' ? 'source_token_group' : 'destination_token_group']: currencyGroup.symbol
-    });
-    const endpoint = direction === "to" ? '/exchange_destination_networks' : '/exchange_source_networks';
-    return `${endpoint}?${parrams.toString()}`;
-};

package/dist/helpers/settingsHelper.d.ts

@@ -0,0 +1 @@
+export declare const getThemeData: (query: any) => Promise<import("../Models/Theme").ThemeData | null>;

package/dist/helpers/settingsHelper.js

@@ -0,0 +1,16 @@
+import { THEME_COLORS } from "../Models/Theme";
+export const getThemeData = async (query) => {
+    try {
+        if (!query)
+            return null;
+        const theme_name = query.theme || query.appName || query.addressSource;
+        // const internalApiClient = new InternalApiClient()
+        // const themeData = await internalApiClient.GetThemeData(theme_name);
+        // result.themeData = themeData as ThemeData;
+        return THEME_COLORS[theme_name] || null;
+    }
+    catch (e) {
+        console.log(e);
+        return null;
+    }
+};

package/dist/helpers/tokenHelper.d.ts

@@ -0,0 +1,3 @@
+import { SwapQuote } from "../lib/apiClients/layerSwapApiClient";
+import { Token } from "../Models/Network";
+export declare const resolveTokenUsdPrice: (token: Token | undefined, quote: SwapQuote | undefined) => number | undefined;

package/dist/helpers/tokenHelper.js

@@ -0,0 +1,9 @@
+export const resolveTokenUsdPrice = (token, quote) => {
+    if (quote?.source_token?.symbol && quote?.source_token?.symbol === token?.symbol) {
+        return quote.source_token.price_in_usd;
+    }
+    if (quote?.destination_token?.symbol && quote?.destination_token?.symbol === token?.symbol) {
+        return quote.destination_token.price_in_usd;
+    }
+    return token?.price_in_usd;
+};

package/dist/hooks/useAllWithdrawalBalances.d.ts

@@ -0,0 +1,5 @@
+import { NetworkBalance } from "../Models/Balance";
+export default function useAllWithdrawalBalances(): {
+    isLoading: boolean;
+    balances: Record<string, NetworkBalance> | null;
+};

package/dist/hooks/useAllWithdrawalBalances.js

@@ -0,0 +1,40 @@
+import { useSettingsState } from "../context/settings";
+import { selectResolvedInitiatedBalances, useBalanceStore } from "../stores/balanceStore";
+import { useEffect, useMemo, useRef } from "react";
+import { useBalanceAccounts } from "../context/balanceAccounts";
+export default function useAllWithdrawalBalances() {
+    const networks = useSettingsState().networks;
+    const balanceAccounts = useBalanceAccounts("from");
+    const walletNetworks = useMemo(() => {
+        return balanceAccounts.map(account => {
+            const wallet = account.wallet;
+            const withdrawalNetworks = wallet.withdrawalSupportedNetworks;
+            if (!withdrawalNetworks || withdrawalNetworks.length === 0)
+                return [];
+            return withdrawalNetworks.map(networkName => {
+                const network = networks.find(n => n.name === networkName);
+                if (!network)
+                    return null;
+                return {
+                    address: account.address,
+                    network,
+                };
+            });
+        }).flat().filter(item => item !== null);
+    }, [balanceAccounts, networks]);
+    const walletNetwokrsString = useMemo(() => {
+        return walletNetworks.map(item => `${item.address}-${item.network.name}`).join(',');
+    }, [walletNetworks]);
+    useEffect(() => {
+        if (walletNetworks)
+            useBalanceStore.getState().initAllBalances(walletNetworks);
+    }, [walletNetwokrsString]);
+    const lastBalancesRef = useRef(null);
+    const resolvedBalances = useBalanceStore(selectResolvedInitiatedBalances);
+    const isLoading = useBalanceStore(s => s.isLoading);
+    if (resolvedBalances != null && Object.keys(resolvedBalances).length > 0) {
+        lastBalancesRef.current = resolvedBalances;
+    }
+    const result = resolvedBalances === null && isLoading ? lastBalancesRef.current : resolvedBalances;
+    return useMemo(() => ({ isLoading, balances: result }), [result, isLoading]);
+}