@layerswap/widget 0.1.20 → 1.0.0-alpha1.1

package/dist/esm/lib/knownIds.js

@@ -0,0 +1,164 @@
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+var _a, _b, _c, _d;
+class KnownInternalNames {
+}
+KnownInternalNames.Exchanges = (_a = class {
+    },
+    __setFunctionName(_a, "Exchanges"),
+    _a.Coinbase = "COINBASE",
+    _a.Coinspot = "COINSPOT",
+    _a.Gateio = "GATEIO",
+    _a.Binance = "BINANCE",
+    _a.Kucoin = "KUCOIN",
+    _a.Huobi = "HUOBI",
+    _a.FtxUs = "FTXUS",
+    _a.FtxCom = "FTXCOM",
+    _a.Okex = "OKEX",
+    _a.Bitfinex = "BITFINEX",
+    _a.Kraken = "KRAKEN",
+    _a.Bittrex = "BITTREX",
+    _a.CryptoCom = "CRYPTOCOM",
+    _a.CryptoComApp = "CRYPTOCOMAPP",
+    _a.BinanceUS = "BINANCEUS",
+    _a.Blocktane = "BLOCKTANE",
+    _a.MexcGlobal = "MEXC",
+    _a);
+KnownInternalNames.Networks = (_b = class {
+    },
+    __setFunctionName(_b, "Networks"),
+    _b.CronosMainnet = "CRONOS_MAINNET",
+    _b.OsmosisMainnet = "OSMOSIS_MAINNET",
+    _b.ArbitrumMainnet = "ARBITRUM_MAINNET",
+    _b.ArbitrumNova = "ARBITRUMNOVA_MAINNET",
+    _b.ArbitrumRinkeby = "ARBITRUM_RINKEBY",
+    _b.ArbitrumGoerli = "ARBITRUM_GOERLI",
+    _b.ArbitrumSepolia = "ARBITRUM_SEPOLIA",
+    _b.ModMainnet = "MODE_MAINNET",
+    _b.OptimismMainnet = "OPTIMISM_MAINNET",
+    _b.OptimismGoerli = "OPTIMISM_GOERLI",
+    _b.OptimismKovan = "OPTIMISM_KOVAN",
+    _b.RoninMainnet = "RONIN_MAINNET",
+    _b.BobaMainnet = "BOBA_MAINNET",
+    _b.BobaRinkeby = "BOBA_RINKEBY",
+    _b.ZksyncMainnet = "ZKSYNC_MAINNET",
+    _b.ZksyncEraMainnet = "ZKSYNCERA_MAINNET",
+    _b.ZkspaceMainnet = "ZKSPACE_MAINNET",
+    _b.ZksyncRinkeby = "ZKSYNC_RINKEBY",
+    _b.EthereumRinkeby = "ETHEREUM_RINKEBY",
+    _b.EthereumMainnet = "ETHEREUM_MAINNET",
+    _b.EthereumGoerli = "ETHEREUM_GOERLI",
+    _b.EthereumSepolia = "ETHEREUM_SEPOLIA",
+    _b.PolygonMainnet = "POLYGON_MAINNET",
+    _b.LoopringMainnet = "LOOPRING_MAINNET",
+    _b.LoopringGoerli = "LOOPRING_GOERLI",
+    _b.LoopringSepolia = "LOOPRING_SEPOLIA",
+    _b.MoonbeamMainnet = "MOONBEAM_MAINNET",
+    _b.StarkNetGoerli = "STARKNET_GOERLI",
+    _b.StarkNetMainnet = "STARKNET_MAINNET",
+    _b.StarkNetSepolia = "STARKNET_SEPOLIA",
+    _b.ImmutableXMainnet = "IMMUTABLEX_MAINNET",
+    _b.ImmutableXGoerli = "IMMUTABLEX_GOERLI",
+    _b.ImmutableXSepolia = "IMMUTABLEX_SEPOLIA",
+    _b.ImmutableZkEVM = "IMMUTABLEZK_MAINNET",
+    _b.AstarMainnet = "ASTAR_MAINNET",
+    _b.NahmiiMainnet = "NAHMII_MAINNET",
+    _b.RhinoFiMainnet = "RHINOFI_MAINNET",
+    _b.DydxMainnet = "DYDX_MAINNET",
+    _b.DydxGoerli = "DYDX_GOERLI",
+    _b.BNBChainMainnet = "BSC_MAINNET",
+    _b.SolanaMainnet = "SOLANA_MAINNET",
+    _b.SolanaTestnet = "SOLANA_TESTNET",
+    _b.SolanaDevnet = "SOLANA_DEVNET",
+    _b.SoonMainnet = "SOON_MAINNET",
+    _b.SoonTestnet = "SOON_TESTNET",
+    _b.SorareStage = "SORARE_MAINNET",
+    _b.KCCMainnet = "KCC_MAINNET",
+    _b.OKCMainnet = "OKC_MAINNET",
+    _b.PolygonZkMainnet = "POLYGONZK_MAINNET",
+    _b.LineaMainnet = "LINEA_MAINNET",
+    _b.BaseMainnet = "BASE_MAINNET",
+    _b.BaseTestnet = "BASE_TESTNET",
+    _b.AvalancheMainnet = "AVAX_MAINNET",
+    _b.PGNMainnet = "PGN_MAINNET",
+    _b.PGNTestnet = "PGN_TESTNET",
+    _b.MantleMainnet = "MANTLE_MAINNET",
+    _b.ZoraMainnet = "ZORA_MAINNET",
+    _b.RolluxMainnet = "ROLLUX_MAINNET",
+    _b.OpBNBMainnet = "OPBNB_MAINNET",
+    _b.MantaMainnet = "MANTA_MAINNET",
+    _b.ScrollMainnet = "SCROLL_MAINNET",
+    _b.TONMainnet = "TON_MAINNET",
+    _b.TONTestnet = "TON_TESTNET",
+    _b.BrineMainnet = "BRINE_MAINNET",
+    _b.BlastSepolia = "BLAST_SEPOLIA",
+    _b.BlastMainnet = "BLAST_MAINNET",
+    _b.ParadexTestnet = "PARADEX_TESTNET",
+    _b.ParadexMainnet = "PARADEX_MAINNET",
+    _b.FuelMainnet = "FUEL_MAINNET",
+    _b.FuelTestnet = "FUEL_TESTNET",
+    _b.FuelDevnet = "FUEL_DEVNET",
+    _b.TronMainnet = "TRON_MAINNET",
+    _b.TronTestnet = "TRON_TESTNET",
+    _b.EclipseTestnet = "ECLIPSE_TESTNET",
+    _b.EclipseMainnet = "ECLIPSE_MAINNET",
+    _b.SophonMainnet = "SOPHON_MAINNET",
+    _b.SophonSepolia = "SOPHON_SEPOLIA",
+    _b.RedStoneMainnet = "REDSTONE_MAINNET",
+    _b.SoneiumMainnet = "SONEIUM_MAINNET",
+    _b.RariMainnet = "RARI_MAINNET",
+    _b.LightlinkMainnet = "LIGHTLINK_MAINNET",
+    _b.ZetachainMainnet = "ZETACHAIN_MAINNET",
+    _b.AvaxMainnet = "AVAX_TESTNET",
+    _b.XaiMainnet = "XAI_MAINNET",
+    _b.UnichainMainnet = "UNICHAIN_MAINNET",
+    _b.XlayerMainnet = "XLAYER_MAINNET",
+    _b.FraxtalMainnet = "FRAXTAL_MAINNET",
+    _b.WorldchainMainnet = "WORLDCHAIN_MAINNET",
+    _b.AbstractMainnet = "ABSTRACT_MAINNET",
+    _b.CeloMainnet = "CELO_MAINNET",
+    _b.KromaMainnet = "KROMA_MAINNET",
+    _b.ShapeMainnet = "SHAPE_MAINNET",
+    _b.GnosisMainnet = "GNOSIS_MAINNET",
+    _b.TaikoMainnet = "TAIKO_MAINNET",
+    _b.InkMainnet = "INK_MAINNET",
+    _b.MintMainnet = "MINT_MAINNET",
+    _b.Ancient8Mainnet = "ANCIENT8_MAINNET",
+    _b.BobMainnet = "BOB_MAINNET",
+    _b.FuseMainnet = "FUSE_MAINNET",
+    _b.SonicMainnet = "SONIC_MAINNET",
+    _b.ZeroMainnet = "ZERO_MAINNET",
+    _b.ZircuitMainnet = "ZIRCUIT_MAINNET",
+    _b.SuperseedMainnet = "SUPERSEED_MAINNET",
+    _b.LiskMainnet = "LISK_MAINNET",
+    _b.MorphMainnet = "MORPH_MAINNET",
+    _b.SeiMainnet = "SEI_MAINNET",
+    _b.GravityMainnet = "GRAVITY_MAINNET",
+    _b.BitcoinMainnet = "BITCOIN_MAINNET",
+    _b.BitcoinTestnet = "BITCOIN_TESTNET",
+    _b.HyperliquidMainnet = "HYPERLIQUID_MAINNET",
+    _b.HyperliquidTestnet = "HYPERLIQUID_TESTNET",
+    _b);
+KnownInternalNames.Currencies = (_c = class {
+    },
+    __setFunctionName(_c, "Currencies"),
+    _c.USDT = "USDT",
+    _c.ETH = "ETH",
+    _c.USDC = "USDC",
+    _c.USDCe = "USDC.e",
+    _c.USDCE = "USDC.E",
+    _c.LRC = "LRC",
+    _c.IMX = "IMX",
+    _c.SNX = "SNX",
+    _c.ZKS = "ZKS",
+    _c);
+KnownInternalNames.LiquidityProviders = (_d = class {
+    },
+    __setFunctionName(_d, "LiquidityProviders"),
+    _d.ConnextId = "39BF4D10-0AF8-4F54-A8B1-4C69A81ACA14".toLowerCase(),
+    _d.LayerSwapId = "168D5457-05ED-46E3-AAB3-72A2D2098F0F".toLowerCase(),
+    _d.StarkNetId = "fa3f93eb-9fea-44f3-a8a6-a5ced0f6d646".toLowerCase(),
+    _d);
+export default KnownInternalNames;

