@lifi/widget 3.0.0-alpha.3 → 3.0.0-alpha.5

package/_esm/providers/WidgetProvider/WidgetProvider.js

@@ -0,0 +1,89 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { config, createConfig } from '@lifi/sdk';
+import { createContext, useContext, useId, useMemo } from 'react';
+import { version } from '../../config/version';
+import { setDefaultSettings } from '../../stores';
+import { formatInputAmount } from '../../utils';
+const initialContext = {
+    elementId: '',
+    integrator: '',
+};
+const WidgetContext = createContext(initialContext);
+export const useWidgetConfig = () => useContext(WidgetContext);
+let sdkInitialized = false;
+export const WidgetProvider = ({ children, config: widgetConfig }) => {
+    const elementId = useId();
+    if (!widgetConfig?.integrator) {
+        throw Error('Required property "integrator" is missing.');
+    }
+    const value = useMemo(() => {
+        try {
+            // Get search params from URL
+            const searchParams = Object.fromEntries(new URLSearchParams(window?.location.search));
+            // Prevent using fromToken/toToken params if chain is not selected
+            ['from', 'to'].forEach((key) => {
+                if (searchParams[`${key}Token`] && !searchParams[`${key}Chain`]) {
+                    delete searchParams[`${key}Token`];
+                }
+            });
+            // Create widget configuration object
+            const value = {
+                ...widgetConfig,
+                fromChain: (searchParams.fromChain &&
+                    !isNaN(parseInt(searchParams.fromChain, 10))) ||
+                    typeof widgetConfig.fromChain === 'number'
+                    ? parseInt(searchParams.fromChain, 10) || widgetConfig.fromChain
+                    : undefined,
+                toChain: (searchParams.toChain &&
+                    !isNaN(parseInt(searchParams.toChain, 10))) ||
+                    typeof widgetConfig.toChain === 'number'
+                    ? parseInt(searchParams.toChain, 10) || widgetConfig.toChain
+                    : undefined,
+                fromToken: searchParams.fromToken || widgetConfig.fromToken,
+                toToken: searchParams.toToken || widgetConfig.toToken,
+                fromAmount: typeof searchParams.fromAmount === 'string' &&
+                    !isNaN(parseFloat(searchParams.fromAmount))
+                    ? formatInputAmount(searchParams.fromAmount)
+                    : widgetConfig.fromAmount,
+                toAddress: searchParams.toAddress || widgetConfig.toAddress,
+                integrator: widgetConfig.integrator,
+                elementId,
+            };
+            // Set default settings for widget settings store
+            setDefaultSettings(value);
+            // Configure SDK
+            const _config = {
+                ...widgetConfig.sdkConfig,
+                apiKey: widgetConfig.apiKey,
+                integrator: widgetConfig.integrator ?? window?.location.hostname,
+                routeOptions: {
+                    fee: widgetConfig.fee,
+                    referrer: widgetConfig.referrer,
+                    order: widgetConfig.routePriority,
+                    slippage: widgetConfig.slippage,
+                    ...widgetConfig.sdkConfig?.routeOptions,
+                },
+                disableVersionCheck: true,
+                widgetVersion: version,
+                preloadChains: false,
+            };
+            if (!sdkInitialized) {
+                createConfig(_config);
+                sdkInitialized = true;
+            }
+            else {
+                config.set(_config);
+            }
+            return value;
+        }
+        catch (e) {
+            console.warn(e);
+            return {
+                ...widgetConfig,
+                elementId,
+                integrator: widgetConfig.integrator,
+            };
+        }
+    }, [elementId, widgetConfig]);
+    return (_jsx(WidgetContext.Provider, { value: value, children: children }));
+};

package/_esm/providers/WidgetProvider/index.js

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './utils';
+export * from './WidgetProvider';

package/_esm/providers/WidgetProvider/types.d.ts

@@ -0,0 +1,9 @@
+import type { WidgetConfig } from '../../types';
+export type WidgetContextProps = WidgetConfig & {
+    fromChain?: number;
+    toChain?: number;
+    elementId: string;
+};
+export interface WidgetProviderProps {
+    config?: WidgetConfig;
+}

package/_esm/providers/WidgetProvider/types.js

@@ -0,0 +1 @@
+export {};

package/_esm/providers/WidgetProvider/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const isItemAllowed: <T>(itemId: T, items?: {
+    allow?: T[] | undefined;
+    deny?: T[] | undefined;
+} | undefined) => boolean;

