@lifi/sdk 1.4.1 → 1.5.0

package/dist/execution/StepExecutor.js

@@ -10,26 +10,37 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { BridgeExecutionManager } from './bridges/bridge.execute';
 import { SwapExecutionManager } from './exchanges/swap.execute';
 import { switchChain } from './switchChain';
-const defaultExecutionHaltSettings = {
+// Please be careful when changing the defaults as it may break the behavior (e.g., background execution)
+const defaultInteractionSettings = {
+    allowInteraction: true,
     allowUpdates: true,
+    stopExecution: false,
 };
 export class StepExecutor {
     constructor(statusManager, settings) {
         this.swapExecutionManager = new SwapExecutionManager();
         this.bridgeExecutionManager = new BridgeExecutionManager();
+        this.allowUserInteraction = true;
         this.executionStopped = false;
-        this.stopStepExecution = (settings) => {
-            const haltingSettings = Object.assign(Object.assign({}, defaultExecutionHaltSettings), settings);
-            this.swapExecutionManager.setShouldContinue(false);
-            this.bridgeExecutionManager.setShouldContinue(false);
-            this.statusManager.setShouldUpdate(haltingSettings.allowUpdates);
-            this.executionStopped = true;
+        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.statusManager.allowUpdates(interactionSettings.allowUpdates);
+            this.executionStopped = interactionSettings.stopExecution;
+        };
+        // TODO: add checkChain method and update signer inside executors
+        // This can come in handy when we execute multiple routes simultaneously and
+        // should be sure that we are on the right chain when waiting for transactions.
+        this.checkChain = () => {
+            throw new Error('checkChain is not implemented.');
         };
         this.executeStep = (signer, step) => __awaiter(this, void 0, void 0, function* () {
-            // check if signer is for correct chain
-            const updatedSigner = yield switchChain(signer, this.statusManager, step, this.settings.switchChainHook, !this.executionStopped);
+            // Make sure that the chain is still correct
+            const updatedSigner = yield switchChain(signer, this.statusManager, step, this.settings.switchChainHook, this.allowUserInteraction);
             if (!updatedSigner) {
-                // chain switch was not successful, stop execution here
+                // Chain switch was not successful, stop execution here
                 return step;
             }
             signer = updatedSigner;
@@ -46,24 +57,24 @@ export class StepExecutor {
             }
             return step;
         });
-        this.executeSwap = (signer, step) => __awaiter(this, void 0, void 0, function* () {
+        this.executeSwap = (signer, step) => {
             const swapParams = {
                 signer,
                 step,
                 settings: this.settings,
                 statusManager: this.statusManager,
             };
-            return yield this.swapExecutionManager.execute(swapParams);
-        });
-        this.executeCross = (signer, step) => __awaiter(this, void 0, void 0, function* () {
+            return this.swapExecutionManager.execute(swapParams);
+        };
+        this.executeCross = (signer, step) => {
             const crossParams = {
                 signer,
                 step,
                 settings: this.settings,
                 statusManager: this.statusManager,
             };
-            return yield this.bridgeExecutionManager.execute(crossParams);
-        });
+            return this.bridgeExecutionManager.execute(crossParams);
+        };
         this.statusManager = statusManager;
         this.settings = settings;
     }

package/dist/execution/allowance.execute.d.ts

@@ -1,4 +1,4 @@
 import { Signer } from 'ethers';
-import { Chain, Step, Token } from '../types';
+import { Chain, InternalExecutionSettings, Step } from '../types';
 import { StatusManager } from './StatusManager';
-export declare const checkAllowance: (signer: Signer, step: Step, chain: Chain, token: Token, amount: string, spenderAddress: string, statusManager: StatusManager, infiniteApproval?: boolean, allowUserInteraction?: boolean) => Promise<void>;
+export declare const checkAllowance: (signer: Signer, step: Step, statusManager: StatusManager, settings: InternalExecutionSettings, chain: Chain, allowUserInteraction?: boolean) => Promise<void>;

package/dist/execution/allowance.execute.js

@@ -12,39 +12,33 @@ import { constants } from 'ethers';
 import { getApproved, setApproval } from '../allowance/utils';
 import { getProvider } from '../utils/getProvider';
 import { parseError } from '../utils/parseError';
-export 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
+export 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 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 getApproved(signer, token.address, spenderAddress);
-            if (new BigNumber(amount).gt(approved)) {
+            const approved = yield getApproved(signer, step.action.fromToken.address, step.estimate.approvalAddress);
+            if (new BigNumber(step.action.fromAmount).gt(approved)) {
                 if (!allowUserInteraction) {
                     return;
                 }
-                const approvalAmount = infiniteApproval
+                const approvalAmount = settings.infiniteApproval
                     ? constants.MaxUint256.toString()
-                    : amount;
-                const approveTx = yield setApproval(signer, token.address, spenderAddress, approvalAmount);
-                // update currentExecution
+                    : step.action.fromAmount;
+                const approveTx = yield 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');
             }
@@ -54,7 +48,6 @@ export const checkAllowance = (signer, step, chain, token, amount, spenderAddres
         }
     }
     catch (e) {
-        // -> set status
         if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
             yield transactionReplaced(e.replacement, allowanceProcess, step, chain, statusManager);
         }

package/dist/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/execution/bridges/bridge.execute.js

@@ -7,13 +7,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { constants } from 'ethers';
 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 { personalizeStep } from '../../utils/utils';
+import { isZeroAddress, personalizeStep } from '../../utils/utils';
 import { checkAllowance } from '../allowance.execute';
 import { balanceCheck } from '../balanceCheck.execute';
 import { stepComparison } from '../stepComparison';
@@ -21,98 +20,125 @@ import { switchChain } from '../switchChain';
 import { getSubstatusMessage, waitForReceivingTransaction } from '../utils';
 export 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.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 !== constants.AddressZero) {
-                    // Check Token Approval only if fromToken is not the native token => no approval needed in that case
-                    yield 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) &&
+                !isZeroAddress(step.action.fromToken.address)) {
+                yield 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 getProvider(signer).getTransaction(crossChainProcess.txHash);
-                }
-                else {
-                    // check balance
-                    yield balanceCheck(signer, step);
-                    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.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 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 getProvider(signer).getTransaction(crossChainProcess.txHash);
                     }
