@lifi/sdk 1.6.3 → 1.7.0

package/dist/cjs/execution/utils.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updatedStepMeetsSlippageConditions = exports.getSubstatusMessage = exports.getProcessMessage = exports.waitForReceivingTransaction = void 0;
+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");
@@ -76,20 +76,20 @@ const processMessages = {
         DONE: 'Chain switched successfully.',
     },
     SWAP: {
-        STARTED: 'Preparing swap.',
+        STARTED: 'Preparing swap transaction.',
         ACTION_REQUIRED: 'Please sign the transaction.',
-        PENDING: 'Swapping.',
+        PENDING: 'Waiting for swap transaction.',
         DONE: 'Swap completed.',
     },
     CROSS_CHAIN: {
-        STARTED: 'Preparing transaction.',
+        STARTED: 'Preparing bridge transaction.',
         ACTION_REQUIRED: 'Please sign the transaction.',
-        PENDING: 'Waiting for transaction.',
-        DONE: 'Transaction approved.',
+        PENDING: 'Waiting for bridge transaction.',
+        DONE: 'Bridge transaction confirmed.',
     },
     RECEIVING_CHAIN: {
-        PENDING: 'Waiting for receiving chain.',
-        DONE: 'Funds received.',
+        PENDING: 'Waiting for destination chain.',
+        DONE: 'Bridge completed.',
     },
     TRANSACTION: {},
 };
@@ -124,7 +124,8 @@ function getSubstatusMessage(status, substatus) {
     return message;
 }
 exports.getSubstatusMessage = getSubstatusMessage;
-function updatedStepMeetsSlippageConditions(oldStep, newStep) {
+// Used to check if changed exchange rate is in the range of slippage threshold
+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);
@@ -133,4 +134,4 @@ function updatedStepMeetsSlippageConditions(oldStep, newStep) {
     return (newEstimatedToAmount.gte(oldEstimatedToAmount) &&
         actualSlippage.lte(setSlippage));
 }
-exports.updatedStepMeetsSlippageConditions = updatedStepMeetsSlippageConditions;
+exports.checkStepSlippageThreshold = checkStepSlippageThreshold;

package/dist/cjs/services/ConfigService.js

@@ -15,6 +15,7 @@ const DefaultExecutionSettings = {
     updateCallback: () => { },
     switchChainHook: () => Promise.resolve(undefined),
     acceptSlippageUpdateHook: () => Promise.resolve(undefined),
+    acceptExchangeRateUpdateHook: () => Promise.resolve(undefined),
     infiniteApproval: false,
     executeInBackground: false,
 };

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

@@ -8,7 +8,7 @@ export interface TokenWithAmounts extends Token {
     amount?: BigNumber;
     amountRendered?: string;
 }
