@lifi/sdk 1.7.2 → 2.0.0-beta.1

package/dist/cjs/allowance/utils.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,30 +10,30 @@ const ChainsService_1 = __importDefault(require("../services/ChainsService"));
 const types_1 = require("../types");
 const errors_1 = require("../utils/errors");
 const multicall_1 = require("../utils/multicall");
-const getApproved = (signer, tokenAddress, contractAddress) => __awaiter(void 0, void 0, void 0, function* () {
-    const signerAddress = yield signer.getAddress();
+const getApproved = async (signer, tokenAddress, contractAddress) => {
+    const signerAddress = await signer.getAddress();
     const erc20 = new ethers_1.Contract(tokenAddress, types_1.ERC20_ABI, signer);
     try {
-        const approved = yield erc20.allowance(signerAddress, contractAddress);
+        const approved = await erc20.allowance(signerAddress, contractAddress);
         return new bignumber_js_1.default(approved.toString());
     }
     catch (e) {
         return new bignumber_js_1.default(0);
     }
-});
+};
 exports.getApproved = getApproved;
 const setApproval = (signer, tokenAddress, contractAddress, amount) => {
     const erc20 = new ethers_1.Contract(tokenAddress, types_1.ERC20_ABI, signer);
     return erc20.approve(contractAddress, amount);
 };
 exports.setApproval = setApproval;
-const getAllowanceViaMulticall = (signer, chainId, tokenData) => __awaiter(void 0, void 0, void 0, function* () {
+const getAllowanceViaMulticall = async (signer, chainId, tokenData) => {
     const chainsService = ChainsService_1.default.getInstance();
-    const chain = yield chainsService.getChainById(chainId);
+    const chain = await chainsService.getChainById(chainId);
     if (!chain.multicallAddress) {
         throw new errors_1.ServerError(`No multicall address configured for chainId ${chainId}.`);
     }
-    const ownerAddress = yield signer.getAddress();
+    const ownerAddress = await signer.getAddress();
     const calls = [];
     tokenData.map(({ token, approvalAddress }) => {
         calls.push({
@@ -51,22 +42,19 @@ const getAllowanceViaMulticall = (signer, chainId, tokenData) => __awaiter(void
             params: [ownerAddress, approvalAddress],
         });
     });
-    const result = yield (0, multicall_1.fetchDataUsingMulticall)(calls, types_1.ERC20_ABI, chainId, chain.multicallAddress);
+    const result = await (0, multicall_1.fetchDataUsingMulticall)(calls, types_1.ERC20_ABI, chainId, chain.multicallAddress);
     if (!result.length) {
         throw new errors_1.ServerError(`Couldn't load allowance from chainId ${chainId} using multicall.`);
     }
-    const parsedResult = result.map(({ data }) => {
-        var _a;
-        return ({
-            approvalAmount: (_a = data) !== null && _a !== void 0 ? _a : new bignumber_js_1.default(0),
-        });
-    });
+    const parsedResult = result.map(({ data }) => ({
+        approvalAmount: data ?? new bignumber_js_1.default(0),
+    }));
     return tokenData.map(({ token, approvalAddress }, i) => ({
         token,
         approvalAddress,
         approvedAmount: parsedResult[i].approvalAmount,
     }));
-});
+};
 exports.getAllowanceViaMulticall = getAllowanceViaMulticall;
 const groupByChain = (tokenDataList) => {
     // group by chain

package/dist/cjs/balance/checkBalance.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 };
 };
@@ -16,17 +7,17 @@ exports.checkBalance = void 0;
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const errors_1 = require("../utils/errors");
 const getTokenBalance_1 = require("./getTokenBalance");