-                    const { transactionRequest } = step;
-                    if (!transactionRequest) {
-                        throw new TransactionError(LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                    else {
+                        crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'STARTED');
+                        // Check balance
+                        yield balanceCheck(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 { transactionRequest } = step;
+                        if (!transactionRequest) {
+                            throw new TransactionError(LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                        }
+                        // STEP 3: Send the transaction
+                        // Make sure that the chain is still correct
+                        const updatedSigner = yield 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 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 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 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 waitForReceivingTransaction(crossChainProcess.txHash, statusManager, receivingChainProcess.type, step);
+                receivingChainProcess = statusManager.updateProcess(step, receivingChainProcess.type, 'DONE', {
+                    substatus: statusResponse.substatus,
+                    substatusMessage: statusResponse.substatusMessage ||
+                        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', {
@@ -123,24 +149,9 @@ export class BridgeExecutionManager {
                     },
                 });
                 statusManager.updateExecution(step, 'FAILED');
+                console.warn(e);
                 throw e;
             }
-            receivingChainProcess = statusManager.updateProcess(step, receivingChainProcess.type, 'DONE', {
-                substatus: statusResponse.substatus,
-                substatusMessage: statusResponse.substatusMessage ||
-                    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/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/execution/exchanges/swap.execute.js

@@ -7,13 +7,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { constants } from 'ethers';
 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 { personalizeStep } from '../../utils/utils';
+import { isZeroAddress, personalizeStep } from '../../utils/utils';
 import { checkAllowance } from '../allowance.execute';
 import { balanceCheck } from '../balanceCheck.execute';
 import { stepComparison } from '../stepComparison';
@@ -21,86 +20,72 @@ import { switchChain } from '../switchChain';
 import { waitForReceivingTransaction } from '../utils';
 export 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.getInstance();
-            const fromChain = yield chainsService.getChainById(action.fromChainId);
-            // Approval
-            if (action.fromToken.address !== constants.AddressZero) {
-                yield 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 (!isZeroAddress(step.action.fromToken.address)) {
+                yield 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 getProvider(signer).getTransaction(swapProcess.txHash);
+                    // Make sure that the chain is still correct
+                    const updatedSigner = yield 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 getProvider(signer).getTransaction(swapProcess.txHash);
                 }
                 else {
-                    // -> check balance
+                    swapProcess = statusManager.updateProcess(step, swapProcess.type, 'STARTED');
+                    // Check balance
                     yield balanceCheck(signer, step);
-                    // -> get tx from backend
+                    // 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.shouldContinue))), { execution: step.execution });
+                        step = Object.assign(Object.assign({}, (yield stepComparison(statusManager, personalizedStep, updatedStep, settings.acceptSlippageUpdateHook, this.allowUserInteraction))), { execution: step.execution });
                     }
                     const { transactionRequest } = step;
                     if (!transactionRequest) {
                         throw new TransactionError(LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
                     }
-                    // make sure that chain is still correct
-                    const updatedSigner = yield switchChain(signer, statusManager, step, settings.switchChainHook, this.shouldContinue);
+                    // STEP 3: Send the transaction
+                    // Make sure that the chain is still correct
+                    const updatedSigner = yield 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 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] +
@@ -121,6 +106,7 @@ export class SwapExecutionManager {
                     throw error;
                 }
             }
+            // STEP 5: Wait for the receiving chain
             let statusResponse;
             try {
                 if (!swapProcess.txHash) {

package/dist/execution/switchChain.js

@@ -26,8 +26,8 @@ export const switchChain = (signer, statusManager, step, switchChainHook, allowU
     }
     // -> 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;
     }
@@ -45,7 +45,7 @@ export const switchChain = (signer, statusManager, step, switchChainHook, allowU
         switchProcess = statusManager.updateProcess(step, switchProcess.type, 'FAILED', {
             error: {
                 message: error.message,
-                code: error.code,
+                code: LifiErrorCode.ChainSwitchError,
             },
         });
         statusManager.updateExecution(step, 'FAILED');

package/dist/helpers.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { name, version } from './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/services/ConfigService.js

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

package/dist/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 {};