@layerswap/widget 0.1.20 → 1.0.0-alpha1.1

package/dist/lib/axiosInterceptor.js

@@ -1,126 +0,0 @@
-import axios from "axios";
-import { parseJwt } from "./jwtParser";
-import TokenService from "./TokenService";
-import { AuthRefreshFailedError } from './Errors/AuthRefreshFailedError';
-import LayerSwapApiClient from "./layerSwapApiClient";
-const refreshTokenState = {
-    AccessTokenExpires: 0,
-    RefreshTokenExpires: 0,
-    RefreshingToken: false,
-};
-export const InitializeAuthInstance = (baseURL) => {
-    const instance = axios.create({
-        baseURL: baseURL || "",
-        headers: {
-            "Content-Type": "application/json",
-        },
-    });
-    async function RefreshAccessToken(refresh_token) {
-        try {
-            refreshTokenState.RefreshingToken = true;
-            const params = new URLSearchParams();
-            params.append('client_id', 'layerswap_bridge_ui');
-            params.append('grant_type', 'refresh_token');
-            params.append('refresh_token', refresh_token);
-            const rs = await instance.post("/connect/token", params, { headers: { 'Accept': "application/json, text/plain, */*", 'Content-Type': "application/x-www-form-urlencoded;charset=UTF-8", 'Access-Control-Allow-Origin': '*' } });
-            const res = rs.data;
-            const { exp } = parseJwt(res.access_token) || {};
-            refreshTokenState.AccessTokenExpires = exp;
-            TokenService.setAuthData(res);
-            return true;
-        }
-        catch (e) {
-            TokenService.removeAuthData();
-            const apiError = new Error(`Could not refresh token`);
-            apiError.name = `Identity API Error`;
-            apiError.cause = e;
-            // datadogRum.addError(apiError);
-            return false;
-        }
-        finally {
-            refreshTokenState.RefreshingToken = false;
-        }
-    }
-    instance.interceptors.request.use(async (config) => {
-        const authData = TokenService.getAuthData();
-        let access_token = authData?.access_token;
-        let refresh_token = authData?.refresh_token;
-        if (!refreshTokenState.AccessTokenExpires && access_token && refresh_token) {
-            const { exp } = parseJwt(access_token) || {};
-            if (exp)
-                refreshTokenState.AccessTokenExpires = exp;
-        }
-        if (refresh_token && !refreshTokenState.RefreshingToken && refreshTokenState.AccessTokenExpires < Math.floor(Date.now() * 0.001)) {
-            let couldRefresh = await RefreshAccessToken(refresh_token);
-            if (!couldRefresh) {
-                return Promise.reject(new AuthRefreshFailedError());
-            }
-        }
-        let token = TokenService.getAuthData()?.access_token;
-        const apiKey = LayerSwapApiClient.apiKey;
-        if (apiKey) {
-            config.headers["X-LS-APIKEY"] = apiKey;
-        }
-        else {
-            throw new Error("API key is not set up");
-        }
-        if (token) {
-            config.headers["Authorization"] = 'Bearer ' + token;
-        }
-        return config;
-    }, (error) => {
-        return Promise.reject(error);
-    });
-    instance.interceptors.response.use((res) => {
-        return res;
-    }, async (err) => {
-        const originalConfig = err.config;
-        if (err?.response?.status === 401 || err?.response?.status === 403) {
-            if (!originalConfig._retry && !refreshTokenState.RefreshingToken) {
-                originalConfig._retry = true;
-                const config = { ...originalConfig };
-                let goToAuth = false;
-                try {
-                    const refresh_token = TokenService.getAuthData()?.refresh_token;
-                    if (refresh_token) {
-                        const couldRefreshToken = await RefreshAccessToken(refresh_token);
-                        if (couldRefreshToken) {
-                            return instance(config);
-                        }
-                    }
-                    goToAuth = true;
-                }
-                catch (_error) {
-                    goToAuth = true;
-                }
-                if (goToAuth) {
-                    return Promise.reject(new AuthRefreshFailedError());
-                }
-            }
-        }
-        return Promise.reject(err);
-    });
-    return instance;
-};
-export const InitializeUnauthInstance = (baseURL) => {
-    const instance = axios.create({
-        baseURL: baseURL || "",
-        headers: {
-            "Content-Type": "application/json",
-        },
-    });
-    instance.interceptors.request.use(async (config) => {
-        const apiKey = LayerSwapApiClient.apiKey;
-        if (apiKey) {
-            config.headers["X-LS-APIKEY"] = apiKey;
-        }
-        else {
-            throw new Error("API key is not set up");
-        }
-        return config;
-    }, (error) => {
-        return Promise.reject(error);
-    });
-    return instance;
-};
-export default InitializeAuthInstance;