package/_esm/providers/WidgetProvider/utils.js

@@ -0,0 +1,6 @@
+export const isItemAllowed = (itemId, items) => {
+    if (items?.allow?.length) {
+        return items.allow.includes(itemId);
+    }
+    return !items?.deny?.includes(itemId);
+};

package/_esm/providers/index.js

@@ -0,0 +1,5 @@
+export * from './FormProvider';
+export * from './I18nProvider';
+export * from './ThemeProvider';
+export * from './WalletProvider';
+export * from './WidgetProvider';

package/_esm/stores/StoreProvider.d.ts

@@ -0,0 +1,3 @@
+import type { PropsWithChildren } from 'react';
+import type { WidgetConfigProps } from '../types';
+export declare const StoreProvider: React.FC<PropsWithChildren<WidgetConfigProps>>;

package/_esm/stores/StoreProvider.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ChainOrderStoreProvider } from './chains';
+import { HeaderStoreProvider } from './header';
+import { RouteExecutionStoreProvider } from './routes';
+import { SplitSubvariantStoreProvider } from './settings';
+export const StoreProvider = ({ children, config, }) => {
+    return (_jsx(SplitSubvariantStoreProvider, { state: config.subvariant === 'split'
+            ? config.subvariantOptions || 'swap'
+            : undefined, children: _jsx(HeaderStoreProvider, { namePrefix: config?.keyPrefix, children: _jsx(ChainOrderStoreProvider, { namePrefix: config?.keyPrefix, children: _jsx(RouteExecutionStoreProvider, { namePrefix: config?.keyPrefix, children: children }) }) }) }));
+};

package/_esm/stores/chains/ChainOrderStore.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import type { StoreApi } from 'zustand';
+import type { UseBoundStoreWithEqualityFn } from 'zustand/traditional';
+import type { PersistStoreProviderProps } from '../types';
+import type { ChainOrderState } from './types';
+export type ChainOrderStore = UseBoundStoreWithEqualityFn<StoreApi<ChainOrderState>>;
+export declare const ChainOrderStoreContext: import("react").Context<ChainOrderStore | null>;
+export declare function ChainOrderStoreProvider({ children, ...props }: PersistStoreProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useChainOrderStore<T>(selector: (state: ChainOrderState) => T, equalityFn?: (left: T, right: T) => boolean): T;
+export declare function useChainOrderStoreContext(): ChainOrderStore;

package/_esm/stores/chains/ChainOrderStore.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useRef } from 'react';
+import { useFormContext } from 'react-hook-form';
+import { useChains } from '../../hooks';
+import { FormKey } from '../../providers';
+import { createChainOrderStore } from './createChainOrderStore';
+export const ChainOrderStoreContext = createContext(null);
+export function ChainOrderStoreProvider({ children, ...props }) {
+    const storeRef = useRef();
+    const { chains: filteredChains } = useChains();
+    const { setValue, getValues } = useFormContext();
+    if (!storeRef.current) {
+        storeRef.current = createChainOrderStore(props);
+    }
+    useEffect(() => {
+        if (filteredChains) {
+            const chainOrder = storeRef.current
+                ?.getState()
+                .initializeChains(filteredChains.map((chain) => chain.id));
+            if (chainOrder) {
+                const [fromChainValue, toChainValue] = getValues([
+                    FormKey.FromChain,
+                    FormKey.ToChain,
+                ]);
+                if (!fromChainValue) {
+                    setValue(FormKey.FromChain, chainOrder[0]);
+                }
+                if (!toChainValue) {
+                    setValue(FormKey.ToChain, chainOrder[0]);
+                }
+            }
+        }
+    }, [filteredChains, getValues, setValue]);
+    return (_jsx(ChainOrderStoreContext.Provider, { value: storeRef.current, children: children }));
+}
+export function useChainOrderStore(selector, equalityFn) {
+    const useStore = useContext(ChainOrderStoreContext);
+    if (!useStore) {
+        throw new Error(`You forgot to wrap your component in <${ChainOrderStoreProvider.name}>.`);
+    }
+    return useStore(selector, equalityFn);
+}
+export function useChainOrderStoreContext() {
+    const useStore = useContext(ChainOrderStoreContext);
+    if (!useStore) {
+        throw new Error(`You forgot to wrap your component in <${ChainOrderStoreProvider.name}>.`);
+    }
+    return useStore;
+}

package/_esm/stores/chains/createChainOrderStore.d.ts

