@lifi/sdk 3.0.0-alpha.4 → 3.0.0-alpha.7

package/dist/cjs/services/ApiService.js

@@ -281,10 +281,10 @@ const getAvailableConnections = async (connectionRequest) => {
         url.searchParams.append('fromToken', fromToken);
     }
     if (toChain) {
-        url.searchParams.append('fromToken', toChain);
+        url.searchParams.append('toChain', toChain);
     }
     if (toToken) {
-        url.searchParams.append('fromToken', toToken);
+        url.searchParams.append('toToken', toToken);
     }
     const connectionRequestArrayParams = [
         'allowBridges',

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

@@ -1,4 +1,5 @@
-import type { Chain, Config, ConfigUpdate } from '../types';
+import type { Chain } from '@lifi/types';
+import type { SDKConfig, SDKOptions } from '../types';
 export default class ConfigService {
     private static instance;
     private readonly config;
@@ -12,12 +13,12 @@ export default class ConfigService {
      * This call immediately returns the current config. It does not make sure that all chain data is already loaded
      * Use this if you need access to basic information like API urls or settings
      */
-    getConfig: () => Config;
+    getConfig: () => SDKConfig;
     /**
      * This call waits for all setup promises to be done.
      * Use this if you need access to chain data (RPCs or multicalls)
      */
-    getConfigAsync: () => Promise<Config>;
-    updateConfig: (configUpdate: Partial<ConfigUpdate>) => Config;
-    updateChains: (chains: Chain[]) => Config;
+    getConfigAsync: () => Promise<SDKConfig>;
+    updateConfig: (configUpdate: Partial<SDKOptions>) => SDKConfig;
+    updateChains: (chains: Chain[]) => SDKConfig;
 }

package/dist/cjs/services/ConfigService.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("../types");
+const types_1 = require("@lifi/types");
 const DefaultExecutionSettings = {
-    /* eslint-disable-next-line @typescript-eslint/no-empty-function */
     updateRouteHook: () => { },
     switchChainHook: () => Promise.resolve(undefined),
     acceptExchangeRateUpdateHook: () => Promise.resolve(undefined),
@@ -38,6 +37,7 @@ class ConfigService {
             this.config.defaultExecutionSettings = Object.assign(this.config.defaultExecutionSettings, configUpdate.defaultExecutionSettings);
             // OPTIONS
             this.config.defaultRouteOptions = Object.assign(this.config.defaultRouteOptions, configUpdate.defaultRouteOptions);
+            this.config.apiKey = configUpdate.apiKey || this.config.apiKey;
             this.config.userId = configUpdate.userId || this.config.userId;
             this.config.integrator = configUpdate.integrator || this.config.integrator;
             this.config.defaultRouteOptions.integrator =
@@ -46,7 +46,7 @@ class ConfigService {
                     this.config.integrator;
             this.config.widgetVersion =
                 configUpdate.widgetVersion || this.config.widgetVersion;
-            this.config.multisig = configUpdate.multisigConfig || this.config.multisig;
+            this.config.multisig = configUpdate.multisig || this.config.multisig;
             return this.config;
         };
         this.updateChains = (chains) => {

package/dist/cjs/typeguards.d.ts

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

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

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

package/dist/cjs/types/index.js

@@ -14,9 +14,5 @@ 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;
-__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("./abi"), exports);
-__exportStar(require("./internal.types"), exports);
+__exportStar(require("./internal"), exports);

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

@@ -0,0 +1,60 @@
+import type { ChainId, RouteOptions } from '@lifi/types';
+import type { ExecutionSettings, InternalExecutionSettings, MultisigConfig } from '../execution/types';
+import type { BaseProvider } from '../providers/BaseProvider';
+export interface SDKConfig {
+    apiUrl: string;
+    apiKey?: string;
+    rpcs: Record<ChainId, string[]>;
+    multicallAddresses: Record<ChainId, string | undefined>;
+    defaultExecutionSettings: InternalExecutionSettings;
+    defaultRouteOptions: RouteOptions;
+    disableVersionCheck?: boolean;
+    userId?: string;
+    integrator: string;
+    widgetVersion?: string;
+    multisig?: MultisigConfig;
+    providers?: BaseProvider[];
+}
+export interface SDKOptions extends Partial<Omit<SDKConfig, 'defaultExecutionSettings' | 'integrator'>> {
+    defaultExecutionSettings?: ExecutionSettings;
+    integrator: string;
+}
+export interface TenderlyResponse {
+    hash: string;
+    block_hash: string;
+    block_number: number;
+    from: string;
+    gas: number;
+    gas_price: number;
+    gas_fee_cap: number;
+    gas_tip_cap: number;
+    cumulative_gas_used: number;
+    gas_used: number;
+    effective_gas_price: number;
+    input: string;
+    nonce: number;
+    to: string;
+    index: number;
+    value: string;
+    access_list: unknown;
+    status: boolean;
+    addresses: string[];
+    contract_ids: string[];
+    network_id: string;
+    timestamp: string;
+    function_selector: string;
+    l1_block_number: number;
+    l1_timestamp: number;
+    deposit_tx: boolean;
+    system_tx: boolean;
+    mint: number;
+    sig: {
+        v: string;
+        r: string;
+        s: string;
+    };
+    error_message: string;
+    method: string;
+    decoded_input: unknown;
+    call_trace: unknown;
+}

package/dist/cjs/types/internal.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,4 +1,4 @@
-import type { LifiStep, Process } from '@lifi/types';
+import type { LiFiStep, Process } from '@lifi/types';
 import { LiFiError } from './errors';
 /**
  * Available MetaMask error codes:
@@ -31,7 +31,7 @@ import { LiFiError } from './errors';
  * https://eips.ethereum.org/EIPS/eip-1474#error-codes
  * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
  */
-export declare const getTransactionNotSentMessage: (step?: LifiStep, process?: Process) => Promise<string>;
-export declare const getTransactionFailedMessage: (step: LifiStep, txLink?: string) => Promise<string>;
-export declare const parseError: (e: any, step?: LifiStep, process?: Process) => Promise<LiFiError>;
+export declare const getTransactionNotSentMessage: (step?: LiFiStep, process?: Process) => Promise<string>;
+export declare const getTransactionFailedMessage: (step: LiFiStep, txLink?: string) => Promise<string>;
+export declare const parseError: (e: any, step?: LiFiStep, process?: Process) => Promise<LiFiError>;
 export declare const parseBackendError: (e: any) => Promise<LiFiError>;

package/dist/cjs/version.d.ts

@@ -1,2 +1,2 @@
 export declare const name = "@lifi/sdk";
-export declare const version = "3.0.0-alpha.4";
+export declare const version = "3.0.0-alpha.7";

package/dist/cjs/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = exports.name = void 0;
 exports.name = '@lifi/sdk';
-exports.version = '3.0.0-alpha.4';
+exports.version = '3.0.0-alpha.7';

package/dist/connectors.d.ts

@@ -1,6 +1,6 @@
+import type { ChainId } from '@lifi/types';
 import type { PublicClient } from 'viem';
 import type { Chain } from 'viem/chains';
-import type { ChainId } from './types';
 export declare const getChainById: (chainId: ChainId) => Chain | undefined;
 export declare const getRpcUrl: (chainId: ChainId) => Promise<string>;
 export declare const getRpcUrls: (chainId: ChainId) => Promise<string[]>;

package/dist/execution/BaseStepExecutor.d.ts

@@ -0,0 +1,12 @@
+import type { LiFiStep } from '@lifi/types';
+import type { StatusManager } from './StatusManager';
+import type { InteractionSettings, InternalExecutionSettings, StepExecutorOptions } from './types';
+export declare abstract class BaseStepExecutor {
+    settings: InternalExecutionSettings;
+    statusManager: StatusManager;
+    allowUserInteraction: boolean;
+    allowExecution: boolean;
+    constructor(options: StepExecutorOptions);
+    setInteraction: (settings?: InteractionSettings) => void;
+    abstract executeStep(step: LiFiStep): Promise<LiFiStep>;
+}

package/dist/execution/BaseStepExecutor.js

@@ -0,0 +1,23 @@
+// Please be careful when changing the defaults as it may break the behavior (e.g., background execution)
+const defaultInteractionSettings = {
+    allowInteraction: true,
+    allowUpdates: true,
+    allowExecution: true,
+};
+export class BaseStepExecutor {
+    constructor(options) {
+        this.allowUserInteraction = true;
+        this.allowExecution = true;
+        this.setInteraction = (settings) => {
+            const interactionSettings = {
+                ...defaultInteractionSettings,
+                ...settings,
+            };
+            this.allowUserInteraction = interactionSettings.allowInteraction;
+            this.statusManager.allowUpdates(interactionSettings.allowUpdates);
+            this.allowExecution = interactionSettings.allowExecution;
+        };
+        this.statusManager = options.statusManager;
+        this.settings = options.settings;
+    }
+}

package/dist/execution/EVMStepExecutor.d.ts

@@ -0,0 +1,13 @@
+import type { LiFiStep } from '@lifi/types';
+import type { WalletClient } from 'viem';
+import { BaseStepExecutor } from './BaseStepExecutor';
+import type { StepExecutorOptions } from './types';
+export interface EVMStepExecutorOptions extends StepExecutorOptions {
+    walletClient: WalletClient;
+}
+export declare class EVMStepExecutor extends BaseStepExecutor {
+    walletClient: WalletClient;
+    constructor(options: EVMStepExecutorOptions);
+    checkChain: () => never;
+    executeStep: (step: LiFiStep) => Promise<LiFiStep>;
+}

package/dist/execution/EVMStepExecutor.js

@@ -0,0 +1,285 @@
+import { publicActions } from 'viem';
+import ApiService from '../services/ApiService';
+import ChainsService from '../services/ChainsService';
+import ConfigService from '../services/ConfigService';
+import { getMaxPriorityFeePerGas } from '../utils';
+import { LiFiErrorCode, TransactionError, ValidationError, } from '../utils/errors';
+import { getTransactionFailedMessage, parseError } from '../utils/parseError';
+import { isZeroAddress } from '../utils/utils';
+import { BaseStepExecutor } from './BaseStepExecutor';
+import { checkAllowance } from './checkAllowance';
+import { checkBalance } from './checkBalance';
+import { updateMultisigRouteProcess } from './multisig';
+import { stepComparison } from './stepComparison';
+import { switchChain } from './switchChain';
+import { getSubstatusMessage } from './utils';
+import { waitForReceivingTransaction } from './waitForReceivingTransaction';
+export class EVMStepExecutor extends BaseStepExecutor {
+    constructor(options) {
+        super(options);
+        // TODO: add checkChain method and update wallet client inside executors
+        // This can come in handy when we execute multiple routes simultaneously and
+        // should be sure that we are on the right chain when waiting for transactions.
+        this.checkChain = () => {
+            throw new Error('checkChain is not implemented.');
+        };
+        this.executeStep = async (step) => {
+            // Make sure that the chain is still correct
+            // Find if it's bridging and the step is waiting for a transaction on the receiving chain
+            const recievingChainProcess = step.execution?.process.find((process) => process.type === 'RECEIVING_CHAIN');
+            // If the step is waiting for a transaction on the receiving chain, we do not switch the chain
+            // All changes are already done from the source chain
+            // Return the step
+            if (recievingChainProcess?.substatus !== 'WAIT_DESTINATION_TRANSACTION' ||
+                !recievingChainProcess) {
+                const updatedWalletClient = await switchChain(this.walletClient, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
+                if (!updatedWalletClient) {
+                    // Chain switch was not successful, stop execution here
+                    return step;
+                }
+                this.walletClient = updatedWalletClient;
+            }
+            const client = this.walletClient.extend(publicActions);
+            const config = ConfigService.getInstance().getConfig();
+            const isMultisigWalletClient = !!config.multisig?.isMultisigWalletClient;
+            const multisigBatchTransactions = [];
+            const shouldBatchTransactions = config.multisig?.shouldBatchTransactions &&
+                !!config.multisig.sendBatchTransaction;
+            step.execution = this.statusManager.initExecutionObject(step);
+            const chainsService = ChainsService.getInstance();
+            const fromChain = await chainsService.getChainById(step.action.fromChainId);
+            const toChain = await chainsService.getChainById(step.action.toChainId);
+            const isBridgeExecution = fromChain.id !== toChain.id;
+            const currentProcessType = isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP';
+            // STEP 1: Check allowance
+            const existingProcess = step.execution.process.find((p) => p.type === currentProcessType);
+            // Check token approval only if fromToken is not the native token => no approval needed in that case
+            const checkForAllowance = !existingProcess?.txHash &&
+                !isZeroAddress(step.action.fromToken.address) &&
+                (shouldBatchTransactions || !isMultisigWalletClient);
+            if (checkForAllowance) {
+                const data = await checkAllowance(client, step, this.statusManager, this.settings, fromChain, this.allowUserInteraction, shouldBatchTransactions);
+                if (data) {
+                    // allowance doesn't need value
+                    const baseTransaction = {
+                        to: step.action.fromToken.address,
+                        data,
+                    };
+                    multisigBatchTransactions.push(baseTransaction);
+                }
+            }
+            // STEP 2: Get transaction
+            let process = this.statusManager.findOrCreateProcess(step, currentProcessType);
+            if (process.status !== 'DONE') {
+                const multisigProcess = step.execution.process.find((p) => !!p.multisigTxHash);
+                try {
+                    if (isMultisigWalletClient && multisigProcess) {
+                        const multisigTxHash = multisigProcess.multisigTxHash;
+                        if (!multisigTxHash) {
+                            throw new ValidationError('Multisig internal transaction hash is undefined.');
+                        }
+                        await updateMultisigRouteProcess(multisigTxHash, step, this.statusManager, process.type, fromChain);
+                    }
+                    let txHash;
+                    if (process.txHash) {
+                        // Make sure that the chain is still correct
+                        const updatedWalletClient = await switchChain(this.walletClient, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
+                        if (!updatedWalletClient) {
+                            // Chain switch was not successful, stop execution here
+                            return step;
+                        }
+                        this.walletClient = updatedWalletClient;
+                        // Load exiting transaction
+                        txHash = process.txHash;
+                    }
+                    else {
+                        process = this.statusManager.updateProcess(step, process.type, 'STARTED');
+                        // Check balance
+                        await checkBalance(client.account.address, step);
+                        // Create new transaction
+                        if (!step.transactionRequest) {
+                            const updatedStep = await ApiService.getStepTransaction(step);
+                            const comparedStep = await stepComparison(this.statusManager, step, updatedStep, this.settings, this.allowUserInteraction);
+                            step = {
+                                ...comparedStep,
+                                execution: step.execution,
+                            };
+                        }
+                        if (!step.transactionRequest) {
+                            throw new TransactionError(LiFiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                        }
+                        // STEP 3: Send the transaction
+                        // Make sure that the chain is still correct
+                        const updatedWalletClient = await switchChain(this.walletClient, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
+                        if (!updatedWalletClient) {
+                            // Chain switch was not successful, stop execution here
+                            return step;
+                        }
+                        this.walletClient = updatedWalletClient;
+                        process = this.statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED');
+                        if (!this.allowUserInteraction) {
+                            return step;
+                        }
+                        let transactionRequest = {
+                            to: step.transactionRequest.to,
+                            from: step.transactionRequest.from,
+                            data: step.transactionRequest.data,
+                            value: step.transactionRequest.value
+                                ? BigInt(step.transactionRequest.value)
+                                : undefined,
+                            gas: step.transactionRequest.gasLimit
+                                ? BigInt(step.transactionRequest.gasLimit)
+                                : undefined,
+                            // gasPrice: step.transactionRequest.gasPrice
+                            //   ? BigInt(step.transactionRequest.gasPrice as string)
+                            //   : undefined,
+                            // maxFeePerGas: step.transactionRequest.maxFeePerGas
+                            //   ? BigInt(step.transactionRequest.maxFeePerGas as string)
+                            //   : undefined,
+                            maxPriorityFeePerGas: this.walletClient.account?.type === 'local'
+                                ? await getMaxPriorityFeePerGas(client)
+                                : step.transactionRequest.maxPriorityFeePerGas
+                                    ? BigInt(step.transactionRequest.maxPriorityFeePerGas)
+                                    : undefined,
+                        };
+                        if (this.settings.updateTransactionRequestHook) {
+                            const customizedTransactionRequest = await this.settings.updateTransactionRequestHook({
+                                requestType: 'transaction',
+                                ...transactionRequest,
+                            });
+                            transactionRequest = {
+                                ...transactionRequest,
+                                ...customizedTransactionRequest,
+                            };
+                        }
+                        if (shouldBatchTransactions &&
+                            config.multisig?.sendBatchTransaction) {
+                            if (transactionRequest.to && transactionRequest.data) {
+                                const populatedTransaction = {
+                                    value: transactionRequest.value,
+                                    to: transactionRequest.to,
+                                    data: transactionRequest.data,
+                                };
+                                multisigBatchTransactions.push(populatedTransaction);
+                                txHash = await config.multisig?.sendBatchTransaction(multisigBatchTransactions);
+                            }
+                            else {
+                                throw new TransactionError(LiFiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                            }
+                        }
+                        else {
+                            txHash = await this.walletClient.sendTransaction({
+                                to: transactionRequest.to,
+                                account: this.walletClient.account,
+                                data: transactionRequest.data,
+                                gas: transactionRequest.gas,
+                                gasPrice: transactionRequest.gasPrice,
+                                maxFeePerGas: transactionRequest.maxFeePerGas,
+                                maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
+                                chain: null,
+                            });
+                        }
+                        // STEP 4: Wait for the transaction
+                        if (isMultisigWalletClient) {
+                            process = this.statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED', {
+                                multisigTxHash: txHash,
+                            });
+                        }
+                        else {
+                            process = this.statusManager.updateProcess(step, process.type, 'PENDING', {
+                                txHash: txHash,
+                                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
+                            });
+                        }
+                    }
+                    let replacementReason;
+                    const transactionReceipt = await client.waitForTransactionReceipt({
+                        hash: txHash,
+                        onReplaced: (response) => {
+                            replacementReason = response.reason;
+                            this.statusManager.updateProcess(step, process.type, 'PENDING', {
+                                txHash: response.transaction.hash,
+                                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${response.transaction.hash}`,
+                            });
+                        },
+                    });
+                    if (replacementReason === 'cancelled') {
+                        throw new TransactionError(LiFiErrorCode.TransactionCanceled, 'User canceled transaction.');
+                    }
+                    // if it's multisig wallet client and the process is in ACTION_REQUIRED
+                    // then signatures are still needed
+                    if (isMultisigWalletClient && process.status === 'ACTION_REQUIRED') {
+                        await updateMultisigRouteProcess(transactionReceipt.transactionHash, step, this.statusManager, process.type, fromChain);
+                    }
+                    if (!isMultisigWalletClient) {
+                        process = this.statusManager.updateProcess(step, process.type, 'PENDING', {
+                            txHash: transactionReceipt.transactionHash,
+                            txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${transactionReceipt.transactionHash}`,
+                        });
+                    }
+                    if (isBridgeExecution) {
+                        process = this.statusManager.updateProcess(step, process.type, 'DONE');
+                    }
+                }
+                catch (e) {
+                    const error = await parseError(e, step, process);
+                    process = this.statusManager.updateProcess(step, process.type, 'FAILED', {
+                        error: {
+                            message: error.message,
+                            htmlMessage: error.htmlMessage,
+                            code: error.code,
+                        },
+                    });
+                    this.statusManager.updateExecution(step, 'FAILED');
+                    throw error;
+                }
+            }
+            // STEP 5: Wait for the receiving chain
+            const processTxHash = process.txHash;
+            if (isBridgeExecution) {
+                process = this.statusManager.findOrCreateProcess(step, 'RECEIVING_CHAIN', 'PENDING');
+            }
+            let statusResponse;
+            try {
+                if (!processTxHash) {
+                    throw new Error('Transaction hash is undefined.');
+                }
+                statusResponse = (await waitForReceivingTransaction(processTxHash, this.statusManager, process.type, step));
+                const statusReceiving = statusResponse.receiving;
+                process = this.statusManager.updateProcess(step, process.type, 'DONE', {
+                    substatus: statusResponse.substatus,
+                    substatusMessage: statusResponse.substatusMessage ||
+                        getSubstatusMessage(statusResponse.status, statusResponse.substatus),
+                    txHash: statusReceiving?.txHash,
+                    txLink: `${toChain.metamask.blockExplorerUrls[0]}tx/${statusReceiving?.txHash}`,
+                });
+                this.statusManager.updateExecution(step, 'DONE', {
+                    fromAmount: statusResponse.sending.amount,
+                    toAmount: statusReceiving?.amount,
+                    toToken: statusReceiving?.token,
+                    gasAmount: statusResponse.sending.gasAmount,
+                    gasAmountUSD: statusResponse.sending.gasAmountUSD,
+                    gasPrice: statusResponse.sending.gasPrice,
+                    gasToken: statusResponse.sending.gasToken,
+                    gasUsed: statusResponse.sending.gasUsed,
+                });
+            }
+            catch (e) {
+                const htmlMessage = await getTransactionFailedMessage(step, process.txLink);
+                process = this.statusManager.updateProcess(step, process.type, 'FAILED', {
+                    error: {
+                        code: LiFiErrorCode.TransactionFailed,
+                        message: 'Failed while waiting for receiving chain.',
+                        htmlMessage,
+                    },
+                });
+                this.statusManager.updateExecution(step, 'FAILED');
+                console.warn(e);
+                throw e;
+            }
+            // DONE
+            return step;
+        };
+        this.walletClient = options.walletClient;
+    }
+}

package/dist/execution/RouteExecutionManager.d.ts

@@ -1,30 +1,29 @@
 import type { Route } from '@lifi/types';
-import type { WalletClient } from 'viem';
 import ConfigService from '../services/ConfigService';
-import type { ConfigUpdate, ExecutionSettings } from '../types';
+import type { SDKOptions } from '../types';
+import type { ExecutionSettings } from './types';
 export declare class RouteExecutionManager {
     private executionDictionary;
     private executionPromiseDictionary;
     protected configService: ConfigService;
-    constructor(configUpdate: ConfigUpdate);
+    private providers;
+    constructor(options: SDKOptions);
     /**
      * Execute a route.
-     * @param walletClient - The walletClient required to send the transactions.
      * @param route - The route that should be executed. Cannot be an active route.
      * @param settings - An object containing settings and callbacks.
      * @returns The executed route.
      * @throws {LiFiError} Throws a LiFiError if the execution fails.
      */
-    executeRoute: (walletClient: WalletClient, route: Route, settings?: ExecutionSettings) => Promise<Route>;
+    executeRoute: (route: Route, settings?: ExecutionSettings) => Promise<Route>;
     /**
      * Resume the execution of a route that has been stopped or had an error while executing.
-     * @param walletClient - The walletClient required to send the transactions.
      * @param route - The route that is to be executed. Cannot be an active route.
      * @param settings - An object containing settings and callbacks.
      * @returns The executed route.
      * @throws {LiFiError} Throws a LiFiError if the execution fails.
      */
-    resumeRoute: (walletClient: WalletClient, route: Route, settings?: ExecutionSettings) => Promise<Route>;
+    resumeRoute: (route: Route, settings?: ExecutionSettings) => Promise<Route>;
     private executeSteps;
     /**
      * Updates route execution to background or foreground state.