-const checkBalance = (signer, step, depth = 0) => __awaiter(void 0, void 0, void 0, function* () {
-    const tokenAmount = yield (0, getTokenBalance_1.getTokenBalance)(yield signer.getAddress(), step.action.fromToken);
+const checkBalance = async (signer, step, depth = 0) => {
+    const tokenAmount = await (0, getTokenBalance_1.getTokenBalance)(await signer.getAddress(), step.action.fromToken);
     if (tokenAmount) {
         const currentBalance = new bignumber_js_1.default(tokenAmount.amount).shiftedBy(tokenAmount.decimals);
         const neededBalance = new bignumber_js_1.default(step.action.fromAmount);
         if (currentBalance.lt(neededBalance)) {
             if (depth <= 3) {
-                yield new Promise((resolve) => {
+                await new Promise((resolve) => {
                     setTimeout(resolve, 200);
                 });
-                yield (0, exports.checkBalance)(signer, step, depth + 1);
+                await (0, exports.checkBalance)(signer, step, depth + 1);
             }
             else if (neededBalance.multipliedBy(1 - step.action.slippage).lte(currentBalance)) {
                 // adjust amount in slippage limits
@@ -50,5 +41,5 @@ const checkBalance = (signer, step, depth = 0) => __awaiter(void 0, void 0, void
             }
         }
     }
-});
+};
 exports.checkBalance = checkBalance;

package/dist/cjs/balance/getTokenBalance.js

@@ -1,25 +1,16 @@
 "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.getTokenBalancesForChains = exports.getTokenBalances = exports.getTokenBalance = void 0;
 const utils_1 = __importDefault(require("./utils"));
-const getTokenBalance = (walletAddress, token) => __awaiter(void 0, void 0, void 0, function* () {
-    const tokenAmounts = yield (0, exports.getTokenBalances)(walletAddress, [token]);
+const getTokenBalance = async (walletAddress, token) => {
+    const tokenAmounts = await (0, exports.getTokenBalances)(walletAddress, [token]);
     return tokenAmounts.length ? tokenAmounts[0] : null;
-});
+};
 exports.getTokenBalance = getTokenBalance;
-const getTokenBalances = (walletAddress, tokens) => __awaiter(void 0, void 0, void 0, function* () {
+const getTokenBalances = async (walletAddress, tokens) => {
     // split by chain
     const tokensByChain = {};
     tokens.forEach((token) => {
@@ -28,18 +19,18 @@ const getTokenBalances = (walletAddress, tokens) => __awaiter(void 0, void 0, vo
         }
         tokensByChain[token.chainId].push(token);
     });
-    const tokenAmountsByChain = yield (0, exports.getTokenBalancesForChains)(walletAddress, tokensByChain);
+    const tokenAmountsByChain = await (0, exports.getTokenBalancesForChains)(walletAddress, tokensByChain);
     return Object.values(tokenAmountsByChain).flat();
-});
+};
 exports.getTokenBalances = getTokenBalances;
-const getTokenBalancesForChains = (walletAddress, tokensByChain) => __awaiter(void 0, void 0, void 0, function* () {
+const getTokenBalancesForChains = async (walletAddress, tokensByChain) => {
     const tokenAmountsByChain = {};
-    const promises = Object.keys(tokensByChain).map((chainIdStr) => __awaiter(void 0, void 0, void 0, function* () {
+    const promises = Object.keys(tokensByChain).map(async (chainIdStr) => {
         const chainId = parseInt(chainIdStr);
-        const tokenAmounts = yield utils_1.default.getBalances(walletAddress, tokensByChain[chainId]);
+        const tokenAmounts = await utils_1.default.getBalances(walletAddress, tokensByChain[chainId]);
         tokenAmountsByChain[chainId] = tokenAmounts;
-    }));
-    yield Promise.allSettled(promises);
+    });
+    await Promise.allSettled(promises);
     return tokenAmountsByChain;
-});
+};
 exports.getTokenBalancesForChains = getTokenBalancesForChains;

package/dist/cjs/balance/index.d.ts

@@ -1,2 +1,13 @@
 export * from './checkBalance';
 export * from './getTokenBalance';
+declare const _default: {
+    checkBalance: (signer: import("ethers").Signer, step: import("@lifi/types").Step, depth?: number) => Promise<void>;
+    getTokenBalance: (walletAddress: string, token: import("@lifi/types").Token) => Promise<import("@lifi/types").TokenAmount | null>;
+    getTokenBalances: (walletAddress: string, tokens: import("@lifi/types").Token[]) => Promise<import("@lifi/types").TokenAmount[]>;
+    getTokenBalancesForChains: (walletAddress: string, tokensByChain: {
+        [chainId: number]: import("@lifi/types").Token[];
+    }) => Promise<{
+        [chainId: number]: import("@lifi/types").TokenAmount[];
+    }>;
+};
+export default _default;

package/dist/cjs/balance/index.js

@@ -16,3 +16,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./checkBalance"), exports);
 __exportStar(require("./getTokenBalance"), exports);
+const checkBalance_1 = require("./checkBalance");
+const getTokenBalance_1 = require("./getTokenBalance");
+exports.default = {
+    checkBalance: checkBalance_1.checkBalance,
+    getTokenBalance: getTokenBalance_1.getTokenBalance,
+    getTokenBalances: getTokenBalance_1.getTokenBalances,
+    getTokenBalancesForChains: getTokenBalance_1.getTokenBalancesForChains,
+};

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

@@ -1,4 +1,5 @@
 import { Token, TokenAmount } from '@lifi/types';
+export declare const getBalances: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;
 declare const _default: {
     getBalances: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;
 };

package/dist/cjs/balance/utils.js

@@ -1,17 +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.getBalances = void 0;
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const ethers_1 = require("ethers");
 const connectors_1 = require("../connectors");
@@ -37,7 +29,7 @@ const balanceAbi = [
         type: 'function',
     },
 ];
-const getBalances = (walletAddress, tokens) => __awaiter(void 0, void 0, void 0, function* () {
+const getBalances = async (walletAddress, tokens) => {
     if (tokens.length === 0) {
         return [];
     }
@@ -49,23 +41,24 @@ const getBalances = (walletAddress, tokens) => __awaiter(void 0, void 0, void 0,
             return [];
         }
     });
-    if ((yield (0, connectors_1.getMulticallAddress)(chainId)) && tokens.length > 1) {
+    if ((await (0, connectors_1.getMulticallAddress)(chainId)) && tokens.length > 1) {
         return getBalancesFromProviderUsingMulticall(walletAddress, tokens);
     }
     else {
         return getBalancesFromProvider(walletAddress, tokens);
     }
-});
-const getBalancesFromProviderUsingMulticall = (walletAddress, tokens) => __awaiter(void 0, void 0, void 0, function* () {
+};
+exports.getBalances = getBalances;
+const getBalancesFromProviderUsingMulticall = async (walletAddress, tokens) => {
     // Configuration
     const { chainId } = tokens[0];
-    const multicallAddress = yield (0, connectors_1.getMulticallAddress)(chainId);
+    const multicallAddress = await (0, connectors_1.getMulticallAddress)(chainId);
     if (!multicallAddress) {
         throw new Error('No multicallAddress found for the given chain.');
     }
     return executeMulticall(walletAddress, tokens, multicallAddress, chainId);
-});
-const executeMulticall = (walletAddress, tokens, multicallAddress, chainId) => __awaiter(void 0, void 0, void 0, function* () {
+};
+const executeMulticall = async (walletAddress, tokens, multicallAddress, chainId) => {
     // Collect calls we want to make
     const calls = [];
     tokens.map((token) => {
@@ -84,7 +77,7 @@ const executeMulticall = (walletAddress, tokens, multicallAddress, chainId) => _
             });
         }
     });
-    const res = yield fetchViaMulticall(calls, balanceAbi, chainId, multicallAddress);
+    const res = await fetchViaMulticall(calls, balanceAbi, chainId, multicallAddress);
     if (!res.length) {
         return [];
     }
@@ -92,24 +85,28 @@ const executeMulticall = (walletAddress, tokens, multicallAddress, chainId) => _
         const amount = new bignumber_js_1.default(res[i].amount.toString() || '0')
             .shiftedBy(-token.decimals)
             .toFixed();
-        return Object.assign(Object.assign({}, token), { amount: amount || '0', blockNumber: res[i].blockNumber });
+        return {
+            ...token,
+            amount: amount || '0',
+            blockNumber: res[i].blockNumber,
+        };
     });