package/dist/lib/balances/balanceResolver.d.ts

@@ -1,12 +0,0 @@
-import { NetworkWithTokens } from "../../Models/Network";
-export declare class BalanceResolver {
-    private providers;
-    getBalance(address: string, network: NetworkWithTokens): Promise<import("../../Models/Balance").Balance[] | undefined> | Promise<{
-        network: string;
-        amount: number;
-        decimals: number;
-        isNativeCurrency: boolean;
-        token: string;
-        request_time: string;
-    }[] | null>;
-}

package/dist/lib/balances/balanceResolver.js

@@ -1,36 +0,0 @@
-import { EVMBalanceProvider } from "./providers/evmBalanceProvider";
-// import { FuelBalanceProvider } from "./providers/fuelBalanceProvider";
-// import { ImmutableXBalanceProvider } from "./providers/immutableXBalanceProvider";
-// import { LoopringBalanceProvider } from "./providers/loopringBalanceProvider";
-// import { ParadexBalanceProvider } from "./providers/paradexBalanceProvider";
-import { QueryBalanceProvider } from "./providers/queryBalanceProvider";
-// import { SolanaBalanceProvider } from "./providers/solanaBalanceProvider";
-// import { StarknetBalanceProvider } from "./providers/starknetBalanceProvider";
-// import { TonBalanceProvider } from "./providers/tonBalanceProvider";
-// import { TronBalanceProvider } from "./providers/tronBalanceResolver";
-import { ZkSyncBalanceProvider } from "./providers/zkSyncBalanceProvider";
-export class BalanceResolver {
-    constructor() {
-        this.providers = [
-            new QueryBalanceProvider(),
-            // new StarknetBalanceProvider(),
-            new EVMBalanceProvider(),
-            // new FuelBalanceProvider(),
-            // new ImmutableXBalanceProvider(),
-            // new LoopringBalanceProvider(),
-            // new SolanaBalanceProvider(),
-            // new TonBalanceProvider(),
-            new ZkSyncBalanceProvider(),
-            // new TronBalanceProvider(),
-            // new ParadexBalanceProvider()
-        ];
-    }
-    getBalance(address, network) {
-        const provider = this.providers.find(p => p.supportsNetwork(network));
-        //TODO: create interface for balance providers in case of empty state they shoudl throw error 
-        //never return undefined as SWR does not set loading state if undefined is returned
-        if (!provider)
-            throw new Error(`No balance provider found for network ${network.name}`);
-        return provider.fetchBalance(address, network);
-    }
-}

package/dist/lib/balances/providers/evmBalanceProvider.d.ts

