@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

package/dist/stores/balanceStore.d.ts

@@ -0,0 +1,38 @@
+import { NetworkBalance } from '../Models/Balance';
+import { NetworkWithTokens } from '../Models/Network';
+export declare function getKey(address: string, network: NetworkWithTokens): string;
+export declare function getKey(address: string, networkName: string): string;
+type Status = 'loading' | 'success' | 'error';
+export interface BalanceEntry {
+    data?: NetworkBalance;
+    error?: unknown;
+    status: Status;
+    promise?: Promise<NetworkBalance>;
+}
+type Options = {
+    dedupeInterval?: number;
+    ignoreCache?: boolean;
+};
+interface BalanceStore {
+    balances: Record<string, BalanceEntry>;
+    lastFetchMap: Record<string, number>;
+    fetchBalance: (address: string, network: NetworkWithTokens, options?: Options) => Promise<NetworkBalance>;
+    initiatedBalances: Record<string, string> | null;
+    isLoading: boolean;
+    initAllBalances: (pairs: Array<{
+        address: string;
+        network: NetworkWithTokens;
+    }>) => void;
+    getResolvedInitiatedBalances: () => Record<string, NetworkBalance> | null;
+}
+export declare const useBalanceStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<BalanceStore>, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: BalanceStore, previousSelectedState: BalanceStore) => void): () => void;
+        <U>(selector: (state: BalanceStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}>;
+export declare const selectResolvedInitiatedBalances: (state: BalanceStore) => Record<string, NetworkBalance> | null;
+export {};

package/dist/stores/balanceStore.js

@@ -0,0 +1,167 @@
+import { create } from 'zustand';
+import { subscribeWithSelector } from 'zustand/middleware';
+import { BalanceResolver } from '../lib/balances/balanceResolver';
+export function getKey(address, networkOrName) {
+    const name = typeof networkOrName === 'string' ? networkOrName : networkOrName.name;
+    return `${address}:${name}`;
+}
+const balanceFetcher = new BalanceResolver();
+const MAX_CONCURRENT = 500;
+let activeCount = 0;
+const queue = [];
+function processQueue() {
+    while (activeCount < MAX_CONCURRENT && queue.length > 0) {
+        const job = queue.shift();
+        activeCount++;
+        job();
+    }
+}
+export const useBalanceStore = create()(subscribeWithSelector((set, get, api) => ({
+    balances: {},
+    lastFetchMap: {},
+    initiatedBalances: null,
+    isLoading: false,
+    fetchBalance: (address, network, options) => {
+        const key = getKey(address, network);
+        const entry = get().balances[key];
+        const dedupeInterval = options?.dedupeInterval ?? 120000;
+        const now = Date.now();
+        const last = get().lastFetchMap[key] ?? 0;
+        if (entry?.promise)
+            return entry.promise;
+        if (!options?.ignoreCache && entry && now - last < dedupeInterval)
+            return Promise.resolve(entry.data);
+        const queuedPromise = new Promise((resolve, reject) => {
+            const job = () => {
+                balanceFetcher.getBalance(network, address)
+                    .then(data => {
+                    set(state => ({
+                        balances: {
+                            ...state.balances,
+                            [key]: { data, status: 'success' },
+                        },
+                        lastFetchMap: {
+                            ...state.lastFetchMap,
+                            [key]: Date.now(),
+                        }
+                    }));
+                    resolve(data);
+                })
+                    .catch(error => {
+                    set(state => ({
+                        balances: {
+                            ...state.balances,
+                            [key]: { ...state.balances[key], error, status: 'error' },
+                        },
+                        lastFetchMap: {
+                            ...state.lastFetchMap,
+                            [key]: Date.now(),
+                        }
+                    }));
+                    reject(error);
+                })
+                    .finally(() => {
+                    activeCount--;
+                    processQueue();
+                });
+            };
+            queue.push(job);
+            processQueue();
+        });
+        set(state => ({
+            balances: {
+                ...state.balances,
+                [key]: { ...state.balances[key], status: 'loading', promise: queuedPromise },
+            }
+        }));
+        return queuedPromise;
+    },
+    initAllBalances: pairs => {
+        if (pairs.length > 0)
+            set({ isLoading: true });
+        set({ initiatedBalances: null });
+        // kick off every fetch
+        pairs.forEach(({ address, network }) => {
+            get().fetchBalance(address, network, { dedupeInterval: 120000, ignoreCache: true });
+        });
+        // subscribe to balance map changes
+        const unsub = api.subscribe(state => state.balances, balances => {
+            const done = pairs.every(({ address, network }) => balances[getKey(address, network)]?.status !== 'loading');
+            if (done) {
+                const finalMap = pairs.reduce((acc, { address, network }) => {
+                    const key = getKey(address, network);
+                    const entry = balances[key];
+                    if (entry)
+                        acc[network.name] = key;
+                    return acc;
+                }, {});
+                set({ initiatedBalances: finalMap });
+                set({ isLoading: false });
+                unsub(); // cleanup subscription
+            }
+        });
+    },
+    getResolvedInitiatedBalances: () => {
+        const keys = get().initiatedBalances;
+        if (!keys)
+            return null;
+        const balances = get().balances;
+        return Object.entries(keys).reduce((acc, [networkName, key]) => {
+            const entry = balances[key];
+            if (entry?.data)
+                acc[networkName] = entry.data;
+            return acc;
+        }, {});
+    }
+})));
+// Memoized selector to prevent unnecessary object creation
+let lastInitiatedBalances = null;
+let lastBalances = {};
+let memoizedResult = null;
+//Discuss with Babken M.
+export const selectResolvedInitiatedBalances = (state) => {
+    const keys = state.initiatedBalances;
+    if (!keys)
+        return null;
+    // Only recalculate if initiatedBalances or balances have actually changed
+    if (keys === lastInitiatedBalances && state.balances === lastBalances && memoizedResult) {
+        return memoizedResult;
+    }
+    // Check if the actual data has changed, not just the object references
+    if (lastInitiatedBalances && memoizedResult) {
+        let hasChanged = false;
+        // Check if keys are different
+        const currentKeySet = Object.keys(keys);
+        const lastKeySet = Object.keys(lastInitiatedBalances);
+        if (currentKeySet.length !== lastKeySet.length ||
+            !currentKeySet.every(k => lastKeySet.includes(k))) {
+            hasChanged = true;
+        }
+        // Check if balance data has changed for existing keys
+        if (!hasChanged) {
+            for (const [_, key] of Object.entries(keys)) {
+                const entry = state.balances[key];
+                const lastEntry = lastBalances[key];
+                if (entry?.data !== lastEntry?.data) {
+                    hasChanged = true;
+                    break;
+                }
+            }
+        }
+        if (!hasChanged) {
+            return memoizedResult;
+        }
+    }
+    // Recalculate the result
+    const result = Object.entries(keys).reduce((acc, [networkName, key]) => {
+        const entry = state.balances[key];
+        if (entry?.data)
+            acc[networkName] = entry.data;
+        return acc;
+    }, {});
+    // Update memoization cache
+    lastInitiatedBalances = keys;
+    lastBalances = state.balances;
+    memoizedResult = result;
+    return result;
+};

package/dist/stores/contractWalletsStore.d.ts

@@ -10,15 +10,17 @@ export declare class ContractWalletInfo {
     ready: boolean;
     static keyDeriver(address: string, network_internal_name: string): string;
 }
-export declare const useContractWalletsStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<WalletState>, "persist"> & {
+export declare const useContractWalletsStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<WalletState>, "setState" | "persist"> & {
+    setState(partial: WalletState | Partial<WalletState> | ((state: WalletState) => WalletState | Partial<WalletState>), replace?: false | undefined): unknown;
+    setState(state: WalletState | ((state: WalletState) => WalletState), replace: true): unknown;
     persist: {
-        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<WalletState, unknown>>) => void;
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<WalletState, unknown, unknown>>) => void;
         clearStorage: () => void;
         rehydrate: () => Promise<void> | void;
         hasHydrated: () => boolean;
         onHydrate: (fn: (state: WalletState) => void) => () => void;
         onFinishHydration: (fn: (state: WalletState) => void) => () => void;
-        getOptions: () => Partial<import("zustand/middleware").PersistOptions<WalletState, unknown>>;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<WalletState, unknown, unknown>>;
     };
 }>;
 export {};

