@lifi/sdk 1.4.1 → 1.5.0

package/dist/cjs/execution/bridges/bridge.execute.d.ts

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

package/dist/cjs/execution/bridges/bridge.execute.js

@@ -13,7 +13,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BridgeExecutionManager = void 0;
-const ethers_1 = require("ethers");
 const ApiService_1 = __importDefault(require("../../services/ApiService"));
 const ChainsService_1 = __importDefault(require("../../services/ChainsService"));
 const errors_1 = require("../../utils/errors");
@@ -27,98 +26,125 @@ const switchChain_1 = require("../switchChain");
 const utils_2 = require("../utils");
 class BridgeExecutionManager {
     constructor() {
-        this.shouldContinue = true;
-        this.setShouldContinue = (val) => {
-            this.shouldContinue = val;
+        this.allowUserInteraction = true;
+        this.allowInteraction = (value) => {
+            this.allowUserInteraction = value;
         };
         this.execute = ({ signer, step, statusManager, settings, }) => __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d;
-            const { action, estimate } = step;
             step.execution = statusManager.initExecutionObject(step);
             const chainsService = ChainsService_1.default.getInstance();
-            const fromChain = yield chainsService.getChainById(action.fromChainId);
-            const toChain = yield chainsService.getChainById(action.toChainId);
-            // STEP 1: Check Allowance ////////////////////////////////////////////////
-            // approval still needed?
+            const fromChain = yield chainsService.getChainById(step.action.fromChainId);
+            const toChain = yield chainsService.getChainById(step.action.toChainId);
+            // STEP 1: Check allowance
             const oldCrossProcess = step.execution.process.find((p) => p.type === 'CROSS_CHAIN');
-            if (!(oldCrossProcess === null || oldCrossProcess === void 0 ? void 0 : oldCrossProcess.txHash)) {
-                if (action.fromToken.address !== ethers_1.constants.AddressZero) {
-                    // Check Token Approval only if fromToken is not the native token => no approval needed in that case
-                    yield (0, allowance_execute_1.checkAllowance)(signer, step, fromChain, action.fromToken, action.fromAmount, estimate.approvalAddress, statusManager, settings.infiniteApproval, this.shouldContinue);
-                }
+            // 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) &&
+                !(0, utils_1.isZeroAddress)(step.action.fromToken.address)) {
+                yield (0, allowance_execute_1.checkAllowance)(signer, step, statusManager, settings, fromChain, this.allowUserInteraction);
             }
-            // STEP 2: Get Transaction ////////////////////////////////////////////////
-            let crossChainProcess = statusManager.findOrCreateProcess('CROSS_CHAIN', step);
-            try {
-                let tx;
-                if (crossChainProcess.txHash) {
-                    // load exiting transaction
-                    tx = yield (0, getProvider_1.getProvider)(signer).getTransaction(crossChainProcess.txHash);
-                }
-                else {
-                    // check balance
-                    yield (0, balanceCheck_execute_1.balanceCheck)(signer, step);
-                    if (!step.transactionRequest) {
-                        const personalizedStep = yield (0, utils_1.personalizeStep)(signer, step);
-                        const updatedStep = yield ApiService_1.default.getStepTransaction(personalizedStep);
-                        step = Object.assign(Object.assign({}, (yield (0, stepComparison_1.stepComparison)(statusManager, personalizedStep, updatedStep, settings.acceptSlippageUpdateHook, this.shouldContinue))), { execution: step.execution });
+            // STEP 2: Get transaction
+            let crossChainProcess = statusManager.findOrCreateProcess(step, 'CROSS_CHAIN');
+            if (crossChainProcess.status !== 'DONE') {
+                try {
+                    let transaction;
+                    if (crossChainProcess.txHash) {
+                        // Make sure that the chain is still correct
+                        const updatedSigner = yield (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
+                        if (!updatedSigner) {
+                            // Chain switch was not successful, stop execution here
+                            return step.execution;
+                        }
+                        signer = updatedSigner;
+                        // Load exiting transaction
+                        transaction = yield (0, getProvider_1.getProvider)(signer).getTransaction(crossChainProcess.txHash);
                     }
-                    const { transactionRequest } = step;
-                    if (!transactionRequest) {
-                        throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                    else {
+                        crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'STARTED');
+                        // Check balance
+                        yield (0, balanceCheck_execute_1.balanceCheck)(signer, step);
+                        // Create new transaction
+                        if (!step.transactionRequest) {
+                            const personalizedStep = yield (0, utils_1.personalizeStep)(signer, step);
+                            const updatedStep = yield ApiService_1.default.getStepTransaction(personalizedStep);
+                            step = Object.assign(Object.assign({}, (yield (0, stepComparison_1.stepComparison)(statusManager, personalizedStep, updatedStep, settings.acceptSlippageUpdateHook, this.allowUserInteraction))), { execution: step.execution });
+                        }
+                        const { transactionRequest } = step;
+                        if (!transactionRequest) {
+                            throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                        }
+                        // STEP 3: Send the transaction
+                        // Make sure that the chain is still correct
+                        const updatedSigner = yield (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
+                        if (!updatedSigner) {
+                            // Chain switch was not successful, stop execution here
+                            return step.execution;
+                        }
+                        signer = updatedSigner;
+                        crossChainProcess = statusManager.updateProcess(step, crossChainProcess.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', {
+                            txHash: transaction.hash,
+                            txLink: fromChain.metamask.blockExplorerUrls[0] +
+                                'tx/' +
+                                transaction.hash,
+                        });
                     }
-                    // STEP 3: Send Transaction ///////////////////////////////////////////////
-                    // make sure that chain is still correct
-                    const updatedSigner = yield (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.shouldContinue);
-                    if (!updatedSigner) {
-                        // chain switch was not successful, stop execution here
-                        return step.execution;
+                    yield transaction.wait();
+                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'DONE');
+                }
+                catch (e) {
+                    if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
+                        crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'DONE', {
+                            txHash: e.replacement.hash,
+                            txLink: fromChain.metamask.blockExplorerUrls[0] +
+                                'tx/' +
+                                e.replacement.hash,
+                        });
                     }
-                    signer = updatedSigner;
-                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'ACTION_REQUIRED');
-                    if (!this.shouldContinue) {
-                        return step.execution;
+                    else {
+                        const error = yield (0, parseError_1.parseError)(e, step, crossChainProcess);
+                        crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'FAILED', {
+                            error: {
+                                message: error.message,
+                                htmlMessage: error.htmlMessage,
+                                code: error.code,
+                            },
+                        });
+                        statusManager.updateExecution(step, 'FAILED');
+                        throw error;
                     }
-                    tx = yield signer.sendTransaction(transactionRequest);
-                    // STEP 4: Wait for Transaction ///////////////////////////////////////////
-                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'PENDING', {
-                        txHash: tx.hash,
-                        txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + tx.hash,
-                    });
-                }
-                yield tx.wait();
-            }
-            catch (e) {
-                if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
-                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'PENDING', {
-                        txHash: e.replacement.hash,
-                        txLink: fromChain.metamask.blockExplorerUrls[0] +
-                            'tx/' +
-                            e.replacement.hash,
-                    });
-                }
-                else {
-                    const error = yield (0, parseError_1.parseError)(e, step, crossChainProcess);
-                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'FAILED', {
-                        error: {
-                            message: error.message,
-                            htmlMessage: error.htmlMessage,
-                            code: error.code,
-                        },
-                    });
-                    statusManager.updateExecution(step, 'FAILED');
-                    throw error;
                 }
             }