@@ -1,37 +0,0 @@
-import { PublicClient } from "viem";
-import { Balance } from "../../../Models/Balance";
-import { Network, NetworkWithTokens, Token } from "../../../Models/Network";
-import { GetBalanceReturnType } from '@wagmi/core';
-export declare class EVMBalanceProvider {
-    supportsNetwork(network: NetworkWithTokens): boolean;
-    fetchBalance: (address: string, network: NetworkWithTokens) => Promise<Balance[] | undefined>;
-}
-export type ERC20ContractRes = ({
-    error: Error;
-    result?: undefined | null;
-    status: "failure";
-} | {
-    error?: undefined | null;
-    result: unknown;
-    status: "success";
-});
-export declare const resolveERC20Balances: (multicallRes: ERC20ContractRes[], from: NetworkWithTokens) => Promise<{
-    network: string;
-    token: string;
-    amount: number;
-    request_time: string;
-    decimals: number;
-    isNativeCurrency: boolean;
-}[] | null>;
-type GetBalanceArgs = {
-    address: string;
-    network: Network;
-    assets: Token[];
-    publicClient: PublicClient;
-    hasMulticall: boolean;
-};
-export declare const getErc20Balances: ({ address, network, assets, publicClient, hasMulticall }: GetBalanceArgs) => Promise<ERC20ContractRes[] | null>;
-export declare const getTokenBalance: (address: `0x${string}`, network: Network, contract?: `0x${string}` | null) => Promise<GetBalanceReturnType | null>;
-export declare const resolveBalance: (network: Network, token: Token, balanceData: GetBalanceReturnType) => Promise<Balance>;
-export declare const resolveERC20Balance: (network: Network, token: Token, balanceData: GetBalanceReturnType) => Promise<Balance>;
-export {};

package/dist/lib/balances/providers/evmBalanceProvider.js

@@ -1,177 +0,0 @@
-import { NetworkType } from "../../../Models/Network";
-import formatAmount from "../../formatAmount";
-import { http, createConfig } from '@wagmi/core';
-import { erc20Abi } from 'viem';
-import { multicall } from '@wagmi/core';
-import { getBalance } from '@wagmi/core';
-import resolveChain from "../../resolveChain";
-// import { datadogRum } from "@datadog/browser-rum"
-export class EVMBalanceProvider {
-    constructor() {
-        this.fetchBalance = async (address, network) => {
-            if (!network)
-                return;
-            try {
-                const chain = resolveChain(network);
-                if (!chain)
-                    return;
-                const { createPublicClient, http } = await import("viem");
-                const publicClient = createPublicClient({
-                    chain,
-                    transport: http()
-                });
-                let erc20Balances = [];
-                try {
-                    const erc20BalancesContractRes = await getErc20Balances({
-                        address,
-                        assets: network.tokens,
-                        network,
-                        publicClient,
-                        hasMulticall: !!network.metadata?.evm_multicall_contract
-                    });
-                    const balances = (erc20BalancesContractRes && await resolveERC20Balances(erc20BalancesContractRes, network)) || [];
-                    erc20Balances = balances;
-                }
-                catch (e) {
-                    console.log(e);
-                }
-                const nativeToken = network.token;
-                const nativeBalanceData = await getTokenBalance(address, network);
-                const nativeBalance = (nativeToken && nativeBalanceData) && await resolveBalance(network, nativeToken, nativeBalanceData);
-                let res = [];
-                return res.concat(erc20Balances, nativeBalance ? [nativeBalance] : []);
-            }
-            catch (e) {
-                console.log(e);
-            }
-        };
-    }
-    supportsNetwork(network) {
-        return network.type === NetworkType.EVM && !!network.token;
-    }
-}
-export const resolveERC20Balances = async (multicallRes, from) => {
-    const assets = from?.tokens?.filter(a => a.contract);
-    if (!assets)
-        return null;
-    const contractBalances = multicallRes?.map((d, index) => {
-        const currency = assets[index];
-        return {
-            network: from.name,
-            token: currency.symbol,
-            amount: formatAmount(d.result, currency.decimals),
-            request_time: new Date().toJSON(),
-            decimals: currency.decimals,
-            isNativeCurrency: false,
-        };
-    });
-    return contractBalances;
-};
-export const getErc20Balances = async ({ address, network, assets, publicClient, hasMulticall = false }) => {
-    const contracts = assets?.filter(a => a.contract).map(a => ({
-        address: a?.contract,
-        abi: erc20Abi,
-        functionName: 'balanceOf',
-        args: [address],
-    }));
-    try {
-        if (hasMulticall) {
-            const chain = resolveChain(network);
-            if (!chain)
-                throw new Error("Could not resolve chain");
-            const config = createConfig({
-                chains: [chain],
-                transports: {
-                    [chain.id]: http()
-                }
-            });
-            const contractRes = await multicall(config, {
-                chainId: chain.id,
-                contracts: contracts
-            });
-            return contractRes;
-        }
-        else {
-            const balances = [];
-            for (let i = 0; i < contracts.length; i++) {
-                try {
-                    const contract = contracts[i];
-                    const balance = await publicClient.readContract({
-                        address: contract?.address,
-                        abi: erc20Abi,
-                        functionName: 'balanceOf',
-                        args: [address]
-                    });
-                    balances.push({
-                        status: "success",
-                        result: balance,
-                        error: undefined
-                    });
-                }
-                catch (e) {
-                    balances.push({
-                        status: "failure",
-                        result: null,
-                        error: e?.message
-                    });
-                }
-            }
-            return balances;
-        }
-    }
-    catch (e) {
-        const error = new Error(e);
-        error.name = "ERC20BalanceError";
-        error.cause = e;
-        // datadogRum.addError(error);
-        return null;
-    }
-};
-export const getTokenBalance = async (address, network, contract) => {
-    try {
-        const chain = resolveChain(network);
-        if (!chain)
-            throw new Error("Could not resolve chain");
-        const config = createConfig({
-            chains: [chain],
-            transports: {
-                [chain.id]: http()
-            }
-        });
-        const res = await getBalance(config, {
-            address,
-            chainId: chain.id,
-            ...(contract ? { token: contract } : {})
-        });
-        return res;
-    }
-    catch (e) {
-        const error = new Error(e);
-        error.name = "TokenBalanceError";
-        error.cause = e;
-        // datadogRum.addError(error);
-        return null;
-    }
-};
-export const resolveBalance = async (network, token, balanceData) => {
-    const nativeBalance = {
-        network: network.name,
-        token: token.symbol,
-        amount: formatAmount(balanceData?.value, token.decimals),
-        request_time: new Date().toJSON(),
-        decimals: token.decimals,
-        isNativeCurrency: true,
-    };
-    return nativeBalance;
-};
-export const resolveERC20Balance = async (network, token, balanceData) => {
-    const nativeBalance = {
-        network: network.name,
-        token: token.symbol,
-        amount: formatAmount(balanceData?.value, token.decimals),
-        request_time: new Date().toJSON(),
-        decimals: token.decimals,
-        isNativeCurrency: false,
-    };
-    return nativeBalance;
-};

