@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

package/dist/context/LayerswapProvider.js

@@ -3,28 +3,29 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
 import { useEffect, useState } from "react";
 import ThemeWrapper from "../components/themeWrapper";
 import { ErrorBoundary } from "react-error-boundary";
-import { AuthProvider } from "./authContext";
 import { SettingsProvider } from "./settings";
 import { LayerSwapAppSettings } from "../Models/LayerSwapAppSettings";
 import ErrorFallback from "../components/ErrorFallback";
-import QueryProvider from "./query";
 import { THEME_COLORS } from "../Models/Theme";
 import { TooltipProvider } from "../components/shadcn/tooltip";
 import { AsyncModalProvider } from "./asyncModal";
-import WalletsProviders from "../components/Wallet/WalletProviders";
 import { IntercomProvider } from 'react-use-intercom';
 import AppSettings from "../lib/AppSettings";
 import { getSettings } from "../helpers/getSettings";
-import { WidgetLoading } from "../components/WidgetLoading";
-import LayerSwapApiClient from "../lib/layerSwapApiClient";
+import LayerSwapApiClient from "../lib/apiClients/layerSwapApiClient";
 import ColorSchema from "../components/ColorSchema";
+import { WidgetLoading } from "../components/WidgetLoading";
+import WalletsProviders from "../components/Wallet/WalletProviders";
+import { CallbackProvider } from "./callbackProvider";
 const INTERCOM_APP_ID = 'h5zisg78';