-            crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'DONE');
-            // STEP 5: Wait for Receiver //////////////////////////////////////
-            let receivingChainProcess = statusManager.findOrCreateProcess('RECEIVING_CHAIN', step, 'PENDING');
+            // STEP 5: Wait for the receiving chain
+            let receivingChainProcess = statusManager.findOrCreateProcess(step, 'RECEIVING_CHAIN', 'PENDING');
             let statusResponse;
             try {
                 if (!crossChainProcess.txHash) {
                     throw new Error('Transaction hash is undefined.');
                 }
                 statusResponse = yield (0, utils_2.waitForReceivingTransaction)(crossChainProcess.txHash, statusManager, receivingChainProcess.type, step);
+                receivingChainProcess = statusManager.updateProcess(step, receivingChainProcess.type, 'DONE', {
+                    substatus: statusResponse.substatus,
+                    substatusMessage: statusResponse.substatusMessage ||
+                        (0, utils_2.getSubstatusMessage)(statusResponse.status, statusResponse.substatus),
+                    txHash: (_a = statusResponse.receiving) === null || _a === void 0 ? void 0 : _a.txHash,
+                    txLink: toChain.metamask.blockExplorerUrls[0] +
+                        'tx/' +
+                        ((_b = statusResponse.receiving) === null || _b === void 0 ? void 0 : _b.txHash),
+                });
+                statusManager.updateExecution(step, 'DONE', {
+                    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,
+                    gasPrice: statusResponse.sending.gasPrice,
+                });
             }
             catch (e) {
                 receivingChainProcess = statusManager.updateProcess(step, receivingChainProcess.type, 'FAILED', {
@@ -129,24 +155,9 @@ class BridgeExecutionManager {
                     },
                 });
                 statusManager.updateExecution(step, 'FAILED');
+                console.warn(e);
                 throw e;
             }