package/dist/esm/lib/logError.js

@@ -0,0 +1,17 @@
+import posthog from "posthog-js";
+import AppSettings from "./AppSettings";
+const logError = (message) => {
+    const error = new Error(message + ` env: ${AppSettings.ApiVersion ?? 'prod'}`);
+    error.name = 'AlertUI';
+    error.cause = error;
+    posthog.capture('$exception', {
+        name: error.name,
+        message: error.message,
+        $layerswap_exception_type: "Alert UI",
+        stack: error.stack,
+        cause: error.cause,
+        where: 'alertUI',
+        severity: 'error',
+    });
+};
+export default logError;

package/dist/esm/lib/nft/nftBalanceResolver.js

@@ -0,0 +1,12 @@
+export class NftBalanceResolver {
+    constructor(providers) {
+        this.providers = providers || [];
+    }
+    async getBalance({ address, network, contractAddress }) {
+        const provider = this.providers.find(p => p.supportsNetwork(network));
+        if (!provider) {
+            throw new Error(`No provider found for network ${network.name}`);
+        }
+        return provider.getBalance({ address, network, contractAddress });
+    }
+}

package/dist/esm/lib/nft/useSWRNftBalance.js

@@ -0,0 +1,15 @@
+import useSWR from "swr";
+import { resolverService } from "../resolvers/resolverService";
+const useSWRNftBalance = (address, network, contractAddress) => {
+    const { data: balance, error, isLoading } = useSWR((network && address && contractAddress) ? `/nft-balance/${address}/${network.name}/${contractAddress}` : null, () => {
+        if (!network || !contractAddress || !address)
+            return 0;
+        return resolverService.getNftResolver().getBalance({ address, network, contractAddress });
+    }, { refreshInterval: 60000 });
+    return {
+        balance: typeof balance === 'number' ? balance : 0,
+        isLoading,
+        error
+    };
+};
+export default useSWRNftBalance;