@@ -0,0 +1,4 @@
+import type { PersistStoreProps } from '../types';
+import type { ChainOrderState } from './types';
+export declare const maxChainToOrder = 9;
+export declare const createChainOrderStore: ({ namePrefix }: PersistStoreProps) => import("zustand/traditional").UseBoundStoreWithEqualityFn<import("zustand").StoreApi<ChainOrderState>>;

package/_esm/stores/chains/createChainOrderStore.js

@@ -0,0 +1,49 @@
+import { persist } from 'zustand/middleware';
+import { createWithEqualityFn } from 'zustand/traditional';
+export const maxChainToOrder = 9;
+export const createChainOrderStore = ({ namePrefix }) => createWithEqualityFn(persist((set, get) => ({
+    chainOrder: [],
+    availableChains: [],
+    initializeChains: (chainIds) => {
+        set((state) => {
+            const chainOrder = state.chainOrder.filter((chainId) => chainIds.includes(chainId));
+            const chainsToAdd = chainIds.filter((chainId) => !chainOrder.includes(chainId));
+            if (chainOrder.length === maxChainToOrder || !chainsToAdd.length) {
+                return {
+                    availableChains: chainIds,
+                    chainOrder,
+                };
+            }
+            const chainsToAddLength = maxChainToOrder - chainOrder.length;
+            for (let index = 0; index < chainsToAddLength; index++) {
+                chainOrder.push(chainsToAdd[index]);
+            }
+            return {
+                availableChains: chainIds,
+                chainOrder,
+            };
+        });
+        return get().chainOrder;
+    },
+    setChain: (chainId) => {
+        const state = get();
+        if (state.chainOrder.includes(chainId) ||
+            !state.availableChains.includes(chainId)) {
+            return;
+        }
+        set((state) => {
+            const chainOrder = state.chainOrder.slice();
+            chainOrder.unshift(chainId);
+            if (chainOrder.length > maxChainToOrder) {
+                chainOrder.pop();
+            }
+            return {
+                chainOrder,
+            };
+        });
+    },
+}), {
+    name: `${namePrefix || 'li.fi'}-widget-chains-order`,
+    version: 0,
+    partialize: (state) => ({ chainOrder: state.chainOrder }),
+}), Object.is);

package/_esm/stores/chains/index.js

@@ -0,0 +1,4 @@
+export * from './ChainOrderStore';
+export * from './createChainOrderStore';
+export * from './types';
+export * from './useChainOrder';

package/_esm/stores/chains/types.d.ts

@@ -0,0 +1,8 @@
+export interface ChainOrderProps {
+    chainOrder: number[];
+    availableChains: number[];
+}
+export interface ChainOrderState extends ChainOrderProps {
+    initializeChains(chainIds: number[]): number[];
+    setChain(chainId: number): void;
+}

package/_esm/stores/chains/types.js

@@ -0,0 +1 @@
+export {};

package/_esm/stores/chains/useChainOrder.d.ts

@@ -0,0 +1 @@
+export declare const useChainOrder: () => [number[], (chainId: number) => void];

package/_esm/stores/chains/useChainOrder.js

@@ -0,0 +1,5 @@
+import { shallow } from 'zustand/shallow';
+import { useChainOrderStore } from './ChainOrderStore';
+export const useChainOrder = () => {
+    return useChainOrderStore((state) => [state.chainOrder, state.setChain], shallow);
+};

package/_esm/stores/header/index.js

@@ -0,0 +1 @@
+export * from './useHeaderStore';

package/_esm/stores/header/types.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import type { StoreApi } from 'zustand';
+import type { UseBoundStoreWithEqualityFn } from 'zustand/traditional';
+export type HeaderStore = UseBoundStoreWithEqualityFn<StoreApi<HeaderState>>;
+export interface HeaderStateBase {
+    element?: React.ReactNode | null;
+    title?: string;
+}
+export interface HeaderState extends HeaderStateBase {
+    setAction(element?: React.ReactNode | null): () => void;
+    setTitle(title?: string): () => void;
+    removeAction(): void;
+    removeTitle(): void;
+}

package/_esm/stores/header/types.js

@@ -0,0 +1 @@
+export {};

