@lifi/sdk 2.2.3 → 3.0.0-alpha.2

package/dist/cjs/execution/prepareRestart.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareRestart = void 0;
+const viem_1 = require("viem");
+const errors_1 = require("../utils/errors");
+const prepareRestart = async (route, walletClient) => {
+    for (let index = 0; index < route.steps.length; index++) {
+        const step = route.steps[index];
+        const stepHasFailed = step.execution?.status === 'FAILED';
+        if (stepHasFailed) {
+            await handleErrorType(walletClient, step);
+            deleteFailedProcesses(step);
+            deleteTransactionData(step);
+        }
+    }
+};
+exports.prepareRestart = prepareRestart;
+const handleErrorType = async (walletClient, step) => {
+    const client = walletClient.extend(viem_1.publicActions);
+    const isGasLimitError = step.execution?.process.some((p) => p.error?.code === errors_1.LiFiErrorCode.GasLimitError);
+    const isGasPriceError = step.execution?.process.some((p) => p.error?.code === errors_1.LiFiErrorCode.TransactionUnderpriced);
+    const { transactionRequest } = step;
+    // if (isGasLimitError) {
+    //   if (transactionRequest) {
+    //     let gasLimit = transactionRequest.gasLimit
+    //     try {
+    //       gasLimit = await client.estimateGas(transactionRequest)
+    //     } catch (error) {}
+    //     if (gasLimit) {
+    //       transactionRequest.gasLimit = BigNumber.from(
+    //         `${(BigInt(gasLimit.toString()) * 125n) / 100n}`
+    //       )
+    //     }
+    //   }
+    //   step.estimate.gasCosts?.forEach(
+    //     (gasCost) =>
+    //       (gasCost.limit = `${Math.round(Number(gasCost.limit) * 1.25)}`)
+    //   )
+    // }
+    // if (isGasPriceError) {
+    //   if (transactionRequest) {
+    //     let gasPrice = transactionRequest.gasPrice
+    //     try {
+    //       gasPrice = await client.getGasPrice()
+    //     } catch (error) {}
+    //     if (gasPrice) {
+    //       transactionRequest.gasPrice = BigNumber.from(
+    //         `${(BigInt(gasPrice.toString()) * 125n) / 100n}`
+    //       )
+    //     }
+    //   }
+    //   step.estimate.gasCosts?.forEach(
+    //     (gasCost) =>
+    //       (gasCost.price = `${Math.round(Number(gasCost.price) * 1.25)}`)
+    //   )
+    // }
+};
+const deleteFailedProcesses = (step) => {
+    if (step.execution) {
+        step.execution.process = step.execution.process.filter((process) => process.status === 'DONE');
+    }
+};
+const deleteTransactionData = (step) => {
+    step.transactionRequest = undefined;
+};

package/dist/cjs/execution/stepComparison.d.ts

@@ -1,14 +1,14 @@
-import { StatusManager } from '.';
-import { InternalExecutionSettings, LifiStep } from '../types';
+import type { InternalExecutionSettings, LifiStep } from '../types';
+import type { StatusManager } from './StatusManager';
 /**
  * This method checks whether the new and updated Step meets the required exchange rate conditions.
  * If yes it returns the updated Step.
  * If no and if user interaction is allowed it triggers the acceptExchangeRateUpdateHook. If no user interaction is allowed it aborts.
- *
  * @param statusManager
  * @param oldStep
  * @param newStep
  * @param settings
  * @param allowUserInteraction
+ * @returns Return LifiStep
  */
 export declare const stepComparison: (statusManager: StatusManager, oldStep: LifiStep, newStep: LifiStep, settings: InternalExecutionSettings, allowUserInteraction: boolean) => Promise<LifiStep>;

package/dist/cjs/execution/stepComparison.js

@@ -7,12 +7,12 @@ const utils_1 = require("./utils");
  * This method checks whether the new and updated Step meets the required exchange rate conditions.
  * If yes it returns the updated Step.
  * If no and if user interaction is allowed it triggers the acceptExchangeRateUpdateHook. If no user interaction is allowed it aborts.
- *
  * @param statusManager
  * @param oldStep
  * @param newStep
  * @param settings
  * @param allowUserInteraction