package/dist/lib/balances/providers/fuelBalanceProvider.d.ts

@@ -1,6 +0,0 @@
-import { Balance } from "../../../Models/Balance";
-import { NetworkWithTokens } from "../../../Models/Network";
-export declare class FuelBalanceProvider {
-    supportsNetwork(network: NetworkWithTokens): boolean;
-    fetchBalance: (address: string, network: NetworkWithTokens) => Promise<Balance[] | undefined>;
-}

package/dist/lib/balances/providers/fuelBalanceProvider.js

@@ -1,62 +0,0 @@
-import formatAmount from "../../formatAmount";
-import KnownInternalNames from "../../knownIds";
-import retryWithExponentialBackoff from "../../retry";
-export class FuelBalanceProvider {
-    constructor() {
-        this.fetchBalance = async (address, network) => {
-            let balances = [];
-            if (!network?.tokens)
-                return;
-            const BALANCES_QUERY = `query Balances($filter: BalanceFilterInput) {
-            balances(filter: $filter, first: 5) {
-              nodes {
-                amount
-                assetId
-              }
-            }
-          }`;
-            const BALANCES_ARGS = {
-                filter: {
-                    owner: address,
-                },
-            };
-            try {
-                const response = await retryWithExponentialBackoff(async () => await fetch(network.node_url, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        Accept: 'application/json',
-                    },
-                    body: JSON.stringify({
-                        query: BALANCES_QUERY,
-                        variables: BALANCES_ARGS,
-                    }),
-                }));
-                const json = await response.json();
-                for (let i = 0; i < network.tokens.length; i++) {
-                    const token = network.tokens[i];
-                    const balance = json.data.balances.nodes.find(b => b?.assetId === token.contract) || null;
-                    const balanceObj = {
-                        network: network.name,
-                        amount: formatAmount(Number(balance?.amount || 0), token.decimals),
-                        decimals: token.decimals,
-                        isNativeCurrency: network.token?.symbol === token.symbol,
-                        token: token.symbol,
-                        request_time: new Date().toJSON()
-                    };
-                    balances = [
-                        ...balances,
-                        balanceObj,
-                    ];
-                }
-            }
-            catch (e) {
-                console.log(e);
-            }
-            return balances;
-        };
-    }
-    supportsNetwork(network) {
-        return KnownInternalNames.Networks.FuelMainnet.includes(network.name) || KnownInternalNames.Networks.FuelTestnet.includes(network.name);
-    }
-}