package/_esm/stores/header/useHeaderStore.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import type { PersistStoreProps, PersistStoreProviderProps } from '../types';
+import type { HeaderState, HeaderStore } from './types';
+export declare const HeaderStoreContext: import("react").Context<HeaderStore | null>;
+export declare function HeaderStoreProvider({ children, ...props }: PersistStoreProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useHeaderStore<T>(selector: (state: HeaderState) => T): T;
+export declare function useHeaderStoreContext(): HeaderStore;
+export declare const createHeaderStore: ({ namePrefix }: PersistStoreProps) => import("zustand/traditional").UseBoundStoreWithEqualityFn<import("zustand").StoreApi<HeaderState>>;

package/_esm/stores/header/useHeaderStore.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useRef } from 'react';
+import { createWithEqualityFn } from 'zustand/traditional';
+export const HeaderStoreContext = createContext(null);
+export function HeaderStoreProvider({ children, ...props }) {
+    const storeRef = useRef();
+    if (!storeRef.current) {
+        storeRef.current = createHeaderStore(props);
+    }
+    return (_jsx(HeaderStoreContext.Provider, { value: storeRef.current, children: children }));
+}
+export function useHeaderStore(selector) {
+    const useStore = useContext(HeaderStoreContext);
+    if (!useStore) {
+        throw new Error(`You forgot to wrap your component in <${HeaderStoreProvider.name}>.`);
+    }
+    return useStore(selector);
+}
+export function useHeaderStoreContext() {
+    const useStore = useContext(HeaderStoreContext);
+    if (!useStore) {
+        throw new Error(`You forgot to wrap your component in <${HeaderStoreProvider.name}>.`);
+    }
+    return useStore;
+}
+export const createHeaderStore = ({ namePrefix }) => createWithEqualityFn((set, get) => ({
+    setAction: (element) => {
+        set(() => ({
+            element,
+        }));
+        return get().removeAction;
+    },
+    setTitle: (title) => {
+        set(() => ({
+            title,
+        }));
+        return get().removeTitle;
+    },
+    removeAction: () => {
+        set(() => ({
+            element: null,
+        }));
+    },
+    removeTitle: () => {
+        set(() => ({
+            title: undefined,
+        }));
+    },
+}), Object.is);

package/_esm/stores/index.js

@@ -0,0 +1,5 @@
+export * from './StoreProvider';
+export * from './chains';
+export * from './header';
+export * from './routes';
+export * from './settings';

package/_esm/stores/routes/RouteExecutionStore.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import type { StoreApi } from 'zustand';
+import type { UseBoundStoreWithEqualityFn } from 'zustand/traditional';
+import type { PersistStoreProviderProps } from '../types';
+import type { RouteExecutionState } from './types';
+export type RouteExecutionStore = UseBoundStoreWithEqualityFn<StoreApi<RouteExecutionState>>;
+export declare const RouteExecutionStoreContext: import("react").Context<RouteExecutionStore | null>;
+export declare function RouteExecutionStoreProvider({ children, ...props }: PersistStoreProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useRouteExecutionStore<T>(selector: (state: RouteExecutionState) => T, equalityFn?: (left: T, right: T) => boolean): T;
+export declare function useRouteExecutionStoreContext(): RouteExecutionStore;

package/_esm/stores/routes/RouteExecutionStore.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useRef } from 'react';
+import { createRouteExecutionStore } from './createRouteExecutionStore';
+export const RouteExecutionStoreContext = createContext(null);
+export function RouteExecutionStoreProvider({ children, ...props }) {
+    const storeRef = useRef();
+    if (!storeRef.current) {
+        storeRef.current = createRouteExecutionStore(props);
+    }
+    return (_jsx(RouteExecutionStoreContext.Provider, { value: storeRef.current, children: children }));
+}
+export function useRouteExecutionStore(selector, equalityFn) {
+    const useStore = useContext(RouteExecutionStoreContext);
+    if (!useStore) {
+        throw new Error(`You forgot to wrap your component in <${RouteExecutionStoreProvider.name}>.`);
+    }
+    return useStore(selector, equalityFn);
+}
+export function useRouteExecutionStoreContext() {
+    const useStore = useContext(RouteExecutionStoreContext);
+    if (!useStore) {
+        throw new Error(`You forgot to wrap your component in <${RouteExecutionStoreProvider.name}>.`);
+    }
+    return useStore;
+}

package/_esm/stores/routes/createRouteExecutionStore.d.ts

@@ -0,0 +1,3 @@
+import type { PersistStoreProps } from '../types';
+import type { RouteExecutionState } from './types';
+export declare const createRouteExecutionStore: ({ namePrefix }: PersistStoreProps) => import("zustand/traditional").UseBoundStoreWithEqualityFn<import("zustand").StoreApi<RouteExecutionState>>;

