@lifi/sdk 1.7.1 → 2.0.0-beta.0

package/dist/cjs/utils/errors.d.ts

@@ -77,4 +77,9 @@ export declare class NotFoundError extends LifiError {
 export declare class UnknownError extends LifiError {
     constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
 }
+export declare class HTTPError extends Error {
+    response: Response;
+    status: number;
+    constructor(response: Response);
+}
 export {};

package/dist/cjs/utils/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnknownError = exports.NotFoundError = exports.BalanceError = exports.SlippageError = exports.TransactionError = exports.ValidationError = exports.ServerError = exports.ProviderError = exports.RPCError = exports.LifiError = exports.MetaMaskProviderErrorCode = exports.MetaMaskRPCErrorCode = exports.LifiErrorCode = void 0;
+exports.HTTPError = exports.UnknownError = exports.NotFoundError = exports.BalanceError = exports.SlippageError = exports.TransactionError = exports.ValidationError = exports.ServerError = exports.ProviderError = exports.RPCError = exports.LifiError = exports.MetaMaskProviderErrorCode = exports.MetaMaskRPCErrorCode = exports.LifiErrorCode = void 0;
 var ErrorType;
 (function (ErrorType) {
     ErrorType["RPCError"] = "RPCError";
@@ -121,3 +121,16 @@ class UnknownError extends LifiError {
     }
 }
 exports.UnknownError = UnknownError;
+class HTTPError extends Error {
+    constructor(response) {
+        const code = response.status || response.status === 0 ? response.status : '';
+        const title = response.statusText || '';
+        const status = `${code} ${title}`.trim();
+        const reason = status ? `status code ${status}` : 'an unknown error';
+        super(`Request failed with ${reason}`);
+        this.name = 'HTTPError';
+        this.response = response;
+        this.status = response.status;
+    }
+}
+exports.HTTPError = HTTPError;

package/dist/cjs/utils/multicall.js

@@ -1,13 +1,4 @@
 "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) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -19,21 +10,21 @@ const connectors_1 = require("../connectors");
 const utils_1 = require("./utils");
 const multicallAbi_json_1 = __importDefault(require("./multicallAbi.json"));
 const MAX_MULTICALL_SIZE = 100;
-const fetchDataUsingMulticall = (calls, abi, chainId, multicallAddress, requireSuccess = false) => __awaiter(void 0, void 0, void 0, function* () {
+const fetchDataUsingMulticall = async (calls, abi, chainId, multicallAddress, requireSuccess = false) => {
     // 1. create contract using multicall contract address and abi...
-    const provider = yield (0, connectors_1.getRpcProvider)(chainId);
+    const provider = await (0, connectors_1.getRpcProvider)(chainId);
     const multicallContract = new contracts_1.Contract(multicallAddress, multicallAbi_json_1.default, provider);
     const abiInterface = new abi_1.Interface(abi);
     // split up lists into chunks to stay below multicall limit
     const chunkedList = (0, utils_1.splitListIntoChunks)(calls, MAX_MULTICALL_SIZE);
-    const chunkedResults = yield Promise.all(chunkedList.map((chunkedCalls) => __awaiter(void 0, void 0, void 0, function* () {
+    const chunkedResults = await Promise.all(chunkedList.map(async (chunkedCalls) => {
         const callData = chunkedCalls.map((call) => [
             call.address.toLowerCase(),
             abiInterface.encodeFunctionData(call.name, call.params),
         ]);
         try {
             // 3. get bytes array from multicall contract by process aggregate method...
-            const { blockNumber, returnData } = yield multicallContract.tryBlockAndAggregate(requireSuccess, callData);
+            const { blockNumber, returnData } = await multicallContract.tryBlockAndAggregate(requireSuccess, callData);
             // 4. decode bytes array to useful data array...
             return returnData
                 .map(({ success, returnData }, i) => {
@@ -71,7 +62,7 @@ const fetchDataUsingMulticall = (calls, abi, chainId, multicallAddress, requireS
             console.error(`Multicall failed on chainId "${chainId}"`, chunkedList, e);
             return [];
         }
-    })));
+    }));
     return chunkedResults.flat();
-});
+};
 exports.fetchDataUsingMulticall = fetchDataUsingMulticall;

package/dist/cjs/utils/parseError.d.ts

@@ -32,6 +32,6 @@ import { LifiError } from './errors';
  * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
  */
 export declare const getTransactionNotSentMessage: (step?: Step, process?: Process) => Promise<string>;
-export declare const getTransactionFailedMessage: (step: Step, txLink?: string) => string;
+export declare const getTransactionFailedMessage: (step: Step, txLink?: string) => Promise<string>;
 export declare const parseError: (e: any, step?: Step, process?: Process) => Promise<LifiError>;
-export declare const parseBackendError: (e: any) => LifiError;
+export declare const parseBackendError: (e: any) => Promise<LifiError>;

package/dist/cjs/utils/parseError.js

@@ -1,19 +1,9 @@
 "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) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseBackendError = exports.parseError = exports.getTransactionFailedMessage = exports.getTransactionNotSentMessage = void 0;
-const types_1 = require("@lifi/types");
 const eth_rpc_errors_1 = require("eth-rpc-errors");
 const ChainsService_1 = __importDefault(require("../services/ChainsService"));
 const errors_1 = require("./errors");
@@ -49,12 +39,12 @@ const utils_1 = require("./utils");
  * https://eips.ethereum.org/EIPS/eip-1474#error-codes
  * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
  */
-const getTransactionNotSentMessage = (step, process) => __awaiter(void 0, void 0, void 0, function* () {
+const getTransactionNotSentMessage = async (step, process) => {
     let transactionNotSend = 'Transaction was not sent, your funds are still in your wallet';
     // add information about funds if available
     if (step) {
         const chainService = ChainsService_1.default.getInstance();
-        const chain = yield chainService.getChainById(step.action.fromChainId);
+        const chain = await chainService.getChainById(step.action.fromChainId);
         transactionNotSend += ` (${(0, utils_1.formatTokenAmountOnly)(step.action.fromToken, step.action.fromAmount)} ${step.action.fromToken.symbol} on ${chain.name})`;
     }
     transactionNotSend +=
@@ -65,19 +55,20 @@ const getTransactionNotSentMessage = (step, process) => __awaiter(void 0, void 0
             ? `<br>You can check the failed transaction&nbsp;<a href="${process.txLink}" target="_blank" rel="nofollow noreferrer">here</a>.`
             : '';
     return transactionNotSend;
-});
+};
 exports.getTransactionNotSentMessage = getTransactionNotSentMessage;
-const getTransactionFailedMessage = (step, txLink) => {
+const getTransactionFailedMessage = async (step, txLink) => {
+    const chainsService = ChainsService_1.default.getInstance();
+    const chain = await chainsService.getChainById(step.action.toChainId);
     const baseString = `It appears that your transaction may not have been successful.
-  However, to confirm this, please check your ${(0, types_1.getChainById)(step.action.toChainId).name} wallet for ${step.action.toToken.symbol}.`;
+  However, to confirm this, please check your ${chain.name} wallet for ${step.action.toToken.symbol}.`;
     return txLink
         ? `${baseString}
     You can also check the&nbsp;<a href="${txLink}" target="_blank" rel="nofollow noreferrer">block explorer</a> for more information.`
         : baseString;
 };
 exports.getTransactionFailedMessage = getTransactionFailedMessage;
-const parseError = (e, step, process) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
+const parseError = async (e, step, process) => {
     if (e instanceof errors_1.LifiError) {
         return e;
     }
@@ -88,49 +79,56 @@ const parseError = (e, step, process) => __awaiter(void 0, void 0, void 0, funct
                 // rpc errors
                 // underpriced errors are sent as internal errors, so we need to parse the message manually
                 if (e.code === eth_rpc_errors_1.errorCodes.rpc.internal &&
-                    ((_a = e.message) === null || _a === void 0 ? void 0 : _a.includes('underpriced'))) {
-                    return new errors_1.RPCError(errors_1.LifiErrorCode.TransactionUnderpriced, 'Transaction is underpriced.', yield (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+                    (e.message?.includes('underpriced') ||
+                        e.message?.includes('replacement fee too low'))) {
+                    return new errors_1.RPCError(errors_1.LifiErrorCode.TransactionUnderpriced, 'Transaction is underpriced.', await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
                 }
-                if (((_b = e.message) === null || _b === void 0 ? void 0 : _b.includes('intrinsic gas too low')) ||
-                    ((_c = e.message) === null || _c === void 0 ? void 0 : _c.includes('out of gas'))) {
-                    return new errors_1.TransactionError(errors_1.LifiErrorCode.GasLimitError, 'Gas limit is too low.', yield (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+                if (e.message?.includes('intrinsic gas too low') ||
+                    e.message?.includes('out of gas')) {
+                    return new errors_1.TransactionError(errors_1.LifiErrorCode.GasLimitError, 'Gas limit is too low.', await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
                 }
-                return new errors_1.RPCError(e.code, (0, eth_rpc_errors_1.getMessageFromCode)(e.code), yield (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+                return new errors_1.RPCError(e.code, (0, eth_rpc_errors_1.getMessageFromCode)(e.code), await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
             }
             // provider errors
             if (Object.values(eth_rpc_errors_1.errorCodes.provider).includes(e.code)) {
-                return new errors_1.ProviderError(e.code, (0, eth_rpc_errors_1.getMessageFromCode)(e.code), yield (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+                return new errors_1.ProviderError(e.code, (0, eth_rpc_errors_1.getMessageFromCode)(e.code), await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
             }
         }
     }
     switch (e.code) {
         case 'CALL_EXCEPTION':
-            return new errors_1.ProviderError(errors_1.LifiErrorCode.TransactionFailed, e.reason, yield (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+            return new errors_1.ProviderError(errors_1.LifiErrorCode.TransactionFailed, e.reason, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
         case 'ACTION_REJECTED':
         case errors_1.MetaMaskProviderErrorCode.userRejectedRequest:
-            return new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionRejected, e.message, yield (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+            return new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionRejected, e.message, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
         case errors_1.LifiErrorCode.TransactionUnprepared:
-            return new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionUnprepared, e.message, yield (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
+            return new errors_1.TransactionError(errors_1.LifiErrorCode.TransactionUnprepared, e.message, await (0, exports.getTransactionNotSentMessage)(step, process), e.stack);
         case errors_1.LifiErrorCode.ValidationError:
             return new errors_1.TransactionError(errors_1.LifiErrorCode.ValidationError, e.message, e.htmlMessage);
         default:
             return new errors_1.UnknownError(errors_1.LifiErrorCode.InternalError, e.message || 'Unknown error occurred.', undefined, e.stack);
     }
-});
+};
 exports.parseError = parseError;
-const parseBackendError = (e) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
-    if (((_a = e.response) === null || _a === void 0 ? void 0 : _a.status) === 400) {
-        return new errors_1.ValidationError(((_c = (_b = e.response) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.message) || ((_d = e.response) === null || _d === void 0 ? void 0 : _d.statusText), undefined, e.stack);
+const parseBackendError = async (e) => {
+    let data;
+    try {
+        data = await e.response?.json();
+    }
+    catch (error) {
+        // ignore
+    }
+    if (e.response?.status === 400) {
+        return new errors_1.ValidationError(data?.message || e.response?.statusText, undefined, e.stack);
     }
-    if (((_e = e.response) === null || _e === void 0 ? void 0 : _e.status) === 404) {
-        return new errors_1.NotFoundError(((_g = (_f = e.response) === null || _f === void 0 ? void 0 : _f.data) === null || _g === void 0 ? void 0 : _g.message) || ((_h = e.response) === null || _h === void 0 ? void 0 : _h.statusText), undefined, e.stack);
+    if (e.response?.status === 404) {
+        return new errors_1.NotFoundError(data?.message || e.response?.statusText, undefined, e.stack);
     }
-    if (((_j = e.response) === null || _j === void 0 ? void 0 : _j.status) === 409) {
-        return new errors_1.SlippageError(((_l = (_k = e.response) === null || _k === void 0 ? void 0 : _k.data) === null || _l === void 0 ? void 0 : _l.message) || ((_m = e.response) === null || _m === void 0 ? void 0 : _m.statusText), 'The slippage is larger than the defined threshold. Please request a new route to get a fresh quote.', e.stack);
+    if (e.response?.status === 409) {
+        return new errors_1.SlippageError(data?.message || e.response?.statusText, 'The slippage is larger than the defined threshold. Please request a new route to get a fresh quote.', e.stack);
     }
-    if (((_o = e.response) === null || _o === void 0 ? void 0 : _o.status) === 500) {
-        return new errors_1.ServerError(((_q = (_p = e.response) === null || _p === void 0 ? void 0 : _p.data) === null || _q === void 0 ? void 0 : _q.message) || ((_r = e.response) === null || _r === void 0 ? void 0 : _r.statusText), undefined, e.stack);
+    if (e.response?.status === 500) {
+        return new errors_1.ServerError(data?.message || e.response?.statusText, undefined, e.stack);
     }
     return new errors_1.ServerError('Something went wrong.', undefined, e.stack);
 };

package/dist/cjs/utils/preRestart.js

@@ -3,9 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handlePreRestart = void 0;
 const errors_1 = require("./errors");
 const handlePreRestart = (route) => {
-    var _a;
     for (let index = 0; index < route.steps.length; index++) {
-        const stepHasFailed = ((_a = route.steps[index].execution) === null || _a === void 0 ? void 0 : _a.status) === 'FAILED';
+        const stepHasFailed = route.steps[index].execution?.status === 'FAILED';
         if (stepHasFailed) {
             handleErrorType(route, index);
             deleteFailedProcesses(route, index);
@@ -15,14 +14,13 @@ const handlePreRestart = (route) => {
 };
 exports.handlePreRestart = handlePreRestart;
 const handleErrorType = (route, index) => {
-    var _a, _b, _c, _d;
-    const isGasLimitError = (_a = route.steps[index].execution) === null || _a === void 0 ? void 0 : _a.process.some((p) => { var _a; return ((_a = p.error) === null || _a === void 0 ? void 0 : _a.code) === errors_1.LifiErrorCode.GasLimitError; });
-    const isGasPriceError = (_b = route.steps[index].execution) === null || _b === void 0 ? void 0 : _b.process.some((p) => { var _a; return ((_a = p.error) === null || _a === void 0 ? void 0 : _a.code) === errors_1.LifiErrorCode.TransactionUnderpriced; });
+    const isGasLimitError = route.steps[index].execution?.process.some((p) => p.error?.code === errors_1.LifiErrorCode.GasLimitError);
+    const isGasPriceError = route.steps[index].execution?.process.some((p) => p.error?.code === errors_1.LifiErrorCode.TransactionUnderpriced);
     if (isGasLimitError) {
-        (_c = route.steps[index].estimate.gasCosts) === null || _c === void 0 ? void 0 : _c.forEach((gasCost) => (gasCost.limit = `${Math.round(Number(gasCost.limit) * 1.25)}`));
+        route.steps[index].estimate.gasCosts?.forEach((gasCost) => (gasCost.limit = `${Math.round(Number(gasCost.limit) * 1.25)}`));
     }
     if (isGasPriceError) {
-        (_d = route.steps[index].estimate.gasCosts) === null || _d === void 0 ? void 0 : _d.forEach((gasCost) => (gasCost.price = `${Math.round(Number(gasCost.price) * 1.25)}`));
+        route.steps[index].estimate.gasCosts?.forEach((gasCost) => (gasCost.price = `${Math.round(Number(gasCost.price) * 1.25)}`));
     }
 };
 const deleteFailedProcesses = (route, index) => {

package/dist/cjs/utils/utils.d.ts

@@ -3,7 +3,6 @@ import { Token } from '@lifi/types';
 import BigNumber from 'bignumber.js';
 import { Signer } from 'ethers';
 import { ChainId, Step } from '../types';
-export declare const deepClone: <T>(src: T) => T;
 export declare const sleep: (mills: number) => Promise<undefined>;
 export declare const personalizeStep: (signer: Signer, step: Step) => Promise<Step>;
 export declare const splitListIntoChunks: <T>(list: T[], chunkSize: number) => T[][];

package/dist/cjs/utils/utils.js

@@ -1,41 +1,34 @@
 "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) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNativeTokenAddress = exports.isZeroAddress = exports.loadTransactionReceipt = exports.repeatUntilDone = exports.formatTokenAmountOnly = exports.splitListIntoChunks = exports.personalizeStep = exports.sleep = exports.deepClone = void 0;
+exports.isNativeTokenAddress = exports.isZeroAddress = exports.loadTransactionReceipt = exports.repeatUntilDone = exports.formatTokenAmountOnly = exports.splitListIntoChunks = exports.personalizeStep = exports.sleep = void 0;
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const ethers_1 = require("ethers");
 const connectors_1 = require("../connectors");
-const deepClone = (src) => {
-    return JSON.parse(JSON.stringify(src));
-};
-exports.deepClone = deepClone;
 const sleep = (mills) => {
     return new Promise((resolve) => {
         setTimeout(resolve, mills);
     });
 };
 exports.sleep = sleep;
-const personalizeStep = (signer, step) => __awaiter(void 0, void 0, void 0, function* () {
+const personalizeStep = async (signer, step) => {
     if (step.action.toAddress && step.action.fromAddress) {
         return step;
     }
-    const address = yield signer.getAddress();
+    const address = await signer.getAddress();
     const fromAddress = step.action.fromAddress || address;
     const toAddress = step.action.toAddress || address;
-    return Object.assign(Object.assign({}, step), { action: Object.assign(Object.assign({}, step.action), { fromAddress,
-            toAddress }) });
-});
+    return {
+        ...step,
+        action: {
+            ...step.action,
+            fromAddress,
+            toAddress,
+        },
+    };
+};
 exports.personalizeStep = personalizeStep;
 const splitListIntoChunks = (list, chunkSize) => list.reduce((resultList, item, index) => {
     const chunkIndex = Math.floor(index / chunkSize);
@@ -65,7 +58,7 @@ const formatTokenAmountOnly = (token, amount) => {
     }
     // show at least 4 decimal places and at least two non-zero digests
     let decimalPlaces = 3;
-    while (floated.lt(1 / Math.pow(10, decimalPlaces))) {
+    while (floated.lt(1 / 10 ** decimalPlaces)) {
         decimalPlaces++;
     }
     return floated.toFixed(decimalPlaces + 1, 1);
@@ -77,16 +70,16 @@ exports.formatTokenAmountOnly = formatTokenAmountOnly;
  * @param timeout The timeout in milliseconds between retries, defaults to 5000
  * @returns The result of the toRepeat function
  */
-const repeatUntilDone = (toRepeat, timeout = 5000) => __awaiter(void 0, void 0, void 0, function* () {
+const repeatUntilDone = async (toRepeat, timeout = 5000) => {
     let result;
     while (!result) {
-        result = yield toRepeat();
+        result = await toRepeat();
         if (!result) {
-            yield (0, exports.sleep)(timeout);
+            await (0, exports.sleep)(timeout);
         }
     }
     return result;
-});
+};
 exports.repeatUntilDone = repeatUntilDone;
 /**
  * Loads a transaction receipt using the rpc for the given chain id
@@ -94,11 +87,11 @@ exports.repeatUntilDone = repeatUntilDone;
  * @param txHash The hash of the transaction
  * @returns TransactionReceipt
  */
-const loadTransactionReceipt = (chainId, txHash) => __awaiter(void 0, void 0, void 0, function* () {
-    const rpc = yield (0, connectors_1.getRpcProvider)(chainId);
-    const tx = yield rpc.getTransaction(txHash);
+const loadTransactionReceipt = async (chainId, txHash) => {
+    const rpc = await (0, connectors_1.getRpcProvider)(chainId);
+    const tx = await rpc.getTransaction(txHash);
     return tx.wait();
-});
+};
 exports.loadTransactionReceipt = loadTransactionReceipt;
 const isZeroAddress = (address) => {
     if (address === ethers_1.constants.AddressZero ||

package/dist/cjs/version.d.ts

@@ -1,2 +1,2 @@
 export declare const name = "@lifi/sdk";
-export declare const version = "1.7.1";
+export declare const version = "2.0.0-beta.0";

package/dist/cjs/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = exports.name = void 0;
 exports.name = '@lifi/sdk';
-exports.version = '1.7.1';
+exports.version = '2.0.0-beta.0';

package/dist/connectors.js

@@ -1,16 +1,8 @@
-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) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { providers } from 'ethers';
-import { getRandomNumber, ServerError } from '.';
 import { ChainId } from './types';
 import ConfigService from './services/ConfigService';
+import { getRandomNumber } from './helpers';
+import { ServerError } from './utils/errors';
 // cached providers
 const chainProviders = {};
 // Archive RPC Provider
@@ -21,33 +13,33 @@ const archiveRpcs = {
     [ChainId.FTM]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/fantom/mainnet',
 };
 // RPC Urls
-export const getRpcUrl = (chainId, archive = false) => __awaiter(void 0, void 0, void 0, function* () {
-    const rpcUrls = yield getRpcUrls(chainId, archive);
+export const getRpcUrl = async (chainId, archive = false) => {
+    const rpcUrls = await getRpcUrls(chainId, archive);
     return rpcUrls[0];
-});
-export const getRpcUrls = (chainId, archive = false) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const getRpcUrls = async (chainId, archive = false) => {
     if (archive && archiveRpcs[chainId]) {
         return [archiveRpcs[chainId]];
     }
     const configService = ConfigService.getInstance();
-    const config = yield configService.getConfigAsync();
+    const config = await configService.getConfigAsync();
     return config.rpcs[chainId];
-});
+};
 const getRandomProvider = (providerList) => {
     const index = getRandomNumber(0, providerList.length - 1);
     return providerList[index];
 };
 // Provider
-export const getRpcProvider = (chainId, archive = false) => __awaiter(void 0, void 0, void 0, function* () {
+export const getRpcProvider = async (chainId, archive = false) => {
     if (archive && archiveRpcs[chainId]) {
         // return archive PRC, but don't cache it
         return new providers.FallbackProvider([
-            new providers.StaticJsonRpcProvider(yield getRpcUrl(chainId, archive), chainId),
+            new providers.StaticJsonRpcProvider(await getRpcUrl(chainId, archive), chainId),
         ]);
     }
     if (!chainProviders[chainId]) {
         chainProviders[chainId] = [];
-        const urls = yield getRpcUrls(chainId, archive);
+        const urls = await getRpcUrls(chainId, archive);
         urls.forEach((url) => {
             chainProviders[chainId].push(new providers.FallbackProvider([
                 new providers.StaticJsonRpcProvider(url, chainId),
@@ -58,10 +50,10 @@ export const getRpcProvider = (chainId, archive = false) => __awaiter(void 0, vo
         throw new ServerError(`Unable to configure provider for chain ${chainId}`);
     }
     return getRandomProvider(chainProviders[chainId]);
-});
+};
 // Multicall
-export const getMulticallAddress = (chainId) => __awaiter(void 0, void 0, void 0, function* () {
+export const getMulticallAddress = async (chainId) => {
     const configService = ConfigService.getInstance();
-    const config = yield configService.getConfigAsync();
+    const config = await configService.getConfigAsync();
     return config.multicallAddresses[chainId];
-});
+};

package/dist/execution/ExecutionManager.js

@@ -1,12 +1,3 @@
-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) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { checkAllowance } from '../allowance';
 import { checkBalance } from '../balance';
 import ApiService from '../services/ApiService';
@@ -24,20 +15,19 @@ export class ExecutionManager {
         this.allowInteraction = (value) => {
             this.allowUserInteraction = value;
         };
-        this.execute = ({ signer, step, statusManager, settings, }) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
+        this.execute = async ({ signer, step, statusManager, settings, }) => {
             step.execution = statusManager.initExecutionObject(step);
             const chainsService = ChainsService.getInstance();
-            const fromChain = yield chainsService.getChainById(step.action.fromChainId);
-            const toChain = yield chainsService.getChainById(step.action.toChainId);
+            const fromChain = await chainsService.getChainById(step.action.fromChainId);
+            const toChain = await chainsService.getChainById(step.action.toChainId);
             const isBridgeExecution = fromChain.id !== toChain.id;
             const currentProcessType = isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP';
             // STEP 1: Check allowance
             const existingProcess = step.execution.process.find((p) => p.type === currentProcessType);
             // Check token approval only if fromToken is not the native token => no approval needed in that case
-            if (!(existingProcess === null || existingProcess === void 0 ? void 0 : existingProcess.txHash) &&
+            if (!existingProcess?.txHash &&
                 !isZeroAddress(step.action.fromToken.address)) {
-                yield checkAllowance(signer, step, statusManager, settings, fromChain, this.allowUserInteraction);
+                await checkAllowance(signer, step, statusManager, settings, fromChain, this.allowUserInteraction);
             }
             // STEP 2: Get transaction
             let process = statusManager.findOrCreateProcess(step, currentProcessType);
@@ -46,25 +36,28 @@ export class ExecutionManager {
                     let transaction;
                     if (process.txHash) {
                         // Make sure that the chain is still correct
-                        const updatedSigner = yield switchChain(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
+                        const updatedSigner = await 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(process.txHash);
+                        transaction = await getProvider(signer).getTransaction(process.txHash);
                     }
                     else {
                         process = statusManager.updateProcess(step, process.type, 'STARTED');
                         // Check balance
-                        yield checkBalance(signer, step);
+                        await checkBalance(signer, step);
                         // Create new transaction
                         if (!step.transactionRequest) {
-                            const personalizedStep = yield personalizeStep(signer, step);
-                            const updatedStep = yield ApiService.getStepTransaction(personalizedStep);
-                            const comparedStep = yield stepComparison(statusManager, personalizedStep, updatedStep, settings, this.allowUserInteraction);
-                            step = Object.assign(Object.assign({}, comparedStep), { execution: step.execution });
+                            const personalizedStep = await personalizeStep(signer, step);
+                            const updatedStep = await ApiService.getStepTransaction(personalizedStep);
+                            const comparedStep = await stepComparison(statusManager, personalizedStep, updatedStep, settings, this.allowUserInteraction);
+                            step = {
+                                ...comparedStep,
+                                execution: step.execution,
+                            };
                         }
                         const { transactionRequest } = step;
                         if (!transactionRequest) {
@@ -72,7 +65,7 @@ export class ExecutionManager {
                         }
                         // STEP 3: Send the transaction
                         // Make sure that the chain is still correct
-                        const updatedSigner = yield switchChain(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
+                        const updatedSigner = await switchChain(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
                         if (!updatedSigner) {
                             // Chain switch was not successful, stop execution here
                             return step.execution;
@@ -83,7 +76,7 @@ export class ExecutionManager {
                             return step.execution;
                         }
                         // Submit the transaction
-                        transaction = yield signer.sendTransaction(transactionRequest);
+                        transaction = await signer.sendTransaction(transactionRequest);
                         // STEP 4: Wait for the transaction
                         process = statusManager.updateProcess(step, process.type, 'PENDING', {
                             txHash: transaction.hash,
@@ -92,7 +85,7 @@ export class ExecutionManager {
                                 transaction.hash,
                         });
                     }
-                    yield transaction.wait();
+                    await transaction.wait();
                     process = statusManager.updateProcess(step, process.type, 'PENDING', {
                         txHash: transaction.hash,
                         txLink: fromChain.metamask.blockExplorerUrls[0] + 'tx/' + transaction.hash,
@@ -111,7 +104,7 @@ export class ExecutionManager {
                         });
                     }
                     else {
-                        const error = yield parseError(e, step, process);
+                        const error = await parseError(e, step, process);
                         process = statusManager.updateProcess(step, process.type, 'FAILED', {
                             error: {
                                 message: error.message,
@@ -134,20 +127,20 @@ export class ExecutionManager {
                 if (!processTxHash) {
                     throw new Error('Transaction hash is undefined.');
                 }
-                statusResponse = yield waitForReceivingTransaction(processTxHash, statusManager, process.type, step);
+                statusResponse = await waitForReceivingTransaction(processTxHash, statusManager, process.type, step);
                 process = statusManager.updateProcess(step, process.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,
+                    txHash: statusResponse.receiving?.txHash,
                     txLink: toChain.metamask.blockExplorerUrls[0] +
                         'tx/' +
-                        ((_b = statusResponse.receiving) === null || _b === void 0 ? void 0 : _b.txHash),
+                        statusResponse.receiving?.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,
+                    toAmount: statusResponse.receiving?.amount,
+                    toToken: statusResponse.receiving?.token,
                     gasAmount: statusResponse.sending.gasAmount,
                     gasAmountUSD: statusResponse.sending.gasAmountUSD,
                     gasPrice: statusResponse.sending.gasPrice,
@@ -156,11 +149,12 @@ export class ExecutionManager {
                 });
             }
             catch (e) {
+                const htmlMessage = await getTransactionFailedMessage(step, process.txLink);
                 process = statusManager.updateProcess(step, process.type, 'FAILED', {
                     error: {
                         code: LifiErrorCode.TransactionFailed,
                         message: 'Failed while waiting for receiving chain.',
-                        htmlMessage: getTransactionFailedMessage(step, process.txLink),
+                        htmlMessage,
                     },
                 });
                 statusManager.updateExecution(step, 'FAILED');
@@ -169,6 +163,6 @@ export class ExecutionManager {
             }
             // DONE
             return step.execution;
-        });
+        };
     }
 }