@lifi/sdk 3.0.0-alpha.9 → 3.0.0-beta.1

package/src/utils/parseError.ts

@@ -0,0 +1,210 @@
+import type { LiFiStep, Process } from '@lifi/types'
+import {
+  errorCodes as MetaMaskErrorCodes,
+  getMessageFromCode,
+} from 'eth-rpc-errors'
+import { fetchTxErrorDetails } from '../helpers.js'
+import {
+  ErrorMessage,
+  EthersErrorMessage,
+  EthersErrorType,
+  LiFiError,
+  LiFiErrorCode,
+  MetaMaskProviderErrorCode,
+  ProviderError,
+  RPCError,
+  TransactionError,
+  UnknownError,
+} from './errors.js'
+import { getTransactionNotSentMessage } from './getTransactionMessage.js'
+
+/**
+ * Available MetaMask error codes:
+ *
+ * export const errorCodes: ErrorCodes = {
+     rpc: {
+      invalidInput: -32000,
+      resourceNotFound: -32001,
+      resourceUnavailable: -32002,
+      transactionRejected: -32003,
+      methodNotSupported: -32004,
+      limitExceeded: -32005,
+      parse: -32700,
+      invalidRequest: -32600,
+      methodNotFound: -32601,
+      invalidParams: -32602,
+      internal: -32603,
+    },
+    provider: {
+      userRejectedRequest: 4001,
+      unauthorized: 4100,
+      unsupportedMethod: 4200,
+      disconnected: 4900,
+      chainDisconnected: 4901,
+    },
+  };
+ *
+ * For more information about error codes supported by metamask check
+ * https://github.com/MetaMask/eth-rpc-errors
+ * https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
+ */
+
+export const parseError = async (
+  e: any,
+  step?: LiFiStep,
+  process?: Process
+): Promise<LiFiError> => {
+  if (e instanceof LiFiError) {
+    return e
+  }
+
+  const errorCode = e.code || e.cause?.code
+
+  switch (errorCode) {
+    case EthersErrorType.CallExecption:
+      const defaultErrorMessage = await getTransactionNotSentMessage(
+        step,
+        process
+      )
+      try {
+        if (!step?.action.fromChainId) {
+          throw new Error('fromChainId is not defined.')
+        }
+
+        const response = await fetchTxErrorDetails(
+          e.transactionHash,
+          step?.action.fromChainId
+        )
+
+        const errorMessage = response?.error_message ?? e.reason
+
+        const isAllowanceError =
+          response?.error_message?.includes(
+            EthersErrorMessage.ERC20Allowance
+          ) || e.reason?.includes(EthersErrorMessage.ERC20Allowance)
+
+        if (isAllowanceError) {
+          return new TransactionError(
+            LiFiErrorCode.AllowanceRequired,
+            e.reason,
+            errorMessage,
+            e.stack
+          )
+        }
+
+        // Error messages other than allowance error will be handled in catch block
+        throw new Error(e)
+      } catch (error) {
+        return new ProviderError(
+          LiFiErrorCode.TransactionFailed,
+          e.reason,
+          defaultErrorMessage,
+          e.stack
+        )
+      }
+    case EthersErrorType.InsufficientFunds:
+      return new TransactionError(
+        LiFiErrorCode.InsufficientFunds,
+        e.message,
+        await getTransactionNotSentMessage(step, process),
+        e.stack
+      )
+    case EthersErrorType.ActionRejected:
+    case MetaMaskProviderErrorCode.userRejectedRequest:
+      return new TransactionError(
+        LiFiErrorCode.SignatureRejected,
+        e.message,
+        await getTransactionNotSentMessage(step, process),
+        e.stack
+      )
+    case LiFiErrorCode.TransactionUnprepared:
+      return new TransactionError(
+        LiFiErrorCode.TransactionUnprepared,
+        e.message,
+        await getTransactionNotSentMessage(step, process),
+        e.stack
+      )
+    case LiFiErrorCode.ValidationError:
+      return new TransactionError(
+        LiFiErrorCode.ValidationError,
+        e.message,
+        e.htmlMessage
+      )
+    case LiFiErrorCode.TransactionCanceled:
+      return new TransactionError(
+        LiFiErrorCode.TransactionCanceled,
+        e.message,
+        e.htmlMessage
+      )
+    case LiFiErrorCode.ExchangeRateUpdateCanceled:
+      return new TransactionError(
+        LiFiErrorCode.ExchangeRateUpdateCanceled,
+        e.message,
+        e.htmlMessage
+      )
+    case LiFiErrorCode.WalletChangedDuringExecution:
+      return new TransactionError(
+        LiFiErrorCode.WalletChangedDuringExecution,
+        e.message,
+        e.htmlMessage
+      )
+    default: {
+      if (errorCode && typeof errorCode === 'number') {
+        if (Object.values(MetaMaskErrorCodes.rpc).includes(errorCode as any)) {
+          // rpc errors
+          // underpriced errors are sent as internal errors, so we need to parse the message manually
+          if (
+            errorCode === MetaMaskErrorCodes.rpc.internal &&
+            (e.message?.includes(EthersErrorMessage.Underpriced) ||
+              e.message?.includes(EthersErrorMessage.LowReplacementFee))
+          ) {
+            return new RPCError(
+              LiFiErrorCode.TransactionUnderpriced,
+              ErrorMessage.TransactionUnderpriced,
+              await getTransactionNotSentMessage(step, process),
+              e.stack
+            )
+          }
+
+          if (
+            e.message?.includes(EthersErrorMessage.LowGas) ||
+            e.message?.includes(EthersErrorMessage.OutOfGas)
+          ) {
+            return new TransactionError(
+              LiFiErrorCode.GasLimitError,
+              ErrorMessage.GasLimitLow,
+              await getTransactionNotSentMessage(step, process),
+              e.stack
+            )
+          }
+
+          return new RPCError(
+            errorCode,
+            getMessageFromCode(errorCode),
+            await getTransactionNotSentMessage(step, process),
+            e.stack
+          )
+        }
+
+        // provider errors
+        if (
+          Object.values(MetaMaskErrorCodes.provider).includes(errorCode as any)
+        ) {
+          return new ProviderError(
+            errorCode,
+            getMessageFromCode(errorCode),
+            await getTransactionNotSentMessage(step, process),
+            e.stack
+          )
+        }
+      }
+      return new UnknownError(
+        LiFiErrorCode.InternalError,
+        e.message || ErrorMessage.UnknownError,
+        undefined,
+        e.stack
+      )
+    }
+  }
+}

