@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

package/dist/lib/apiClients/jsonRpcClient.js

@@ -0,0 +1,28 @@
+export class JsonRpcClient {
+    constructor(url) {
+        this.nextId = 1;
+        this.url = url;
+    }
+    async call(method, params) {
+        const request = {
+            jsonrpc: '2.0',
+            method,
+            params,
+            id: this.nextId++,
+        };
+        const res = await fetch(this.url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(request),
+        });
+        const response = await res.json();
+        if (response.error) {
+            throw new Error(`RPC Error ${response.error.code}: ${response.error.message}`);
+        }
+        if (!res.ok) {
+            throw new Error(`Network error: ${res.status} ${res.statusText}`);
+        }
+        // response.result is guaranteed if no error
+        return response.result;
+    }
+}

package/dist/lib/{layerSwapApiClient.d.ts → apiClients/layerSwapApiClient.d.ts}

@@ -1,8 +1,8 @@
-import { SwapStatus } from "../Models/SwapStatus";
+import { SwapStatus } from "../../Models/SwapStatus";
 import { AxiosInstance } from "axios";
-import { ApiResponse } from "../Models/ApiResponse";
-import { NetworkWithTokens, Network, Token } from "../Models/Network";
-import { Exchange } from "../Models/Exchange";
+import { ApiResponse } from "../../Models/ApiResponse";
+import { NetworkWithTokens, Network, Token } from "../../Models/Network";
+import { Exchange } from "../../Models/Exchange";
 export default class LayerSwapApiClient {
     static apiBaseEndpoint?: string;
     static apiKey: string;
@@ -12,7 +12,6 @@ export default class LayerSwapApiClient {
     fetcher: (url: string) => Promise<ApiResponse<any>>;
     GetRoutesAsync(direction: 'sources' | 'destinations'): Promise<ApiResponse<NetworkWithTokens[]>>;
     GetSourceExchangesAsync(): Promise<ApiResponse<Exchange[]>>;
-    GetDestinationExchangesAsync(): Promise<ApiResponse<Exchange[]>>;
     GetLSNetworksAsync(): Promise<ApiResponse<NetworkWithTokens[]>>;
     CreateSwapAsync(params: CreateSwapParams): Promise<ApiResponse<SwapResponse>>;
     GetSwapsAsync(page: number, include_expired: boolean): Promise<ApiResponse<SwapResponse[]>>;
@@ -53,6 +52,7 @@ export type CreateSwapParams = {
     app_name?: string;
 };
 export type SwapResponse = {
+    deposit_actions?: DepositAction[];
     swap: SwapItem;
     quote: SwapQuote;
     refuel?: Refuel;
@@ -63,6 +63,30 @@ export type Refuel = {
     amount: number;
     amount_in_usd: number;
 };
+export type SwapBasicData = {
+    source_network: Network;
+    source_token: Token;
+    source_exchange?: Exchange;
+    destination_network: Network;
+    destination_token: Token;
+    destination_address: string;
+    requested_amount: number;
+    use_deposit_address: boolean;
+};
+export type SwapDetails = {
+    id: string;
+    created_date: string;
+    status: SwapStatus;
+    transactions: Transaction[];
+    exchange_account_connected: boolean;
+    exchange_account_name?: string;
+    fail_reason?: string;
+    metadata: {
+        reference_id: string | null;
+        app: string | null;
+        sequence_number: number;
+    };
+};
 export type SwapItem = {
     id: string;
     created_date: string;
@@ -71,12 +95,10 @@ export type SwapItem = {
     source_exchange?: Exchange;
     destination_network: Network;
     destination_token: Token;
-    destination_exchange?: Exchange;
-    status: SwapStatus;
-    source_address: `0x${string}`;
-    destination_address: `0x${string}`;
+    destination_address: string;
     requested_amount: number;
     use_deposit_address: boolean;
+    status: SwapStatus;
     transactions: Transaction[];
     exchange_account_connected: boolean;
     exchange_account_name?: string;
@@ -86,6 +108,7 @@ export type SwapItem = {
         app: string | null;
         sequence_number: number;
     };
+    destination_exchange?: Exchange;
 };
 export type DepositAction = {
     amount: number;
@@ -101,8 +124,8 @@ export type DepositAction = {
 };
 export type Quote = {
     quote: SwapQuote;
-    refuel: Refuel;
-    reward: QuoteReward;
+    refuel?: Refuel;
+    reward?: QuoteReward;
 };
 export type QuoteReward = {
     amount: number;
@@ -129,6 +152,7 @@ export type SwapQuote = {
     source_token?: Token;
     destination_network?: Network;
     destination_token?: Token;
+    requested_amount?: number;
     receive_amount: number;
     min_receive_amount: number;
     fee_discount?: number;
@@ -164,7 +188,8 @@ export type Transaction = {
 export declare enum TransactionType {
     Input = "input",
     Output = "output",
-    Refuel = "refuel"
+    Refuel = "refuel",
+    Refund = "refund"
 }
 export declare enum BackendTransactionStatus {
     Completed = "completed",

package/dist/lib/{layerSwapApiClient.js → apiClients/layerSwapApiClient.js}

@@ -1,14 +1,13 @@
-import AppSettings from "./AppSettings";
-import { InitializeUnauthInstance, InitializeAuthInstance } from "./axiosInterceptor";
+import AppSettings from "../AppSettings";
+import { InitializeUnauthInstance, InitializeAuthInstance } from "../axiosInterceptor";
 import { v4 as uuidv4 } from 'uuid';
-import { AuthRefreshFailedError } from "./Errors/AuthRefreshFailedError";
-import { EmptyApiResponse } from "../Models/ApiResponse";
-import LayerSwapAuthApiClient from "./userAuthApiClient";
-// import { datadogRum } from '@datadog/browser-rum';
+import { AuthRefreshFailedError } from "../Errors/AuthRefreshFailedError";
+import { EmptyApiResponse } from "../../Models/ApiResponse";
+import posthog from "posthog-js";
 class LayerSwapApiClient {
     constructor() {
         this.fetcher = (url) => this.AuthenticatedRequest("GET", url);
-        this._authInterceptor = InitializeAuthInstance(LayerSwapAuthApiClient.identityBaseEndpoint);
+        this._authInterceptor = InitializeAuthInstance();
         this._unauthInterceptor = InitializeUnauthInstance(LayerSwapApiClient.apiBaseEndpoint);
     }
     async GetRoutesAsync(direction) {
@@ -17,9 +16,6 @@ class LayerSwapApiClient {
     async GetSourceExchangesAsync() {
         return await this.UnauthenticatedRequest("GET", `/source_exchanges`);
     }
-    async GetDestinationExchangesAsync() {
-        return await this.UnauthenticatedRequest("GET", `/destination_exchanges`);
-    }
     async GetLSNetworksAsync() {
         return await this.UnauthenticatedRequest("GET", `/networks`);
     }
@@ -66,7 +62,14 @@ class LayerSwapApiClient {
                 const renderingError = new Error(`API request error with uri:${uri}`);
                 renderingError.name = `APIError`;
                 renderingError.cause = reason;
-                // datadogRum.addError(renderingError);
+                posthog.capture('$exception', {
+                    name: renderingError.name,
+                    message: renderingError.message,
+                    stack: renderingError.stack,
+                    cause: renderingError.cause,
+                    where: 'apiClient',
+                    severity: 'error',
+                });
                 return Promise.reject(reason);
             }
         });
@@ -100,6 +103,7 @@ export var TransactionType;
     TransactionType["Input"] = "input";
     TransactionType["Output"] = "output";
     TransactionType["Refuel"] = "refuel";
+    TransactionType["Refund"] = "refund";
 })(TransactionType || (TransactionType = {}));
 export var BackendTransactionStatus;
 (function (BackendTransactionStatus) {

package/dist/lib/axiosInterceptor.js

@@ -1,13 +1,5 @@
 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,
-};
+import LayerSwapApiClient from "./apiClients/layerSwapApiClient";
 export const InitializeAuthInstance = (baseURL) => {
     const instance = axios.create({
         baseURL: baseURL || "",
@@ -15,91 +7,18 @@ export const InitializeAuthInstance = (baseURL) => {
             "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;
+            throw new Error("NEXT_PUBLIC_API_KEY is not set up in env vars");
         }
         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) => {
@@ -115,7 +34,7 @@ export const InitializeUnauthInstance = (baseURL) => {
             config.headers["X-LS-APIKEY"] = apiKey;
         }
         else {
-            throw new Error("API key is not set up");
+            throw new Error("NEXT_PUBLIC_API_KEY is not set up in env vars");
         }
         return config;
     }, (error) => {

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

@@ -1,12 +1,6 @@
+import { NetworkBalance } from "../../Models/Balance";
 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>;
+    getBalance(network: NetworkWithTokens, address?: string): Promise<NetworkBalance>;
 }

package/dist/lib/balances/balanceResolver.js

@@ -1,36 +1,55 @@
-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";
+import posthog from "posthog-js";
+import { truncateDecimals } from "../../components/utils/RoundDecimals";
+import { BitcoinBalanceProvider, EVMBalanceProvider, FuelBalanceProvider, ImmutableXBalanceProvider, LoopringBalanceProvider, ParadexBalanceProvider, SolanaBalanceProvider, StarknetBalanceProvider, TonBalanceProvider, TronBalanceProvider, ZkSyncBalanceProvider, HyperliquidBalanceProvider } from "./providers";
 export class BalanceResolver {
     constructor() {
         this.providers = [
-            new QueryBalanceProvider(),
-            // new StarknetBalanceProvider(),
+            new StarknetBalanceProvider(),
             new EVMBalanceProvider(),
-            // new FuelBalanceProvider(),
-            // new ImmutableXBalanceProvider(),
-            // new LoopringBalanceProvider(),
-            // new SolanaBalanceProvider(),
-            // new TonBalanceProvider(),
+            new FuelBalanceProvider(),
+            new ImmutableXBalanceProvider(),
+            new LoopringBalanceProvider(),
+            new SolanaBalanceProvider(),
+            new TonBalanceProvider(),
             new ZkSyncBalanceProvider(),
-            // new TronBalanceProvider(),
-            // new ParadexBalanceProvider()
+            new TronBalanceProvider(),
+            new ParadexBalanceProvider(),
+            new BitcoinBalanceProvider(),
+            new HyperliquidBalanceProvider()
         ];
     }
-    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);
+    async getBalance(network, address) {
+        try {
+            if (!address)
+                throw new Error(`No address provided for network ${network.name}`);
+            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}`);
+            const balances = await provider.fetchBalance(address, network);
+            const totalInUSD = balances?.reduce((acc, b) => {
+                const token = network.tokens.find(t => t?.symbol === b?.token);
+                const tokenPriceInUsd = token?.price_in_usd || 0;
+                const tokenPrecision = token?.precision || 0;
+                const formattedBalance = b.amount ? Number(truncateDecimals(b?.amount, tokenPrecision)) : 0;
+                return acc + (formattedBalance * tokenPriceInUsd);
+            }, 0);
+            return { balances, totalInUSD };
+        }
+        catch (e) {
+            const error = new Error(e);
+            error.name = "BalanceError";
+            error.cause = e;
+            posthog.capture('$exception', {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+                cause: error.cause,
+                where: 'BalanceProviderError',
+                severity: 'error',
+            });
+            return { balances: [], totalInUSD: 0 };
+        }
     }
 }

package/dist/lib/balances/{providers/helpers.d.ts → helpers.d.ts}

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

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

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

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

@@ -0,0 +1,49 @@
+import KnownInternalNames from "../../knownIds";
+import axios from "axios";
+import { BalanceProvider } from "../../../Models/BalanceProvider";
+export class BitcoinBalanceProvider extends BalanceProvider {
+    constructor() {
+        super(...arguments);
+        this.supportsNetwork = (network) => {
+            return KnownInternalNames.Networks.BitcoinMainnet.includes(network.name) || KnownInternalNames.Networks.BitcoinTestnet.includes(network.name);
+        };
+        this.fetchBalance = async (address, network) => {
+            let balances = [];
+            const token = network.tokens.find(t => t.symbol == 'BTC');
+            if (!token)
+                return;
+            try {
+                const utxos = await fetchUtxos(address, network.name);
+                const balanceSats = sumUtxos(utxos);
+                const formattedBalance = formatBtc(balanceSats);
+                if (!token)
+                    throw new Error(`Token not found for network ${network.name}`);
+                const balanceObj = {
+                    network: network.name,
+                    amount: formattedBalance,
+                    decimals: token.decimals,
+                    isNativeCurrency: network.token?.symbol === token.symbol,
+                    token: token.symbol,
+                    request_time: new Date().toJSON()
+                };
+                balances.push(balanceObj);
+            }
+            catch (e) {
+                balances.push(this.resolveTokenBalanceFetchError(e, token, network, true));
+            }
+            return balances;
+        };
+    }
+}
+async function fetchUtxos(address, networkName) {
+    const url = `https://mempool.space${networkName.toLowerCase().includes('testnet') ? '/testnet' : ''}/api/address/${address}/utxo`;
+    const utxosData = await axios.get(url);
+    const utxos = utxosData.data;
+    return utxos;
+}
+function sumUtxos(utxos) {
+    return utxos.reduce((sum, u) => sum + u.value, 0);
+}
+function formatBtc(sats) {
+    return Number((sats / 1e8).toFixed(8));
+}

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

@@ -1,10 +1,15 @@
-import { PublicClient } from "viem";
-import { Balance } from "../../../Models/Balance";
+import { Chain, PublicClient } from "viem";
+import { TokenBalance } 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>;
+import { BalanceProvider } from "../../../Models/BalanceProvider";
+export declare class EVMBalanceProvider extends BalanceProvider {
+    supportsNetwork: (network: NetworkWithTokens) => boolean;
+    fetchBalance: (address: string, network: NetworkWithTokens) => Promise<TokenBalance[] | null | undefined>;
+    getBalances: (address: string, chain: Chain, network: NetworkWithTokens) => Promise<TokenBalance[] | undefined>;
+    contractGetBalances: (address: string, chain: Chain, network: NetworkWithTokens) => Promise<TokenBalance[] | null>;
+    resolveERC20Balances: (multicallRes: ERC20ContractRes[], network: NetworkWithTokens) => TokenBalance[] | null;
+    resolveBalance: (network: Network, token: Token, balanceData: NativeBalanceResponse) => TokenBalance;
 }
 export type ERC20ContractRes = ({
     error: Error;
@@ -15,14 +20,6 @@ export type ERC20ContractRes = ({
     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;
@@ -31,7 +28,10 @@ type GetBalanceArgs = {
     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>;
+type NativeBalanceResponse = (GetBalanceReturnType & {
+    error: null;
+} | {
+    error: string;
+});
+export declare const getTokenBalance: (address: `0x${string}`, network: Network, contract?: `0x${string}` | null) => Promise<NativeBalanceResponse | null>;
 export {};