@lifi/sdk 1.3.1 → 1.5.0

package/dist/cjs/execution/allowance.execute.js

@@ -18,39 +18,33 @@ const ethers_1 = require("ethers");
 const utils_1 = require("../allowance/utils");
 const getProvider_1 = require("../utils/getProvider");
 const parseError_1 = require("../utils/parseError");
-const checkAllowance = (signer, step, chain, token, amount, spenderAddress, statusManager, infiniteApproval = false, allowUserInteraction = false
-// eslint-disable-next-line max-params
-) => __awaiter(void 0, void 0, void 0, function* () {
-    // Ask user to set allowance
-    // -> set currentExecution
-    let allowanceProcess = statusManager.findOrCreateProcess('TOKEN_ALLOWANCE', step);
-    // -> check allowance
+const checkAllowance = (signer, step, statusManager, settings, chain, allowUserInteraction = false) => __awaiter(void 0, void 0, void 0, function* () {
+    // Ask the user to set an allowance
+    let allowanceProcess = statusManager.findOrCreateProcess(step, 'TOKEN_ALLOWANCE');
+    // Check allowance
     try {
-        if (allowanceProcess.txHash) {
-            allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING');
+        if (allowanceProcess.txHash && allowanceProcess.status !== 'DONE') {
+            if (allowanceProcess.status !== 'PENDING') {
+                allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING');
+            }
             yield (0, getProvider_1.getProvider)(signer).waitForTransaction(allowanceProcess.txHash);
             allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-            // TODO: Do we need this check?
-        }
-        else if (allowanceProcess.status === 'DONE') {
-            allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
         }
         else {
-            const approved = yield (0, utils_1.getApproved)(signer, token.address, spenderAddress);
-            if (new bignumber_js_1.default(amount).gt(approved)) {
+            const approved = yield (0, utils_1.getApproved)(signer, step.action.fromToken.address, step.estimate.approvalAddress);
+            if (new bignumber_js_1.default(step.action.fromAmount).gt(approved)) {
                 if (!allowUserInteraction) {
                     return;
                 }
-                const approvalAmount = infiniteApproval
+                const approvalAmount = settings.infiniteApproval
                     ? ethers_1.constants.MaxUint256.toString()
-                    : amount;
-                const approveTx = yield (0, utils_1.setApproval)(signer, token.address, spenderAddress, approvalAmount);
-                // update currentExecution
+                    : step.action.fromAmount;
+                const approveTx = yield (0, utils_1.setApproval)(signer, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount);
                 allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING', {
                     txHash: approveTx.hash,
                     txLink: chain.metamask.blockExplorerUrls[0] + 'tx/' + approveTx.hash,
                 });
-                // wait for transcation
+                // Wait for the transcation
                 yield approveTx.wait();
                 allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
             }
@@ -60,7 +54,6 @@ const checkAllowance = (signer, step, chain, token, amount, spenderAddress, stat
         }
     }
     catch (e) {
-        // -> set status
         if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
             yield transactionReplaced(e.replacement, allowanceProcess, step, chain, statusManager);
         }

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,97 +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);
-                    // create new transaction
-                    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 });
-                    const { transactionRequest } = step;
-                    if (!transactionRequest) {
-                        throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+            // 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);
                     }
-                    // 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;
+                    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,
+                        });
                     }
-                    signer = updatedSigner;
-                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'ACTION_REQUIRED');
-                    if (!this.shouldContinue) {
-                        return step.execution;
-                    }
-                    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 transaction.wait();
+                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'DONE');
                 }
-                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;
+                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,
+                        });
+                    }
+                    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', {
@@ -128,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,84 +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
-                    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 });
+                    // 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.');
                     }
-                    // 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] +
@@ -125,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() {
@@ -49,11 +50,11 @@ class ConfigService {
             return this.config;
         };
         this.updateChains = (chains) => {
-            var _a;
+            var _a, _b;
             for (const chain of chains) {
                 const chainId = chain.id;
                 // set RPCs if they were not configured by the user before
-                if (!this.config.rpcs[chainId].length) {
+                if (!((_a = this.config.rpcs[chainId]) === null || _a === void 0 ? void 0 : _a.length)) {
                     this.config.rpcs[chainId] = chain.metamask.rpcUrls;
                 }
                 // set multicall addresses if they exist and were not configured by the user before
@@ -61,7 +62,7 @@ class ConfigService {
                     this.config.multicallAddresses[chainId] = chain.multicallAddress;
                 }
             }
-            (_a = this.resolveSetupPromise) === null || _a === void 0 ? void 0 : _a.call(this);
+            (_b = this.resolveSetupPromise) === null || _b === void 0 ? void 0 : _b.call(this);
             return this.config;
         };
         this.config = ConfigService.getDefaultConfig();

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

@@ -9,6 +9,7 @@ const handlePreRestart = (route) => {
         if (stepHasFailed) {
             handleErrorType(route, index);
             deleteFailedProcesses(route, index);
+            deleteTransactionData(route, index);
         }
     }
 };
@@ -26,6 +27,9 @@ 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) => {
+    route.steps[index].transactionRequest = undefined;
+};

package/dist/cjs/version.d.ts

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