package/dist/stores/recentRoutesStore.d.ts

@@ -0,0 +1,37 @@
+export type RoutesHistory = {
+    sourceRoutes: RouteItem;
+    destinationRoutes: RouteItem;
+};
+type RouteItem = {
+    [key: string]: {
+        [key: string]: number;
+    };
+};
+type UpdateHistoryArgs = {
+    from: {
+        network: string;
+        token: string;
+    } | undefined;
+    to: {
+        network: string;
+        token: string;
+    };
+};
+interface RecentNetworksState {
+    recentRoutes: RoutesHistory;
+    updateRecentNetworks: (args: UpdateHistoryArgs) => void;
+}
+export declare const useRecentNetworksStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<RecentNetworksState>, "setState" | "persist"> & {
+    setState(partial: RecentNetworksState | Partial<RecentNetworksState> | ((state: RecentNetworksState) => RecentNetworksState | Partial<RecentNetworksState>), replace?: false | undefined): unknown;
+    setState(state: RecentNetworksState | ((state: RecentNetworksState) => RecentNetworksState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<RecentNetworksState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: RecentNetworksState) => void) => () => void;
+        onFinishHydration: (fn: (state: RecentNetworksState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<RecentNetworksState, unknown, unknown>>;
+    };
+}>;
+export {};

package/dist/stores/recentRoutesStore.js

@@ -0,0 +1,37 @@
+import { create } from 'zustand';
+import { createJSONStorage, persist } from 'zustand/middleware';
+export const useRecentNetworksStore = create()(persist((set) => ({
+    recentRoutes: {
+        sourceRoutes: {},
+        destinationRoutes: {},
+    },
+    updateRecentNetworks: (args) => {
+        set(state => ({
+            recentRoutes: updateRecentNetworksHelper(state.recentRoutes, args)
+        }));
+    }
+}), {
+    name: 'recentRoutes',
+    storage: createJSONStorage(() => localStorage),
+}));
+const updateRecentNetworksHelper = (prev, data) => {
+    const { from, to } = data;
+    return {
+        sourceRoutes: {
+            ...prev.sourceRoutes,
+            ...(from ? {
+                [from.network]: {
+                    ...prev.sourceRoutes[from.network],
+                    [from.token]: (prev.sourceRoutes?.[from.network]?.[from.token] || 0) + 1
+                }
+            } : {})
+        },
+        destinationRoutes: {
+            ...prev.destinationRoutes,
+            [to.network]: {
+                ...prev.sourceRoutes[to.network],
+                [to.token]: (prev.sourceRoutes?.[to.network]?.[to.token] || 0) + 1
+            }
+        },
+    };
+};

package/dist/stores/routeTokenSwitchStore.d.ts

@@ -0,0 +1,6 @@
+type RouteTokenSwitchState = {
+    showTokens: boolean;
+    setShowTokens: (val: boolean) => void;
+};
+export declare const useRouteTokenSwitchStore: import("zustand").UseBoundStore<import("zustand").StoreApi<RouteTokenSwitchState>>;
+export {};

package/dist/stores/routeTokenSwitchStore.js

@@ -0,0 +1,5 @@
+import { create } from 'zustand';
+export const useRouteTokenSwitchStore = create((set) => ({
+    showTokens: false,
+    setShowTokens: (val) => set({ showTokens: val }),
+}));

package/dist/stores/swapTransactionStore.d.ts

@@ -1,4 +1,4 @@
-import { BackendTransactionStatus, TransactionStatus } from '../lib/layerSwapApiClient';
+import { BackendTransactionStatus, TransactionStatus } from '../lib/apiClients/layerSwapApiClient';
 type SwapTransaction = {
     hash: string;
     status: BackendTransactionStatus | TransactionStatus;
@@ -14,26 +14,30 @@ type SwapDepositHintClickedStore = {
     swapTransactions: Record<string, boolean>;
     setSwapDepositHintClicked: (Id: string) => void;
 };
-export declare const useSwapTransactionStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<SwapTransactionStore>, "persist"> & {
+export declare const useSwapTransactionStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<SwapTransactionStore>, "setState" | "persist"> & {
+    setState(partial: SwapTransactionStore | Partial<SwapTransactionStore> | ((state: SwapTransactionStore) => SwapTransactionStore | Partial<SwapTransactionStore>), replace?: false | undefined): unknown;
+    setState(state: SwapTransactionStore | ((state: SwapTransactionStore) => SwapTransactionStore), replace: true): unknown;
     persist: {
-        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<SwapTransactionStore, SwapTransactionStore>>) => void;
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<SwapTransactionStore, SwapTransactionStore, unknown>>) => void;
         clearStorage: () => void;
         rehydrate: () => Promise<void> | void;
         hasHydrated: () => boolean;
         onHydrate: (fn: (state: SwapTransactionStore) => void) => () => void;
         onFinishHydration: (fn: (state: SwapTransactionStore) => void) => () => void;
-        getOptions: () => Partial<import("zustand/middleware").PersistOptions<SwapTransactionStore, SwapTransactionStore>>;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<SwapTransactionStore, SwapTransactionStore, unknown>>;
     };
 }>;
-export declare const useSwapDepositHintClicked: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<SwapDepositHintClickedStore>, "persist"> & {
+export declare const useSwapDepositHintClicked: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<SwapDepositHintClickedStore>, "setState" | "persist"> & {
+    setState(partial: SwapDepositHintClickedStore | Partial<SwapDepositHintClickedStore> | ((state: SwapDepositHintClickedStore) => SwapDepositHintClickedStore | Partial<SwapDepositHintClickedStore>), replace?: false | undefined): unknown;
+    setState(state: SwapDepositHintClickedStore | ((state: SwapDepositHintClickedStore) => SwapDepositHintClickedStore), replace: true): unknown;
     persist: {
-        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<SwapDepositHintClickedStore, SwapDepositHintClickedStore>>) => void;
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<SwapDepositHintClickedStore, SwapDepositHintClickedStore, unknown>>) => void;
         clearStorage: () => void;
         rehydrate: () => Promise<void> | void;
         hasHydrated: () => boolean;
         onHydrate: (fn: (state: SwapDepositHintClickedStore) => void) => () => void;
         onFinishHydration: (fn: (state: SwapDepositHintClickedStore) => void) => () => void;
-        getOptions: () => Partial<import("zustand/middleware").PersistOptions<SwapDepositHintClickedStore, SwapDepositHintClickedStore>>;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<SwapDepositHintClickedStore, SwapDepositHintClickedStore, unknown>>;
     };
 }>;
 export {};