package/dist/esm/lib/resolvers/resolverService.js

@@ -0,0 +1,43 @@
+import { BalanceResolver } from "../../lib/balances/balanceResolver";
+import { GasResolver } from "../../lib/gases/gasResolver";
+import { AddressUtilsResolver } from '../../lib/address/addressUtilsResolver';
+import { NftBalanceResolver } from "../nft/nftBalanceResolver";
+class UtilsResolverService {
+    constructor() {
+        this.balanceResolver = null;
+        this.gasResolver = null;
+        this.addressUtilsResolver = null;
+        this.nftResolver = null;
+    }
+    setProviders(balanceProviders, gasProviders, addressUtilsProviders, nftProviders) {
+        this.balanceResolver = new BalanceResolver(balanceProviders);
+        this.gasResolver = new GasResolver(gasProviders);
+        this.addressUtilsResolver = new AddressUtilsResolver(addressUtilsProviders);
+        this.nftResolver = new NftBalanceResolver(nftProviders);
+    }
+    getBalanceResolver() {
+        if (!this.balanceResolver) {
+            throw new Error('ResolverService not initialized. Make sure to call setProviders first.');
+        }
+        return this.balanceResolver;
+    }
+    getGasResolver() {
+        if (!this.gasResolver) {
+            throw new Error('ResolverService not initialized. Make sure to call setProviders first.');
+        }
+        return this.gasResolver;
+    }
+    getAddressUtilsResolver() {
+        if (!this.addressUtilsResolver) {
+            throw new Error('ResolverService not initialized. Make sure to call setProviders first.');
+        }
+        return this.addressUtilsResolver;
+    }
+    getNftResolver() {
+        if (!this.nftResolver) {
+            throw new Error('NftResolverService not initialized. Make sure to call setProviders first.');
+        }
+        return this.nftResolver;
+    }
+}
+export const resolverService = new UtilsResolverService();