-const LayerswapProviderComponent = ({ children, settings: _settings, themeData, apiKey, integrator, version, walletConnect }) => {
+const LayerswapProviderComponent = ({ children, settings: _settings, themeData, apiKey, integrator, version, callbacks, initialValues, walletConnect, imtblPassport }) => {
     const [fetchedSettings, setFetchedSettings] = useState(null);
     AppSettings.ApiVersion = version;
     AppSettings.Integrator = integrator;
     AppSettings.ThemeData = { ...THEME_COLORS['default'], ...themeData };
-    LayerSwapApiClient.apiKey = apiKey;
+    AppSettings.ImtblPassportConfig = imtblPassport;
+    if (apiKey)
+        LayerSwapApiClient.apiKey = apiKey;
     useEffect(() => {
         if (!_settings) {
             (async () => {
@@ -40,7 +41,7 @@ const LayerswapProviderComponent = ({ children, settings: _settings, themeData,
         return _jsx(WidgetLoading, {});
     let appSettings = new LayerSwapAppSettings(settings);
     themeData = { ...THEME_COLORS['default'], ...themeData };
-    return (_jsx(IntercomProvider, { appId: INTERCOM_APP_ID, initializeDelay: 2500, children: _jsx(QueryProvider, { query: {}, children: _jsx(SettingsProvider, { data: appSettings, children: _jsx(AuthProvider, { children: _jsx(TooltipProvider, { delayDuration: 500, children: _jsx(ErrorBoundary, { FallbackComponent: ErrorFallback, children: _jsx(ThemeWrapper, { children: _jsx(WalletsProviders, { themeData: themeData, children: _jsx(AsyncModalProvider, { children: children }) }) }) }) }) }) }) }) }));
+    return (_jsx(IntercomProvider, { appId: INTERCOM_APP_ID, initializeDelay: 2500, children: _jsx(SettingsProvider, { initialLayerswapData: appSettings, initialSettings: initialValues, children: _jsx(CallbackProvider, { callbacks: callbacks, children: _jsx(TooltipProvider, { delayDuration: 500, children: _jsx(ErrorBoundary, { FallbackComponent: ErrorFallback, children: _jsx(ThemeWrapper, { children: _jsx(WalletsProviders, { appName: integrator, basePath: "/", themeData: themeData, children: _jsx(AsyncModalProvider, { children: children }) }) }) }) }) }) }) }));
 };
 export const LayerswapProvider = (props) => {
     return (_jsxs(_Fragment, { children: [_jsx(ColorSchema, { themeData: props.themeData }), _jsx("div", { style: { backgroundColor: 'transparent' }, className: "layerswap-styles", children: _jsx(LayerswapProviderComponent, { ...props, children: props.children }) })] }));

package/dist/context/asyncModal.d.ts

@@ -1,13 +1,4 @@
-import React, { FC } from "react";
-import { ModalProps } from "../components/Modal/modal";
-interface AsyncModalProps extends ModalProps {
-    onConfirm: () => void;
-    onDismiss: () => void;
-    content: React.ReactNode;
-    submitText?: string;
-    dismissText?: string;
-}
-declare const AsyncModal: FC<AsyncModalProps>;
+import React from "react";
 declare const AsyncModalProvider: ({ children }: {
     children: any;
 }) => import("react/jsx-runtime").JSX.Element;
@@ -18,5 +9,4 @@ declare const useAsyncModal: () => {
         dismissText?: string;
     }) => Promise<unknown>;
 };
-export default AsyncModal;
 export { AsyncModalProvider, useAsyncModal };

package/dist/context/asyncModal.js

@@ -1,11 +1,12 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from "react";
-import Modal from "../components/Modal/modal";
 import SubmitButton from "../components/Buttons/submitButton";
 import SecondaryButton from "../components/Buttons/secondaryButton";
+import VaulDrawer from "../components/Modal/vaulModal";
 ;
-const AsyncModal = ({ onConfirm, onDismiss, content, submitText, dismissText, ...props }) => {
-    return (_jsx(Modal, { onClose: onDismiss, ...props, children: _jsxs("div", { className: "flex flex-col items-center gap-6 mt-2", children: [content, _jsxs("div", { className: "h-full w-full space-y-3", children: [_jsx(SubmitButton, { type: "button", onClick: onConfirm, children: submitText ?? 'Confirm' }), _jsx(SecondaryButton, { className: "w-full h-full py-3 !text-base", onClick: onDismiss, children: dismissText ?? 'Cancel' })] })] }) }));
+const AsyncModal = ({ onConfirm, onDismiss, children, submitText, dismissText, ...props }) => {
+    return (_jsx(VaulDrawer, { onClose: onDismiss, ...props, children: _jsx(VaulDrawer.Snap, { id: "item-1", children: _jsxs("div", { className: "flex flex-col items-center gap-2 mt-2", children: [children, _jsxs("div", { className: "h-full w-full space-y-3", children: [_jsx(SubmitButton, { type: "button", onClick: onConfirm, children: submitText ?? 'Confirm' }), dismissText &&
+                                _jsx(SecondaryButton, { className: "w-full h-full py-3 !text-base", size: "xl", onClick: onDismiss, children: dismissText })] })] }) }) }));
 };
 const AsyncModalContext = React.createContext(null);
 const AsyncModalProvider = ({ children }) => {
@@ -17,7 +18,6 @@ const AsyncModalProvider = ({ children }) => {
     };
     const resetDialog = () => {
         setDialogOpen(false);
-        setDialogConfig(undefined);
     };
     const onConfirm = () => {
         resetDialog();
@@ -27,7 +27,7 @@ const AsyncModalProvider = ({ children }) => {
         resetDialog();
         dialogConfig?.actionCallback(false);
     };
-    return (_jsxs(AsyncModalContext.Provider, { value: { openDialog }, children: [_jsx(AsyncModal, { show: dialogOpen, setShow: setDialogOpen, onConfirm: onConfirm, onDismiss: onDismiss, content: dialogConfig?.content, submitText: dialogConfig?.submitText, dismissText: dialogConfig?.dismissText, modalId: "asyncModal", height: "fit" }), children] }));
+    return (_jsxs(AsyncModalContext.Provider, { value: { openDialog }, children: [_jsx(AsyncModal, { show: dialogOpen, setShow: setDialogOpen, onConfirm: onConfirm, onDismiss: onDismiss, onAnimationEnd: (v) => !v && setDialogConfig(undefined), submitText: dialogConfig?.submitText, dismissText: dialogConfig?.dismissText, modalId: "asyncModal", children: dialogConfig?.content }), children] }));
 };
 const useAsyncModal = () => {
     const context = React.useContext(AsyncModalContext);
@@ -39,5 +39,4 @@ const useAsyncModal = () => {
     });
     return { getConfirmation };
 };
-export default AsyncModal;
 export { AsyncModalProvider, useAsyncModal };

package/dist/context/balanceAccounts.d.ts

@@ -0,0 +1,32 @@
+import { Wallet, WalletProvider } from '../Models/WalletProvider';
+import { SwapDirection } from '../components/Pages/Swap/Form/SwapFormValues';
+import { BalanceEntry } from '../stores/balanceStore';
+type PickerAccountsProviderProps = {
+    children: React.ReactNode;
+};
+type BaseAccountIdentity = {
+    address: string;
+    providerName: string;
+    id: string;
+};
+export type AccountIdentity = BaseAccountIdentity & {
+    displayName: string;
+    addresses: string[];
+    provider: WalletProvider;
+    icon: (props: any) => React.JSX.Element;
+};
+export type AccountIdentityWithWallet = AccountIdentity & {
+    wallet: Wallet;
+};
+export declare function BalanceAccountsProvider({ children }: PickerAccountsProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useBalanceAccounts(direction: "from"): AccountIdentityWithWallet[];
+export declare function useBalanceAccounts(direction: "to"): AccountIdentity[];
+export declare function useBalanceAccounts(direction: SwapDirection): (AccountIdentity | AccountIdentityWithWallet)[];
+export declare function useSelectedAccount(direction: "from", providerName: string | undefined): AccountIdentityWithWallet | undefined;
+export declare function useSelectedAccount(direction: "to", providerName: string | undefined): AccountIdentity | undefined;
+export declare function useSelectedAccount(direction: SwapDirection, providerName: string | undefined): AccountIdentity | AccountIdentityWithWallet | undefined;
+export declare function useNetworkAccount(direction: SwapDirection, networkName: string | undefined): AccountIdentity | undefined;
+export declare function useNetworkBalanceKey(direction: SwapDirection, networkName: string | undefined): string | undefined;
+export declare function useNetworkBalance(direction: SwapDirection, networkName: string | undefined): BalanceEntry | undefined;
+export declare function useUpdateBalanceAccount(direction: SwapDirection): (account: BaseAccountIdentity) => void;
+export {};

package/dist/context/balanceAccounts.js

@@ -0,0 +1,149 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useMemo, useState } from 'react';
+import useWallet from '../hooks/useWallet';
+import AddressIcon from '../components/Common/AddressIcon';
+import { getKey, useBalanceStore } from '../stores/balanceStore';
+const BalanceAccountsStateContext = createContext(null);
+const BalanceAccountsUpdateContext = createContext(null);
+export function BalanceAccountsProvider({ children }) {
+    const [selectedDestAccounts, setSelectedDestinationAccounts] = useState([]);
+    const [selectedSourceAccounts, setSelectedSourceAccounts] = useState([]);
+    const { providers } = useWallet();
+    const sourceAccounts = useMemo(() => {
+        return providers.map(provider => {
+            if (!hasWallet(provider))
+                return null;
+            const selectedWallet = provider.connectedWallets?.find(wallet => wallet.id === selectedSourceAccounts.find(acc => acc.providerName === provider.name && wallet.addresses.some(a => a === acc.address))?.id && wallet.addresses);
+            const wallet = selectedWallet || provider.activeWallet;
+            const selectedAccountAddress = selectedWallet ? selectedSourceAccounts.find(acc => acc.providerName === provider.name && acc.id === selectedWallet.id)?.address : undefined;
+            const address = selectedAccountAddress ? selectedAccountAddress : wallet.address;
+            return ResolveWalletBalanceAccount(provider, wallet, address);
+        }).filter(Boolean);
+    }, [providers, selectedSourceAccounts]);
+    const destinationAccounts = useMemo(() => {
+        return providers.map(provider => {
+            const manuallyAdded = selectedDestAccounts.find(acc => acc.providerName === provider.name && acc.id === 'manually_added');
+            if (manuallyAdded) {
+                return ResolveManualBalanceAccount(provider, manuallyAdded.address);
+            }
+            if (!hasWallet(provider))
+                return null;
+            const selectedWallet = provider.connectedWallets?.find(wallet => wallet.id === selectedDestAccounts.find(acc => acc.providerName === provider.name && wallet.addresses.some(a => a === acc.address))?.id && wallet.addresses);
+            const wallet = selectedWallet || provider.activeWallet;
+            const selectedAccountAddress = selectedWallet ? selectedDestAccounts.find(acc => acc.providerName === provider.name && acc.id === selectedWallet.id)?.address : undefined;
+            const address = selectedAccountAddress ? selectedAccountAddress : wallet.address;
+            return ResolveWalletBalanceAccount(provider, wallet, address);
+        }).filter(Boolean);
+    }, [providers, selectedDestAccounts]);
+    const selectDestinationAccount = useCallback((account) => {
+        setSelectedDestinationAccounts(prev => {
+            const existingAccountIndex = prev.findIndex(acc => acc.providerName === account.providerName);
+            if (existingAccountIndex !== -1) {
+                const updatedAccounts = [...prev];
+                updatedAccounts[existingAccountIndex] = account;
+                return updatedAccounts;
+            }
+            return [...prev, account];
+        });
+    }, []);
+    const selectSourceAccount = useCallback((account) => {
+        const previousSourceAccount = sourceAccounts.find(acc => acc.providerName === account.providerName);
+        if (destinationAccounts.some(acc => acc.address === previousSourceAccount?.address && acc.providerName === previousSourceAccount?.providerName)) {
+            selectDestinationAccount(account);
+        }
+        setSelectedSourceAccounts(prev => {
+            const existingAccountIndex = prev.findIndex(acc => acc.providerName === account.providerName);
+            if (existingAccountIndex !== -1) {
+                const updatedAccounts = [...prev];
+                updatedAccounts[existingAccountIndex] = account;
+                return updatedAccounts;
+            }
+            return [...prev, account];
+        });
+    }, [destinationAccounts, sourceAccounts]);
+    const stateValues = useMemo(() => ({
+        sourceAccounts,
+        destinationAccounts
+    }), [sourceAccounts, destinationAccounts]);
+    const update = useMemo(() => ({
+        selectDestinationAccount,
+        selectSourceAccount,
+    }), [sourceAccounts, destinationAccounts, selectSourceAccount, selectDestinationAccount]);
+    return (_jsx(BalanceAccountsStateContext.Provider, { value: stateValues, children: _jsx(BalanceAccountsUpdateContext.Provider, { value: update, children: children }) }));
+}
+export function useBalanceAccounts(direction) {
+    const values = useContext(BalanceAccountsStateContext);
+    if (values === undefined) {
+        throw new Error('useBalanceAccounts must be used within a BalanceAccountsProvider');
+    }
+    return direction === "from" ? values.sourceAccounts : values.destinationAccounts;
+}
+export function useSelectedAccount(direction, providerName) {
+    const values = useContext(BalanceAccountsStateContext);
+    if (!providerName)
+        return undefined;
+    if (values === undefined) {
+        throw new Error('useBalanceAccounts must be used within a BalanceAccountsProvider');
+    }
+    return direction === "from" ? values.sourceAccounts.find(acc => acc.providerName === providerName) : values.destinationAccounts.find(acc => acc.providerName === providerName);
+}
+export function useNetworkAccount(direction, networkName) {
+    const values = useContext(BalanceAccountsStateContext);
+    if (!networkName)
+        return undefined;
+    if (values === undefined) {
+        throw new Error('useBalanceAccounts must be used within a BalanceAccountsProvider');
+    }
+    return direction === "from" ? values.sourceAccounts.find(acc => acc.wallet.withdrawalSupportedNetworks?.some(n => n === networkName))
+        :
+            values.destinationAccounts.find(acc => {
+                if ('wallet' in acc) {
+                    return acc.wallet.autofillSupportedNetworks?.some(n => n === networkName);
+                }
+                return acc.provider?.autofillSupportedNetworks?.some(n => n === networkName);
+            });
+}
+export function useNetworkBalanceKey(direction, networkName) {
+    const account = useNetworkAccount(direction, networkName);
+    if (!account || !networkName)
+        return undefined;
+    return getKey(account.address, networkName);
+}
+export function useNetworkBalance(direction, networkName) {
+    const balanceKey = useNetworkBalanceKey(direction, networkName);
+    const balance = useBalanceStore((s) => (s.isLoading ? undefined : s.balances[balanceKey || "unknown"]));
+    return balance;
+}
+export function useUpdateBalanceAccount(direction) {
+    const values = useContext(BalanceAccountsUpdateContext);
+    if (values === undefined) {
+        throw new Error('useUpdateBalanceAccount must be used within a BalanceAccountsUpdateContext');
+    }
+    return direction === "from" ? values.selectSourceAccount : values.selectDestinationAccount;
+}
+function hasWallet(p) {
+    return Boolean(p.activeWallet);
+}
+function ResolveWalletBalanceAccount(provider, wallet, address) {
+    return {
+        address,
+        provider,
+        providerName: provider.name,
+        id: wallet.id,
+        wallet,
+        displayName: wallet.displayName || provider.name,
+        addresses: wallet.addresses || [address],
+        icon: wallet.icon || ((props) => _jsx(AddressIcon, { address: address, size: 24, ...props })),
+    };
+}
+function ResolveManualBalanceAccount(provider, address) {
+    return {
+        address,
+        provider,
+        providerName: provider.name,
+        id: 'manually_added',
+        displayName: "Manual",
+        addresses: [address],
+        icon: (props) => (_jsx(AddressIcon, { className: "h-4 w-4 p-0.5", address: address, size: 20, ...props })),
+    };
+}

package/dist/context/callbackProvider.d.ts

@@ -0,0 +1,25 @@
+import { SwapFormValues } from '../components/Pages/Swap/Form/SwapFormValues';
+import { SwapResponse } from '../lib/apiClients/layerSwapApiClient';
+import { ReactNode } from 'react';
+export interface CallbacksContextType {
+    onFormChange?: (formData: SwapFormValues) => void;
+    onSwapCreate?: (swapData: SwapResponse) => void;
+    onSwapComplete?: (swapData: SwapResponse) => void;
+    onSwapModalStateChange?: (open: boolean) => void;
+    onSwapIdChange?: (swapId: string | undefined) => void;
+    onBackClick?: () => void;
+    onError?: (error: any) => void;
+}
+export interface CallbackProviderProps {
+    children: ReactNode;
+    callbacks?: CallbacksContextType;
+}
+export declare function CallbackProvider({ children, callbacks }: CallbackProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useCallbacks(): CallbacksContextType;
+export declare function useFormChangeCallback(): (formData: SwapFormValues) => void;
+export declare function useSwapCreateCallback(): (swapData: SwapResponse) => void;
+export declare function useSwapCompleteCallback(): (swapData: SwapResponse) => void;
+export declare function useSwapModalStateChangeCallback(): (open: boolean) => void;
+export declare function useSwapIdChangeCallback(): (swapId: string | undefined) => void;
+export declare function useBackClickCallback(): () => void;
+export declare function useErrorCallback(): (error: any) => void;

package/dist/context/callbackProvider.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useCallback } from 'react';
+const CallbackContext = createContext({});
+export function CallbackProvider({ children, callbacks = {} }) {
+    return (_jsx(CallbackContext.Provider, { value: callbacks, children: children }));
+}
+export function useCallbacks() {
+    const context = useContext(CallbackContext);
+    return context;
+}
+export function useFormChangeCallback() {
+    const { onFormChange } = useCallbacks();
+    return useCallback((formData) => {
+        if (onFormChange) {
+            onFormChange(formData);
+        }
+    }, [onFormChange]);
+}
+export function useSwapCreateCallback() {
+    const { onSwapCreate } = useCallbacks();
+    return useCallback((swapData) => {
+        if (onSwapCreate) {
+            onSwapCreate(swapData);
+        }
+    }, [onSwapCreate]);
+}
+export function useSwapCompleteCallback() {
+    const { onSwapComplete } = useCallbacks();
+    return useCallback((swapData) => {
+        if (onSwapComplete) {
+            onSwapComplete(swapData);
+        }
+    }, [onSwapComplete]);
+}
+export function useSwapModalStateChangeCallback() {
+    const { onSwapModalStateChange } = useCallbacks();
+    return useCallback((open) => {
+        if (onSwapModalStateChange) {
+            onSwapModalStateChange(open);
+        }
+    }, [onSwapModalStateChange]);
+}
+export function useSwapIdChangeCallback() {
+    const { onSwapIdChange } = useCallbacks();
+    return useCallback((swapId) => {
+        if (onSwapIdChange) {
+            onSwapIdChange(swapId);
+        }
+    }, [onSwapIdChange]);
+}
+export function useBackClickCallback() {
+    const { onBackClick } = useCallbacks();
+    return useCallback(() => {
+        if (onBackClick) {
+            onBackClick();
+        }
+    }, [onBackClick]);
+}
+export function useErrorCallback() {
+    const { onError } = useCallbacks();
+    return useCallback((error) => {
+        if (onError) {
+            onError(error);
+        }
+    }, [onError]);
+}

package/dist/context/evmConnectorsContext.d.ts

@@ -0,0 +1,13 @@
+import { WalletConnectWallet } from '../lib/wallets/connectors/resolveConnectors';
+import { CreateConnectorFn } from 'wagmi';
+type ContextType = {
+    connectors: CreateConnectorFn[];
+    walletConnectConnectors: WalletConnectWallet[];
+    addWalletConnectWallet: (connector: WalletConnectWallet) => Promise<void>;
+};
+export declare const featuredWalletsIds: string[];
+export declare function EvmConnectorsProvider({ children }: {
+    children: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useEvmConnectors(): ContextType;
+export {};

package/dist/context/evmConnectorsContext.js

@@ -0,0 +1,82 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo, useState } from 'react';
+import { resolveConnector, walletConnectWallets as _walletConnectWallets } from '../lib/wallets/connectors/resolveConnectors';
+import { coinbaseWallet, walletConnect } from '@wagmi/connectors';
+import { browserInjected } from '../lib/wallets/connectors/browserInjected';
+import { isMobile } from '../lib/isMobile';
+import { usePersistedState } from '../hooks/usePersistedState';
+import AppSettings from '../lib/AppSettings';
+const EvmConnectorsContext = createContext(null);
+export const featuredWalletsIds = [
+    'metamask',
+    'argent',
+    'rainbow',
+    'bitkeep',
+    'okx-wallet',
+];
+const resolveFeaturedWallets = (wallets) => {
+    return wallets.filter(wallet => featuredWalletsIds.includes(wallet.id.toLowerCase()));
+};
+const WALLETCONNECT_PROJECT_ID = AppSettings.WalletConnectConfig.projectId;
+const wltcnnct_inited = walletConnect({ projectId: WALLETCONNECT_PROJECT_ID, showQrModal: isMobile(), customStoragePrefix: 'walletConnect' });
+const featuredWallets = resolveFeaturedWallets(_walletConnectWallets);
+export function EvmConnectorsProvider({ children }) {
+    let [recentConnectors, _] = usePersistedState([], 'recentConnectors', 'localStorage');
+    const [walletConnectWallets, setWalletConnectWallets] = useState([]);
+    const addWalletConnectWallet = async (connector) => {
+        setWalletConnectWallets((prev) => [...prev.filter(v => v.name !== connector.name), connector]);
+    };
+    const initialRecentConnectors = useMemo(() => {
+        const evmRecentConnectors = recentConnectors.filter(c => c.providerName === 'EVM'
+            && c.connectorName
+            && !featuredWalletsIds.includes(c.connectorName.toLowerCase()));
+        return evmRecentConnectors.filter(con => _walletConnectWallets.some(w => w.name.toLowerCase() === con?.connectorName?.toLowerCase())).map(c => {
+            const connector = _walletConnectWallets.find(w => w.name.toLowerCase() === c?.connectorName?.toLowerCase());
+            return connector;
+        });
+    }, [recentConnectors]);
+    const resolvedFeaturedWallets = useMemo(() => {
+        return featuredWallets.map(wallet => {
+            return resolveConnector(wallet.name);
+        });
+    }, [featuredWallets]);
+    const resolvedWalletConnectWallets = useMemo(() => {
+        const resolvedInitialRecentConnectors = initialRecentConnectors.map(wallet => {
+            return resolveConnector(wallet.name);
+        });
+        const resolvedWalletConnectConnectors = walletConnectWallets.map(wallet => {
+            return resolveConnector(wallet.name);
+        });
+        return [
+            ...resolvedInitialRecentConnectors,
+            ...resolvedWalletConnectConnectors
+        ];
+    }, [walletConnectWallets, initialRecentConnectors]);
+    const defaultConnectors = [
+        coinbaseWallet({
+            appName: 'Layerswap',
+            appLogoUrl: 'https://layerswap.io/app/symbol.png',
+        }),
+        wltcnnct_inited,
+        ...resolvedFeaturedWallets,
+        browserInjected()
+    ];
+    const connectors = useMemo(() => {
+        return [
+            ...defaultConnectors,
+            ...resolvedWalletConnectWallets
+        ];
+    }, [defaultConnectors, walletConnectWallets]);
+    return (_jsx(EvmConnectorsContext.Provider, { value: {
+            connectors,
+            walletConnectConnectors: _walletConnectWallets,
+            addWalletConnectWallet
+        }, children: children }));
+}
+export function useEvmConnectors() {
+    const data = useContext(EvmConnectorsContext);
+    if (data === null) {
+        throw new Error('useEvmConnectors must be used within a EvmConnectorsProvider');
+    }
+    return data;
+}

package/dist/context/query.d.ts

@@ -1,9 +1,9 @@
 import React, { FC } from 'react';
-import { QueryParams } from '../Models/QueryParams';
-export declare const QueryStateContext: React.Context<QueryParams | null>;
+import { InitialSettings } from '../Models/InitialSettings';
+export declare const QueryStateContext: React.Context<InitialSettings | null>;
 declare const QueryProvider: FC<{
-    query: QueryParams;
+    query: InitialSettings;
     children?: React.ReactNode;
 }>;
-export declare function useQueryState(): QueryParams;
+export declare function useQueryState(): InitialSettings;
 export default QueryProvider;

package/dist/context/query.js

@@ -7,6 +7,8 @@ const QueryProvider = ({ query, children }) => {
 function mapLegacyQueryParams(params) {
     return {
         ...params,
+        ...(params.destAddress ? { destination_address: params.destAddress } : {}),
+        ...(params.fromExchange ? { from: params.fromExchange } : {}),
         ...(params.sourceExchangeName ? { from: params.sourceExchangeName } : {}),
         ...(params.destNetwork ? { to: params.destNetwork } : {}),
         ...(params.lockExchange ? { lockFrom: params.lockExchange } : {}),

package/dist/context/settings.d.ts

@@ -1,8 +1,15 @@
 import React, { FC } from 'react';
 import { LayerSwapAppSettings } from '../Models/LayerSwapAppSettings';
-export declare const SettingsStateContext: React.Context<LayerSwapAppSettings | null>;
+import { InitialSettings } from '../Models/InitialSettings';
+export interface SettingsContextValue {
+    settings: LayerSwapAppSettings;
+    initialSettings: InitialSettings;
+}
+export declare const SettingsStateContext: React.Context<SettingsContextValue | null>;
 export declare const SettingsProvider: FC<{
-    data: LayerSwapAppSettings;
+    initialLayerswapData: LayerSwapAppSettings;
+    initialSettings?: InitialSettings;
     children?: React.ReactNode;
 }>;
 export declare function useSettingsState(): LayerSwapAppSettings;
+export declare function useInitialSettings(): InitialSettings;

package/dist/context/settings.js

@@ -1,13 +1,38 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
 export const SettingsStateContext = React.createContext(null);
-export const SettingsProvider = ({ children, data }) => {
-    return (_jsx(SettingsStateContext.Provider, { value: data, children: children }));
+export const SettingsProvider = ({ children, initialLayerswapData, initialSettings: initialSettings = {} }) => {
+    const value = {
+        settings: initialLayerswapData,
+        initialSettings: mapLegacySettings(initialSettings)
+    };
+    return (_jsx(SettingsStateContext.Provider, { value: value, children: children }));
 };
 export function useSettingsState() {
     const data = React.useContext(SettingsStateContext);
     if (data === undefined) {
         throw new Error('useSettingsState must be used within a SettingsProvider');
     }
-    return data;
+    return data.settings;
+}
+export function useInitialSettings() {
+    const data = React.useContext(SettingsStateContext);
+    if (data === undefined) {
+        throw new Error('useInitialSettings must be used within a SettingsProvider');
+    }
+    return data.initialSettings;
+}
+function mapLegacySettings(params) {
+    return {
+        ...params,
+        ...(params.destAddress ? { destination_address: params.destAddress } : {}),
+        ...(params.fromExchange ? { from: params.fromExchange } : {}),
+        ...(params.sourceExchangeName ? { from: params.sourceExchangeName } : {}),
+        ...(params.destNetwork ? { to: params.destNetwork } : {}),
+        ...(params.lockExchange ? { lockFrom: params.lockExchange } : {}),
+        ...(params.lockNetwork ? { lockTo: params.lockNetwork } : {}),
+        ...(params.addressSource ? { appName: params.addressSource } : {}),
+        ...(params.asset ? { [params.to ? "toAsset" : "fromAsset"]: params.asset } : {}),
+        ...(params.lockAsset ? { [params.to ? "lockToAsset" : "lockFromAsset"]: params.lockAsset } : {}),
+    };
 }

package/dist/context/swap.d.ts

@@ -1,42 +1,43 @@
 import { Context } from 'react';
-import { SwapFormValues } from '../components/Pages/SwapPages/Form/SwapFormValues';
-import { SwapTransaction, WithdrawType, SwapResponse, DepositAction } from '../lib/layerSwapApiClient';
-import { QueryParams } from '../Models/QueryParams';
+import { SwapTransaction, WithdrawType, SwapResponse, DepositAction, SwapBasicData, SwapQuote, Refuel, SwapDetails } from '../lib/apiClients/layerSwapApiClient';
+import { InitialSettings } from '../Models/InitialSettings';
 import { KeyedMutator } from 'swr';
 import { ApiResponse } from '../Models/ApiResponse';
 import { Partner } from '../Models/Partner';
 import { ApiError } from '../Models/ApiError';
-import { Wallet } from '../Models/WalletProvider';
-export declare const SwapDataStateContext: Context<SwapData>;
-export declare const SwapDataUpdateContext: Context<UpdateInterface | null>;
-export type UpdateInterface = {
-    createSwap: (values: SwapFormValues, query: QueryParams, partner?: Partner) => Promise<string>;
-    setCodeRequested: (codeSubmitted: boolean) => void;
+import { SwapFormValues } from '../components/Pages/Swap/Form/SwapFormValues';
+export declare const SwapDataStateContext: Context<SwapContextData>;
+export declare const SwapDataUpdateContext: Context<UpdateSwapInterface | null>;
+export type UpdateSwapInterface = {
+    createSwap: (values: SwapFormValues, query: InitialSettings, partner?: Partner) => Promise<SwapResponse>;
+    setQuoteLoading: (value: boolean) => void;
     setInterval: (value: number) => void;
     mutateSwap: KeyedMutator<ApiResponse<SwapResponse>>;
     setDepositAddressIsFromAccount: (value: boolean) => void;
     setWithdrawType: (value: WithdrawType) => void;
-    setSwapId: (value: string) => void;
-    setSelectedSourceAccount: (value: {
-        wallet: Wallet;
-        address: string;
-    } | undefined) => void;
+    setSwapId: (value: string | undefined) => void;
+    setSwapDataFromQuery?: (swapData: SwapResponse | undefined) => void;
+    setSubmitedFormValues: (values: NonNullable<SwapFormValues>) => void;
+    setSwapModalOpen: (value: boolean) => void;
 };
-export type SwapData = {
-    codeRequested: boolean;
-    swapResponse?: SwapResponse;
+export type SwapContextData = {
     swapApiError?: ApiError;
     depositAddressIsFromAccount?: boolean;
     depositActionsResponse?: DepositAction[];
     withdrawType: WithdrawType | undefined;
     swapTransaction: SwapTransaction | undefined;
-    selectedSourceAccount?: {
-        wallet: Wallet;
-        address: string;
-    };
+    swapBasicData: SwapBasicData & {
+        refuel: boolean;
+    } | undefined;
+    quote: SwapQuote | undefined;
+    refuel: Refuel | undefined;
+    swapDetails: SwapDetails | undefined;
+    quoteIsLoading: boolean;
+    swapId: string | undefined;
+    swapModalOpen: boolean;
 };
 export declare function SwapDataProvider({ children }: {
     children: any;
 }): import("react/jsx-runtime").JSX.Element;
-export declare function useSwapDataState(): SwapData;
-export declare function useSwapDataUpdate(): UpdateInterface;
+export declare function useSwapDataState(): SwapContextData;
+export declare function useSwapDataUpdate(): UpdateSwapInterface;