package/dist/lib/balances/providers/helpers.d.ts

@@ -1,2 +0,0 @@
-import { Token } from "../../../Models/Network";
-export declare const insertIfNotExists: (arr: Token[], item: Token | undefined) => Token[];

package/dist/lib/balances/providers/immutableXBalanceProvider.d.ts

@@ -1,12 +0,0 @@
-import { NetworkWithTokens } from "../../../Models/Network";
-export declare class ImmutableXBalanceProvider {
-    supportsNetwork(network: NetworkWithTokens): boolean;
-    fetchBalance: (address: string, network: NetworkWithTokens) => Promise<{
-        network: string;
-        amount: number;
-        decimals: number;
-        isNativeCurrency: boolean;
-        token: string;
-        request_time: string;
-    }[] | undefined>;
-}

package/dist/lib/balances/providers/immutableXBalanceProvider.js

@@ -1,29 +0,0 @@
-import formatAmount from "../../formatAmount";
-import KnownInternalNames from "../../knownIds";
-import { insertIfNotExists } from "./helpers";
-export class ImmutableXBalanceProvider {
-    constructor() {
-        this.fetchBalance = async (address, network) => {
-            const axios = (await import("axios")).default;
-            if (!network?.tokens && !network.token)
-                return;
-            const res = await axios.get(`${network?.node_url}/v2/balances/${address}`).then(r => r.data);
-            const tokens = insertIfNotExists(network.tokens || [], network.token);
-            const balances = tokens?.map(asset => {
-                const balance = res.result.find(r => r.symbol === asset.symbol);
-                return {
-                    network: network.name,
-                    amount: formatAmount(balance?.balance, asset.decimals),
-                    decimals: asset.decimals,
-                    isNativeCurrency: false,
-                    token: asset.symbol,
-                    request_time: new Date().toJSON(),
-                };
-            });
-            return balances;
-        };
-    }
-    supportsNetwork(network) {
-        return (KnownInternalNames.Networks.ImmutableXMainnet.includes(network.name) || KnownInternalNames.Networks.ImmutableXGoerli.includes(network.name));
-    }
-}

package/dist/lib/balances/providers/loopringBalanceProvider.js