-});
-const fetchViaMulticall = (calls, abi, chainId, multicallAddress) => __awaiter(void 0, void 0, void 0, function* () {
-    const result = yield (0, multicall_1.fetchDataUsingMulticall)(calls, abi, chainId, multicallAddress);
+};
+const fetchViaMulticall = async (calls, abi, chainId, multicallAddress) => {
+    const result = await (0, multicall_1.fetchDataUsingMulticall)(calls, abi, chainId, multicallAddress);
     return result.map(({ data, blockNumber }) => ({
         amount: data ? data : new bignumber_js_1.default(0),
         blockNumber,
     }));
-});
-const getBalancesFromProvider = (walletAddress, tokens) => __awaiter(void 0, void 0, void 0, function* () {
+};
+const getBalancesFromProvider = async (walletAddress, tokens) => {
     const chainId = tokens[0].chainId;
-    const rpc = yield (0, connectors_1.getRpcProvider)(chainId);
-    const tokenAmountPromises = tokens.map((token) => __awaiter(void 0, void 0, void 0, function* () {
+    const rpc = await (0, connectors_1.getRpcProvider)(chainId);
+    const tokenAmountPromises = tokens.map(async (token) => {
         let amount = '0';
         let blockNumber;
         try {
-            const balance = yield getBalanceFromProvider(walletAddress, token.address, chainId, rpc);
+            const balance = await getBalanceFromProvider(walletAddress, token.address, chainId, rpc);
             amount = new bignumber_js_1.default(balance.amount.toString())
                 .shiftedBy(-token.decimals)
                 .toString();
@@ -119,20 +116,23 @@ const getBalancesFromProvider = (walletAddress, tokens) => __awaiter(void 0, voi
             // eslint-disable-next-line no-console
             console.warn(e);
         }
-        return Object.assign(Object.assign({}, token), { amount,
-            blockNumber });
-    }));
+        return {
+            ...token,
+            amount,
+            blockNumber,
+        };
+    });
     return Promise.all(tokenAmountPromises);
-});
-const getBalanceFromProvider = (walletAddress, assetId, chainId, provider) => __awaiter(void 0, void 0, void 0, function* () {
-    const blockNumber = yield getCurrentBlockNumber(chainId);
+};
+const getBalanceFromProvider = async (walletAddress, assetId, chainId, provider) => {
+    const blockNumber = await getCurrentBlockNumber(chainId);
     let balance;
     if ((0, utils_1.isZeroAddress)(assetId)) {
-        balance = yield provider.getBalance(walletAddress, blockNumber);
+        balance = await provider.getBalance(walletAddress, blockNumber);
     }
     else {
         const contract = new ethers_1.ethers.Contract(assetId, ['function balanceOf(address owner) view returns (uint256)'], provider);
-        balance = yield contract.balanceOf(walletAddress, {
+        balance = await contract.balanceOf(walletAddress, {
             blockTag: blockNumber,
         });
     }
@@ -140,11 +140,11 @@ const getBalanceFromProvider = (walletAddress, assetId, chainId, provider) => __
         amount: balance,
         blockNumber,
     };
-});
-const getCurrentBlockNumber = (chainId) => __awaiter(void 0, void 0, void 0, function* () {
-    const rpc = yield (0, connectors_1.getRpcProvider)(chainId);
+};
+const getCurrentBlockNumber = async (chainId) => {
+    const rpc = await (0, connectors_1.getRpcProvider)(chainId);
     return rpc.getBlockNumber();
-});
+};
 exports.default = {
-    getBalances,
+    getBalances: exports.getBalances,
 };

package/dist/cjs/connectors.js

@@ -1,22 +1,14 @@
 "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.getMulticallAddress = exports.getRpcProvider = exports.getRpcUrls = exports.getRpcUrl = void 0;
 const ethers_1 = require("ethers");
-const _1 = require(".");
 const types_1 = require("./types");
 const ConfigService_1 = __importDefault(require("./services/ConfigService"));
+const helpers_1 = require("./helpers");
+const errors_1 = require("./utils/errors");
 // cached providers
 const chainProviders = {};
 // Archive RPC Provider
@@ -27,35 +19,35 @@ const archiveRpcs = {
     [types_1.ChainId.FTM]: 'https://speedy-nodes-nyc.moralis.io/5ed6053dc39eba789ff466c9/fantom/mainnet',
 };
 // RPC Urls
-const getRpcUrl = (chainId, archive = false) => __awaiter(void 0, void 0, void 0, function* () {
-    const rpcUrls = yield (0, exports.getRpcUrls)(chainId, archive);
+const getRpcUrl = async (chainId, archive = false) => {
+    const rpcUrls = await (0, exports.getRpcUrls)(chainId, archive);
     return rpcUrls[0];
-});
+};
 exports.getRpcUrl = getRpcUrl;
-const getRpcUrls = (chainId, archive = false) => __awaiter(void 0, void 0, void 0, function* () {
+const getRpcUrls = async (chainId, archive = false) => {
     if (archive && archiveRpcs[chainId]) {
         return [archiveRpcs[chainId]];
     }
     const configService = ConfigService_1.default.getInstance();
-    const config = yield configService.getConfigAsync();
+    const config = await configService.getConfigAsync();
     return config.rpcs[chainId];
-});
+};
 exports.getRpcUrls = getRpcUrls;
 const getRandomProvider = (providerList) => {
-    const index = (0, _1.getRandomNumber)(0, providerList.length - 1);
+    const index = (0, helpers_1.getRandomNumber)(0, providerList.length - 1);
     return providerList[index];
 };
 // Provider
-const getRpcProvider = (chainId, archive = false) => __awaiter(void 0, void 0, void 0, function* () {
+const getRpcProvider = async (chainId, archive = false) => {
     if (archive && archiveRpcs[chainId]) {
         // return archive PRC, but don't cache it
         return new ethers_1.providers.FallbackProvider([
-            new ethers_1.providers.StaticJsonRpcProvider(yield (0, exports.getRpcUrl)(chainId, archive), chainId),
+            new ethers_1.providers.StaticJsonRpcProvider(await (0, exports.getRpcUrl)(chainId, archive), chainId),
         ]);
     }
     if (!chainProviders[chainId]) {
         chainProviders[chainId] = [];
-        const urls = yield (0, exports.getRpcUrls)(chainId, archive);
+        const urls = await (0, exports.getRpcUrls)(chainId, archive);
         urls.forEach((url) => {
             chainProviders[chainId].push(new ethers_1.providers.FallbackProvider([
                 new ethers_1.providers.StaticJsonRpcProvider(url, chainId),
@@ -63,15 +55,15 @@ const getRpcProvider = (chainId, archive = false) => __awaiter(void 0, void 0, v
         });
     }
     if (!chainProviders[chainId].length) {
-        throw new _1.ServerError(`Unable to configure provider for chain ${chainId}`);
+        throw new errors_1.ServerError(`Unable to configure provider for chain ${chainId}`);
     }
     return getRandomProvider(chainProviders[chainId]);
-});
+};
 exports.getRpcProvider = getRpcProvider;
 // Multicall
-const getMulticallAddress = (chainId) => __awaiter(void 0, void 0, void 0, function* () {
+const getMulticallAddress = async (chainId) => {
     const configService = ConfigService_1.default.getInstance();
-    const config = yield configService.getConfigAsync();
+    const config = await configService.getConfigAsync();
     return config.multicallAddresses[chainId];
-});
+};
 exports.getMulticallAddress = getMulticallAddress;

package/dist/cjs/execution/ExecutionManager.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 };
 };
@@ -30,20 +21,19 @@ 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_1.default.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 &&
                 !(0, utils_1.isZeroAddress)(step.action.fromToken.address)) {
-                yield (0, allowance_1.checkAllowance)(signer, step, statusManager, settings, fromChain, this.allowUserInteraction);
+                await (0, allowance_1.checkAllowance)(signer, step, statusManager, settings, fromChain, this.allowUserInteraction);
             }
             // STEP 2: Get transaction
             let process = statusManager.findOrCreateProcess(step, currentProcessType);
@@ -52,25 +42,28 @@ class ExecutionManager {
                     let transaction;
                     if (process.txHash) {
                         // Make sure that the chain is still correct
-                        const updatedSigner = yield (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
+                        const updatedSigner = await (0, switchChain_1.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 (0, getProvider_1.getProvider)(signer).getTransaction(process.txHash);
+                        transaction = await (0, getProvider_1.getProvider)(signer).getTransaction(process.txHash);
                     }
                     else {
                         process = statusManager.updateProcess(step, process.type, 'STARTED');
                         // Check balance
-                        yield (0, balance_1.checkBalance)(signer, step);
+                        await (0, balance_1.checkBalance)(signer, step);
                         // Create new transaction
                         if (!step.transactionRequest) {
-                            const personalizedStep = yield (0, utils_1.personalizeStep)(signer, step);
-                            const updatedStep = yield ApiService_1.default.getStepTransaction(personalizedStep);
-                            const comparedStep = yield (0, stepComparison_1.stepComparison)(statusManager, personalizedStep, updatedStep, settings, this.allowUserInteraction);
-                            step = Object.assign(Object.assign({}, comparedStep), { execution: step.execution });
+                            const personalizedStep = await (0, utils_1.personalizeStep)(signer, step);
+                            const updatedStep = await ApiService_1.default.getStepTransaction(personalizedStep);
+                            const comparedStep = await (0, stepComparison_1.stepComparison)(statusManager, personalizedStep, updatedStep, settings, this.allowUserInteraction);
+                            step = {
+                                ...comparedStep,
+                                execution: step.execution,
+                            };
                         }
                         const { transactionRequest } = step;
                         if (!transactionRequest) {
@@ -78,7 +71,7 @@ class ExecutionManager {
                         }
                         // STEP 3: Send the transaction
                         // Make sure that the chain is still correct
-                        const updatedSigner = yield (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
+                        const updatedSigner = await (0, switchChain_1.switchChain)(signer, statusManager, step, settings.switchChainHook, this.allowUserInteraction);
                         if (!updatedSigner) {
                             // Chain switch was not successful, stop execution here
                             return step.execution;
@@ -89,7 +82,7 @@ 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,
@@ -98,7 +91,7 @@ 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,
@@ -117,7 +110,7 @@ class ExecutionManager {
                         });
                     }
                     else {
-                        const error = yield (0, parseError_1.parseError)(e, step, process);
+                        const error = await (0, parseError_1.parseError)(e, step, process);
                         process = statusManager.updateProcess(step, process.type, 'FAILED', {
                             error: {
                                 message: error.message,
@@ -140,20 +133,20 @@ class ExecutionManager {
                 if (!processTxHash) {
                     throw new Error('Transaction hash is undefined.');
                 }
-                statusResponse = yield (0, utils_2.waitForReceivingTransaction)(processTxHash, statusManager, process.type, step);
+                statusResponse = await (0, utils_2.waitForReceivingTransaction)(processTxHash, statusManager, process.type, step);
                 process = statusManager.updateProcess(step, process.type, 'DONE', {
                     substatus: statusResponse.substatus,
                     substatusMessage: statusResponse.substatusMessage ||
                         (0, utils_2.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,
@@ -162,11 +155,12 @@ class ExecutionManager {
                 });
             }
             catch (e) {
+                const htmlMessage = await (0, parseError_1.getTransactionFailedMessage)(step, process.txLink);
                 process = statusManager.updateProcess(step, process.type, 'FAILED', {
                     error: {
                         code: errors_1.LifiErrorCode.TransactionFailed,
                         message: 'Failed while waiting for receiving chain.',
-                        htmlMessage: (0, parseError_1.getTransactionFailedMessage)(step, process.txLink),
+                        htmlMessage,
                     },
                 });
                 statusManager.updateExecution(step, 'FAILED');
@@ -175,7 +169,7 @@ class ExecutionManager {
             }
             // DONE
             return step.execution;
-        });
+        };
     }
 }
 exports.ExecutionManager = ExecutionManager;