-            receivingChainProcess = statusManager.updateProcess(step, receivingChainProcess.type, 'DONE', {
-                substatus: statusResponse.substatus,
-                substatusMessage: statusResponse.substatusMessage ||
-                    (0, utils_2.getSubstatusMessage)(statusResponse.status, statusResponse.substatus),
-                txHash: (_a = statusResponse.receiving) === null || _a === void 0 ? void 0 : _a.txHash,
-                txLink: toChain.metamask.blockExplorerUrls[0] +
-                    'tx/' +
-                    ((_b = statusResponse.receiving) === null || _b === void 0 ? void 0 : _b.txHash),
-            });
-            statusManager.updateExecution(step, 'DONE', {
-                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,
-                gasPrice: statusResponse.sending.gasPrice,
-            });
             // DONE
             return step.execution;
         });

package/dist/cjs/execution/exchanges/swap.execute.d.ts

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

package/dist/cjs/execution/exchanges/swap.execute.js

@@ -13,7 +13,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwapExecutionManager = void 0;
-const ethers_1 = require("ethers");
 const ApiService_1 = __importDefault(require("../../services/ApiService"));
 const ChainsService_1 = __importDefault(require("../../services/ChainsService"));
 const errors_1 = require("../../utils/errors");
@@ -27,86 +26,72 @@ const switchChain_1 = require("../switchChain");
 const utils_2 = require("../utils");
 class SwapExecutionManager {
     constructor() {
-        this.shouldContinue = true;
-        this.setShouldContinue = (val) => {
-            this.shouldContinue = val;
+        this.allowUserInteraction = true;
+        this.allowInteraction = (value) => {
+            this.allowUserInteraction = value;
         };
         this.execute = ({ signer, step, statusManager, settings, }) => __awaiter(this, void 0, void 0, function* () {
-            // setup
             var _a, _b, _c, _d;
-            const { action, estimate } = step;
             step.execution = statusManager.initExecutionObject(step);
             const chainsService = ChainsService_1.default.getInstance();
-            const fromChain = yield chainsService.getChainById(action.fromChainId);
-            // Approval
-            if (action.fromToken.address !== ethers_1.constants.AddressZero) {
-                yield (0, allowance_execute_1.checkAllowance)(signer, step, fromChain, action.fromToken, action.fromAmount, estimate.approvalAddress, statusManager, settings.infiniteApproval, this.shouldContinue);
+            const fromChain = yield chainsService.getChainById(step.action.fromChainId);
+            // STEP 1: Check allowance
+            if (!(0, utils_1.isZeroAddress)(step.action.fromToken.address)) {
+                yield (0, allowance_execute_1.checkAllowance)(signer, step, statusManager, settings, fromChain, this.allowUserInteraction);
             }
-            // Start Swap
-            // -> set step.execution
-            let swapProcess = statusManager.findOrCreateProcess('SWAP', step);
-            // -> swapping
-            let tx;
+            // STEP 2: Get transaction
+            let swapProcess = statusManager.findOrCreateProcess(step, 'SWAP');
+            let transaction;
             try {
                 if (swapProcess.txHash) {
-                    // -> restore existing tx
-                    tx = yield (0, getProvider_1.getProvider)(signer).getTransaction(swapProcess.txHash);
+                    // Make sure that the chain is still correct
+                    const updatedSigner = yield (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
+                    if (!updatedSigner) {
+                        // Chain switch was not successful, stop execution here
+                        return step.execution;
+                    }
+                    signer = updatedSigner;
+                    // Load exiting transaction
+                    transaction = yield (0, getProvider_1.getProvider)(signer).getTransaction(swapProcess.txHash);
                 }
                 else {
-                    // -> check balance
+                    swapProcess = statusManager.updateProcess(step, swapProcess.type, 'STARTED');
+                    // Check balance
                     yield (0, balanceCheck_execute_1.balanceCheck)(signer, step);
-                    // -> get tx from backend
+                    // Create new transaction
                     if (!step.transactionRequest) {
                         const personalizedStep = yield (0, utils_1.personalizeStep)(signer, step);
                         const updatedStep = yield ApiService_1.default.getStepTransaction(personalizedStep);
-                        step = Object.assign(Object.assign({}, (yield (0, stepComparison_1.stepComparison)(statusManager, personalizedStep, updatedStep, settings.acceptSlippageUpdateHook, this.shouldContinue))), { execution: step.execution });
+                        step = Object.assign(Object.assign({}, (yield (0, stepComparison_1.stepComparison)(statusManager, personalizedStep, updatedStep, settings.acceptSlippageUpdateHook, this.allowUserInteraction))), { execution: step.execution });
                     }
                     const { transactionRequest } = step;
                     if (!transactionRequest) {
                         throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
                     }
-                    // make sure that chain is still correct
-                    const updatedSigner = yield (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.shouldContinue);
+                    // STEP 3: Send the transaction
+                    // Make sure that the chain is still correct
+                    const updatedSigner = yield (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
                     if (!updatedSigner) {
-                        // chain switch was not successful, stop execution here
+                        // Chain switch was not successful, stop execution here
                         return step.execution;
                     }
                     signer = updatedSigner;
-                    // -> set step.execution
-                    swapProcess = swapProcess = statusManager.updateProcess(step, swapProcess.type, 'ACTION_REQUIRED');
-                    if (!this.shouldContinue) {
-                        return step.execution; // stop before user interaction is needed
+                    swapProcess = statusManager.updateProcess(step, swapProcess.type, 'ACTION_REQUIRED');
+                    if (!this.allowUserInteraction) {
+                        return step.execution;
                     }
-                    // -> submit tx
-                    tx = yield signer.sendTransaction(transactionRequest);
+                    // Submit the transaction
+                    transaction = yield signer.sendTransaction(transactionRequest);
                 }
-            }
-            catch (e) {
-                const error = yield (0, parseError_1.parseError)(e, step, swapProcess);
-                swapProcess = statusManager.updateProcess(step, swapProcess.type, 'FAILED', {
-                    error: {
-                        message: error.message,
-                        htmlMessage: error.htmlMessage,
-                        code: error.code,
-                    },
+                // STEP 4: Wait for the transaction
+                swapProcess = statusManager.updateProcess(step, swapProcess.type, 'PENDING', {
+                    txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + transaction.hash,
+                    txHash: transaction.hash,
                 });
-                statusManager.updateExecution(step, 'FAILED');
-                throw error;
-            }
-            // Wait for Transaction
-            swapProcess = statusManager.updateProcess(step, swapProcess.type, 'PENDING', {
-                txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + tx.hash,
-                txHash: tx.hash,
-            });
-            // -> waiting
-            let receipt;
-            try {
-                receipt = yield tx.wait();
+                yield transaction.wait();
             }
             catch (e) {
-                // -> set status
                 if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
-                    receipt = e.replacement;
                     swapProcess = statusManager.updateProcess(step, swapProcess.type, 'PENDING', {
                         txHash: e.replacement.hash,
                         txLink: fromChain.metamask.blockExplorerUrls[0] +
@@ -127,6 +112,7 @@ class SwapExecutionManager {
                     throw error;
                 }
             }
+            // STEP 5: Wait for the receiving chain
             let statusResponse;
             try {
                 if (!swapProcess.txHash) {

package/dist/cjs/execution/switchChain.js

@@ -29,8 +29,8 @@ const switchChain = (signer, statusManager, step, switchChainHook, allowUserInte
     }
     // -> set status message
     step.execution = statusManager.initExecutionObject(step);
-    statusManager.updateExecution(step, 'CHAIN_SWITCH_REQUIRED');
-    let switchProcess = statusManager.findOrCreateProcess('SWITCH_CHAIN', step, 'PENDING');
+    statusManager.updateExecution(step, 'ACTION_REQUIRED');
+    let switchProcess = statusManager.findOrCreateProcess(step, 'SWITCH_CHAIN', 'ACTION_REQUIRED');
     if (!allowUserInteraction) {
         return;
     }
@@ -48,7 +48,7 @@ const switchChain = (signer, statusManager, step, switchChainHook, allowUserInte
         switchProcess = statusManager.updateProcess(step, switchProcess.type, 'FAILED', {
             error: {
                 message: error.message,
-                code: error.code,
+                code: errors_1.LifiErrorCode.ChainSwitchError,
             },
         });
         statusManager.updateExecution(step, 'FAILED');

package/dist/cjs/helpers.js

@@ -13,7 +13,7 @@ exports.checkPackageUpdates = exports.isSameToken = exports.getRandomNumber = ex
 const version_1 = require("./version");
 const ethereumRequest = (method, params) => __awaiter(void 0, void 0, void 0, function* () {
     // If ethereum.request() exists, the provider is probably EIP-1193 compliant.
-    if (!ethereum || !ethereum.request) {
+    if (!(ethereum === null || ethereum === void 0 ? void 0 : ethereum.request)) {
         throw new Error('Provider not available.');
     }
     return ethereum.request({

package/dist/cjs/services/ConfigService.js

@@ -16,6 +16,7 @@ const DefaultExecutionSettings = {
     switchChainHook: () => Promise.resolve(undefined),
     acceptSlippageUpdateHook: () => Promise.resolve(undefined),
     infiniteApproval: false,
+    executeInBackground: false,
 };
 class ConfigService {
     constructor() {

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

@@ -64,12 +64,14 @@ export interface ExecutionSettings {
     switchChainHook?: SwitchChainHook;
     acceptSlippageUpdateHook?: AcceptSlippageUpdateHook;
     infiniteApproval?: boolean;
+    executeInBackground?: boolean;
 }
 export interface InternalExecutionSettings extends ExecutionSettings {
     updateCallback: CallbackFunction;
     switchChainHook: SwitchChainHook;
     acceptSlippageUpdateHook: AcceptSlippageUpdateHook;
     infiniteApproval: boolean;
+    executeInBackground: boolean;
 }
 export declare type EnforcedObjectProperties<T> = T & {
     [P in keyof T]-?: T[P];
@@ -81,7 +83,9 @@ export declare type RevokeTokenData = {
     token: Token;
     approvalAddress: string;
 };
-export interface HaltingSettings {
+export interface InteractionSettings {
+    allowInteraction?: boolean;
     allowUpdates?: boolean;
+    stopExecution?: boolean;
 }
 export {};

package/dist/cjs/utils/parseError.js

@@ -77,7 +77,7 @@ const getTransactionFailedMessage = (step, txLink) => {
 };
 exports.getTransactionFailedMessage = getTransactionFailedMessage;
 const parseError = (e, step, process) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
+    var _a, _b, _c;
     if (e instanceof errors_1.LifiError) {
         return e;
     }
@@ -88,12 +88,11 @@ const parseError = (e, step, process) => __awaiter(void 0, void 0, void 0, funct
                 // rpc errors
                 // underpriced errors are sent as internal errors, so we need to parse the message manually
                 if (e.code === eth_rpc_errors_1.errorCodes.rpc.internal &&
-                    e.message &&
-                    e.message.includes('underpriced')) {
+                    ((_a = e.message) === null || _a === void 0 ? void 0 : _a.includes('underpriced'))) {
                     return new errors_1.RPCError(errors_1.LifiErrorCode.TransactionUnderpriced, 'Transaction is underpriced.', yield (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
                 }
-                if (((_a = e.message) === null || _a === void 0 ? void 0 : _a.includes('intrinsic gas too low')) ||
-                    ((_b = e.message) === null || _b === void 0 ? void 0 : _b.includes('out of gas'))) {
+                if (((_b = e.message) === null || _b === void 0 ? void 0 : _b.includes('intrinsic gas too low')) ||
+                    ((_c = e.message) === null || _c === void 0 ? void 0 : _c.includes('out of gas'))) {
                     return new errors_1.TransactionError(errors_1.LifiErrorCode.GasLimitError, 'Gas limit is too low.', yield (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
                 }
                 return new errors_1.RPCError(e.code, (0, eth_rpc_errors_1.getMessageFromCode)(e.code), yield (0, exports.getTransactionNotSentMessage)(step, process), e.stack);

package/dist/cjs/utils/preRestart.js

@@ -27,7 +27,7 @@ const handleErrorType = (route, index) => {
 };
 const deleteFailedProcesses = (route, index) => {
     if (route.steps[index].execution) {
-        route.steps[index].execution.process = route.steps[index].execution.process.filter((process) => process.status !== 'FAILED');
+        route.steps[index].execution.process = route.steps[index].execution.process.filter((process) => process.status === 'DONE');
     }
 };
 const deleteTransactionData = (route, index) => {

package/dist/cjs/version.d.ts

@@ -1,2 +1,2 @@
 export declare const name = "@lifi/sdk";
-export declare const version = "1.4.1";
+export declare const version = "1.5.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.4.1';
+exports.version = '1.5.0';

package/dist/execution/StatusManager.d.ts

@@ -42,7 +42,7 @@ export declare class StatusManager {
      * @param  {Status} status By default created procces is set to the STARTED status. We can override new process with the needed status.
      * @return {Process}
      */
-    findOrCreateProcess: (type: ProcessType, step: Step, status?: Status) => Process;
+    findOrCreateProcess: (step: Step, type: ProcessType, status?: Status) => Process;
     /**
      * Update a process object.
      * @param  {Step} step The step where the process should be updated
@@ -60,6 +60,6 @@ export declare class StatusManager {
      */
     removeProcess: (step: Step, type: ProcessType) => void;
     updateStepInRoute: (step: Step) => Step;
-    setShouldUpdate(value: boolean): void;
+    allowUpdates(value: boolean): void;
 }
 export {};

package/dist/execution/StatusManager.js

@@ -37,12 +37,17 @@ export class StatusManager {
          * @param  {Status} status By default created procces is set to the STARTED status. We can override new process with the needed status.
          * @return {Process}
          */
-        this.findOrCreateProcess = (type, step, status) => {
-            if (!step.execution || !step.execution.process) {
+        this.findOrCreateProcess = (step, type, status) => {
+            var _a;
+            if (!((_a = step.execution) === null || _a === void 0 ? void 0 : _a.process)) {
                 throw new Error("Execution hasn't been initialized.");
             }
             const process = step.execution.process.find((p) => p.type === type);
             if (process) {
+                if (status && process.status !== status) {
+                    process.status = status;
+                    this.updateStepInRoute(step);
+                }
                 return process;
             }
             const newProcess = {
@@ -64,7 +69,7 @@ export class StatusManager {
          * @return {Process} The update process
          */
         this.updateProcess = (step, type, status, params) => {
-            var _a;
+            var _a, _b, _c;
             if (!step.execution) {
                 throw new Error("Can't update an empty step execution.");
             }
@@ -89,9 +94,6 @@ export class StatusManager {
                 case 'ACTION_REQUIRED':
                     step.execution.status = 'ACTION_REQUIRED';
                     break;
-                case 'CHAIN_SWITCH_REQUIRED':
-                    step.execution.status = 'CHAIN_SWITCH_REQUIRED';
-                    break;
                 default:
                     break;
             }
@@ -103,6 +105,11 @@ export class StatusManager {
                     currentProcess[key] = value;
                 }
             }
+            // Sort processes, the ones with DONE status go first
+            step.execution.process = [
+                ...(_b = step === null || step === void 0 ? void 0 : step.execution) === null || _b === void 0 ? void 0 : _b.process.filter((process) => process.status === 'DONE'),
+                ...(_c = step === null || step === void 0 ? void 0 : step.execution) === null || _c === void 0 ? void 0 : _c.process.filter((process) => process.status !== 'DONE'),
+            ];
             this.updateStepInRoute(step); // updates the step in the route
             return currentProcess;
         };
@@ -157,7 +164,7 @@ export class StatusManager {
         this.updateStepInRoute(step);
         return step;
     }
-    setShouldUpdate(value) {
+    allowUpdates(value) {
         this.shouldUpdate = value;
     }
 }

package/dist/execution/StepExecutor.d.ts

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