package/_esm/stores/routes/createRouteExecutionStore.js

@@ -0,0 +1,130 @@
+import { persist } from 'zustand/middleware';
+import { createWithEqualityFn } from 'zustand/traditional';
+import { hasEnumFlag } from '../../utils';
+import { RouteExecutionStatus } from './types';
+import { isRouteDone, isRouteFailed, isRoutePartiallyDone, isRouteRefunded, } from './utils';
+export const createRouteExecutionStore = ({ namePrefix }) => createWithEqualityFn(persist((set, get) => ({
+    routes: {},
+    setExecutableRoute: (route, insurableRouteId) => {
+        if (!get().routes[route.id]) {
+            set((state) => {
+                const routes = { ...state.routes };
+                // clean previous idle and done routes
+                Object.keys(routes)
+                    .filter((routeId) => (routeId !== insurableRouteId &&
+                    hasEnumFlag(routes[routeId].status, RouteExecutionStatus.Idle)) ||
+                    hasEnumFlag(routes[routeId].status, RouteExecutionStatus.Done))
+                    .forEach((routeId) => delete routes[routeId]);
+                routes[route.id] = {
+                    route,
+                    status: RouteExecutionStatus.Idle,
+                };
+                return {
+                    routes,
+                };
+            });
+        }
+    },
+    updateRoute: (route) => {
+        if (get().routes[route.id]) {
+            set((state) => {
+                const updatedState = {
+                    routes: {
+                        ...state.routes,
+                        [route.id]: { ...state.routes[route.id], route },
+                    },
+                };
+                const isFailed = isRouteFailed(route);
+                if (isFailed) {
+                    updatedState.routes[route.id].status =
+                        RouteExecutionStatus.Failed;
+                    return updatedState;
+                }
+                const isDone = isRouteDone(route);
+                if (isDone) {
+                    updatedState.routes[route.id].status =
+                        RouteExecutionStatus.Done;
+                    if (isRoutePartiallyDone(route)) {
+                        updatedState.routes[route.id].status |=
+                            RouteExecutionStatus.Partial;
+                    }
+                    else if (isRouteRefunded(route)) {
+                        updatedState.routes[route.id].status |=
+                            RouteExecutionStatus.Refunded;
+                    }
+                    return updatedState;
+                }
+                const isLoading = route.steps.some((step) => step.execution);
+                if (isLoading) {
+                    updatedState.routes[route.id].status =
+                        RouteExecutionStatus.Pending;
+                }
+                return updatedState;
+            });
+        }
+    },
+    restartRoute: (routeId) => {
+        if (get().routes[routeId]) {
+            set((state) => ({
+                routes: {
+                    ...state.routes,
+                    [routeId]: {
+                        ...state.routes[routeId],
+                        status: RouteExecutionStatus.Pending,
+                    },
+                },
+            }));
+        }
+    },
+    deleteRoute: (routeId) => {
+        if (get().routes[routeId]) {
+            set((state) => {
+                const routes = { ...state.routes };
+                delete routes[routeId];
+                return {
+                    routes,
+                };
+            });
+        }
+    },
+    deleteRoutes: (type) => set((state) => {
+        const routes = { ...state.routes };
+        Object.keys(routes)
+            .filter((routeId) => type === 'completed'
+            ? hasEnumFlag(routes[routeId]?.status ?? 0, RouteExecutionStatus.Done)
+            : !hasEnumFlag(routes[routeId]?.status ?? 0, RouteExecutionStatus.Done))
+            .forEach((routeId) => delete routes[routeId]);
+        return {
+            routes,
+        };
+    }),
+}), {
+    name: `${namePrefix || 'li.fi'}-widget-routes`,
+    version: 1,
+    partialize: (state) => ({ routes: state.routes }),
+    merge: (persistedState, currentState) => {
+        const state = {
+            ...currentState,
+            ...persistedState,
+        };
+        try {
+            // Remove failed transactions from history after 1 day
+            const currentTime = new Date().getTime();
+            const oneDay = 1000 * 60 * 60 * 24;
+            Object.values(state.routes).forEach((routeExecution) => {
+                const startedAt = routeExecution?.route.steps
+                    ?.find((step) => step.execution?.status === 'FAILED')
+                    ?.execution?.process.find((process) => process.startedAt)
+                    ?.startedAt ?? 0;
+                const outdated = startedAt > 0 && currentTime - startedAt > oneDay;
+                if (routeExecution?.route && outdated) {
+                    delete state.routes[routeExecution.route.id];
+                }
+            });
+        }
+        catch (error) {
+            console.error(error);
+        }
+        return state;
+    },
+}), Object.is);

