@lifi/sdk 1.1.2 → 1.1.3

package/dist/execution/StatusManager.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StatusManager = void 0;
-var types_1 = require("../types");
-var utils_1 = require("../utils/utils");
-var utils_2 = require("./utils");
+import { emptyExecution, } from '../types';
+import { deepClone } from '../utils/utils';
+import { getProcessMessage } from './utils';
 /**
  * Manages status updates of a route and provides various functions for tracking processes
  * @param  {Route} route  The route this StatusManger belongs to.
@@ -11,26 +8,25 @@ var utils_2 = require("./utils");
  * @param  {InternalUpdateRouteCallback} internalUpdateRouteCallback  Internal callback to propage route changes.
  * @return {StatusManager}       An instance of StatusManager.
  */
-var StatusManager = /** @class */ (function () {
-    function StatusManager(route, settings, internalUpdateRouteCallback) {
-        var _this = this;
+export class StatusManager {
+    constructor(route, settings, internalUpdateRouteCallback) {
         this.shouldUpdate = true;
         /**
          * Initializes the execution object of a Step.
          * @param  {Step} step  The current step in execution
          * @return {Execution}       The initialized execution object for this step and a function to update this step
          */
-        this.initExecutionObject = function (step) {
-            var currentExecution = step.execution || (0, utils_1.deepClone)(types_1.emptyExecution);
+        this.initExecutionObject = (step) => {
+            const currentExecution = step.execution || deepClone(emptyExecution);
             if (!step.execution) {
                 step.execution = currentExecution;
                 step.execution.status = 'PENDING';
-                _this.updateStepInRoute(step);
+                this.updateStepInRoute(step);
             }
             // Change status to PENDING after resuming from FAILED
             if (currentExecution.status === 'FAILED') {
                 currentExecution.status = 'PENDING';
-                _this.updateStepInRoute(step);
+                this.updateStepInRoute(step);
             }
             return currentExecution;
         };
@@ -41,22 +37,22 @@ var StatusManager = /** @class */ (function () {
          * @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 = function (type, step, status) {
+        this.findOrCreateProcess = (type, step, status) => {
             if (!step.execution || !step.execution.process) {
                 throw new Error("Execution hasn't been initialized.");
             }
-            var process = step.execution.process.find(function (p) { return p.type === type; });
+            const process = step.execution.process.find((p) => p.type === type);
             if (process) {
                 return process;
             }
-            var newProcess = {
+            const newProcess = {
                 type: type,
                 startedAt: Date.now(),
-                message: (0, utils_2.getProcessMessage)(type, status !== null && status !== void 0 ? status : 'STARTED'),
+                message: getProcessMessage(type, status !== null && status !== void 0 ? status : 'STARTED'),
                 status: status !== null && status !== void 0 ? status : 'STARTED',
             };
             step.execution.process.push(newProcess);
-            _this.updateStepInRoute(step);
+            this.updateStepInRoute(step);
             return newProcess;
         };
         /**
@@ -67,12 +63,12 @@ var StatusManager = /** @class */ (function () {
          * @param  {object} [params]   Additional parameters to append to the process.
          * @return {Process} The update process
          */
-        this.updateProcess = function (step, type, status, params) {
+        this.updateProcess = (step, type, status, params) => {
             var _a;
             if (!step.execution) {
                 throw new Error("Can't update an empty step execution.");
             }
-            var currentProcess = (_a = step === null || step === void 0 ? void 0 : step.execution) === null || _a === void 0 ? void 0 : _a.process.find(function (p) { return p.type === type; });
+            const currentProcess = (_a = step === null || step === void 0 ? void 0 : step.execution) === null || _a === void 0 ? void 0 : _a.process.find((p) => p.type === type);
             if (!currentProcess) {
                 throw new Error("Can't find a process for the given type.");
             }
@@ -100,15 +96,14 @@ var StatusManager = /** @class */ (function () {
                     break;
             }
             currentProcess.status = status;
-            currentProcess.message = (0, utils_2.getProcessMessage)(type, status);
+            currentProcess.message = getProcessMessage(type, status);
             // set extra parameters or overwritte the standard params set in the switch statement
             if (params) {
-                for (var _i = 0, _b = Object.entries(params); _i < _b.length; _i++) {
-                    var _c = _b[_i], key = _c[0], value = _c[1];
+                for (const [key, value] of Object.entries(params)) {
                     currentProcess[key] = value;
                 }
             }
-            _this.updateStepInRoute(step); // updates the step in the route
+            this.updateStepInRoute(step); // updates the step in the route
             return currentProcess;
         };
         /**
@@ -117,26 +112,26 @@ var StatusManager = /** @class */ (function () {
          * @param  {ProcessType} type  The process type to remove
          * @return {void}
          */
-        this.removeProcess = function (step, type) {
+        this.removeProcess = (step, type) => {
             if (!step.execution) {
                 throw new Error("Execution hasn't been initialized.");
             }
-            var index = step.execution.process.findIndex(function (p) { return p.type === type; });
+            const index = step.execution.process.findIndex((p) => p.type === type);
             step.execution.process.splice(index, 1);
-            _this.updateStepInRoute(step);
+            this.updateStepInRoute(step);
         };
-        this.updateStepInRoute = function (step) {
-            if (!_this.shouldUpdate) {
+        this.updateStepInRoute = (step) => {
+            if (!this.shouldUpdate) {
                 return step;
             }
-            var stepIndex = _this.route.steps.findIndex(function (routeStep) { return routeStep.id === step.id; });
+            const stepIndex = this.route.steps.findIndex((routeStep) => routeStep.id === step.id);
             if (stepIndex === -1) {
                 throw new Error("Couldn't find a step to update.");
             }
-            _this.route.steps[stepIndex] = Object.assign(_this.route.steps[stepIndex], step);
-            _this.settings.updateCallback(_this.route);
-            _this.internalUpdateRouteCallback(_this.route);
-            return _this.route.steps[stepIndex];
+            this.route.steps[stepIndex] = Object.assign(this.route.steps[stepIndex], step);
+            this.settings.updateCallback(this.route);
+            this.internalUpdateRouteCallback(this.route);
+            return this.route.steps[stepIndex];
         };
         this.route = route;
         this.settings = settings;
@@ -149,7 +144,7 @@ var StatusManager = /** @class */ (function () {
      * @param  {Receipt} receipt Optional. Information about received tokens
      * @return {Step}       The step with the updated execution object
      */
-    StatusManager.prototype.updateExecution = function (step, status, receipt) {
+    updateExecution(step, status, receipt) {
         if (!step.execution) {
             throw Error("Can't update empty execution.");
         }
@@ -161,10 +156,8 @@ var StatusManager = /** @class */ (function () {
         }
         this.updateStepInRoute(step);
         return step;
-    };
-    StatusManager.prototype.setShouldUpdate = function (value) {
+    }
+    setShouldUpdate(value) {
         this.shouldUpdate = value;
-    };
-    return StatusManager;
-}());
-exports.StatusManager = StatusManager;
+    }
+}

package/dist/execution/StepExecutor.js

@@ -1,15 +1,3 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -19,121 +7,64 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StepExecutor = void 0;
-var bridge_execute_1 = require("./bridges/bridge.execute");
-var swap_execute_1 = require("./exchanges/swap.execute");
-var switchChain_1 = require("./switchChain");
-var defaultExecutionHaltSettings = {
+import { BridgeExecutionManager } from './bridges/bridge.execute';
+import { SwapExecutionManager } from './exchanges/swap.execute';
+import { switchChain } from './switchChain';
+const defaultExecutionHaltSettings = {
     allowUpdates: true,
 };
-var StepExecutor = /** @class */ (function () {
-    function StepExecutor(statusManager, settings) {
-        var _this = this;
-        this.swapExecutionManager = new swap_execute_1.SwapExecutionManager();
-        this.bridgeExecutionManager = new bridge_execute_1.BridgeExecutionManager();
+export class StepExecutor {
+    constructor(statusManager, settings) {
+        this.swapExecutionManager = new SwapExecutionManager();
+        this.bridgeExecutionManager = new BridgeExecutionManager();
         this.executionStopped = false;
-        this.stopStepExecution = function (settings) {
-            var haltingSettings = __assign(__assign({}, defaultExecutionHaltSettings), settings);
-            _this.swapExecutionManager.setShouldContinue(false);
-            _this.bridgeExecutionManager.setShouldContinue(false);
-            _this.statusManager.setShouldUpdate(haltingSettings.allowUpdates);
-            _this.executionStopped = true;
+        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.executeStep = function (signer, step) { return __awaiter(_this, void 0, void 0, function () {
-            var updatedSigner, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, (0, switchChain_1.switchChain)(signer, this.statusManager, step, this.settings.switchChainHook, !this.executionStopped)];
-                    case 1:
-                        updatedSigner = _b.sent();
-                        if (!updatedSigner) {
-                            // chain switch was not successful, stop execution here
-                            return [2 /*return*/, step];
-                        }
-                        signer = updatedSigner;
-                        _a = step.type;
-                        switch (_a) {
-                            case 'lifi': return [3 /*break*/, 2];
-                            case 'cross': return [3 /*break*/, 2];
-                            case 'swap': return [3 /*break*/, 4];
-                        }
-                        return [3 /*break*/, 6];
-                    case 2: return [4 /*yield*/, this.executeCross(signer, step)];
-                    case 3:
-                        _b.sent();
-                        return [3 /*break*/, 7];
-                    case 4: return [4 /*yield*/, this.executeSwap(signer, step)];
-                    case 5:
-                        _b.sent();
-                        return [3 /*break*/, 7];
-                    case 6: throw new Error('Unsupported step type.');
-                    case 7: return [2 /*return*/, step];
-                }
-            });
-        }); };
-        this.executeSwap = function (signer, step) { return __awaiter(_this, void 0, void 0, function () {
-            var swapParams;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        swapParams = {
-                            signer: signer,
-                            step: step,
-                            settings: this.settings,
-                            statusManager: this.statusManager,
-                        };
-                        return [4 /*yield*/, this.swapExecutionManager.execute(swapParams)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        }); };
-        this.executeCross = function (signer, step) { return __awaiter(_this, void 0, void 0, function () {
-            var crossParams;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        crossParams = {
-                            signer: signer,
-                            step: step,
-                            settings: this.settings,
-                            statusManager: this.statusManager,
-                        };
-                        return [4 /*yield*/, this.bridgeExecutionManager.execute(crossParams)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        }); };
+        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);
+            if (!updatedSigner) {
+                // chain switch was not successful, stop execution here
+                return step;
+            }
+            signer = updatedSigner;
+            switch (step.type) {
+                case 'lifi':
+                case 'cross':
+                    yield this.executeCross(signer, step);
+                    break;
+                case 'swap':
+                    yield this.executeSwap(signer, step);
+                    break;
+                default:
+                    throw new Error('Unsupported step type.');
+            }
+            return step;
+        });
+        this.executeSwap = (signer, step) => __awaiter(this, void 0, void 0, function* () {
+            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* () {
+            const crossParams = {
+                signer,
+                step,
+                settings: this.settings,
+                statusManager: this.statusManager,
+            };
+            return yield this.bridgeExecutionManager.execute(crossParams);
+        });
         this.statusManager = statusManager;
         this.settings = settings;
     }
-    return StepExecutor;
-}());
-exports.StepExecutor = StepExecutor;
+}

package/dist/execution/allowance.execute.js

@@ -1,4 +1,3 @@
-"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,149 +7,84 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkAllowance = void 0;
-var bignumber_js_1 = __importDefault(require("bignumber.js"));
-var ethers_1 = require("ethers");
-var utils_1 = require("../allowance/utils");
-var getProvider_1 = require("../utils/getProvider");
-var parseError_1 = require("../utils/parseError");
-var checkAllowance = function (signer, step, chain, token, amount, spenderAddress, statusManager, infiniteApproval, allowUserInteraction
+import BigNumber from 'bignumber.js';
+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
-) {
-    if (infiniteApproval === void 0) { infiniteApproval = false; }
-    if (allowUserInteraction === void 0) { allowUserInteraction = false; }
-    return __awaiter(void 0, void 0, void 0, function () {
-        var allowanceProcess, approved, approvalAmount, approveTx, e_1, error;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    allowanceProcess = statusManager.findOrCreateProcess('TOKEN_ALLOWANCE', step);
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 10, , 15]);
-                    if (!allowanceProcess.txHash) return [3 /*break*/, 3];
-                    allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING');
-                    return [4 /*yield*/, (0, getProvider_1.getProvider)(signer).waitForTransaction(allowanceProcess.txHash)];
-                case 2:
-                    _a.sent();
-                    allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-                    return [3 /*break*/, 9];
-                case 3:
-                    if (!(allowanceProcess.status === 'DONE')) return [3 /*break*/, 4];
-                    allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-                    return [3 /*break*/, 9];
-                case 4: return [4 /*yield*/, (0, utils_1.getApproved)(signer, token.address, spenderAddress)];
-                case 5:
-                    approved = _a.sent();
-                    if (!new bignumber_js_1.default(amount).gt(approved)) return [3 /*break*/, 8];
-                    if (!allowUserInteraction) {
-                        return [2 /*return*/];
-                    }
-                    approvalAmount = infiniteApproval
-                        ? ethers_1.constants.MaxUint256.toString()
-                        : amount;
-                    return [4 /*yield*/, (0, utils_1.setApproval)(signer, token.address, spenderAddress, approvalAmount)
-                        // update currentExecution
-                    ];
-                case 6:
-                    approveTx = _a.sent();
-                    // update currentExecution
-                    allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING', {
-                        txHash: approveTx.hash,
-                        txLink: chain.metamask.blockExplorerUrls[0] + 'tx/' + approveTx.hash,
-                    });
-                    // wait for transcation
-                    return [4 /*yield*/, approveTx.wait()];
-                case 7:
-                    // wait for transcation
-                    _a.sent();
-                    allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-                    return [3 /*break*/, 9];
-                case 8:
-                    allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-                    _a.label = 9;
-                case 9: return [3 /*break*/, 15];
-                case 10:
-                    e_1 = _a.sent();
-                    if (!(e_1.code === 'TRANSACTION_REPLACED' && e_1.replacement)) return [3 /*break*/, 12];
-                    return [4 /*yield*/, transactionReplaced(e_1.replacement, allowanceProcess, step, chain, statusManager)];
-                case 11:
-                    _a.sent();
-                    return [3 /*break*/, 14];
-                case 12: return [4 /*yield*/, (0, parseError_1.parseError)(e_1, step, allowanceProcess)];
-                case 13:
-                    error = _a.sent();
-                    allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'FAILED', {
-                        error: {
-                            message: error.message,
-                            htmlMessage: error.htmlMessage,
-                            code: error.code,
-                        },
-                    });
-                    statusManager.updateExecution(step, 'FAILED');
-                    throw error;
-                case 14: return [3 /*break*/, 15];
-                case 15: return [2 /*return*/];
-            }
-        });
-    });
-};
-exports.checkAllowance = checkAllowance;
-var transactionReplaced = function (replacementTx, allowanceProcess, step, chain, statusManager) { return __awaiter(void 0, void 0, void 0, function () {
-    var e_2;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                _a.trys.push([0, 2, , 5]);
+) => __awaiter(void 0, void 0, void 0, function* () {
+    // Ask user to set allowance
+    // -> set currentExecution
+    let allowanceProcess = statusManager.findOrCreateProcess('TOKEN_ALLOWANCE', step);
+    // -> check allowance
+    try {
+        if (allowanceProcess.txHash) {
+            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)) {
+                if (!allowUserInteraction) {
+                    return;
+                }
+                const approvalAmount = infiniteApproval
+                    ? constants.MaxUint256.toString()
+                    : amount;
+                const approveTx = yield setApproval(signer, token.address, spenderAddress, approvalAmount);
+                // update currentExecution
                 allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING', {
-                    txHash: replacementTx.hash,
-                    txLink: chain.metamask.blockExplorerUrls[0] + 'tx/' + replacementTx.hash,
+                    txHash: approveTx.hash,
+                    txLink: chain.metamask.blockExplorerUrls[0] + 'tx/' + approveTx.hash,
                 });
-                return [4 /*yield*/, replacementTx.wait()];
-            case 1:
-                _a.sent();
+                // wait for transcation
+                yield approveTx.wait();
+                allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
+            }
+            else {
                 allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
-                return [3 /*break*/, 5];
-            case 2:
-                e_2 = _a.sent();
-                if (!(e_2.code === 'TRANSACTION_REPLACED' && e_2.replacement)) return [3 /*break*/, 4];
-                return [4 /*yield*/, transactionReplaced(e_2.replacement, allowanceProcess, step, chain, statusManager)];
-            case 3:
-                _a.sent();
-                _a.label = 4;
-            case 4: throw e_2;
-            case 5: return [2 /*return*/];
+            }
         }
-    });
-}); };
+    }
+    catch (e) {
+        // -> set status
+        if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
+            yield transactionReplaced(e.replacement, allowanceProcess, step, chain, statusManager);
+        }
+        else {
+            const error = yield parseError(e, step, allowanceProcess);
+            allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'FAILED', {
+                error: {
+                    message: error.message,
+                    htmlMessage: error.htmlMessage,
+                    code: error.code,
+                },
+            });
+            statusManager.updateExecution(step, 'FAILED');
+            throw error;
+        }
+    }
+});
+const transactionReplaced = (replacementTx, allowanceProcess, step, chain, statusManager) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING', {
+            txHash: replacementTx.hash,
+            txLink: chain.metamask.blockExplorerUrls[0] + 'tx/' + replacementTx.hash,
+        });
+        yield replacementTx.wait();
+        allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
+    }
+    catch (e) {
+        if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
+            yield transactionReplaced(e.replacement, allowanceProcess, step, chain, statusManager);
+        }
+        throw e;
+    }
+});