-export declare type ParsedReceipt = {
+export type ParsedReceipt = {
     fromAmount?: string;
     toAmount: string;
     gasUsed: string;
@@ -16,20 +16,14 @@ export declare type ParsedReceipt = {
     gasFee: string;
     toTokenAddress?: string;
 };
-interface ExecutionParams {
+export interface ExecutionParams {
     signer: Signer;
     step: Step;
     statusManager: StatusManager;
     settings: InternalExecutionSettings;
 }
-export interface ExecuteSwapParams extends ExecutionParams {
-    step: Step;
-}
-export interface ExecuteCrossParams extends ExecutionParams {
-    step: Step;
-}
-export declare type CallbackFunction = (updatedRoute: Route) => void;
-export declare type Config = {
+export type CallbackFunction = (updatedRoute: Route) => void;
+export type Config = {
     apiUrl: string;
     rpcs: Record<ChainId, string[]>;
     multicallAddresses: Record<ChainId, string | undefined>;
@@ -37,7 +31,7 @@ export declare type Config = {
     defaultRouteOptions: RouteOptions;
     disableVersionCheck?: boolean;
 };
-export declare type ConfigUpdate = {
+export type ConfigUpdate = {
     apiUrl?: string;
     rpcs?: Record<number, string[]>;
     multicallAddresses?: Record<number, string | undefined>;
@@ -45,7 +39,7 @@ export declare type ConfigUpdate = {
     defaultRouteOptions?: RouteOptions;
     disableVersionCheck?: boolean;
 };
-export declare type SwitchChainHook = (requiredChainId: number) => Promise<Signer | undefined>;
+export type SwitchChainHook = (requiredChainId: number) => Promise<Signer | undefined>;
 export interface AcceptSlippageUpdateHookParams {
     toToken: Token;
     oldToAmount: string;
@@ -53,33 +47,34 @@ export interface AcceptSlippageUpdateHookParams {
     oldSlippage: number;
     newSlippage: number;
 }
-export declare type AcceptSlippageUpdateHook = (params: AcceptSlippageUpdateHookParams) => Promise<boolean | undefined>;
+export type AcceptSlippageUpdateHook = (params: AcceptSlippageUpdateHookParams) => Promise<boolean | undefined>;
+export interface ExchangeRateUpdateParams {
+    toToken: Token;
+    oldToAmount: string;
+    newToAmount: string;
+}
+export type AcceptExchangeRateUpdateHook = (params: ExchangeRateUpdateParams) => Promise<boolean | undefined>;
 export interface ExecutionData {
     route: Route;
     executors: StepExecutor[];
     settings: InternalExecutionSettings;
 }
-export interface ExecutionSettings {
-    updateCallback?: CallbackFunction;
-    switchChainHook?: SwitchChainHook;
-    acceptSlippageUpdateHook?: AcceptSlippageUpdateHook;
-    infiniteApproval?: boolean;
-    executeInBackground?: boolean;
-}
-export interface InternalExecutionSettings extends ExecutionSettings {
+export type ExecutionSettings = Partial<InternalExecutionSettings>;
+export interface InternalExecutionSettings {
     updateCallback: CallbackFunction;
     switchChainHook: SwitchChainHook;
     acceptSlippageUpdateHook: AcceptSlippageUpdateHook;
+    acceptExchangeRateUpdateHook: AcceptExchangeRateUpdateHook;
     infiniteApproval: boolean;
     executeInBackground: boolean;
 }
-export declare type EnforcedObjectProperties<T> = T & {
+export type EnforcedObjectProperties<T> = T & {
     [P in keyof T]-?: T[P];
 };
 export interface ActiveRouteDictionary {
     [k: string]: ExecutionData;
 }
-export declare type RevokeTokenData = {
+export type RevokeTokenData = {
     token: Token;
     approvalAddress: string;
 };
@@ -88,4 +83,3 @@ export interface InteractionSettings {
     allowUpdates?: boolean;
     stopExecution?: boolean;
 }
-export {};

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

@@ -19,9 +19,10 @@ export declare enum LifiErrorCode {
     ChainSwitchError = 1007,
     TransactionUnprepared = 1008,
     GasLimitError = 1009,
-    SlippageNotMet = 1010,
+    TransactionCanceled = 1010,
     SlippageError = 1011,
-    TransactionRejected = 1012
+    TransactionRejected = 1012,
+    BalanceError = 1013
 }
 export declare enum MetaMaskRPCErrorCode {
     invalidInput = -32000,
@@ -43,7 +44,7 @@ export declare enum MetaMaskProviderErrorCode {
     disconnected = 4900,
     chainDisconnected = 4901
 }
-export declare type ErrorCode = LifiErrorCode | MetaMaskRPCErrorCode | MetaMaskProviderErrorCode;
+export type ErrorCode = LifiErrorCode | MetaMaskRPCErrorCode | MetaMaskProviderErrorCode;
 export declare class LifiError extends Error {
     code: ErrorCode;
     htmlMessage?: string;
@@ -67,6 +68,9 @@ export declare class TransactionError extends LifiError {
 export declare class SlippageError extends LifiError {
     constructor(message: string, htmlMessage?: string, stack?: string);
 }
+export declare class BalanceError extends LifiError {
+    constructor(message: string, htmlMessage?: string, stack?: string);
+}
 export declare class NotFoundError extends LifiError {
     constructor(message: string, htmlMessage?: string, stack?: string);
 }

package/dist/cjs/utils/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnknownError = exports.NotFoundError = exports.SlippageError = exports.TransactionError = exports.ValidationError = exports.ServerError = exports.ProviderError = exports.RPCError = exports.LifiError = exports.MetaMaskProviderErrorCode = exports.MetaMaskRPCErrorCode = exports.LifiErrorCode = void 0;
+exports.UnknownError = exports.NotFoundError = exports.BalanceError = exports.SlippageError = exports.TransactionError = exports.ValidationError = exports.ServerError = exports.ProviderError = exports.RPCError = exports.LifiError = exports.MetaMaskProviderErrorCode = exports.MetaMaskRPCErrorCode = exports.LifiErrorCode = void 0;
 var ErrorType;
 (function (ErrorType) {
     ErrorType["RPCError"] = "RPCError";
@@ -24,9 +24,10 @@ var LifiErrorCode;
     LifiErrorCode[LifiErrorCode["ChainSwitchError"] = 1007] = "ChainSwitchError";
     LifiErrorCode[LifiErrorCode["TransactionUnprepared"] = 1008] = "TransactionUnprepared";
     LifiErrorCode[LifiErrorCode["GasLimitError"] = 1009] = "GasLimitError";
-    LifiErrorCode[LifiErrorCode["SlippageNotMet"] = 1010] = "SlippageNotMet";
+    LifiErrorCode[LifiErrorCode["TransactionCanceled"] = 1010] = "TransactionCanceled";
     LifiErrorCode[LifiErrorCode["SlippageError"] = 1011] = "SlippageError";
     LifiErrorCode[LifiErrorCode["TransactionRejected"] = 1012] = "TransactionRejected";
+    LifiErrorCode[LifiErrorCode["BalanceError"] = 1013] = "BalanceError";
 })(LifiErrorCode = exports.LifiErrorCode || (exports.LifiErrorCode = {}));
 var MetaMaskRPCErrorCode;
 (function (MetaMaskRPCErrorCode) {
@@ -102,6 +103,12 @@ class SlippageError extends LifiError {
     }
 }
 exports.SlippageError = SlippageError;
+class BalanceError extends LifiError {
+    constructor(message, htmlMessage, stack) {
+        super(ErrorType.ValidationError, LifiErrorCode.BalanceError, message, htmlMessage, stack);
+    }
+}
+exports.BalanceError = BalanceError;
 class NotFoundError extends LifiError {
     constructor(message, htmlMessage, stack) {
         super(ErrorType.NotFoundError, LifiErrorCode.NotFound, message, htmlMessage, stack);

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

@@ -1,5 +1,5 @@
 import { Fragment, JsonFragment } from '@ethersproject/abi';
-export declare type MultiCallData = {
+export type MultiCallData = {
     address: string;
     name: string;
     params?: any[];

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

@@ -35,4 +35,3 @@ export declare const getTransactionNotSentMessage: (step?: Step, process?: Proce
 export declare const getTransactionFailedMessage: (step: Step, txLink?: string) => string;
 export declare const parseError: (e: any, step?: Step, process?: Process) => Promise<LifiError>;
 export declare const parseBackendError: (e: any) => LifiError;
-export declare const getSlippageNotMetMessage: (step: Step) => string;

package/dist/cjs/utils/parseError.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSlippageNotMetMessage = exports.parseBackendError = exports.parseError = exports.getTransactionFailedMessage = exports.getTransactionNotSentMessage = void 0;
+exports.parseBackendError = exports.parseError = exports.getTransactionFailedMessage = exports.getTransactionNotSentMessage = void 0;
 const types_1 = require("@lifi/types");
 const eth_rpc_errors_1 = require("eth-rpc-errors");
 const ChainsService_1 = __importDefault(require("../services/ChainsService"));
@@ -135,9 +135,3 @@ const parseBackendError = (e) => {
     return new errors_1.ServerError('Something went wrong.', undefined, e.stack);
 };
 exports.parseBackendError = parseBackendError;
-const getSlippageNotMetMessage = (step) => {
-    const { slippage } = step.action;
-    return `Transaction was not sent, your funds are still in your wallet.
-  The updated quote for the current transaction does not meet your set slippage of ${slippage * 100}%.`;
-};
-exports.getSlippageNotMetMessage = getSlippageNotMetMessage;

package/dist/cjs/version.d.ts

@@ -1,2 +1,2 @@
 export declare const name = "@lifi/sdk";
-export declare const version = "1.6.3";
+export declare const version = "1.7.0";

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 = '1.6.3';
+exports.version = '1.7.0';

package/dist/execution/{exchanges/swap.execute.d.ts → ExecutionManager.d.ts}

@@ -1,7 +1,7 @@
 import { Execution } from '@lifi/types';
-import { ExecuteSwapParams } from '../../types';
-export declare class SwapExecutionManager {
+import { ExecutionParams } from '../types';
+export declare class ExecutionManager {
     allowUserInteraction: boolean;
     allowInteraction: (value: boolean) => void;
-    execute: ({ signer, step, statusManager, settings, }: ExecuteSwapParams) => Promise<Execution>;
+    execute: ({ signer, step, statusManager, settings, }: ExecutionParams) => Promise<Execution>;
 }

package/dist/execution/{bridges/bridge.execute.js → ExecutionManager.js}

@@ -7,18 +7,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import ApiService from '../../services/ApiService';
-import ChainsService from '../../services/ChainsService';
-import { LifiErrorCode, TransactionError } from '../../utils/errors';
-import { getProvider } from '../../utils/getProvider';
-import { getTransactionFailedMessage, parseError } from '../../utils/parseError';
-import { isZeroAddress, personalizeStep } from '../../utils/utils';
-import { checkAllowance } from '../allowance.execute';
-import { balanceCheck } from '../balanceCheck.execute';
-import { stepComparison } from '../stepComparison';
-import { switchChain } from '../switchChain';
-import { getSubstatusMessage, waitForReceivingTransaction } from '../utils';
-export class BridgeExecutionManager {
+import { checkAllowance } from '../allowance';
+import { checkBalance } from '../balance';
+import ApiService from '../services/ApiService';
+import ChainsService from '../services/ChainsService';
+import { LifiErrorCode, TransactionError } from '../utils/errors';
+import { getProvider } from '../utils/getProvider';
+import { getTransactionFailedMessage, parseError } from '../utils/parseError';
+import { isZeroAddress, personalizeStep } from '../utils/utils';
+import { stepComparison } from './stepComparison';
+import { switchChain } from './switchChain';
+import { getSubstatusMessage, waitForReceivingTransaction } from './utils';
+export class ExecutionManager {
     constructor() {
         this.allowUserInteraction = true;
         this.allowInteraction = (value) => {
@@ -30,19 +30,21 @@ export class BridgeExecutionManager {
             const chainsService = ChainsService.getInstance();
             const fromChain = yield chainsService.getChainById(step.action.fromChainId);
             const toChain = yield chainsService.getChainById(step.action.toChainId);
+            const isBridgeExecution = fromChain.id !== toChain.id;
+            const currentProcessType = isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP';
             // STEP 1: Check allowance
-            const oldCrossProcess = step.execution.process.find((p) => p.type === 'CROSS_CHAIN');
+            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
-            if (!(oldCrossProcess === null || oldCrossProcess === void 0 ? void 0 : oldCrossProcess.txHash) &&
+            if (!(existingProcess === null || existingProcess === void 0 ? void 0 : existingProcess.txHash) &&
                 !isZeroAddress(step.action.fromToken.address)) {
                 yield checkAllowance(signer, step, statusManager, settings, fromChain, this.allowUserInteraction);
             }
             // STEP 2: Get transaction
-            let crossChainProcess = statusManager.findOrCreateProcess(step, 'CROSS_CHAIN');
-            if (crossChainProcess.status !== 'DONE') {
+            let process = statusManager.findOrCreateProcess(step, currentProcessType);
+            if (process.status !== 'DONE') {
                 try {
                     let transaction;
-                    if (crossChainProcess.txHash) {
+                    if (process.txHash) {
                         // Make sure that the chain is still correct
                         const updatedSigner = yield switchChain(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
                         if (!updatedSigner) {
@@ -51,17 +53,18 @@ export class BridgeExecutionManager {
                         }
                         signer = updatedSigner;
                         // Load exiting transaction
-                        transaction = yield getProvider(signer).getTransaction(crossChainProcess.txHash);
+                        transaction = yield getProvider(signer).getTransaction(process.txHash);
                     }
                     else {
-                        crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'STARTED');
+                        process = statusManager.updateProcess(step, process.type, 'STARTED');
                         // Check balance
-                        yield balanceCheck(signer, step);
+                        yield checkBalance(signer, step);
                         // Create new transaction
                         if (!step.transactionRequest) {
                             const personalizedStep = yield personalizeStep(signer, step);
                             const updatedStep = yield ApiService.getStepTransaction(personalizedStep);
-                            step = Object.assign(Object.assign({}, (yield stepComparison(statusManager, personalizedStep, updatedStep, settings.acceptSlippageUpdateHook, this.allowUserInteraction))), { execution: step.execution });
+                            const comparedStep = yield stepComparison(statusManager, personalizedStep, updatedStep, settings, this.allowUserInteraction);
+                            step = Object.assign(Object.assign({}, comparedStep), { execution: step.execution });
                         }
                         const { transactionRequest } = step;
                         if (!transactionRequest) {
@@ -75,14 +78,14 @@ export class BridgeExecutionManager {
                             return step.execution;
                         }
                         signer = updatedSigner;
-                        crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'ACTION_REQUIRED');
+                        process = statusManager.updateProcess(step, process.type, 'ACTION_REQUIRED');
                         if (!this.allowUserInteraction) {
                             return step.execution;
                         }
                         // Submit the transaction
                         transaction = yield signer.sendTransaction(transactionRequest);
                         // STEP 4: Wait for the transaction
-                        crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'PENDING', {
+                        process = statusManager.updateProcess(step, process.type, 'PENDING', {
                             txHash: transaction.hash,
                             txLink: fromChain.metamask.blockExplorerUrls[0] +
                                 'tx/' +
@@ -90,11 +93,17 @@ export class BridgeExecutionManager {
                         });
                     }
                     yield transaction.wait();
-                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'DONE');
+                    process = statusManager.updateProcess(step, process.type, 'PENDING', {
+                        txHash: transaction.hash,
+                        txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + transaction.hash,
+                    });
+                    if (isBridgeExecution) {
+                        process = statusManager.updateProcess(step, process.type, 'DONE');
+                    }
                 }
                 catch (e) {
                     if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
-                        crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'DONE', {
+                        process = statusManager.updateProcess(step, process.type, 'DONE', {
                             txHash: e.replacement.hash,
                             txLink: fromChain.metamask.blockExplorerUrls[0] +
                                 'tx/' +
@@ -102,8 +111,8 @@ export class BridgeExecutionManager {
                         });
                     }
                     else {
-                        const error = yield parseError(e, step, crossChainProcess);
-                        crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'FAILED', {
+                        const error = yield parseError(e, step, process);
+                        process = statusManager.updateProcess(step, process.type, 'FAILED', {
                             error: {
                                 message: error.message,
                                 htmlMessage: error.htmlMessage,
@@ -116,14 +125,17 @@ export class BridgeExecutionManager {
                 }
             }
             // STEP 5: Wait for the receiving chain
-            let receivingChainProcess = statusManager.findOrCreateProcess(step, 'RECEIVING_CHAIN', 'PENDING');
+            const processTxHash = process.txHash;
+            if (isBridgeExecution) {
+                process = statusManager.findOrCreateProcess(step, 'RECEIVING_CHAIN', 'PENDING');
+            }
             let statusResponse;
             try {
-                if (!crossChainProcess.txHash) {
+                if (!processTxHash) {
                     throw new Error('Transaction hash is undefined.');
                 }
-                statusResponse = yield waitForReceivingTransaction(crossChainProcess.txHash, statusManager, receivingChainProcess.type, step);
-                receivingChainProcess = statusManager.updateProcess(step, receivingChainProcess.type, 'DONE', {
+                statusResponse = yield waitForReceivingTransaction(processTxHash, statusManager, process.type, step);
+                process = statusManager.updateProcess(step, process.type, 'DONE', {
                     substatus: statusResponse.substatus,
                     substatusMessage: statusResponse.substatusMessage ||
                         getSubstatusMessage(statusResponse.status, statusResponse.substatus),
@@ -136,16 +148,19 @@ export class BridgeExecutionManager {
                     fromAmount: statusResponse.sending.amount,
                     toAmount: (_c = statusResponse.receiving) === null || _c === void 0 ? void 0 : _c.amount,
                     toToken: (_d = statusResponse.receiving) === null || _d === void 0 ? void 0 : _d.token,
-                    gasUsed: statusResponse.sending.gasUsed,
+                    gasAmount: statusResponse.sending.gasAmount,
+                    gasAmountUSD: statusResponse.sending.gasAmountUSD,
                     gasPrice: statusResponse.sending.gasPrice,
+                    gasToken: statusResponse.sending.gasToken,
+                    gasUsed: statusResponse.sending.gasUsed,
                 });
             }
             catch (e) {
-                receivingChainProcess = statusManager.updateProcess(step, receivingChainProcess.type, 'FAILED', {
+                process = statusManager.updateProcess(step, process.type, 'FAILED', {
                     error: {
                         code: LifiErrorCode.TransactionFailed,
                         message: 'Failed while waiting for receiving chain.',
-                        htmlMessage: getTransactionFailedMessage(step, crossChainProcess.txLink),
+                        htmlMessage: getTransactionFailedMessage(step, process.txLink),
                     },
                 });
                 statusManager.updateExecution(step, 'FAILED');

package/dist/execution/StatusManager.d.ts

@@ -3,11 +3,14 @@ interface Receipt {
     fromAmount?: string;
     toAmount?: string;
     toToken?: Token;
-    gasUsed?: string;
     gasPrice?: string;
+    gasUsed?: string;
+    gasToken?: Token;
+    gasAmount?: string;
+    gasAmountUSD?: string;
 }
-declare type InternalUpdateRouteCallback = (route: Route) => void;
-declare type OptionalParameters = Partial<Pick<Process, 'doneAt' | 'failedAt' | 'txHash' | 'txLink' | 'error' | 'substatus' | 'substatusMessage'>>;
+type InternalUpdateRouteCallback = (route: Route) => void;
+type OptionalParameters = Partial<Pick<Process, 'doneAt' | 'failedAt' | 'txHash' | 'txLink' | 'error' | 'substatus' | 'substatusMessage'>>;
 /**
  * Manages status updates of a route and provides various functions for tracking processes
  * @param  {Route} route  The route this StatusManger belongs to.

package/dist/execution/StatusManager.js

@@ -157,9 +157,7 @@ export class StatusManager {
         }
         step.execution.status = status;
         if (receipt) {
-            step.execution.fromAmount = receipt.fromAmount;
-            step.execution.toAmount = receipt.toAmount;
-            step.execution.toToken = receipt.toToken;
+            step.execution = Object.assign(Object.assign({}, step.execution), receipt);
         }
         this.updateStepInRoute(step);
         return step;

package/dist/execution/StepExecutor.d.ts

@@ -1,17 +1,15 @@
 import { Signer } from 'ethers';
 import { InteractionSettings, InternalExecutionSettings, Step } from '../types';
+import { ExecutionManager } from './ExecutionManager';
 import { StatusManager } from './StatusManager';
 export declare class StepExecutor {
-    settings: InternalExecutionSettings;
+    executionManager: ExecutionManager;
     statusManager: StatusManager;
-    private swapExecutionManager;
-    private bridgeExecutionManager;
+    settings: InternalExecutionSettings;
     allowUserInteraction: boolean;
     executionStopped: boolean;
     constructor(statusManager: StatusManager, settings: InternalExecutionSettings);
     setInteraction: (settings?: InteractionSettings) => void;
     checkChain: () => never;
     executeStep: (signer: Signer, step: Step) => Promise<Step>;
-    private executeSwap;
-    private executeCross;
 }

package/dist/execution/StepExecutor.js

@@ -7,8 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { BridgeExecutionManager } from './bridges/bridge.execute';
-import { SwapExecutionManager } from './exchanges/swap.execute';
+import { ExecutionManager } from './ExecutionManager';
 import { switchChain } from './switchChain';
 // Please be careful when changing the defaults as it may break the behavior (e.g., background execution)
 const defaultInteractionSettings = {
@@ -18,15 +17,12 @@ const defaultInteractionSettings = {
 };
 export class StepExecutor {
     constructor(statusManager, settings) {
-        this.swapExecutionManager = new SwapExecutionManager();
-        this.bridgeExecutionManager = new BridgeExecutionManager();
         this.allowUserInteraction = true;
         this.executionStopped = false;
         this.setInteraction = (settings) => {
             const interactionSettings = Object.assign(Object.assign({}, defaultInteractionSettings), settings);
             this.allowUserInteraction = interactionSettings.allowInteraction;
-            this.swapExecutionManager.allowInteraction(interactionSettings.allowInteraction);
-            this.bridgeExecutionManager.allowInteraction(interactionSettings.allowInteraction);
+            this.executionManager.allowInteraction(interactionSettings.allowInteraction);
             this.statusManager.allowUpdates(interactionSettings.allowUpdates);
             this.executionStopped = interactionSettings.stopExecution;
         };
@@ -44,37 +40,16 @@ export class StepExecutor {
                 return step;
             }
             signer = updatedSigner;
-            switch (step.type) {
-                case 'lifi':
-                case 'cross':
-                    yield this.executeCross(signer, step);
-                    break;
-                case 'swap':
-                    yield this.executeSwap(signer, step);
-                    break;
-                default:
-                    throw new Error('Unsupported step type.');
-            }
-            return step;
-        });
-        this.executeSwap = (signer, step) => {
-            const swapParams = {
-                signer,
-                step,
-                settings: this.settings,
-                statusManager: this.statusManager,
-            };
-            return this.swapExecutionManager.execute(swapParams);
-        };
-        this.executeCross = (signer, step) => {
-            const crossParams = {
+            const parameters = {
                 signer,
                 step,
                 settings: this.settings,
                 statusManager: this.statusManager,
             };
-            return this.bridgeExecutionManager.execute(crossParams);
-        };
+            yield this.executionManager.execute(parameters);
+            return step;
+        });
+        this.executionManager = new ExecutionManager();
         this.statusManager = statusManager;
         this.settings = settings;
     }

package/dist/execution/stepComparison.d.ts

@@ -1,9 +1,9 @@
 import { StatusManager } from '.';
-import { AcceptSlippageUpdateHook, Step } from '../types';
+import { InternalExecutionSettings, Step } from '../types';
 /**
- * This method checks whether the new and updated Step meets the required slippage conditions.
+ * 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 acceptSlippageUpdateHook. If no user interaction is allowed it aborts.
+ * If no and if user interaction is allowed it triggers the acceptExchangeRateUpdateHook. If no user interaction is allowed it aborts.
  *
  * @param statusManager
  * @param oldStep
@@ -11,4 +11,4 @@ import { AcceptSlippageUpdateHook, Step } from '../types';
  * @param acceptSlippageUpdateHook
  * @param allowUserInteraction
  */
-export declare const stepComparison: (statusManager: StatusManager, oldStep: Step, newStep: Step, acceptSlippageUpdateHook: AcceptSlippageUpdateHook, allowUserInteraction: boolean) => Promise<Step>;
+export declare const stepComparison: (statusManager: StatusManager, oldStep: Step, newStep: Step, settings: InternalExecutionSettings, allowUserInteraction: boolean) => Promise<Step>;