package/dist/esm/lib/retry.js

@@ -0,0 +1,35 @@
+export async function retryWithExponentialBackoff(fn, maxAttempts = 3, baseDelayMs = 1000) {
+    let attempt = 1;
+    const execute = async () => {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (attempt >= maxAttempts) {
+                throw error;
+            }
+            const delayMs = baseDelayMs * 2 ** attempt;
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+            attempt++;
+            return await execute();
+        }
+    };
+    return await execute();
+}
+export async function retry(fn, maxAttempts = 3, baseDelayMs = 1000) {
+    let attempt = 1;
+    const execute = async () => {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (attempt >= maxAttempts) {
+                throw error;
+            }
+            await new Promise((resolve) => setTimeout(resolve, baseDelayMs));
+            attempt++;
+            return await execute();
+        }
+    };
+    return await execute();
+}

package/dist/esm/lib/sorting.js

@@ -0,0 +1,63 @@
+import CurrencySettings from "./CurrencySettings";
+import ExchangeSettings from "./ExchangeSettings";
+export const ONE_WEEK = 7 * 24 * 60 * 60 * 1000;
+export const SortAscending = (x, y) => x.order - y.order;
+export const SortNetworks = (a, b) => {
+    if (a.order !== b.order) {
+        return b.order - a.order;
+    }
+    return a.name.localeCompare(b.name);
+};
+export const SortNetworkRoutes = (a, b) => {
+    const aIsNew = a?.tokens?.every(t => new Date(t?.listing_date)?.getTime() >= new Date().getTime() - ONE_WEEK);
+    const bIsNew = b?.tokens?.every(t => new Date(t?.listing_date)?.getTime() >= new Date().getTime() - ONE_WEEK);
+    const a_order = ResolveNetworkOrder(a, aIsNew);
+    const b_order = ResolveNetworkOrder(b, bIsNew);
+    if (a_order !== b_order) {
+        return b_order - a_order;
+    }
+    return a.name.localeCompare(b.name);
+};
+export const SortNetworkRoutesWithBalances = (balances) => (a, b) => {
+    const aIsNew = a?.tokens?.every(t => new Date(t?.listing_date)?.getTime() >= new Date().getTime() - ONE_WEEK);
+    const bIsNew = b?.tokens?.every(t => new Date(t?.listing_date)?.getTime() >= new Date().getTime() - ONE_WEEK);
+    const a_order = ResolveNetworkOrder(a, aIsNew);
+    const b_order = ResolveNetworkOrder(b, bIsNew);
+    if (a_order !== b_order) {
+        return b_order - a_order;
+    }
+    const balance_a = balances[a.name]; //useNetworksBalanceStore.getState().getNetworkBalance(a.name)?.totalInUSD || 0
+    const balance_b = balances[b.name]; //useNetworksBalanceStore.getState().getNetworkBalance(b.name)?.totalInUSD || 0
+    if (balance_b !== balance_a) {
+        return balance_b - balance_a;
+    }
+    return a.name.localeCompare(b.name);
+};
+export function ResolveNetworkOrder(network, is_new) {
+    const is_inactive = network.tokens?.every(r => r.status === 'inactive');
+    if (is_inactive) {
+        return -1;
+    }
+    if (is_new) {
+        return 100;
+    }
+    return 50;
+}
+export function ResolveExchangeOrder(exchange, direction) {
+    let orderProp = direction == 'from' ? 'OrderInSource' : 'OrderInDestination';
+    const initial_order = resolveInitialWeightedOrder(ExchangeSettings.KnownSettings[exchange.name]?.[orderProp], 1);
+    return initial_order;
+}
+export function ResolveCurrencyOrder(currency) {
+    const initial_order = resolveInitialWeightedOrder(CurrencySettings.KnownSettings[currency.symbol]?.Order, 1);
+    const is_active = currency.status === 'active';
+    const is_inactive = currency.status === 'inactive';
+    return initial_order + resolveConditionWeight(!is_inactive, 4) + resolveConditionWeight(is_active, 2);
+}
+const resolveInitialWeightedOrder = (settingsOrder, initialOrderWeight) => {
+    // Add 1 to distinguish between 0 and undefined
+    const settings_order = (Number(settingsOrder) + 1);
+    const hasSettings = settings_order > 0;
+    return settings_order || resolveConditionWeight(hasSettings, initialOrderWeight);
+};
+const resolveConditionWeight = (value, priority) => value ? 0 : 10 ** (priority + 1);

