@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

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

@@ -1,72 +1,157 @@
 import { NetworkType } from "../../../Models/Network";
-import formatAmount from "../../formatAmount";
+import formatAmount from "../../../lib/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 {
+import resolveChain from "../../../lib/resolveChain";
+import BalanceGetterAbi from "../../../lib/abis/BALANCEGETTERABI.json";
+import KnownInternalNames from "../../../lib/knownIds";
+import { BalanceProvider } from "../../../Models/BalanceProvider";
+export class EVMBalanceProvider extends BalanceProvider {
     constructor() {
+        super(...arguments);
+        this.supportsNetwork = (network) => {
+            return network.type === NetworkType.EVM && !!network.token;
+        };
         this.fetchBalance = async (address, network) => {
             if (!network)
                 return;
+            const chain = resolveChain(network);
+            if (!chain)
+                throw new Error("Could not resolve chain");
+            try {
+                const balances = await this.contractGetBalances(address, chain, network);
+                return balances;
+            }
+            catch (e) {
+                console.log(e);
+            }
+            const balances = await this.getBalances(address, chain, network);
+            return balances;
+        };
+        this.getBalances = async (address, chain, network) => {
             try {
-                const chain = resolveChain(network);
-                if (!chain)
-                    return;
                 const { createPublicClient, http } = await import("viem");
                 const publicClient = createPublicClient({
                     chain,
-                    transport: http()
+                    transport: http(network.node_url, { retryCount: 1, timeout: 5000 })
                 });
                 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 erc20Promise = getErc20Balances({
+                    address,
+                    assets: network.tokens,
+                    network,
+                    publicClient,
+                    hasMulticall: !!network.metadata?.evm_multicall_contract
+                });
                 const nativeToken = network.token;
-                const nativeBalanceData = await getTokenBalance(address, network);
-                const nativeBalance = (nativeToken && nativeBalanceData) && await resolveBalance(network, nativeToken, nativeBalanceData);
+                const nativePromise = getTokenBalance(address, network);
+                const [erc20BalancesContractRes, nativeBalanceData] = await Promise.all([
+                    erc20Promise,
+                    nativePromise,
+                ]);
+                const balances = (erc20BalancesContractRes && this.resolveERC20Balances(erc20BalancesContractRes, network)) || [];
+                erc20Balances = balances;
+                const nativeBalance = (nativeToken && nativeBalanceData) && this.resolveBalance(network, nativeToken, nativeBalanceData);
                 let res = [];
                 return res.concat(erc20Balances, nativeBalance ? [nativeBalance] : []);
             }
             catch (e) {
-                console.log(e);
+                return network.tokens.map(t => this.resolveTokenBalanceFetchError(e, t, network));
             }
         };
-    }
-    supportsNetwork(network) {
-        return network.type === NetworkType.EVM && !!network.token;
+        this.contractGetBalances = async (address, chain, network) => {
+            if (!network)
+                throw new Error("Network is required for contract get balances");
+            const { createPublicClient, http } = await import("viem");
+            const publicClient = createPublicClient({
+                chain,
+                transport: http(network.node_url, { retryCount: 1, timeout: 5000 })
+            });
+            const contract = contracts.find(c => c.networks.includes(network.name));
+            if (!contract)
+                throw new Error(`No contract found for network ${network.name}`);
+            const tokenContracts = network.tokens?.filter(a => a.contract).map(a => a.contract);
+            const balances = await publicClient.readContract({
+                address: contract?.address,
+                abi: BalanceGetterAbi,
+                functionName: 'getBalances',
+                args: [address, tokenContracts]
+            });
+            const resolvedERC20Balances = network.tokens.filter(t => t.contract)?.map((token, index) => {
+                const amount = balances[1][index];
+                if (amount >= 0)
+                    return {
+                        network: network.name,
+                        token: token.symbol,
+                        amount: formatAmount(amount, token.decimals),
+                        request_time: new Date().toJSON(),
+                        decimals: token.decimals,
+                        isNativeCurrency: false,
+                    };
+                else {
+                    return {
+                        network: network.name,
+                        token: token.symbol,
+                        amount: undefined,
+                        request_time: new Date().toJSON(),
+                        decimals: token.decimals,
+                        isNativeCurrency: false,
+                        error: `Could not fetch ${token.symbol} balance`
+                    };
+                }
+            });
+            const nativeTokenBalance = Number(balances?.[1]?.[balances?.[1]?.length - 1]);
+            const nativeTokenResolvedBalance = network.token?.decimals ? {
+                network: network.name,
+                token: network.token?.symbol,
+                amount: nativeTokenBalance >= 0 ? formatAmount(nativeTokenBalance, network.token?.decimals) : undefined,
+                request_time: new Date().toJSON(),
+                decimals: network.token?.decimals,
+                isNativeCurrency: true,
+                error: nativeTokenBalance === undefined ? "Could not fetch native token balance" : undefined
+            } : undefined;
+            const res = [...resolvedERC20Balances, nativeTokenResolvedBalance].filter((b) => b !== undefined);
+            return res;
+        };
+        this.resolveERC20Balances = (multicallRes, network) => {
+            const assets = network?.tokens?.filter(a => a.contract);
+            if (!assets)
+                return null;
+            const contractBalances = multicallRes?.map((d, index) => {
+                const currency = assets[index];
+                if (!d.error) {
+                    return {
+                        network: network.name,
+                        token: currency.symbol,
+                        amount: formatAmount(d.result, currency.decimals),
+                        request_time: new Date().toJSON(),
+                        decimals: currency.decimals,
+                        isNativeCurrency: false,
+                    };
+                }
+                else {
+                    return this.resolveTokenBalanceFetchError(d.error, currency, network);
+                }
+            });
+            return contractBalances;
+        };
+        this.resolveBalance = (network, token, balanceData) => {
+            if (balanceData.error !== null)
+                return this.resolveTokenBalanceFetchError({ message: balanceData.error }, token, network);
+            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 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,
@@ -82,7 +167,7 @@ export const getErc20Balances = async ({ address, network, assets, publicClient,
             const config = createConfig({
                 chains: [chain],
                 transports: {
-                    [chain.id]: http()
+                    [chain.id]: http(network.node_url, { retryCount: 1, timeout: 5000 })
                 }
             });
             const contractRes = await multicall(config, {
@@ -120,10 +205,6 @@ export const getErc20Balances = async ({ address, network, assets, publicClient,
         }
     }
     catch (e) {
-        const error = new Error(e);
-        error.name = "ERC20BalanceError";
-        error.cause = e;
-        // datadogRum.addError(error);
         return null;
     }
 };
@@ -135,7 +216,7 @@ export const getTokenBalance = async (address, network, contract) => {
         const config = createConfig({
             chains: [chain],
             transports: {
-                [chain.id]: http()
+                [chain.id]: http(network.node_url, { retryCount: 1, timeout: 5000 })
             }
         });
         const res = await getBalance(config, {
@@ -143,35 +224,78 @@ export const getTokenBalance = async (address, network, contract) => {
             chainId: chain.id,
             ...(contract ? { token: contract } : {})
         });
-        return res;
+        return { error: null, ...res };
     }
     catch (e) {
-        const error = new Error(e);
-        error.name = "TokenBalanceError";
-        error.cause = e;
-        // datadogRum.addError(error);
-        return null;
+        return { error: e };
     }
 };
-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;
-};
+const contracts = [
+    {
+        address: '0xb65a146b7C2D5BEec6EE8a5F38C467b5A88b26Dc',
+        networks: [
+            KnownInternalNames.Networks.EthereumMainnet,
+            KnownInternalNames.Networks.BaseMainnet,
+            KnownInternalNames.Networks.RariMainnet,
+            KnownInternalNames.Networks.ScrollMainnet,
+            KnownInternalNames.Networks.LineaMainnet,
+            KnownInternalNames.Networks.LightlinkMainnet,
+            KnownInternalNames.Networks.NahmiiMainnet,
+            KnownInternalNames.Networks.ZetachainMainnet,
+            KnownInternalNames.Networks.AvaxMainnet,
+            KnownInternalNames.Networks.ZksyncEraMainnet,
+            KnownInternalNames.Networks.XaiMainnet,
+            KnownInternalNames.Networks.RedStoneMainnet,
+            KnownInternalNames.Networks.UnichainMainnet,
+            KnownInternalNames.Networks.SoneiumMainnet,
+            KnownInternalNames.Networks.ArbitrumNova,
+            KnownInternalNames.Networks.MantleMainnet,
+            KnownInternalNames.Networks.PolygonZkMainnet,
+            KnownInternalNames.Networks.ZoraMainnet,
+            KnownInternalNames.Networks.FraxtalMainnet,
+            KnownInternalNames.Networks.ModMainnet,
+            KnownInternalNames.Networks.WorldchainMainnet,
+            KnownInternalNames.Networks.MantaMainnet,
+            KnownInternalNames.Networks.AbstractMainnet,
+            KnownInternalNames.Networks.BlastMainnet,
+            KnownInternalNames.Networks.CeloMainnet,
+            KnownInternalNames.Networks.KromaMainnet,
+            KnownInternalNames.Networks.ShapeMainnet,
+            KnownInternalNames.Networks.GnosisMainnet,
+            KnownInternalNames.Networks.TaikoMainnet,
+            KnownInternalNames.Networks.OKCMainnet,
+            KnownInternalNames.Networks.BNBChainMainnet,
+            KnownInternalNames.Networks.PolygonMainnet,
+            KnownInternalNames.Networks.RoninMainnet,
+            KnownInternalNames.Networks.InkMainnet,
+            KnownInternalNames.Networks.MintMainnet,
+            KnownInternalNames.Networks.Ancient8Mainnet,
+            KnownInternalNames.Networks.BobMainnet,
+            KnownInternalNames.Networks.FuseMainnet,
+            KnownInternalNames.Networks.SonicMainnet,
+            KnownInternalNames.Networks.ImmutableZkEVM,
+            KnownInternalNames.Networks.OptimismMainnet,
+            KnownInternalNames.Networks.RolluxMainnet,
+            KnownInternalNames.Networks.ZeroMainnet,
+            KnownInternalNames.Networks.ZircuitMainnet,
+            KnownInternalNames.Networks.OpBNBMainnet,
+            KnownInternalNames.Networks.SuperseedMainnet,
+            KnownInternalNames.Networks.LiskMainnet,
+            KnownInternalNames.Networks.MorphMainnet,
+            KnownInternalNames.Networks.SeiMainnet,
+            KnownInternalNames.Networks.GravityMainnet
+        ]
+    },
+    {
+        address: '0xf3C74887D68Cd6d6c64Fb9ab24ca6812182eED44',
+        networks: [
+            KnownInternalNames.Networks.ArbitrumMainnet,
+        ]
+    },
+    {
+        address: '0x1930cC92B9dCBBE2E8FA0E05c858A88EE39C41E6',
+        networks: [
+            KnownInternalNames.Networks.SophonMainnet,
+        ]
+    }
+];

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

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

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

@@ -1,8 +1,13 @@
+import { BalanceProvider } from "../../../Models/BalanceProvider";
 import formatAmount from "../../formatAmount";
 import KnownInternalNames from "../../knownIds";
 import retryWithExponentialBackoff from "../../retry";
-export class FuelBalanceProvider {
+export class FuelBalanceProvider extends BalanceProvider {
     constructor() {
+        super(...arguments);
+        this.supportsNetwork = (network) => {
+            return KnownInternalNames.Networks.FuelMainnet.includes(network.name) || KnownInternalNames.Networks.FuelTestnet.includes(network.name);
+        };
         this.fetchBalance = async (address, network) => {
             let balances = [];
             if (!network?.tokens)
@@ -38,25 +43,20 @@ export class FuelBalanceProvider {
                     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),
+                        amount: balance?.amount ? formatAmount(Number(balance?.amount), token.decimals) : undefined,
                         decimals: token.decimals,
                         isNativeCurrency: network.token?.symbol === token.symbol,
                         token: token.symbol,
-                        request_time: new Date().toJSON()
+                        request_time: new Date().toJSON(),
+                        error: balance?.amount === undefined ? `Could not fetch balance for ${token.symbol}` : undefined
                     };
-                    balances = [
-                        ...balances,
-                        balanceObj,
-                    ];
+                    balances.push(balanceObj);
                 }
             }
             catch (e) {
-                console.log(e);
+                return network.tokens.map((currency) => (this.resolveTokenBalanceFetchError(e, currency, network)));
             }
             return balances;
         };
     }
-    supportsNetwork(network) {
-        return KnownInternalNames.Networks.FuelMainnet.includes(network.name) || KnownInternalNames.Networks.FuelTestnet.includes(network.name);
-    }
 }

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

@@ -0,0 +1,9 @@
+import { NetworkWithTokens } from "../../../Models/Network";
+import { TokenBalance } from "../../../Models/Balance";
+import { BalanceProvider } from "../../../Models/BalanceProvider";
+export declare class HyperliquidBalanceProvider extends BalanceProvider {
+    private client;
+    constructor();
+    supportsNetwork: (network: NetworkWithTokens) => boolean;
+    fetchBalance: (address: string, network: NetworkWithTokens) => Promise<TokenBalance[] | undefined>;
+}

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

@@ -0,0 +1,45 @@
+import KnownInternalNames from "../../knownIds";
+import { HyperliquidClient } from "../../apiClients/hyperliquidClient";
+import { BalanceProvider } from "../../../Models/BalanceProvider";
+export class HyperliquidBalanceProvider extends BalanceProvider {
+    constructor() {
+        super();
+        this.supportsNetwork = (network) => {
+            return network.name === KnownInternalNames.Networks.HyperliquidMainnet ||
+                network.name === KnownInternalNames.Networks.HyperliquidTestnet;
+        };
+        this.fetchBalance = async (address, network) => {
+            if (!network?.tokens && !network.token)
+                return;
+            try {
+                var nodeUrl = network.node_url;
+                if (nodeUrl == null) {
+                    nodeUrl = network.name == KnownInternalNames.Networks.HyperliquidMainnet
+                        ? "https://api.hyperliquid.xyz" : "https://api.hyperliquid-testnet.xyz";
+                }
+                const clearinghouseState = await this.client.getClearinghouseState(address, nodeUrl);
+                const balances = [];
+                // Only support USDC balances for now
+                const usdcToken = network.tokens.find(token => token.symbol === 'USDC');
+                if (usdcToken) {
+                    const withdrawableAmount = parseFloat(clearinghouseState.withdrawable);
+                    if (withdrawableAmount > 0) {
+                        balances.push({
+                            network: network.name,
+                            amount: withdrawableAmount,
+                            decimals: usdcToken.decimals,
+                            isNativeCurrency: false,
+                            token: usdcToken.symbol,
+                            request_time: new Date().toJSON(),
+                        });
+                    }
+                }
+                return balances;
+            }
+            catch (error) {
+                return network.tokens.map(t => this.resolveTokenBalanceFetchError(error, t, network));
+            }
+        };
+        this.client = new HyperliquidClient();
+    }
+}

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

@@ -1,7 +1,8 @@
+import { BalanceProvider } from "../../../Models/BalanceProvider";
 import { NetworkWithTokens } from "../../../Models/Network";
-export declare class ImmutableXBalanceProvider {
-    supportsNetwork(network: NetworkWithTokens): boolean;
-    fetchBalance: (address: string, network: NetworkWithTokens) => Promise<{
+export declare class ImmutableXBalanceProvider extends BalanceProvider {
+    supportsNetwork: (network: NetworkWithTokens) => boolean;
+    fetchBalance: (address: string, network: NetworkWithTokens) => Promise<import("../../../Models/Balance").TokenBalance[] | {
         network: string;
         amount: number;
         decimals: number;

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

@@ -1,29 +1,36 @@
+import { BalanceProvider } from "../../../Models/BalanceProvider";
 import formatAmount from "../../formatAmount";
 import KnownInternalNames from "../../knownIds";
-import { insertIfNotExists } from "./helpers";
-export class ImmutableXBalanceProvider {
+import { insertIfNotExists } from "../helpers";
+export class ImmutableXBalanceProvider extends BalanceProvider {
     constructor() {
+        super(...arguments);
+        this.supportsNetwork = (network) => {
+            return (KnownInternalNames.Networks.ImmutableXMainnet.includes(network.name) || KnownInternalNames.Networks.ImmutableXGoerli.includes(network.name));
+        };
         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;
+            try {
+                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: balance?.balance ? formatAmount(balance?.balance, asset.decimals) : 0,
+                        decimals: asset.decimals,
+                        isNativeCurrency: false,
+                        token: asset.symbol,
+                        request_time: new Date().toJSON(),
+                    };
+                });
+                return balances;
+            }
+            catch (e) {
+                return network.tokens.map((currency) => (this.resolveTokenBalanceFetchError(e, currency, network)));
+            }
         };
     }
-    supportsNetwork(network) {
-        return (KnownInternalNames.Networks.ImmutableXMainnet.includes(network.name) || KnownInternalNames.Networks.ImmutableXGoerli.includes(network.name));
-    }
 }

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

@@ -0,0 +1,12 @@
+export { BitcoinBalanceProvider } from "./bitcoinBalanceProvider";
+export { EVMBalanceProvider } from "./evmBalanceProvider";
+export { FuelBalanceProvider } from "./fuelBalanceProvider";
+export { ImmutableXBalanceProvider } from "./immutableXBalanceProvider";
+export { LoopringBalanceProvider } from "./loopringBalanceProvider";
+export { ParadexBalanceProvider } from "./paradexBalanceProvider";
+export { SolanaBalanceProvider } from "./solanaBalanceProvider";
+export { StarknetBalanceProvider } from "./starknetBalanceProvider";
+export { TonBalanceProvider } from "./tonBalanceProvider";
+export { TronBalanceProvider } from "./tronBalanceProvider";
+export { ZkSyncBalanceProvider } from "./zkSyncBalanceProvider";
+export { HyperliquidBalanceProvider } from "./hyperliquidBalanceProvider";

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

@@ -0,0 +1,12 @@
+export { BitcoinBalanceProvider } from "./bitcoinBalanceProvider";
+export { EVMBalanceProvider } from "./evmBalanceProvider";
+export { FuelBalanceProvider } from "./fuelBalanceProvider";
+export { ImmutableXBalanceProvider } from "./immutableXBalanceProvider";
+export { LoopringBalanceProvider } from "./loopringBalanceProvider";
+export { ParadexBalanceProvider } from "./paradexBalanceProvider";
+export { SolanaBalanceProvider } from "./solanaBalanceProvider";
+export { StarknetBalanceProvider } from "./starknetBalanceProvider";
+export { TonBalanceProvider } from "./tonBalanceProvider";
+export { TronBalanceProvider } from "./tronBalanceProvider";
+export { ZkSyncBalanceProvider } from "./zkSyncBalanceProvider";
+export { HyperliquidBalanceProvider } from "./hyperliquidBalanceProvider";

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

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