@lifi/sdk 1.1.1 → 1.1.4

package/dist/execution/balanceCheck.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,79 +7,35 @@ 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;
+import BigNumber from 'bignumber.js';
+import balances from '../balances';
+import { ValidationError } from '../utils/errors';
+export const balanceCheck = (signer, step) => __awaiter(void 0, void 0, void 0, function* () {
+    const tokenAmount = yield balances.getTokenBalance(yield signer.getAddress(), step.action.fromToken);
+    if (tokenAmount) {
+        const currentBalance = new BigNumber(tokenAmount.amount).shiftedBy(tokenAmount.decimals);
+        const neededBalance = new BigNumber(step.action.fromAmount);
+        if (currentBalance.lt(neededBalance)) {
+            if (neededBalance.multipliedBy(1 - step.action.slippage).lte(currentBalance)) {
+                // adjust amount in slippage limits
+                step.action.fromAmount = currentBalance.toFixed(0);
             }
-            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.balanceCheck = void 0;
-var bignumber_js_1 = __importDefault(require("bignumber.js"));
-var balances_1 = __importDefault(require("../balances"));
-var errors_1 = require("../utils/errors");
-var balanceCheck = function (signer, step) { return __awaiter(void 0, void 0, void 0, function () {
-    var tokenAmount, _a, _b, currentBalance, neededBalance, neeeded, current, errorMessage;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
-            case 0:
-                _b = (_a = balances_1.default).getTokenBalance;
-                return [4 /*yield*/, signer.getAddress()];
-            case 1: return [4 /*yield*/, _b.apply(_a, [_c.sent(), step.action.fromToken])];
-            case 2:
-                tokenAmount = _c.sent();
-                if (tokenAmount) {
-                    currentBalance = new bignumber_js_1.default(tokenAmount.amount).shiftedBy(tokenAmount.decimals);
-                    neededBalance = new bignumber_js_1.default(step.action.fromAmount);
-                    if (currentBalance.lt(neededBalance)) {
-                        if (neededBalance.multipliedBy(1 - step.action.slippage).lte(currentBalance)) {
-                            // adjust amount in slippage limits
-                            step.action.fromAmount = currentBalance.toFixed(0);
-                        }
-                        else {
-                            neeeded = neededBalance.shiftedBy(-tokenAmount.decimals).toFixed();
-                            current = currentBalance
-                                .shiftedBy(-tokenAmount.decimals)
-                                .toFixed();
-                            errorMessage = "Your ".concat(tokenAmount.symbol, " balance is too low, ") +
-                                "you try to transfer ".concat(neeeded, " ").concat(tokenAmount.symbol, ", ") +
-                                "but your wallet only holds ".concat(current, " ").concat(tokenAmount.symbol, ". ") +
-                                "No funds have been sent. ";
-                            if (!currentBalance.isZero()) {
-                                errorMessage +=
-                                    "If the problem consists, please delete this transfer and " +
-                                        "start a new one with a maximum of ".concat(current, " ").concat(tokenAmount.symbol, ".");
-                            }
-                            throw new errors_1.ValidationError('The balance is too low.', errorMessage);
-                        }
-                    }
+            else {
+                const neeeded = neededBalance.shiftedBy(-tokenAmount.decimals).toFixed();
+                const current = currentBalance
+                    .shiftedBy(-tokenAmount.decimals)
+                    .toFixed();
+                let errorMessage = `Your ${tokenAmount.symbol} balance is too low, ` +
+                    `you try to transfer ${neeeded} ${tokenAmount.symbol}, ` +
+                    `but your wallet only holds ${current} ${tokenAmount.symbol}. ` +
+                    `No funds have been sent. `;
+                if (!currentBalance.isZero()) {
+                    errorMessage +=
+                        `If the problem consists, please delete this transfer and ` +
+                            `start a new one with a maximum of ${current} ${tokenAmount.symbol}.`;
                 }
-                return [2 /*return*/];
+                throw new ValidationError('The balance is too low.', errorMessage);
+            }
         }
-    });
-}); };
-exports.balanceCheck = balanceCheck;
+    }
+});

