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

package/dist/cjs/utils/parseError.js

@@ -1,154 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseBackendError = exports.parseError = exports.getTransactionFailedMessage = exports.getTransactionNotSentMessage = void 0;
-const eth_rpc_errors_1 = require("eth-rpc-errors");
-const viem_1 = require("viem");
-const helpers_1 = require("../helpers");
-const ChainsService_1 = require("../services/ChainsService");
-const errors_1 = require("./errors");
-/**
- * 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
- */
-const getTransactionNotSentMessage = async (step, process) => {
-    let transactionNotSend = 'Transaction was not sent, your funds are still in your wallet';
-    // add information about funds if available
-    if (step) {
-        const chainService = ChainsService_1.ChainsService.getInstance();
-        const chain = await chainService.getChainById(step.action.fromChainId);
-        transactionNotSend += ` (${(0, viem_1.formatUnits)(BigInt(step.action.fromAmount), step.action.fromToken.decimals)} ${step.action.fromToken.symbol} on ${chain.name})`;
-    }
-    transactionNotSend +=
-        ", please retry.<br/>If it still doesn't work, it is safe to delete this transfer and start a new one.";
-    // add transaction explorer link if available
-    transactionNotSend +=
-        process && process.txLink
-            ? `<br>You can check the failed transaction&nbsp;<a href="${process.txLink}" target="_blank" rel="nofollow noreferrer">here</a>.`
-            : '';
-    return transactionNotSend;
-};
-exports.getTransactionNotSentMessage = getTransactionNotSentMessage;
-const getTransactionFailedMessage = async (step, txLink) => {
-    const chainsService = ChainsService_1.ChainsService.getInstance();
-    const chain = await chainsService.getChainById(step.action.toChainId);
-    const baseString = `It appears that your transaction may not have been successful.
-  However, to confirm this, please check your ${chain.name} wallet for ${step.action.toToken.symbol}.`;
-    return txLink
-        ? `${baseString}
-    You can also check the&nbsp;<a href="${txLink}" target="_blank" rel="nofollow noreferrer">block explorer</a> for more information.`
-        : baseString;
-};
-exports.getTransactionFailedMessage = getTransactionFailedMessage;
-const parseError = async (e, step, process) => {
-    if (e instanceof errors_1.LiFiError) {
-        return e;
-    }
-    const errorCode = e.code || e.cause?.code;
-    switch (errorCode) {
-        case errors_1.EthersErrorType.CallExecption:
-            const defaultErrorMessage = await (0, exports.getTransactionNotSentMessage)(step, process);
-            try {
-                if (!step?.action.fromChainId) {
-                    throw new Error('fromChainId is not defined.');
-                }
-                const response = await (0, helpers_1.fetchTxErrorDetails)(e.transactionHash, step?.action.fromChainId);
-                const errorMessage = response?.error_message ?? e.reason;
-                const isAllowanceError = response?.error_message?.includes(errors_1.EthersErrorMessage.ERC20Allowance) || e.reason?.includes(errors_1.EthersErrorMessage.ERC20Allowance);
-                if (isAllowanceError) {
-                    return new errors_1.TransactionError(errors_1.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 errors_1.ProviderError(errors_1.LiFiErrorCode.TransactionFailed, e.reason, defaultErrorMessage, e.stack);
-            }
-        case errors_1.EthersErrorType.InsufficientFunds:
-            return new errors_1.TransactionError(errors_1.LiFiErrorCode.InsufficientFunds, e.message, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-        case errors_1.EthersErrorType.ActionRejected:
-        case errors_1.MetaMaskProviderErrorCode.userRejectedRequest:
-            return new errors_1.TransactionError(errors_1.LiFiErrorCode.SignatureRejected, e.message, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-        case errors_1.LiFiErrorCode.TransactionUnprepared:
-            return new errors_1.TransactionError(errors_1.LiFiErrorCode.TransactionUnprepared, e.message, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-        case errors_1.LiFiErrorCode.ValidationError:
-            return new errors_1.TransactionError(errors_1.LiFiErrorCode.ValidationError, e.message, e.htmlMessage);
-        case errors_1.LiFiErrorCode.TransactionCanceled:
-            return new errors_1.TransactionError(errors_1.LiFiErrorCode.TransactionCanceled, e.message, e.htmlMessage);
-        case errors_1.LiFiErrorCode.ExchangeRateUpdateCanceled:
-            return new errors_1.TransactionError(errors_1.LiFiErrorCode.ExchangeRateUpdateCanceled, e.message, e.htmlMessage);
-        default: {
-            if (errorCode && typeof errorCode === 'number') {
-                if (Object.values(eth_rpc_errors_1.errorCodes.rpc).includes(errorCode)) {
-                    // rpc errors
-                    // underpriced errors are sent as internal errors, so we need to parse the message manually
-                    if (errorCode === eth_rpc_errors_1.errorCodes.rpc.internal &&
-                        (e.message?.includes(errors_1.EthersErrorMessage.Underpriced) ||
-                            e.message?.includes(errors_1.EthersErrorMessage.LowReplacementFee))) {
-                        return new errors_1.RPCError(errors_1.LiFiErrorCode.TransactionUnderpriced, errors_1.ErrorMessage.TransactionUnderpriced, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-                    }
-                    if (e.message?.includes(errors_1.EthersErrorMessage.LowGas) ||
-                        e.message?.includes(errors_1.EthersErrorMessage.OutOfGas)) {
-                        return new errors_1.TransactionError(errors_1.LiFiErrorCode.GasLimitError, errors_1.ErrorMessage.GasLimitLow, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-                    }
-                    return new errors_1.RPCError(errorCode, (0, eth_rpc_errors_1.getMessageFromCode)(errorCode), await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-                }
-                // provider errors
-                if (Object.values(eth_rpc_errors_1.errorCodes.provider).includes(errorCode)) {
-                    return new errors_1.ProviderError(errorCode, (0, eth_rpc_errors_1.getMessageFromCode)(errorCode), await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
-                }
-            }
-            return new errors_1.UnknownError(errors_1.LiFiErrorCode.InternalError, e.message || errors_1.ErrorMessage.UnknownError, undefined, e.stack);
-        }
-    }
-};
-exports.parseError = parseError;
-const parseBackendError = async (e) => {
-    let data;
-    try {
-        data = await e.response?.json();
-    }
-    catch (error) {
-        // ignore
-    }
-    if (e.response?.status === 400) {
-        return new errors_1.ValidationError(data?.message || e.response?.statusText, undefined, e.stack);
-    }
-    if (e.response?.status === 404) {
-        return new errors_1.NotFoundError(data?.message || e.response?.statusText, undefined, e.stack);
-    }
-    if (e.response?.status === 409) {
-        return new errors_1.SlippageError(data?.message || e.response?.statusText, errors_1.ErrorMessage.SlippageError, e.stack);
-    }
-    if (e.response?.status === 500) {
-        return new errors_1.ServerError(data?.message || e.response?.statusText, undefined, e.stack);
-    }
-    return new errors_1.ServerError(errors_1.ErrorMessage.Default, undefined, e.stack);
-};
-exports.parseBackendError = parseBackendError;

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

@@ -1,10 +0,0 @@
-export declare const wait: (ms: number) => Promise<undefined>;
-/**
- * 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 declare const repeatUntilDone: <T>(toRepeat: () => Promise<T | undefined>, timeout?: number) => Promise<T>;
-export declare const isZeroAddress: (address: string) => boolean;
-export declare const isNativeTokenAddress: (address: string) => boolean;

package/dist/cjs/version.d.ts

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

package/dist/connectors.d.ts

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

package/dist/connectors.js

@@ -1,41 +0,0 @@
-import { createPublicClient, fallback, http } from 'viem';
-import * as chains from 'viem/chains'; // TODO: optimize using BE chains
-import { ConfigService } from './services/ConfigService';
-import { ServerError } from './utils/errors';
-// cached providers
-const publicClients = {};
-export const getChainById = (chainId) => {
-    return Object.values(chains).find((chain) => chain.id === chainId);
-};
-// RPC Urls
-export const getRpcUrl = async (chainId) => {
-    const rpcUrls = await getRpcUrls(chainId);
-    return rpcUrls[0];
-};
-export const getRpcUrls = async (chainId) => {
-    const configService = ConfigService.getInstance();
-    const config = await configService.getConfigAsync();
-    return config.rpcs[chainId];
-};
-export const getPublicClient = async (chainId) => {
-    if (!publicClients[chainId]) {
-        const urls = await getRpcUrls(chainId);
-        const fallbackTransports = urls.map((url) => http(url, {
-            batch: true,
-        }));
-        publicClients[chainId] = createPublicClient({
-            chain: getChainById(chainId),
-            transport: fallback(fallbackTransports),
-        });
-    }
-    if (!publicClients[chainId]) {
-        throw new ServerError(`Unable to configure provider for chain ${chainId}`);
-    }
-    return publicClients[chainId];
-};
-// Multicall
-export const getMulticallAddress = async (chainId) => {
-    const configService = ConfigService.getInstance();
-    const config = await configService.getConfigAsync();
-    return config.multicallAddresses[chainId];
-};

package/dist/constants.d.ts

@@ -1,6 +0,0 @@
-export declare const AddressZero = "0x0000000000000000000000000000000000000000";
-export declare const AlternativeAddressZero = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
-/**
- * Cronos require bigger multicall chunks than default 1024 (1 KB)
- */
-export declare const MulticallBatchSize = 16384;

package/dist/execution/BaseStepExecutor.d.ts

@@ -1,12 +0,0 @@
-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

@@ -1,23 +0,0 @@
-// 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

@@ -1,13 +0,0 @@
-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

@@ -1,285 +0,0 @@
-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,60 +0,0 @@
-import type { Route } from '@lifi/types';
-import type { ProviderType, SDKProvider } from '../providers';
-import { ConfigService } from '../services/ConfigService';
-import type { SDKOptions } from '../types';
-import type { ExecutionSettings } from './types';
-export declare class RouteExecutionManager {
-    private executionDictionary;
-    private executionPromiseDictionary;
-    protected configService: ConfigService;
-    private providers?;
-    constructor(options: SDKOptions);
-    /**
-     * Execute a route.
-     * @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: (route: Route, settings?: ExecutionSettings) => Promise<Route>;
-    /**
-     * Resume the execution of a route that has been stopped or had an error while executing.
-     * @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: (route: Route, settings?: ExecutionSettings) => Promise<Route>;
-    private executeSteps;
-    /**
-     * Updates route execution to background or foreground state.
-     * @param route - A route that is currently in execution.
-     * @param settings - An object with execution settings.
-     */
-    updateRouteExecution: (route: Route, settings: Pick<ExecutionSettings, 'executeInBackground'>) => void;
-    /**
-     * Update the ExecutionSettings for an active route.
-     * @param settings - An object with execution settings.
-     * @param route - The active route that gets the new execution settings.
-     * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
-     */
-    updateExecutionSettings: (settings: ExecutionSettings, route: Route) => void;
-    /**
-     * Stops the execution of an active route.
-     * @param route - A route that is currently in execution.
-     * @returns The stopped route.
-     */
-    stopExecution: (route: Route) => Route;
-    /**
-     * Get the list of active routes.
-     * @returns A list of routes.
-     */
-    getActiveRoutes: () => Route[];
-    /**
-     * Return the current route information for given route. The route has to be active.
-     * @param route - A route object.
-     * @returns The updated route.
-     */
-    getActiveRoute: (route: Route) => Route | undefined;
-    getProvider: (type: ProviderType) => SDKProvider | undefined;
-}