package/_esm/stores/routes/index.js

@@ -0,0 +1,5 @@
+export * from './RouteExecutionStore';
+export * from './types';
+export * from './useExecutingRoutesIds';
+export * from './useSetExecutableRoute';
+export * from './utils';

package/_esm/stores/routes/types.d.ts

@@ -0,0 +1,21 @@
+import type { Route, RouteExtended } from '@lifi/sdk';
+export interface RouteExecution {
+    route: RouteExtended;
+    status: RouteExecutionStatus;
+}
+export interface RouteExecutionState {
+    routes: Partial<Record<string, RouteExecution>>;
+    setExecutableRoute: (route: Route, insurableRouteId?: string) => void;
+    updateRoute: (route: Route) => void;
+    restartRoute: (routeId: string) => void;
+    deleteRoute: (routeId: string) => void;
+    deleteRoutes: (type: 'completed' | 'active') => void;
+}
+export declare enum RouteExecutionStatus {
+    Idle = 0,
+    Pending = 1,
+    Done = 2,
+    Failed = 4,
+    Partial = 8,
+    Refunded = 16
+}

package/_esm/stores/routes/types.js

@@ -0,0 +1,9 @@
+export var RouteExecutionStatus;
+(function (RouteExecutionStatus) {
+    RouteExecutionStatus[RouteExecutionStatus["Idle"] = 0] = "Idle";
+    RouteExecutionStatus[RouteExecutionStatus["Pending"] = 1] = "Pending";
+    RouteExecutionStatus[RouteExecutionStatus["Done"] = 2] = "Done";
+    RouteExecutionStatus[RouteExecutionStatus["Failed"] = 4] = "Failed";
+    RouteExecutionStatus[RouteExecutionStatus["Partial"] = 8] = "Partial";
+    RouteExecutionStatus[RouteExecutionStatus["Refunded"] = 16] = "Refunded";
+})(RouteExecutionStatus || (RouteExecutionStatus = {}));

package/_esm/stores/routes/useExecutingRoutesIds.d.ts

@@ -0,0 +1 @@
+export declare const useExecutingRoutesIds: (address?: string) => string[];

package/_esm/stores/routes/useExecutingRoutesIds.js

@@ -0,0 +1,12 @@
+import { shallow } from 'zustand/shallow';
+import { useRouteExecutionStore } from './RouteExecutionStore';
+import { RouteExecutionStatus } from './types';
+export const useExecutingRoutesIds = (address) => {
+    return useRouteExecutionStore((state) => Object.values(state.routes)
+        .filter((item) => item.route.fromAddress === address &&
+        (item.status === RouteExecutionStatus.Pending ||
+            item.status === RouteExecutionStatus.Failed))
+        .sort((a, b) => (b?.route.steps[0].execution?.process[0].startedAt ?? 0) -
+        (a?.route.steps[0].execution?.process[0].startedAt ?? 0))
+        .map(({ route }) => route.id), shallow);
+};

package/_esm/stores/routes/useSetExecutableRoute.d.ts

@@ -0,0 +1 @@
+export declare const useSetExecutableRoute: () => (route: import("@lifi/types").Route, insurableRouteId?: string | undefined) => void;

package/_esm/stores/routes/useSetExecutableRoute.js

@@ -0,0 +1,4 @@
+import { useRouteExecutionStore } from './RouteExecutionStore';
+export const useSetExecutableRoute = () => {
+    return useRouteExecutionStore((state) => state.setExecutableRoute);
+};

package/_esm/stores/routes/utils.d.ts

@@ -0,0 +1,8 @@
+import type { Process, RouteExtended } from '@lifi/sdk';
+export declare const isRouteDone: (route: RouteExtended) => boolean;
+export declare const isRoutePartiallyDone: (route: RouteExtended) => boolean;
+export declare const isRouteRefunded: (route: RouteExtended) => boolean;
+export declare const isRouteFailed: (route: RouteExtended) => boolean;
+export declare const isRouteActive: (route?: RouteExtended) => boolean;
+export declare const getUpdatedProcess: (currentRoute: RouteExtended, updatedRoute: RouteExtended) => Process | undefined;
+export declare const getSourceTxHash: (route?: RouteExtended) => string | undefined;