@lifi/sdk 1.4.1 → 1.6.0

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;

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>;
 }