+ * @returns Return LifiStep
  */
 const stepComparison = async (statusManager, oldStep, newStep, settings, allowUserInteraction) => {
     // Check if changed exchange rate is in the range of slippage threshold
@@ -29,7 +29,7 @@ const stepComparison = async (statusManager, oldStep, newStep, settings, allowUs
     }
     if (!allowStepUpdate) {
         // The user declined the new exchange rate, so we are not going to proceed
-        throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionCanceled, 'Exchange rate has changed!', `Transaction was not sent, your funds are still in your wallet.
+        throw new errors_1.TransactionError(errors_1.LiFiErrorCode.ExchangeRateUpdateCanceled, 'Exchange rate has changed!', `Transaction was not sent, your funds are still in your wallet.
       The exchange rate has changed and the previous estimation can not be fulfilled due to value loss.`);
     }
     return statusManager.updateStepInRoute(newStep);

package/dist/cjs/execution/switchChain.d.ts

@@ -1,16 +1,21 @@
-import { LifiStep } from '@lifi/types';
-import { Signer } from 'ethers';
-import { SwitchChainHook } from '../types';
-import { StatusManager } from './StatusManager';
+import type { LifiStep } from '@lifi/types';
+import type { WalletClient } from 'viem';
+import type { SwitchChainHook } from '../types';
+import type { StatusManager } from './StatusManager';
 /**
- * This method checks whether the signer is configured for the correct chain.
- * If yes it returns the signer.
+ * This method checks whether the wallet client is configured for the correct chain.
+ * If yes it returns the wallet clien.
  * If no and if user interaction is allowed it triggers the switchChainHook. If no user interaction is allowed it aborts.
  *
- * @param signer
+ * Account Type: local -
+ * We need to create and return a new WalletClient from the switchChainHook in order to continue execution on a new chain.
+ *
+ * Account Type: json-rpc -
+ * We can switch chain and return existing WalletClient from the switchChainHook in order to continue execution on a new chain.
+ * @param walletClient
  * @param statusManager
  * @param step
  * @param switchChainHook
  * @param allowUserInteraction
  */
-export declare const switchChain: (signer: Signer, statusManager: StatusManager, step: LifiStep, switchChainHook: SwitchChainHook, allowUserInteraction: boolean) => Promise<Signer | undefined>;
+export declare const switchChain: (walletClient: WalletClient, statusManager: StatusManager, step: LifiStep, switchChainHook: SwitchChainHook, allowUserInteraction: boolean) => Promise<WalletClient | undefined>;

package/dist/cjs/execution/switchChain.js

@@ -3,20 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.switchChain = void 0;
 const errors_1 = require("../utils/errors");
 /**
- * This method checks whether the signer is configured for the correct chain.
- * If yes it returns the signer.
+ * This method checks whether the wallet client is configured for the correct chain.
+ * If yes it returns the wallet clien.
  * If no and if user interaction is allowed it triggers the switchChainHook. If no user interaction is allowed it aborts.
  *
- * @param signer
+ * Account Type: local -
+ * We need to create and return a new WalletClient from the switchChainHook in order to continue execution on a new chain.
+ *
+ * Account Type: json-rpc -
+ * We can switch chain and return existing WalletClient from the switchChainHook in order to continue execution on a new chain.
+ * @param walletClient
  * @param statusManager
  * @param step
  * @param switchChainHook
  * @param allowUserInteraction
  */
-const switchChain = async (signer, statusManager, step, switchChainHook, allowUserInteraction) => {
+const switchChain = async (walletClient, statusManager, step, switchChainHook, allowUserInteraction) => {
     // if we are already on the correct chain we can proceed directly
-    if ((await signer.getChainId()) === step.action.fromChainId) {
-        return signer;
+    if ((await walletClient.getChainId()) === step.action.fromChainId) {
+        return walletClient;
     }
     // -> set status message
     step.execution = statusManager.initExecutionObject(step);
@@ -26,20 +31,20 @@ const switchChain = async (signer, statusManager, step, switchChainHook, allowUs
         return;
     }
     try {
-        const updatedSigner = await switchChainHook(step.action.fromChainId);
-        const updatedChainId = await updatedSigner?.getChainId();
+        const updatedWalletClient = await switchChainHook(step.action.fromChainId);
+        const updatedChainId = await updatedWalletClient?.getChainId();
         if (updatedChainId !== step.action.fromChainId) {
-            throw new errors_1.ProviderError(errors_1.LifiErrorCode.ChainSwitchError, 'Chain switch required.');
+            throw new errors_1.ProviderError(errors_1.LiFiErrorCode.ChainSwitchError, 'Chain switch required.');
         }
         switchProcess = statusManager.updateProcess(step, switchProcess.type, 'DONE');
         statusManager.updateExecution(step, 'PENDING');
-        return updatedSigner;
+        return updatedWalletClient;
     }
     catch (error) {
         statusManager.updateProcess(step, switchProcess.type, 'FAILED', {
             error: {
                 message: error.message,
-                code: errors_1.LifiErrorCode.ChainSwitchError,
+                code: errors_1.LiFiErrorCode.ChainSwitchError,
             },
         });
         statusManager.updateExecution(step, 'FAILED');

package/dist/cjs/execution/utils.d.ts

@@ -1,6 +1,12 @@
-import { LifiStep, ProcessType, Status, StatusMessage, StatusResponse, Substatus } from '@lifi/types';
-import { StatusManager } from '..';
-export declare function waitForReceivingTransaction(txHash: string, statusManager: StatusManager, processType: ProcessType, step: LifiStep): Promise<StatusResponse>;
+import type { LifiStep, ProcessType, Status, StatusMessage, Substatus } from '@lifi/types';
 export declare function getProcessMessage(type: ProcessType, status: Status): string | undefined;
 export declare function getSubstatusMessage(status: StatusMessage, substatus?: Substatus): string | undefined;
+/**
+ * Used to check if changed exchange rate is in the range of slippage threshold.
+ * We use a slippage value as a threshold to trigger the rate change hook.
+ * This can result in almost doubled slippage for the user and need to be revisited.
+ * @param oldStep
+ * @param newStep
+ * @returns Boolean
+ */
 export declare function checkStepSlippageThreshold(oldStep: LifiStep, newStep: LifiStep): boolean;

package/dist/cjs/execution/utils.js

@@ -1,61 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkStepSlippageThreshold = exports.getSubstatusMessage = exports.getProcessMessage = exports.waitForReceivingTransaction = void 0;
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const ApiService_1 = __importDefault(require("../services/ApiService"));
-const errors_1 = require("../utils/errors");
-const utils_1 = require("../utils/utils");
-const TRANSACTION_HASH_OBSERVERS = {};
-async function waitForReceivingTransaction(txHash, statusManager, processType, step) {
-    const getStatus = () => new Promise(async (resolve, reject) => {
-        let statusResponse;
-        try {
-            statusResponse = await ApiService_1.default.getStatus({
-                bridge: step.tool,
-                fromChain: step.action.fromChainId,
-                toChain: step.action.toChainId,
-                txHash,
-            });
-        }
-        catch (e) {
-            console.debug('Fetching status from backend failed.', e);
-            return resolve(undefined);
-        }
-        switch (statusResponse.status) {
-            case 'DONE':
-                return resolve(statusResponse);
-            case 'PENDING':
-                statusManager?.updateProcess(step, processType, 'PENDING', {
-                    substatus: statusResponse.substatus,
-                    substatusMessage: statusResponse.substatusMessage ||
-                        getSubstatusMessage(statusResponse.status, statusResponse.substatus),
-                    txLink: statusResponse.bridgeExplorerLink,
-                });
-                return resolve(undefined);
-            case 'NOT_FOUND':
-                return resolve(undefined);
-            case 'FAILED':
-            default:
-                return reject();
-        }
-    });
-    let status;
-    if (txHash in TRANSACTION_HASH_OBSERVERS) {
-        status = await TRANSACTION_HASH_OBSERVERS[txHash];
-    }
-    else {
-        TRANSACTION_HASH_OBSERVERS[txHash] = (0, utils_1.repeatUntilDone)(getStatus, 5000);
-        status = await TRANSACTION_HASH_OBSERVERS[txHash];
-    }
-    if (!status.receiving) {
-        throw new errors_1.ServerError("Status doesn't contain receiving information.");
-    }
-    return status;
-}
-exports.waitForReceivingTransaction = waitForReceivingTransaction;
+exports.checkStepSlippageThreshold = exports.getSubstatusMessage = exports.getProcessMessage = void 0;
 const processMessages = {
     TOKEN_ALLOWANCE: {
         STARTED: 'Setting token allowance.',
@@ -115,18 +60,26 @@ function getSubstatusMessage(status, substatus) {
     return message;
 }
 exports.getSubstatusMessage = getSubstatusMessage;
-// Used to check if changed exchange rate is in the range of slippage threshold
+/**
+ * Used to check if changed exchange rate is in the range of slippage threshold.
+ * We use a slippage value as a threshold to trigger the rate change hook.
+ * This can result in almost doubled slippage for the user and need to be revisited.
+ * @param oldStep
+ * @param newStep
+ * @returns Boolean
+ */
 function checkStepSlippageThreshold(oldStep, newStep) {
-    const setSlippage = new bignumber_js_1.default(oldStep.action.slippage);
-    const oldEstimatedToAmount = new bignumber_js_1.default(oldStep.estimate.toAmountMin);
-    const newEstimatedToAmount = new bignumber_js_1.default(newStep.estimate.toAmountMin);
-    const amountDifference = oldEstimatedToAmount.minus(newEstimatedToAmount);
+    const setSlippage = oldStep.action.slippage;
+    const oldEstimatedToAmount = BigInt(oldStep.estimate.toAmountMin);
+    const newEstimatedToAmount = BigInt(newStep.estimate.toAmountMin);
+    const amountDifference = oldEstimatedToAmount - newEstimatedToAmount;
     // oldEstimatedToAmount can be 0 when we use conract calls
-    let actualSlippage = new bignumber_js_1.default(0);
-    if (oldEstimatedToAmount.gt(0)) {
-        actualSlippage = amountDifference.dividedBy(oldEstimatedToAmount);
+    let actualSlippage = 0;
+    if (oldEstimatedToAmount > 0) {
+        actualSlippage =
+            Number((amountDifference * 1000000000n) / oldEstimatedToAmount) /
+                1000000000;
     }
-    return (newEstimatedToAmount.gte(oldEstimatedToAmount) &&
-        actualSlippage.lte(setSlippage));
+    return actualSlippage <= setSlippage;
 }
 exports.checkStepSlippageThreshold = checkStepSlippageThreshold;

package/dist/cjs/execution/waitForReceivingTransaction.d.ts

@@ -0,0 +1,3 @@
+import type { LifiStep, ProcessType, StatusResponse } from '@lifi/types';
+import type { StatusManager } from '..';
+export declare function waitForReceivingTransaction(txHash: string, statusManager: StatusManager, processType: ProcessType, step: LifiStep): Promise<StatusResponse>;

package/dist/cjs/execution/waitForReceivingTransaction.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForReceivingTransaction = void 0;
+const ApiService_1 = __importDefault(require("../services/ApiService"));
+const errors_1 = require("../utils/errors");
+const utils_1 = require("../utils/utils");
+const utils_2 = require("./utils");
+const TRANSACTION_HASH_OBSERVERS = {};
+async function waitForReceivingTransaction(txHash, statusManager, processType, step) {
+    const getStatus = () => new Promise(async (resolve, reject) => {
+        let statusResponse;
+        try {
+            statusResponse = await ApiService_1.default.getStatus({
+                bridge: step.tool,
+                fromChain: step.action.fromChainId,
+                toChain: step.action.toChainId,
+                txHash,
+            });
+        }
+        catch (e) {
+            console.debug('Fetching status from backend failed.', e);
+            return resolve(undefined);
+        }
+        switch (statusResponse.status) {
+            case 'DONE':
+                return resolve(statusResponse);
+            case 'PENDING':
+                statusManager?.updateProcess(step, processType, 'PENDING', {
+                    substatus: statusResponse.substatus,
+                    substatusMessage: statusResponse.substatusMessage ||
+                        (0, utils_2.getSubstatusMessage)(statusResponse.status, statusResponse.substatus),
+                    txLink: statusResponse.bridgeExplorerLink,
+                });
+                return resolve(undefined);
+            case 'NOT_FOUND':
+                return resolve(undefined);
+            case 'FAILED':
+            default:
+                return reject();
+        }
+    });
+    let status;
+    if (txHash in TRANSACTION_HASH_OBSERVERS) {
+        status = await TRANSACTION_HASH_OBSERVERS[txHash];
+    }
+    else {
+        TRANSACTION_HASH_OBSERVERS[txHash] = (0, utils_1.repeatUntilDone)(getStatus, 5000);
+        status = await TRANSACTION_HASH_OBSERVERS[txHash];
+    }
+    if (!status.receiving) {
+        throw new errors_1.ServerError("Status doesn't contain receiving information.");
+    }
+    return status;
+}
+exports.waitForReceivingTransaction = waitForReceivingTransaction;

package/dist/cjs/helpers.d.ts

@@ -1,27 +1,17 @@
-import { LifiStep, Route, Token } from '@lifi/types';
-import { TenderlyResponse } from './types';
-/**
- * Predefined hook that decrypts calldata using EIP-1193 compliant wallet functions.
- * @param {string} walletAddress - The wallet address of the user that should decrypt the calldata.
- * @return {(encryptedData: string) => Promise<any>} A function that decrypts data using EIP-1193 compliant wallet functions.
- */
-export declare const getEthereumDecryptionHook: (walletAddress: string) => (encryptedData: string) => Promise<string>;
-/**
- * Predefined hook that get the public encryption key of a user using EIP-1193 compliant wallet functions.
- * @param {string} walletAddress - The wallet address of the user.
- * @return {(walletAddress: string) => () => Promise<any>} A function that return the public encryption key using EIP-1193 compliant wallet functions.
- */
-export declare const getEthereumPublicKeyHook: (walletAddress: string) => () => Promise<string>;
+import type { LifiStep, Route } from '@lifi/types';
+import type { TenderlyResponse } from './types';
 /**
  * Returns a random number between min (inclusive) and max (inclusive)
+ * @param min - minimum number.
+ * @param max - maximum number.
+ * @returns - random number.
  */
 export declare const getRandomNumber: (min: number, max: number) => number;
-export declare const isSameToken: (tokenA: Token, tokenB: Token) => boolean;
 export declare const checkPackageUpdates: (packageName?: string, packageVersion?: string, disableCheck?: boolean) => Promise<void>;
 /**
  * Converts a quote to Route
- * @param {LifiStep} step - Step returned from the quote endpoint.
- * @return {Route} - The route to be executed.
+ * @param step - Step returned from the quote endpoint.
+ * @returns - The route to be executed.
  * @throws {ValidationError} Throws a ValidationError if the step has missing values.
  */
 export declare const convertQuoteToRoute: (step: LifiStep) => Route;

package/dist/cjs/helpers.js

@@ -1,51 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchTxErrorDetails = exports.convertQuoteToRoute = exports.checkPackageUpdates = exports.isSameToken = exports.getRandomNumber = exports.getEthereumPublicKeyHook = exports.getEthereumDecryptionHook = void 0;
+exports.fetchTxErrorDetails = exports.convertQuoteToRoute = exports.checkPackageUpdates = exports.getRandomNumber = void 0;
 const request_1 = require("./request");
 const errors_1 = require("./utils/errors");
 const version_1 = require("./version");
-const ethereumRequest = async (method, params) => {
-    // If ethereum.request() exists, the provider is probably EIP-1193 compliant.
-    if (!ethereum?.request) {
-        throw new Error('Provider not available.');
-    }
-    return ethereum.request({
-        method,
-        params,
-    });
-};
-/**
- * Predefined hook that decrypts calldata using EIP-1193 compliant wallet functions.
- * @param {string} walletAddress - The wallet address of the user that should decrypt the calldata.
- * @return {(encryptedData: string) => Promise<any>} A function that decrypts data using EIP-1193 compliant wallet functions.
- */
-const getEthereumDecryptionHook = (walletAddress) => {
-    return (encryptedData) => {
-        return ethereumRequest('eth_decrypt', [encryptedData, walletAddress]);
-    };
-};
-exports.getEthereumDecryptionHook = getEthereumDecryptionHook;
-/**
- * Predefined hook that get the public encryption key of a user using EIP-1193 compliant wallet functions.
- * @param {string} walletAddress - The wallet address of the user.
- * @return {(walletAddress: string) => () => Promise<any>} A function that return the public encryption key using EIP-1193 compliant wallet functions.
- */
-const getEthereumPublicKeyHook = (walletAddress) => {
-    return () => {
-        return ethereumRequest('eth_getEncryptionPublicKey', [walletAddress]);
-    };
-};
-exports.getEthereumPublicKeyHook = getEthereumPublicKeyHook;
 /**
  * Returns a random number between min (inclusive) and max (inclusive)
+ * @param min - minimum number.
+ * @param max - maximum number.
+ * @returns - random number.
  */
 const getRandomNumber = (min, max) => {
     return Math.floor(Math.random() * (max - min + 1) + min);
 };
 exports.getRandomNumber = getRandomNumber;
-const isSameToken = (tokenA, tokenB) => tokenA.chainId === tokenB.chainId &&
-    tokenA.address.toLowerCase() === tokenB.address.toLowerCase();
-exports.isSameToken = isSameToken;
 function semverCompare(a, b) {
     if (a.startsWith(b + '-')) {
         return -1;
@@ -81,8 +49,8 @@ const checkPackageUpdates = async (packageName, packageVersion, disableCheck) =>
 exports.checkPackageUpdates = checkPackageUpdates;
 /**
  * Converts a quote to Route
- * @param {LifiStep} step - Step returned from the quote endpoint.
- * @return {Route} - The route to be executed.
+ * @param step - Step returned from the quote endpoint.
+ * @returns - The route to be executed.
  * @throws {ValidationError} Throws a ValidationError if the step has missing values.
  */
 const convertQuoteToRoute = (step) => {

package/dist/cjs/request.js

@@ -51,7 +51,7 @@ const request = async (url, options = {
     }
     catch (error) {
         if (options.retries > 0 && error?.status === 500) {
-            await (0, utils_1.sleep)(500);
+            await (0, utils_1.wait)(500);
             return (0, exports.request)(url, { ...options, retries: options.retries - 1 });
         }
         throw error;

package/dist/cjs/services/ApiService.d.ts

@@ -1,5 +1,5 @@
-import { ConnectionsRequest, ConnectionsResponse, ContractCallQuoteRequest, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, LifiStep, QuoteRequest, RequestOptions, TokensRequest, TokensResponse } from '@lifi/types';
-import { ChainId, ChainKey, ExtendedChain, PossibilitiesRequest, PossibilitiesResponse, RoutesRequest, RoutesResponse, StatusResponse, Token, ToolsRequest, ToolsResponse } from '../types';
+import type { ConnectionsRequest, ConnectionsResponse, ContractCallQuoteRequest, GasRecommendationRequest, GasRecommendationResponse, GetStatusRequest, LifiStep, QuoteRequest, RequestOptions, TokensRequest, TokensResponse } from '@lifi/types';
+import type { ChainId, ChainKey, ExtendedChain, PossibilitiesRequest, PossibilitiesResponse, RoutesRequest, RoutesResponse, StatusResponse, Token, ToolsRequest, ToolsResponse } from '../types';
 declare const _default: {
     getChains: (options?: RequestOptions | undefined) => Promise<ExtendedChain[]>;
     getContractCallQuote: (requestConfig: ContractCallQuoteRequest, options?: RequestOptions | undefined) => Promise<LifiStep>;

package/dist/cjs/services/ApiService.js

@@ -9,6 +9,8 @@ const errors_1 = require("../utils/errors");
 const parseError_1 = require("../utils/parseError");
 const ConfigService_1 = __importDefault(require("./ConfigService"));
 /**
+ * @param requestConfig
+ * @param options
  * @deprecated We don't want to support this endpoint anymore in the future. /chains, /tools, /connections, and /tokens should be used instead
  */
 const getPossibilities = async (requestConfig, options) => {
@@ -279,10 +281,10 @@ const getAvailableConnections = async (connectionRequest) => {
         url.searchParams.append('fromToken', fromToken);
     }
     if (toChain) {
-        url.searchParams.append('toChain', toChain);
+        url.searchParams.append('fromToken', toChain);
     }
     if (toToken) {
-        url.searchParams.append('toToken', toToken);
+        url.searchParams.append('fromToken', toToken);
     }
     const connectionRequestArrayParams = [
         'allowBridges',

package/dist/cjs/services/ChainsService.d.ts

@@ -1,4 +1,4 @@
-import { ChainId, ExtendedChain } from '@lifi/types';
+import type { ChainId, ExtendedChain } from '@lifi/types';
 export default class ChainsService {
     private static instance;
     private readonly loadingPromise;

package/dist/cjs/services/ConfigService.d.ts

@@ -1,4 +1,4 @@
-import { Chain, Config, ConfigUpdate } from '../types';
+import type { Chain, Config, ConfigUpdate } from '../types';
 export default class ConfigService {
     private static instance;
     private readonly config;

package/dist/cjs/services/ConfigService.js

@@ -46,8 +46,7 @@ class ConfigService {
                     this.config.integrator;
             this.config.widgetVersion =
                 configUpdate.widgetVersion || this.config.widgetVersion;
-            this.config.multisigConfig =
-                configUpdate.multisigConfig || this.config.multisigConfig;
+            this.config.multisig = configUpdate.multisigConfig || this.config.multisig;
             return this.config;
         };
         this.updateChains = (chains) => {

package/dist/cjs/typeguards.d.ts

@@ -1,4 +1,4 @@
-import { LifiStep, RoutesRequest, StaticToken } from './types';
+import type { LifiStep, RoutesRequest, StaticToken } from './types';
 export declare const isRoutesRequest: (routesRequest: RoutesRequest) => routesRequest is RoutesRequest;
 export declare const isStep: (step: LifiStep) => step is LifiStep;
 export declare const isToken: (token: StaticToken) => token is StaticToken;

package/dist/cjs/types/abi.d.ts

@@ -0,0 +1,5 @@
+import type { Abi } from 'viem';
+export declare const approveAbi: Abi;
+export declare const allowanceAbi: Abi;
+export declare const getEthBalanceAbi: Abi;
+export declare const balanceOfAbi: Abi;

package/dist/cjs/types/abi.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.balanceOfAbi = exports.getEthBalanceAbi = exports.allowanceAbi = exports.approveAbi = void 0;
+exports.approveAbi = [
+    {
+        name: 'approve',
+        inputs: [
+            { internalType: 'address', name: 'spender', type: 'address' },
+            { internalType: 'uint256', name: 'amount', type: 'uint256' },
+        ],
+        outputs: [{ internalType: 'bool', name: 'approved', type: 'bool' }],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+];
+exports.allowanceAbi = [
+    {
+        name: 'allowance',
+        inputs: [
+            { internalType: 'address', name: 'owner', type: 'address' },
+            { internalType: 'address', name: 'spender', type: 'address' },
+        ],
+        outputs: [{ internalType: 'uint256', name: 'allowance', type: 'uint256' }],
+        stateMutability: 'view',
+        type: 'function',
+    },
+];
+exports.getEthBalanceAbi = [
+    {
+        inputs: [{ name: '_owner', type: 'address' }],
+        name: 'getEthBalance',
+        outputs: [{ name: 'balance', type: 'uint256' }],
+        type: 'function',
+        stateMutability: 'view',
+    },
+];
+exports.balanceOfAbi = [
+    {
+        inputs: [{ name: '_owner', type: 'address' }],
+        name: 'balanceOf',
+        outputs: [{ name: 'balance', type: 'uint256' }],
+        type: 'function',
+        stateMutability: 'view',
+    },
+];

package/dist/cjs/types/index.d.ts

@@ -1,4 +1,4 @@
 export * from '@lifi/types';
-export { ErrorCode, LifiError } from '../utils/errors';
-export * from './ERC20';
+export { ErrorCode, LiFiError } from '../utils/errors';
+export * from './abi';
 export * from './internal.types';

package/dist/cjs/types/index.js

@@ -14,9 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LifiError = void 0;
+exports.LiFiError = void 0;
 __exportStar(require("@lifi/types"), exports);
 var errors_1 = require("../utils/errors");
-Object.defineProperty(exports, "LifiError", { enumerable: true, get: function () { return errors_1.LifiError; } });
-__exportStar(require("./ERC20"), exports);
+Object.defineProperty(exports, "LiFiError", { enumerable: true, get: function () { return errors_1.LiFiError; } });
+__exportStar(require("./abi"), exports);
 __exportStar(require("./internal.types"), exports);