package/dist/stores/walletStore.d.ts

@@ -15,15 +15,17 @@ interface WalletState {
     addParadexAccount: (v: ParadexAccount) => void;
     removeParadexAccount: (address: string) => void;
 }
-export declare const useWalletStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<WalletState>, "persist"> & {
+export declare const useWalletStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<WalletState>, "setState" | "persist"> & {
+    setState(partial: WalletState | Partial<WalletState> | ((state: WalletState) => WalletState | Partial<WalletState>), replace?: false | undefined): unknown;
+    setState(state: WalletState | ((state: WalletState) => WalletState), replace: true): unknown;
     persist: {
-        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<WalletState, unknown>>) => void;
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<WalletState, unknown, unknown>>) => void;
         clearStorage: () => void;
         rehydrate: () => Promise<void> | void;
         hasHydrated: () => boolean;
         onHydrate: (fn: (state: WalletState) => void) => () => void;
         onFinishHydration: (fn: (state: WalletState) => void) => () => void;
-        getOptions: () => Partial<import("zustand/middleware").PersistOptions<WalletState, unknown>>;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<WalletState, unknown, unknown>>;
     };
 }>;
 export {};

package/dist/stores/walletStore.js

@@ -13,8 +13,14 @@ export const useWalletStore = create()(persist((set) => ({
     // we check if the wallet is already connected do not modify the state
     // TODO: get rid of useEffect hooks and implement singelton pattern
     connectWallet: (wallet) => set((state) => {
-        if (state.connectedWallets.find(w => w.providerName == wallet.providerName && w.id == wallet.id && w.address == wallet.address)) {
-            return state;
+        const existingWallet = state.connectedWallets.find(w => w.providerName == wallet.providerName && w.id == wallet.id && w.address == wallet.address);
+        if (existingWallet) {
+            return {
+                connectedWallets: [
+                    ...state.connectedWallets.filter(w => !(w.providerName == wallet.providerName && w.id == wallet.id && w.address == wallet.address)),
+                    wallet
+                ]
+            };
         }
         return ({
             connectedWallets: [

package/dist/stories/Data/initialValues.d.ts

@@ -0,0 +1,2 @@
+import { SwapFormValues } from "../../components/Pages/Swap/Form/SwapFormValues";
+export declare const initialValues: SwapFormValues;

package/dist/stories/Data/initialValues.js

@@ -0,0 +1,138 @@
+import { NetworkType } from "../../Models/Network";
+export const initialValues = {
+    "amount": "0.001803",
+    "destination_address": "0xf51c208e2c37a99b13dcf01a3434cc71be8b2bdd",
+    "from": {
+        "tokens": [
+            {
+                "symbol": "USDC.e",
+                "listing_date": "2023-12-27T16:46:50.617075+00:00",
+                "logo": "https://devlslayerswapbridgesa.blob.core.windows.net/layerswap/currencies/usdc.e.png",
+                "contract": "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",
+                "decimals": 6,
+                "price_in_usd": 0.999873,
+                "precision": 6,
+                display_asset: ""
+            },
+            {
+                "symbol": "USDC",
+                "listing_date": "2023-12-27T16:46:50.617075+00:00",
+                "logo": "https://devlslayerswapbridgesa.blob.core.windows.net/layerswap/currencies/usdc.png",
+                "contract": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+                "decimals": 6,
+                "price_in_usd": 0.999873,
+                "precision": 6,
+                display_asset: ""
+            },
+            {
+                "symbol": "ETH",
+                "listing_date": "2023-12-27T16:46:50.617075+00:00",
+                "logo": "https://devlslayerswapbridgesa.blob.core.windows.net/layerswap/currencies/eth.png",
+                "contract": null,
+                "decimals": 18,
+                "price_in_usd": 3234.87,
+                "precision": 6,
+                display_asset: ""
+            }
+        ],
+        "name": "ARBITRUM_MAINNET",
+        "display_name": "Arbitrum One",
+        "logo": "https://devlslayerswapbridgesa.blob.core.windows.net/layerswap/networks/arbitrum_mainnet.png",
+        "chain_id": "42161",
+        "node_url": "https://arbitrum-one.public.blastapi.io",
+        "type": NetworkType.EVM,
+        "transaction_explorer_template": "https://arbiscan.io/tx/{0}",
+        "account_explorer_template": "https://arbiscan.io/address/{0}",
+        "token": {
+            "symbol": "ETH",
+            "listing_date": "2023-12-27T16:46:50.617075+00:00",
+            "logo": "https://devlslayerswapbridgesa.blob.core.windows.net/layerswap/currencies/eth.png",
+            "contract": null,
+            "decimals": 18,
+            "price_in_usd": 0,
+            "precision": 6,
+            "display_asset": ""
+        },
+        "metadata": {
+            "listing_date": "2023-12-27T16:46:50.617075+00:00"
+        },
+        "deposit_methods": [
+            "deposit_address",
+            "wallet"
+        ]
+    },
+    "fromAsset": {
+        "symbol": "ETH",
+        "listing_date": "2023-12-27T16:46:50.617075+00:00",
+        "logo": "https://devlslayerswapbridgesa.blob.core.windows.net/layerswap/currencies/eth.png",
+        "contract": null,
+        "decimals": 18,
+        "price_in_usd": 3234.87,
+        "precision": 6,
+        "display_asset": ""
+    },
+    fromExchange: undefined,
+    to: {
+        "tokens": [
+            {
+                "status": "active",
+                "symbol": "USDC",
+                "listing_date": "2023-12-27T16:46:50.617075+00:00",
+                "logo": "https://devlslayerswapbridgesa.blob.core.windows.net/layerswap/currencies/usdc.png",
+                "contract": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+                "decimals": 6,
+                "price_in_usd": 0.999873,
+                "precision": 6,
+                display_asset: ""
+            },
+            {
+                "status": "active",
+                "symbol": "ETH",
+                "listing_date": "2023-12-27T16:46:50.617075+00:00",
+                "logo": "https://devlslayerswapbridgesa.blob.core.windows.net/layerswap/currencies/eth.png",
+                "contract": null,
+                "decimals": 18,
+                "price_in_usd": 3234.87,
+                "precision": 6,
+                display_asset: ""
+            }
+        ],
+        "name": "ETHEREUM_MAINNET",
+        "display_name": "Ethereum",
+        "logo": "https://devlslayerswapbridgesa.blob.core.windows.net/layerswap/networks/ethereum_mainnet.png",
+        "chain_id": "1",
+        "node_url": 'null',
+        "type": NetworkType.EVM,
+        "transaction_explorer_template": "https://etherscan.io/tx/{0}",
+        "account_explorer_template": "https://etherscan.io/address/{0}",
+        "token": {
+            "symbol": "ETH",
+            "listing_date": "2023-12-27T16:46:50.617075+00:00",
+            "logo": "https://devlslayerswapbridgesa.blob.core.windows.net/layerswap/currencies/eth.png",
+            "contract": null,
+            "decimals": 18,
+            "price_in_usd": 3234.87,
+            "precision": 6,
+            "display_asset": ""
+        },
+        "metadata": {
+            "listing_date": "2023-12-27T16:46:50.617075+00:00"
+        },
+        "deposit_methods": [
+            "deposit_address",
+            "wallet"
+        ]
+    },
+    "toAsset": {
+        "status": "active",
+        "symbol": "ETH",
+        "listing_date": "2023-12-27T16:46:50.617075+00:00",
+        "logo": "https://devlslayerswapbridgesa.blob.core.windows.net/layerswap/currencies/eth.png",
+        "contract": null,
+        "decimals": 18,
+        "price_in_usd": 3234.87,
+        "precision": 6,
+        "display_asset": ""
+    },
+    "toExchange": undefined,
+};

package/dist/stories/Data/settings.d.ts

@@ -0,0 +1,3 @@
+import { LayerSwapSettings } from "../../Models/LayerSwapSettings";
+export declare const Settings: LayerSwapSettings;
+export declare const SettingChains: any;