package/dist/esm/lib/telegram.js

@@ -0,0 +1,25 @@
+const configs = process.env.NEXT_PUBLIC_TELEGRAM_CONFIGS ? JSON.parse(process.env.NEXT_PUBLIC_TELEGRAM_CONFIGS) : undefined;
+export const SendFeedbackMessage = async (title, text) => {
+    if (!configs.feedback_token || !configs.feedback_chat_id)
+        return;
+    return await (await fetch(`https://api.telegram.org/bot${configs.feedback_token}/sendMessage?chat_id=${configs.feedback_chat_id}&text=${title} %0A ${text}`)).json();
+};
+export const SendErrorMessage = async (title, text) => {
+    if (!configs.error_token || !configs.error_chat_id)
+        return;
+    if (text.length > 2000) {
+        text = text.slice(0, 2000);
+    }
+    return await (await fetch(`https://api.telegram.org/bot${configs.error_token}/sendMessage?chat_id=${configs.error_chat_id}&text=${title} %0A ${text}`)).json();
+};
+export const SendTransactionData = async (swapId, txHash) => {
+    if (!configs.error_token || !configs.error_chat_id)
+        return console.log('Set up token and chat id in env');
+    try {
+        return await (await fetch(`https://api.telegram.org/bot${configs.error_token}/sendMessage?chat_id=${configs.error_chat_id}&text=swapId:  ${swapId} %0A transaction hash: ${txHash}`)).json();
+    }
+    catch (e) {
+        //TODO log to logger
+        console.log(e);
+    }
+};