package/src/utils/utils.ts

@@ -0,0 +1,48 @@
+import { AddressZero, AlternativeAddressZero } from '../constants.js'
+
+export const wait = (ms: number): Promise<undefined> => {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms)
+  })
+}
+
+/**
+ * Repeatedly calls a given asynchronous function until it resolves with a value
+ * @param toRepeat The function that should be repeated
+ * @param timeout The timeout in milliseconds between retries, defaults to 5000
+ * @returns The result of the toRepeat function
+ */
+export const repeatUntilDone = async <T>(
+  toRepeat: () => Promise<T | undefined>,
+  timeout = 5000
+): Promise<T> => {
+  let result: T | undefined
+
+  while (!result) {
+    result = await toRepeat()
+    if (!result) {
+      await wait(timeout)
+    }
+  }
+
+  return result
+}
+
+export const isZeroAddress = (address: string): boolean => {
+  if (address === AddressZero || address === AlternativeAddressZero) {
+    return true
+  }
+  return false
+}
+
+export const isNativeTokenAddress = (address: string): boolean => {
+  if (
+    address === AddressZero ||
+    address === AlternativeAddressZero ||
+    // CELO native token
+    address === '0x471ece3750da237f93b8e339c536989b8978a438'
+  ) {
+    return true
+  }
+  return false
+}

package/src/version.ts

@@ -0,0 +1,2 @@
+export const name = '@lifi/sdk'
+export const version = '3.0.0-beta.1'

package/dist/LiFi.d.ts