@@ -1,56 +0,0 @@
-// import axios from "axios";
-// import { NetworkWithTokens } from "../../../Models/Network";
-// import formatAmount from "../../formatAmount";
-// import KnownInternalNames from "../../knownIds";
-// import { LOOPRING_URLs } from "../../loopring/defs";
-// import { LoopringAPI } from "../../loopring/LoopringAPI";
-// import { Balance } from "../../../Models/Balance";
-// import { insertIfNotExists } from "./helpers";
-// export class LoopringBalanceProvider {
-//     supportsNetwork(network: NetworkWithTokens): boolean {
-//         return (KnownInternalNames.Networks.LoopringMainnet.includes(network.name) || KnownInternalNames.Networks.LoopringGoerli.includes(network.name))
-//     }
-//     fetchBalance = async (address: string, network: NetworkWithTokens) => {
-//         let balances: Balance[] = [];
-//         if (!network?.tokens) return
-//         try {
-//             const account: { data: AccountInfo } = await axios.get(`${LoopringAPI.BaseApi}${LOOPRING_URLs.ACCOUNT_ACTION}?owner=${address}`)
-//             const accInfo = account.data
-//             const tokens = insertIfNotExists(network.tokens || [], network.token)
-//             const tokensString = tokens?.map(obj => obj.contract).join(',');
-//             const result: { data: LpBalance[] } = await axios.get(`${LoopringAPI.BaseApi}${LOOPRING_URLs.GET_USER_EXCHANGE_BALANCES}?accountId=${accInfo.accountId}&tokens=${tokensString}`)
-//             const loopringBalances = tokens?.map(asset => {
-//                 const amount = result.data.find(d => d.tokenId == Number(asset.contract))?.total;
-//                 return ({
-//                     network: network.name,
-//                     token: asset?.symbol,
-//                     amount: amount ? formatAmount(amount, Number(asset?.decimals)) : 0,
-//                     request_time: new Date().toJSON(),
-//                     decimals: Number(asset?.decimals),
-//                     isNativeCurrency: false
-//                 })
-//             });
-//             balances = [
-//                 ...loopringBalances,
-//             ]
-//         }
-//         catch (e) {
-//             console.log(e)
-//         }
-//         return balances
-//     }
-// }
-// interface AccountInfo {
-//     accountId: number;
-// }
-// type PendingBalances = {
-//     withdraw: string;
-//     deposit: string;
-// }
-// type LpBalance = {
-//     accountId: number;
-//     tokenId: number;
-//     total: string;
-//     locked: string;
-//     pending: PendingBalances;
-// }

package/dist/lib/balances/providers/paradexBalanceProvider.js

@@ -1,42 +0,0 @@
-// import { Balance } from "../../../Models/Balance";
-// import { NetworkWithTokens } from "../../../Models/Network";
-// import AppSettings from "../../AppSettings";
-// import KnownInternalNames from "../../knownIds";
-// import * as Paradex from "../../wallets/paradex/lib";
-// import { insertIfNotExists } from "./helpers";
-// export class ParadexBalanceProvider {
-//     supportsNetwork(network: NetworkWithTokens): boolean {
-//         return KnownInternalNames.Networks.ParadexMainnet.includes(network.name) || KnownInternalNames.Networks.ParadexTestnet.includes(network.name)
-//     }
-//     fetchBalance = async (address: string, network: NetworkWithTokens) => {
-//         try {
-//             const environment = AppSettings.ApiVersion === 'sandbox' ? 'testnet' : 'prod'
-//             const config = await Paradex.Config.fetchConfig(environment);
-//             const tokens = insertIfNotExists(network.tokens || [], network.token)
-//             const paraclearProvider = new Paradex.ParaclearProvider.DefaultProvider(config);
-//             const result: Balance[] = []
-//             for (const token of tokens) {
-//                 const getBalanceResult = await Paradex.Paraclear.getTokenBalance({
-//                     provider: paraclearProvider, //account can be passed as the provider
-//                     config,
-//                     account: { address },
-//                     token: token.symbol,
-//                 });
-//                 const balance = {
-//                     network: network.name,
-//                     token: token.symbol,
-//                     amount: Number(getBalanceResult.size),
-//                     request_time: new Date().toJSON(),
-//                     decimals: Number(token?.decimals),
-//                     isNativeCurrency: false
-//                 }
-//                 result.push(balance)
-//             }
-//             return result
-//         }
-//         catch (e) {
-//             console.log(e)
-//             throw e
-//         }
-//     }
-// }

package/dist/lib/balances/providers/queryBalanceProvider.d.ts

@@ -1,15 +0,0 @@
-import { NetworkWithTokens } from "../../../Models/Network";
-export declare class QueryBalanceProvider {
-    private query;
-    constructor();
-    private getQueryParams;
-    supportsNetwork(network: NetworkWithTokens): boolean;
-    fetchBalance: (address: string, network: NetworkWithTokens) => Promise<{
-        network: string;
-        amount: number;
-        decimals: number;
-        isNativeCurrency: boolean;
-        token: string;
-        request_time: string;
-    }[] | null>;
-}