package/dist/execution/bridges/bridge.execute.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,218 +7,141 @@ 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.BridgeExecutionManager = void 0;
-var ethers_1 = require("ethers");
-var ApiService_1 = __importDefault(require("../../services/ApiService"));
-var ChainsService_1 = __importDefault(require("../../services/ChainsService"));
-var errors_1 = require("../../utils/errors");
-var getProvider_1 = require("../../utils/getProvider");
-var parseError_1 = require("../../utils/parseError");
-var utils_1 = require("../../utils/utils");
-var allowance_execute_1 = require("../allowance.execute");
-var balanceCheck_execute_1 = require("../balanceCheck.execute");
-var stepComparison_1 = require("../stepComparison");
-var switchChain_1 = require("../switchChain");
-var utils_2 = require("../utils");
-var BridgeExecutionManager = /** @class */ (function () {
-    function BridgeExecutionManager() {
-        var _this = this;
+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 { checkAllowance } from '../allowance.execute';
+import { balanceCheck } from '../balanceCheck.execute';
+import { stepComparison } from '../stepComparison';
+import { switchChain } from '../switchChain';
+import { getSubstatusMessage, waitForReceivingTransaction } from '../utils';
+export class BridgeExecutionManager {
+    constructor() {
         this.shouldContinue = true;
-        this.setShouldContinue = function (val) {
-            _this.shouldContinue = val;
+        this.setShouldContinue = (val) => {
+            this.shouldContinue = val;
         };
-        this.execute = function (_a) {
-            var signer = _a.signer, step = _a.step, statusManager = _a.statusManager, settings = _a.settings;
-            return __awaiter(_this, void 0, void 0, function () {
-                var action, estimate, chainsService, fromChain, toChain, oldCrossProcess, crossChainProcess, tx, personalizedStep, updatedStep, _b, transactionRequest, updatedSigner, e_1, error, receivingChainProcess, statusResponse, e_2;
-                var _c, _d, _e, _f;
-                return __generator(this, function (_g) {
-                    switch (_g.label) {
-                        case 0:
-                            action = step.action, estimate = step.estimate;
-                            step.execution = statusManager.initExecutionObject(step);
-                            chainsService = ChainsService_1.default.getInstance();
-                            return [4 /*yield*/, chainsService.getChainById(action.fromChainId)];
-                        case 1:
-                            fromChain = _g.sent();
-                            return [4 /*yield*/, chainsService.getChainById(action.toChainId)
-                                // STEP 1: Check Allowance ////////////////////////////////////////////////
-                                // approval still needed?
-                            ];
-                        case 2:
-                            toChain = _g.sent();
-                            oldCrossProcess = step.execution.process.find(function (p) { return p.type === 'CROSS_CHAIN'; });
-                            if (!!(oldCrossProcess === null || oldCrossProcess === void 0 ? void 0 : oldCrossProcess.txHash)) return [3 /*break*/, 4];
-                            if (!(action.fromToken.address !== ethers_1.constants.AddressZero)) return [3 /*break*/, 4];
-                            // Check Token Approval only if fromToken is not the native token => no approval needed in that case
-                            return [4 /*yield*/, (0, allowance_execute_1.checkAllowance)(signer, step, fromChain, action.fromToken, action.fromAmount, estimate.approvalAddress, statusManager, settings.infiniteApproval, this.shouldContinue)];
-                        case 3:
-                            // Check Token Approval only if fromToken is not the native token => no approval needed in that case
-                            _g.sent();
-                            _g.label = 4;
-                        case 4:
-                            crossChainProcess = statusManager.findOrCreateProcess('CROSS_CHAIN', step);
-                            _g.label = 5;
-                        case 5:
-                            _g.trys.push([5, 16, , 20]);
-                            tx = void 0;
-                            if (!crossChainProcess.txHash) return [3 /*break*/, 7];
-                            return [4 /*yield*/, (0, getProvider_1.getProvider)(signer).getTransaction(crossChainProcess.txHash)];
-                        case 6:
-                            // load exiting transaction
-                            tx = _g.sent();
-                            return [3 /*break*/, 14];
-                        case 7: 
-                        // check balance
-                        return [4 /*yield*/, (0, balanceCheck_execute_1.balanceCheck)(signer, step)
-                            // create new transaction
-                        ];
-                        case 8:
-                            // check balance
-                            _g.sent();
-                            return [4 /*yield*/, (0, utils_1.personalizeStep)(signer, step)];
-                        case 9:
-                            personalizedStep = _g.sent();
-                            return [4 /*yield*/, ApiService_1.default.getStepTransaction(personalizedStep)];
-                        case 10:
-                            updatedStep = _g.sent();
-                            _b = [{}];
-                            return [4 /*yield*/, (0, stepComparison_1.stepComparison)(statusManager, personalizedStep, updatedStep, settings.acceptSlippageUpdateHook, this.shouldContinue)];
-                        case 11:
-                            step = __assign.apply(void 0, [__assign.apply(void 0, _b.concat([(_g.sent())])), { execution: step.execution }]);
-                            transactionRequest = step.transactionRequest;
-                            if (!transactionRequest) {
-                                throw new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
-                            }
-                            return [4 /*yield*/, (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.shouldContinue)];
-                        case 12:
-                            updatedSigner = _g.sent();
-                            if (!updatedSigner) {
-                                // chain switch was not successful, stop execution here
-                                return [2 /*return*/, step.execution];
-                            }
-                            signer = updatedSigner;
-                            crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'ACTION_REQUIRED');
-                            if (!this.shouldContinue) {
-                                return [2 /*return*/, step.execution];
-                            }
-                            return [4 /*yield*/, signer.sendTransaction(transactionRequest)
-                                // STEP 4: Wait for Transaction ///////////////////////////////////////////
-                            ];
-                        case 13:
-                            tx = _g.sent();
-                            // STEP 4: Wait for Transaction ///////////////////////////////////////////
-                            crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'PENDING', {
-                                txHash: tx.hash,
-                                txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + tx.hash,
-                            });
-                            _g.label = 14;
-                        case 14: return [4 /*yield*/, tx.wait()];
-                        case 15:
-                            _g.sent();
-                            return [3 /*break*/, 20];
-                        case 16:
-                            e_1 = _g.sent();
-                            if (!(e_1.code === 'TRANSACTION_REPLACED' && e_1.replacement)) return [3 /*break*/, 17];
-                            crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'PENDING', {
-                                txHash: e_1.replacement.hash,
-                                txLink: fromChain.metamask.blockExplorerUrls[0] +
-                                    'tx/' +
-                                    e_1.replacement.hash,
-                            });
-                            return [3 /*break*/, 19];
-                        case 17: return [4 /*yield*/, (0, parseError_1.parseError)(e_1, step, crossChainProcess)];
-                        case 18:
-                            error = _g.sent();
-                            crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'FAILED', {
-                                error: {
-                                    message: error.message,
-                                    htmlMessage: error.htmlMessage,
-                                    code: error.code,
-                                },
-                            });
-                            statusManager.updateExecution(step, 'FAILED');
-                            throw error;
-                        case 19: return [3 /*break*/, 20];
-                        case 20:
-                            crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'DONE');
-                            receivingChainProcess = statusManager.findOrCreateProcess('RECEIVING_CHAIN', step, 'PENDING');
-                            _g.label = 21;
-                        case 21:
-                            _g.trys.push([21, 23, , 24]);
-                            if (!crossChainProcess.txHash) {
-                                throw new Error('Transaction hash is undefined.');
-                            }
-                            return [4 /*yield*/, (0, utils_2.waitForReceivingTransaction)(crossChainProcess.txHash, statusManager, receivingChainProcess.type, step)];
-                        case 22:
-                            statusResponse = _g.sent();
-                            return [3 /*break*/, 24];
-                        case 23:
-                            e_2 = _g.sent();
-                            receivingChainProcess = statusManager.updateProcess(step, receivingChainProcess.type, 'FAILED', {
-                                error: {
-                                    code: errors_1.LifiErrorCode.TransactionFailed,
-                                    message: 'Failed while waiting for receiving chain.',
-                                    htmlMessage: (0, parseError_1.getTransactionFailedMessage)(step, crossChainProcess.txLink),
-                                },
-                            });
-                            statusManager.updateExecution(step, 'FAILED');
-                            throw e_2;
-                        case 24:
-                            receivingChainProcess = statusManager.updateProcess(step, receivingChainProcess.type, 'DONE', {
-                                substatus: statusResponse.substatus,
-                                substatusMessage: statusResponse.substatusMessage ||
-                                    (0, utils_2.getSubstatusMessage)(statusResponse.status, statusResponse.substatus),
-                                txHash: (_c = statusResponse.receiving) === null || _c === void 0 ? void 0 : _c.txHash,
-                                txLink: toChain.metamask.blockExplorerUrls[0] +
-                                    'tx/' +
-                                    ((_d = statusResponse.receiving) === null || _d === void 0 ? void 0 : _d.txHash),
-                            });
-                            statusManager.updateExecution(step, 'DONE', {
-                                fromAmount: statusResponse.sending.amount,
-                                toAmount: (_e = statusResponse.receiving) === null || _e === void 0 ? void 0 : _e.amount,
-                                toToken: (_f = statusResponse.receiving) === null || _f === void 0 ? void 0 : _f.token,
-                                gasUsed: statusResponse.sending.gasUsed,
-                                gasPrice: statusResponse.sending.gasPrice,
-                            });
-                            // DONE
-                            return [2 /*return*/, step.execution];
+        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 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);
+                }
+            }
+            // 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);
+                    // create new transaction
+                    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 });
+                    const { transactionRequest } = step;
+                    if (!transactionRequest) {
+                        throw new TransactionError(LifiErrorCode.TransactionUnprepared, 'Unable to prepare transaction.');
+                    }
+                    // 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;
                     }
+                    signer = updatedSigner;
+                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'ACTION_REQUIRED');
+                    if (!this.shouldContinue) {
+                        return step.execution;
+                    }
+                    tx = yield signer.sendTransaction(transactionRequest);
+                    // STEP 4: Wait for Transaction ///////////////////////////////////////////
+                    crossChainProcess = statusManager.updateProcess(step, crossChainProcess.type, 'PENDING', {
+                        txHash: tx.hash,
+                        txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + tx.hash,
+                    });
+                }
+                yield 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');
+            let statusResponse;
+            try {
+                if (!crossChainProcess.txHash) {
+                    throw new Error('Transaction hash is undefined.');
+                }
+                statusResponse = yield waitForReceivingTransaction(crossChainProcess.txHash, statusManager, receivingChainProcess.type, step);
+            }
+            catch (e) {
+                receivingChainProcess = statusManager.updateProcess(step, receivingChainProcess.type, 'FAILED', {
+                    error: {
+                        code: LifiErrorCode.TransactionFailed,
+                        message: 'Failed while waiting for receiving chain.',
+                        htmlMessage: getTransactionFailedMessage(step, crossChainProcess.txLink),
+                    },
                 });
+                statusManager.updateExecution(step, 'FAILED');
+                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;
+        });
     }
-    return BridgeExecutionManager;
-}());
-exports.BridgeExecutionManager = BridgeExecutionManager;
+}