@@ -1,178 +0,0 @@
-import type { ChainId, ChainKey, ConnectionsRequest, ConnectionsResponse, ContractCallQuoteRequest, ExtendedChain, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, LiFiStep, PossibilitiesRequest, PossibilitiesResponse, QuoteRequest, RequestOptions, RoutesRequest, RoutesResponse, StatusResponse, Token, TokenAmount, TokensRequest, TokensResponse, ToolsRequest, ToolsResponse } from '@lifi/types';
-import type { Hash, PublicClient } from 'viem';
-import type { ApproveTokenRequest, RevokeApprovalRequest, TokenAllowance, TokenSpender } from './allowance';
-import { RouteExecutionManager } from './execution/RouteExecutionManager';
-import type { SDKConfig, SDKOptions } from './types';
-export declare class LiFi extends RouteExecutionManager {
-    private chainsService;
-    constructor(options: SDKOptions);
-    /**
-     * Get the current configuration of the SDK
-     * @returns - The config object
-     */
-    getConfig: () => SDKConfig;
-    /**
-     * Get the SDK configuration after all setup calls are finished
-     * @returns - The config object
-     */
-    getConfigAsync: () => Promise<SDKConfig>;
-    /**
-     * Get an instance of a provider for a specific chain
-     * @param chainId - Id of the chain the provider is for
-     * @returns The public client for the given chain
-     */
-    getPublicClient: (chainId: number) => Promise<PublicClient>;
-    /**
-     * Set a new confuration for the SDK
-     * @param configUpdate - An object containing the configuration fields that should be updated.
-     * @returns The renewed config object
-     */
-    setConfig: (configUpdate: Partial<SDKOptions>) => SDKConfig;
-    /**
-     * Get a set of current possibilities based on a request that specifies which chains, exchanges and bridges are preferred or unwanted.
-     * @param request - Object defining preferences regarding chain, exchanges and bridges
-     * @param options - Request options
-     * @returns Object listing current possibilities for any-to-any cross-chain-swaps based on the provided preferences.
-     * @throws {LiFiError} Throws a LiFiError if request fails.
-     * @deprecated We don't want to support this endpoint anymore in the future. /chains, /tools, /connections, and /tokens should be used instead
-     */
-    getPossibilities: (request?: PossibilitiesRequest, options?: RequestOptions) => Promise<PossibilitiesResponse>;
-    /**
-     * Fetch information about a Token
-     * @param chain - Id or key of the chain that contains the token
-     * @param token - Address or symbol of the token on the requested chain
-     * @param options - Request options
-     * @throws {LiFiError} - Throws a LiFiError if request fails
-     * @returns Token information
-     */
-    getToken: (chain: ChainKey | ChainId, token: string, options?: RequestOptions) => Promise<Token>;
-    /**
-     * Get a quote for a token transfer
-     * @param request - The configuration of the requested quote
-     * @param options - Request options
-     * @throws {LiFiError} - Throws a LiFiError if request fails
-     * @returns Quote for a token transfer
-     */
-    getQuote: (request: QuoteRequest, options?: RequestOptions) => Promise<LiFiStep>;
-    /**
-     * Get a quote for a destination contract call
-     * @param request - The configuration of the requested destination call
-     * @param options - Request options
-     * @throws {LiFiError} - Throws a LiFiError if request fails
-     * @returns - Returns step.
-     */
-    getContractCallQuote: (request: ContractCallQuoteRequest, options?: RequestOptions) => Promise<LiFiStep>;
-    /**
-     * Check the status of a transfer. For cross chain transfers, the "bridge" parameter is required.
-     * @param request - Configuration of the requested status
-     * @param options - Rrquest options.
-     * @throws {LiFiError} - Throws a LiFiError if request fails
-     * @returns Returns status response.
-     */
-    getStatus: (request: GetStatusRequest, options?: RequestOptions) => Promise<StatusResponse>;
-    /**
-     * Get the available tools to bridge and swap tokens.
-     * @param request - The configuration of the requested tools
-     * @param options - Request options
-     * @returns The tools that are available on the requested chains
-     */
-    getTools: (request?: ToolsRequest, options?: RequestOptions) => Promise<ToolsResponse>;
-    /**
-     * Get all known tokens.
-     * @param request - The configuration of the requested tokens
-     * @param options - Request options
-     * @returns The tokens that are available on the requested chains
-     */
-    getTokens: (request?: TokensRequest, options?: RequestOptions) => Promise<TokensResponse>;
-    /**
-     * Get all available chains
-     * @returns A list of all available chains
-     * @throws {LiFiError} Throws a LiFiError if request fails.
-     */
-    getChains: () => Promise<ExtendedChain[]>;
-    /**
-     * Get a set of routes for a request that describes a transfer of tokens.
-     * @param request - A description of the transfer.
-     * @param options - Request options
-     * @returns The resulting routes that can be used to realize the described transfer of tokens.
-     * @throws {LiFiError} Throws a LiFiError if request fails.
-     */
-    getRoutes: (request: RoutesRequest, options?: RequestOptions) => Promise<RoutesResponse>;
-    /**
-     * Get the transaction data for a single step of a route
-     * @param step - The step object.
-     * @param options - Request options
-     * @returns The step populated with the transaction data.
-     * @throws {LiFiError} Throws a LiFiError if request fails.
-     */
-    getStepTransaction: (step: LiFiStep, options?: RequestOptions) => Promise<LiFiStep>;
-    /**
-     * Get gas recommendation for a certain chain
-     * @param request - Configuration of the requested recommendation.
-     * @param options - Request options
-     * @throws {LiFiError} Throws a LiFiError if request fails.
-     * @returns Gas recommendation response.
-     */
-    getGasRecommendation: (request: GasRecommendationRequest, options?: RequestOptions) => Promise<GasRecommendationResponse>;
-    /**
-     * Returns the balances of a specific token a wallet holds across all aggregated chains.
-     * @param walletAddress - A wallet address.
-     * @param token - A Token object.
-     * @returns An object containing the token and the amounts on different chains.
-     * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-     */
-    getTokenBalance: (walletAddress: string, token: Token) => Promise<TokenAmount | null>;
-    /**
-     * Returns the balances for a list tokens a wallet holds  across all aggregated chains.
-     * @param walletAddress - A wallet address.
-     * @param tokens - A list of Token objects.
-     * @returns A list of objects containing the tokens and the amounts on different chains.
-     * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-     */
-    getTokenBalances: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;
-    /**
-     * This method queries the balances of tokens for a specific list of chains for a given wallet.
-     * @param walletAddress - A walletaddress.
-     * @param tokensByChain - A list of Token objects organized by chain ids.
-     * @returns A list of objects containing the tokens and the amounts on different chains organized by the chosen chains.
-     * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-     */
-    getTokenBalancesByChain: (walletAddress: string, tokensByChain: {
-        [chainId: number]: Token[];
-    }) => Promise<{
-        [chainId: number]: TokenAmount[];
-    }>;
-    /**
-     * Get the current allowance for a certain token.
-     * @param token - The token that should be checked
-     * @param ownerAddress - The owner of the token
-     * @param spenderAddress - The spender address that has to be approved
-     * @returns Returns allowance
-     */
-    getTokenAllowance: (token: Token, ownerAddress: string, spenderAddress: string) => Promise<bigint | undefined>;
-    /**
-     * Get the current allowance for a list of token/spender address pairs.
-     * @param ownerAddress - The owner of the tokens
-     * @param tokens - A list of token and spender address pairs
-     * @returns Returns array of tokens and their allowance
-     */
-    getTokenAllowanceMulticall: (ownerAddress: string, tokens: TokenSpender[]) => Promise<TokenAllowance[]>;
-    /**
-     * Set approval for a certain token and amount.
-     * @param request - The approval request
-     * @returns Returns Hash or nothing
-     */
-    setTokenApproval: (request: ApproveTokenRequest) => Promise<Hash | undefined>;
-    /**
-     * Revoke approval for a certain token.
-     * @param request - The revoke request
-     * @returns Returns Hash or nothing
-     */
-    revokeTokenApproval: (request: RevokeApprovalRequest) => Promise<Hash | undefined>;
-    /**
-     * Get all the available connections for swap/bridging tokens
-     * @param connectionRequest ConnectionsRequest
-     * @returns ConnectionsResponse
-     */
-    getConnections: (connectionRequest: ConnectionsRequest) => Promise<ConnectionsResponse>;
-}

package/dist/LiFi.js

@@ -1,253 +0,0 @@
-import { getTokenAllowance, getTokenAllowanceMulticall, revokeTokenApproval, setTokenAllowance, } from './allowance';
-import * as balance from './balance';
-import { getPublicClient } from './connectors';
-import { RouteExecutionManager } from './execution/RouteExecutionManager';
-import { checkPackageUpdates } from './helpers';
-import ApiService from './services/ApiService';
-import { ChainsService } from './services/ChainsService';
-import { isToken } from './typeguards';
-import { ValidationError } from './utils/errors';
-import { name, version } from './version';
-export class LiFi extends RouteExecutionManager {
-    constructor(options) {
-        super(options);
-        /**
-         * Get the current configuration of the SDK
-         * @returns - The config object
-         */
-        this.getConfig = () => {
-            return this.configService.getConfig();
-        };
-        /**
-         * Get the SDK configuration after all setup calls are finished
-         * @returns - The config object
-         */
-        this.getConfigAsync = () => {
-            return this.configService.getConfigAsync();
-        };
-        /**
-         * Get an instance of a provider for a specific chain
-         * @param chainId - Id of the chain the provider is for
-         * @returns The public client for the given chain
-         */
-        this.getPublicClient = (chainId) => {
-            return getPublicClient(chainId);
-        };
-        /**
-         * Set a new confuration for the SDK
-         * @param configUpdate - An object containing the configuration fields that should be updated.
-         * @returns The renewed config object
-         */
-        this.setConfig = (configUpdate) => {
-            return this.configService.updateConfig(configUpdate);
-        };
-        /**
-         * Get a set of current possibilities based on a request that specifies which chains, exchanges and bridges are preferred or unwanted.
-         * @param request - Object defining preferences regarding chain, exchanges and bridges
-         * @param options - Request options
-         * @returns Object listing current possibilities for any-to-any cross-chain-swaps based on the provided preferences.
-         * @throws {LiFiError} Throws a LiFiError if request fails.
-         * @deprecated We don't want to support this endpoint anymore in the future. /chains, /tools, /connections, and /tokens should be used instead
-         */
-        this.getPossibilities = async (request, options) => {
-            return ApiService.getPossibilities(request, options);
-        };
-        /**
-         * Fetch information about a Token
-         * @param chain - Id or key of the chain that contains the token
-         * @param token - Address or symbol of the token on the requested chain
-         * @param options - Request options
-         * @throws {LiFiError} - Throws a LiFiError if request fails
-         * @returns Token information
-         */
-        this.getToken = async (chain, token, options) => {
-            return ApiService.getToken(chain, token, options);
-        };
-        /**
-         * Get a quote for a token transfer
-         * @param request - The configuration of the requested quote
-         * @param options - Request options
-         * @throws {LiFiError} - Throws a LiFiError if request fails
-         * @returns Quote for a token transfer
-         */
-        this.getQuote = async (request, options) => {
-            return ApiService.getQuote(request, options);
-        };
-        /**
-         * Get a quote for a destination contract call
-         * @param request - The configuration of the requested destination call
-         * @param options - Request options
-         * @throws {LiFiError} - Throws a LiFiError if request fails
-         * @returns - Returns step.
-         */
-        this.getContractCallQuote = async (request, options) => {
-            return ApiService.getContractCallQuote(request, options);
-        };
-        /**
-         * Check the status of a transfer. For cross chain transfers, the "bridge" parameter is required.
-         * @param request - Configuration of the requested status
-         * @param options - Rrquest options.
-         * @throws {LiFiError} - Throws a LiFiError if request fails
-         * @returns Returns status response.
-         */
-        this.getStatus = async (request, options) => {
-            return ApiService.getStatus(request, options);
-        };
-        /**
-         * Get the available tools to bridge and swap tokens.
-         * @param request - The configuration of the requested tools
-         * @param options - Request options
-         * @returns The tools that are available on the requested chains
-         */
-        this.getTools = async (request, options) => {
-            return ApiService.getTools(request || {}, options);
-        };
-        /**
-         * Get all known tokens.
-         * @param request - The configuration of the requested tokens
-         * @param options - Request options
-         * @returns The tokens that are available on the requested chains
-         */
-        this.getTokens = async (request, options) => {
-            return ApiService.getTokens(request || {}, options);
-        };
-        /**
-         * Get all available chains
-         * @returns A list of all available chains
-         * @throws {LiFiError} Throws a LiFiError if request fails.
-         */
-        this.getChains = async () => {
-            return this.chainsService.getChains();
-        };
-        /**
-         * Get a set of routes for a request that describes a transfer of tokens.
-         * @param request - A description of the transfer.
-         * @param options - Request options
-         * @returns The resulting routes that can be used to realize the described transfer of tokens.
-         * @throws {LiFiError} Throws a LiFiError if request fails.
-         */
-        this.getRoutes = async (request, options) => {
-            return ApiService.getRoutes(request, options);
-        };
-        /**
-         * Get the transaction data for a single step of a route
-         * @param step - The step object.
-         * @param options - Request options
-         * @returns The step populated with the transaction data.
-         * @throws {LiFiError} Throws a LiFiError if request fails.
-         */
-        this.getStepTransaction = async (step, options) => {
-            return ApiService.getStepTransaction(step, options);
-        };
-        /**
-         * Get gas recommendation for a certain chain
-         * @param request - Configuration of the requested recommendation.
-         * @param options - Request options
-         * @throws {LiFiError} Throws a LiFiError if request fails.
-         * @returns Gas recommendation response.
-         */
-        this.getGasRecommendation = async (request, options) => {
-            return ApiService.getGasRecommendation(request, options);
-        };
-        /**
-         * Returns the balances of a specific token a wallet holds across all aggregated chains.
-         * @param walletAddress - A wallet address.
-         * @param token - A Token object.
-         * @returns An object containing the token and the amounts on different chains.
-         * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-         */
-        this.getTokenBalance = async (walletAddress, token) => {
-            if (!walletAddress) {
-                throw new ValidationError('Missing walletAddress.');
-            }
-            if (!isToken(token)) {
-                throw new ValidationError(`Invalid token passed: address "${token.address}" on chainId "${token.chainId}"`);
-            }
-            return balance.getTokenBalance(walletAddress, token);
-        };
-        /**
-         * Returns the balances for a list tokens a wallet holds  across all aggregated chains.
-         * @param walletAddress - A wallet address.
-         * @param tokens - A list of Token objects.
-         * @returns A list of objects containing the tokens and the amounts on different chains.
-         * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-         */
-        this.getTokenBalances = async (walletAddress, tokens) => {
-            if (!walletAddress) {
-                throw new ValidationError('Missing walletAddress.');
-            }
-            const invalidTokens = tokens.filter((token) => !isToken(token));
-            if (invalidTokens.length) {
-                throw new ValidationError(`Invalid token passed: address "${invalidTokens[0].address}" on chainId "${invalidTokens[0].chainId}"`);
-            }
-            return balance.getTokenBalances(walletAddress, tokens);
-        };
-        /**
-         * This method queries the balances of tokens for a specific list of chains for a given wallet.
-         * @param walletAddress - A walletaddress.
-         * @param tokensByChain - A list of Token objects organized by chain ids.
-         * @returns A list of objects containing the tokens and the amounts on different chains organized by the chosen chains.
-         * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-         */
-        this.getTokenBalancesByChain = async (walletAddress, tokensByChain) => {
-            if (!walletAddress) {
-                throw new ValidationError('Missing walletAddress.');
-            }
-            const tokenList = Object.values(tokensByChain).flat();
-            const invalidTokens = tokenList.filter((token) => !isToken(token));
-            if (invalidTokens.length) {
-                throw new ValidationError(`Invalid token passed: address "${invalidTokens[0].address}" on chainId "${invalidTokens[0].chainId}"`);
-            }
-            return balance.getTokenBalancesByChain(walletAddress, tokensByChain);
-        };
-        /**
-         * Get the current allowance for a certain token.
-         * @param token - The token that should be checked
-         * @param ownerAddress - The owner of the token
-         * @param spenderAddress - The spender address that has to be approved
-         * @returns Returns allowance
-         */
-        this.getTokenAllowance = async (token, ownerAddress, spenderAddress) => {
-            return getTokenAllowance(token, ownerAddress, spenderAddress);
-        };
-        /**
-         * Get the current allowance for a list of token/spender address pairs.
-         * @param ownerAddress - The owner of the tokens
-         * @param tokens - A list of token and spender address pairs
-         * @returns Returns array of tokens and their allowance
-         */
-        this.getTokenAllowanceMulticall = async (ownerAddress, tokens) => {
-            return getTokenAllowanceMulticall(ownerAddress, tokens);
-        };
-        /**
-         * Set approval for a certain token and amount.
-         * @param request - The approval request
-         * @returns Returns Hash or nothing
-         */
-        this.setTokenApproval = (request) => {
-            return setTokenAllowance(request);
-        };
-        /**
-         * Revoke approval for a certain token.
-         * @param request - The revoke request
-         * @returns Returns Hash or nothing
-         */
-        this.revokeTokenApproval = (request) => {
-            return revokeTokenApproval(request);
-        };
-        /**
-         * Get all the available connections for swap/bridging tokens
-         * @param connectionRequest ConnectionsRequest
-         * @returns ConnectionsResponse
-         */
-        this.getConnections = async (connectionRequest) => {
-            const connections = await ApiService.getAvailableConnections(connectionRequest);
-            return connections;
-        };
-        this.chainsService = ChainsService.getInstance();
-        this.chainsService.getChains().then((chains) => {
-            this.configService.updateChains(chains);
-        });
-        checkPackageUpdates(name, version, options.disableVersionCheck);
-    }
-}