@lifi/sdk 1.7.2 → 2.0.0-beta.1

package/dist/cjs/Lifi.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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 };
 };
@@ -47,7 +38,6 @@ const ConfigService_1 = __importDefault(require("./services/ConfigService"));
 const typeguards_1 = require("./typeguards");
 const errors_1 = require("./utils/errors");
 const preRestart_1 = require("./utils/preRestart");
-const utils_1 = require("./utils/utils");
 const version_1 = require("./version");
 class LIFI {
     constructor(configUpdate) {
@@ -89,84 +79,84 @@ class LIFI {
          * @return {Promise<PossibilitiesResponse>} Object listing current possibilities for any-to-any cross-chain-swaps based on the provided preferences.
          * @throws {LifiError} Throws a LifiError if request fails.
          */
-        this.getPossibilities = (request, options) => __awaiter(this, void 0, void 0, function* () {
+        this.getPossibilities = async (request, options) => {
             return ApiService_1.default.getPossibilities(request, options);
-        });
+        };
         /**
          * Fetch information about a Token
          * @param {ChainKey | ChainId} chain - Id or key of the chain that contains the token
          * @param {string} token - Address or symbol of the token on the requested chain
          * @throws {LifiError} - Throws a LifiError if request fails
          */
-        this.getToken = (chain, token, options) => __awaiter(this, void 0, void 0, function* () {
+        this.getToken = async (chain, token, options) => {
             return ApiService_1.default.getToken(chain, token, options);
-        });
+        };
         /**
          * Get a quote for a token transfer
          * @param {QuoteRequest} request - The configuration of the requested quote
          * @throws {LifiError} - Throws a LifiError if request fails
          */
-        this.getQuote = (request, options) => __awaiter(this, void 0, void 0, function* () {
+        this.getQuote = async (request, options) => {
             return ApiService_1.default.getQuote(request, options);
-        });
+        };
         /**
          * Get a quote for a destination contract call
          * @param {ContractCallQuoteRequest} request - The configuration of the requested destination call
          * @throws {LifiError} - Throws a LifiError if request fails
          */
-        this.getContractCallQuote = (request, options) => __awaiter(this, void 0, void 0, function* () {
+        this.getContractCallQuote = async (request, options) => {
             return ApiService_1.default.getContractCallQuote(request, options);
-        });
+        };
         /**
          * Check the status of a transfer. For cross chain transfers, the "bridge" parameter is required.
          * @param {GetStatusRequest} request - Configuration of the requested status
          * @throws {LifiError} - Throws a LifiError if request fails
          */
-        this.getStatus = (request, options) => __awaiter(this, void 0, void 0, function* () {
+        this.getStatus = async (request, options) => {
             return ApiService_1.default.getStatus(request, options);
-        });
+        };
         /**
          * Get the available tools to bridge and swap tokens.
          * @param {ToolsRequest?} request - The configuration of the requested tools
          * @returns The tools that are available on the requested chains
          */
-        this.getTools = (request, options) => __awaiter(this, void 0, void 0, function* () {
+        this.getTools = async (request, options) => {
             return ApiService_1.default.getTools(request || {}, options);
-        });
+        };
         /**
          * Get all known tokens.
          * @param {TokensRequest?} request - The configuration of the requested tokens
          * @returns The tokens that are available on the requested chains
          */
-        this.getTokens = (request, options) => __awaiter(this, void 0, void 0, function* () {
+        this.getTokens = async (request, options) => {
             return ApiService_1.default.getTokens(request || {}, options);
-        });
+        };
         /**
          * Get all available chains
          * @return {Promise<Chain[]>} A list of all available chains
          * @throws {LifiError} Throws a LifiError if request fails.
          */
-        this.getChains = () => __awaiter(this, void 0, void 0, function* () {
+        this.getChains = async () => {
             return this.chainsService.getChains();
-        });
+        };
         /**
          * Get a set of routes for a request that describes a transfer of tokens.
          * @param {RoutesRequest} routesRequest - A description of the transfer.
          * @return {Promise<RoutesResponse>} The resulting routes that can be used to realize the described transfer of tokens.
          * @throws {LifiError} Throws a LifiError if request fails.
          */
-        this.getRoutes = (request, options) => __awaiter(this, void 0, void 0, function* () {
+        this.getRoutes = async (request, options) => {
             return ApiService_1.default.getRoutes(request, options);
-        });
+        };
         /**
          * Get the transaction data for a single step of a route
          * @param {Step} step - The step object.
          * @return {Promise<Step>} The step populated with the transaction data.
          * @throws {LifiError} Throws a LifiError if request fails.
          */
-        this.getStepTransaction = (step, options) => __awaiter(this, void 0, void 0, function* () {
+        this.getStepTransaction = async (step, options) => {
             return ApiService_1.default.getStepTransaction(step, options);
-        });
+        };
         /**
          * Stops the execution of an active route.
          * @param {Route} route - A route that is currently in execution.
@@ -176,7 +166,8 @@ class LIFI {
             if (!this.activeRouteDictionary[route.id]) {
                 return route;
             }
-            for (const executor of this.activeRouteDictionary[route.id].executors) {
+            const { executionData } = this.activeRouteDictionary[route.id];
+            for (const executor of executionData.executors) {
                 executor.setInteraction({
                     allowInteraction: false,
                     allowUpdates: false,
@@ -192,14 +183,17 @@ class LIFI {
          * @deprecated use updateRouteExecution instead.
          */
         this.moveExecutionToBackground = (route) => {
-            const activeRoute = this.activeRouteDictionary[route.id];
-            if (!activeRoute) {
+            const { executionData } = this.activeRouteDictionary[route.id];
+            if (!executionData) {
                 return;
             }
-            for (const executor of activeRoute.executors) {
+            for (const executor of executionData.executors) {
                 executor.setInteraction({ allowInteraction: false, allowUpdates: true });
             }
-            activeRoute.settings = Object.assign(Object.assign({}, activeRoute.settings), { executeInBackground: true });
+            executionData.settings = {
+                ...executionData.settings,
+                executeInBackground: true,
+            };
         };
         /**
          * Updates route execution to background or foreground state.
@@ -207,18 +201,21 @@ class LIFI {
          * @param {boolean} settings - An object with execution settings.
          */
         this.updateRouteExecution = (route, settings) => {
-            const activeRoute = this.activeRouteDictionary[route.id];
-            if (!activeRoute) {
+            const { executionData } = this.activeRouteDictionary[route.id];
+            if (!executionData) {
                 return;
             }
-            for (const executor of activeRoute.executors) {
+            for (const executor of executionData.executors) {
                 executor.setInteraction({
                     allowInteraction: !settings.executeInBackground,
                     allowUpdates: true,
                 });
             }
             // Update active route settings so we know what the current state of execution is
-            activeRoute.settings = Object.assign(Object.assign({}, activeRoute.settings), settings);
+            executionData.settings = {
+                ...executionData.settings,
+                ...settings,
+            };
         };
         /**
          * Execute a route.
@@ -228,16 +225,21 @@ class LIFI {
          * @return {Promise<Route>} The executed route.
          * @throws {LifiError} Throws a LifiError if the execution fails.
          */
-        this.executeRoute = (signer, route, settings) => __awaiter(this, void 0, void 0, function* () {
+        this.executeRoute = async (signer, route, settings) => {
             // Deep clone to prevent side effects
-            const clonedRoute = (0, utils_1.deepClone)(route);
+            const clonedRoute = structuredClone(route);
             // Check if route is already running
             if (this.activeRouteDictionary[clonedRoute.id]) {
                 // TODO: maybe inform user why nothing happens?
-                return clonedRoute;
+                return this.activeRouteDictionary[clonedRoute.id].executionPromise;
             }
-            return this.executeSteps(signer, clonedRoute, settings);
-        });
+            const executionPromise = this.executeSteps(signer, clonedRoute, settings);
+            this.activeRouteDictionary[clonedRoute.id] = {
+                ...this.activeRouteDictionary[clonedRoute.id],
+                executionPromise,
+            };
+            return executionPromise;
+        };
         /**
          * Resume the execution of a route that has been stopped or had an error while executing.
          * @param {Signer} signer - The signer required to send the transactions.
@@ -246,62 +248,70 @@ class LIFI {
          * @return {Promise<Route>} The executed route.
          * @throws {LifiError} Throws a LifiError if the execution fails.
          */
-        this.resumeRoute = (signer, route, settings) => __awaiter(this, void 0, void 0, function* () {
+        this.resumeRoute = async (signer, route, settings) => {
             // Deep clone to prevent side effects
-            const clonedRoute = (0, utils_1.deepClone)(route);
-            const activeRoute = this.activeRouteDictionary[clonedRoute.id];
-            if (activeRoute) {
-                const executionHalted = activeRoute.executors.some((executor) => executor.executionStopped);
+            const clonedRoute = structuredClone(route);
+            const { executionData, executionPromise } = this.activeRouteDictionary[clonedRoute.id];
+            if (executionData) {
+                const executionHalted = executionData.executors.some((executor) => executor.executionStopped);
                 if (!executionHalted) {
                     // Check if we want to resume route execution in the background
                     this.updateRouteExecution(route, {
-                        executeInBackground: settings === null || settings === void 0 ? void 0 : settings.executeInBackground,
+                        executeInBackground: settings?.executeInBackground,
                     });
-                    return clonedRoute;
+                    return executionPromise;
                 }
             }
             (0, preRestart_1.handlePreRestart)(clonedRoute);
-            return this.executeSteps(signer, clonedRoute, settings);
-        });
-        this.executeSteps = (signer, route, settings) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
+            const newExecutionPromise = this.executeSteps(signer, clonedRoute, settings);
+            this.activeRouteDictionary[clonedRoute.id] = {
+                ...this.activeRouteDictionary[clonedRoute.id],
+                executionPromise: newExecutionPromise,
+            };
+            return newExecutionPromise;
+        };
+        this.executeSteps = async (signer, route, settings) => {
             const config = this.configService.getConfig();
-            const executionData = {
+            const updatedExecutionData = {
                 route,
                 executors: [],
-                settings: Object.assign(Object.assign({}, config.defaultExecutionSettings), settings),
+                settings: { ...config.defaultExecutionSettings, ...settings },
+            };
+            this.activeRouteDictionary[route.id].executionData = {
+                ...updatedExecutionData,
             };
-            this.activeRouteDictionary[route.id] = executionData;
-            const statusManager = new StatusManager_1.StatusManager(route, this.activeRouteDictionary[route.id].settings, (route) => {
+            const { executionData } = this.activeRouteDictionary[route.id];
+            const statusManager = new StatusManager_1.StatusManager(route, executionData.settings, (route) => {
                 if (this.activeRouteDictionary[route.id]) {
-                    this.activeRouteDictionary[route.id].route = route;
+                    executionData.route = route;
                 }
             });
             // Loop over steps and execute them
             for (let index = 0; index < route.steps.length; index++) {
-                const activeRoute = this.activeRouteDictionary[route.id];
+                const { executionData } = this.activeRouteDictionary[route.id];
                 // Check if execution has stopped in the meantime
-                if (!activeRoute) {
+                if (!executionData) {
                     break;
                 }
                 const step = route.steps[index];
                 const previousStep = route.steps[index - 1];
                 // Check if the step is already done
-                if (((_a = step.execution) === null || _a === void 0 ? void 0 : _a.status) === 'DONE') {
+                //
+                if (step.execution?.status === 'DONE') {
                     continue;
                 }
                 // Update amount using output of previous execution. In the future this should be handled by calling `updateRoute`
-                if ((_b = previousStep === null || previousStep === void 0 ? void 0 : previousStep.execution) === null || _b === void 0 ? void 0 : _b.toAmount) {
+                if (previousStep?.execution?.toAmount) {
                     step.action.fromAmount = previousStep.execution.toAmount;
                 }
                 try {
-                    const stepExecutor = new StepExecutor_1.StepExecutor(statusManager, activeRoute.settings);
-                    activeRoute.executors.push(stepExecutor);
+                    const stepExecutor = new StepExecutor_1.StepExecutor(statusManager, executionData.settings);
+                    executionData.executors.push(stepExecutor);
                     // Check if we want to execute this step in the background
-                    this.updateRouteExecution(route, activeRoute.settings);
-                    const executedStep = yield stepExecutor.executeStep(signer, step);
+                    this.updateRouteExecution(route, executionData.settings);
+                    const executedStep = await stepExecutor.executeStep(signer, step);
                     // We may reach this point if user interaction isn't allowed. We want to stop execution until we resume it
-                    if (((_c = executedStep.execution) === null || _c === void 0 ? void 0 : _c.status) !== 'DONE') {
+                    if (executedStep.execution?.status !== 'DONE') {
                         this.stopExecution(route);
                     }
                     // Execution stopped during the current step, we don't want to continue to the next step so we return already
@@ -317,7 +327,7 @@ class LIFI {
             // Clean up after the execution
             delete this.activeRouteDictionary[route.id];
             return route;
-        });
+        };
         /**
          * Update the ExecutionSettings for an active route.
          * @param {ExecutionSettings} settings - An object with execution settings.
@@ -329,14 +339,17 @@ class LIFI {
                 throw new errors_1.ValidationError("Can't set ExecutionSettings for the inactive route.");
             }
             const config = this.configService.getConfig();
-            this.activeRouteDictionary[route.id].settings = Object.assign(Object.assign({}, config.defaultExecutionSettings), settings);
+            this.activeRouteDictionary[route.id].executionData.settings = {
+                ...config.defaultExecutionSettings,
+                ...settings,
+            };
         };
         /**
          * Get the list of active routes.
          * @return {Route[]} A list of routes.
          */
         this.getActiveRoutes = () => {
-            return Object.values(this.activeRouteDictionary).map((dict) => dict.route);
+            return Object.values(this.activeRouteDictionary).map((dict) => dict.executionData.route);
         };
         /**
          * Return the current route information for given route. The route has to be active.
@@ -344,8 +357,7 @@ class LIFI {
          * @return {Route} The updated route.
          */
         this.getActiveRoute = (route) => {
-            var _a;
-            return (_a = this.activeRouteDictionary[route.id]) === null || _a === void 0 ? void 0 : _a.route;
+            return this.activeRouteDictionary[route.id]?.executionData.route;
         };
         /**
          * Returns the balances of a specific token a wallet holds across all aggregated chains.
@@ -354,7 +366,7 @@ class LIFI {
          * @return {Promise<TokenAmount | null>} An object containing the token and the amounts on different chains.
          * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
          */
-        this.getTokenBalance = (walletAddress, token) => __awaiter(this, void 0, void 0, function* () {
+        this.getTokenBalance = async (walletAddress, token) => {
             if (!walletAddress) {
                 throw new errors_1.ValidationError('Missing walletAddress.');
             }
@@ -362,7 +374,7 @@ class LIFI {
                 throw new errors_1.ValidationError(`Invalid token passed: address "${token.address}" on chainId "${token.chainId}"`);
             }
             return balance.getTokenBalance(walletAddress, token);
-        });
+        };
         /**
          * Returns the balances for a list tokens a wallet holds  across all aggregated chains.
          * @param {string} walletAddress - A wallet address.
@@ -370,7 +382,7 @@ class LIFI {
          * @return {Promise<TokenAmount[]>} A list of objects containing the tokens and the amounts on different chains.
          * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
          */
-        this.getTokenBalances = (walletAddress, tokens) => __awaiter(this, void 0, void 0, function* () {
+        this.getTokenBalances = async (walletAddress, tokens) => {
             if (!walletAddress) {
                 throw new errors_1.ValidationError('Missing walletAddress.');
             }
@@ -379,7 +391,7 @@ class LIFI {
                 throw new errors_1.ValidationError(`Invalid token passed: address "${invalidTokens[0].address}" on chainId "${invalidTokens[0].chainId}"`);
             }
             return balance.getTokenBalances(walletAddress, tokens);
-        });
+        };
         /**
          * This method queries the balances of tokens for a specific list of chains for a given wallet.
          * @param {string} walletAddress - A walletaddress.
@@ -387,7 +399,7 @@ class LIFI {
          * @return {Promise<{ [chainId: number]: TokenAmount[] }>} A list of objects containing the tokens and the amounts on different chains organized by the chosen chains.
          * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
          */
-        this.getTokenBalancesForChains = (walletAddress, tokensByChain) => __awaiter(this, void 0, void 0, function* () {
+        this.getTokenBalancesForChains = async (walletAddress, tokensByChain) => {
             if (!walletAddress) {
                 throw new errors_1.ValidationError('Missing walletAddress.');
             }
@@ -397,24 +409,24 @@ class LIFI {
                 throw new errors_1.ValidationError(`Invalid token passed: address "${invalidTokens[0].address}" on chainId "${invalidTokens[0].chainId}"`);
             }
             return balance.getTokenBalancesForChains(walletAddress, tokensByChain);
-        });
+        };
         /**
          * Get the current approval for a certain token.
          * @param signer - The signer owning the token
          * @param token - The token that should be checked
          * @param approvalAddress - The address that has be approved
          */
-        this.getTokenApproval = (signer, token, approvalAddress) => __awaiter(this, void 0, void 0, function* () {
+        this.getTokenApproval = async (signer, token, approvalAddress) => {
             return (0, allowance_1.getTokenApproval)(signer, token, approvalAddress);
-        });
+        };
         /**
          * Get the current approval for a list of token / approval address pairs.
          * @param signer - The signer owning the tokens
          * @param tokenData - A list of token and approval address pairs
          */
-        this.bulkGetTokenApproval = (signer, tokenData) => __awaiter(this, void 0, void 0, function* () {
+        this.bulkGetTokenApproval = async (signer, tokenData) => {
             return (0, allowance_1.bulkGetTokenApproval)(signer, tokenData);
-        });
+        };
         /**
          * Set approval for a certain token and amount.
          * @param { ApproveTokenRequest } request - The approval request
@@ -438,7 +450,7 @@ class LIFI {
         this.chainsService.getChains().then((chains) => {
             this.configService.updateChains(chains);
         });
-        (0, helpers_1.checkPackageUpdates)(version_1.name, version_1.version, configUpdate === null || configUpdate === void 0 ? void 0 : configUpdate.disableVersionCheck);
+        (0, helpers_1.checkPackageUpdates)(version_1.name, version_1.version, configUpdate?.disableVersionCheck);
     }
 }
 exports.default = LIFI;

package/dist/cjs/allowance/checkAllowance.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,7 +10,7 @@ const ethers_1 = require("ethers");
 const utils_1 = require("../allowance/utils");
 const getProvider_1 = require("../utils/getProvider");
 const parseError_1 = require("../utils/parseError");
-const checkAllowance = (signer, step, statusManager, settings, chain, allowUserInteraction = false) => __awaiter(void 0, void 0, void 0, function* () {
+const checkAllowance = async (signer, step, statusManager, settings, chain, allowUserInteraction = false) => {
     // Ask the user to set an allowance
     let allowanceProcess = statusManager.findOrCreateProcess(step, 'TOKEN_ALLOWANCE');
     // Check allowance
@@ -28,11 +19,11 @@ const checkAllowance = (signer, step, statusManager, settings, chain, allowUserI
             if (allowanceProcess.status !== 'PENDING') {
                 allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING');
             }
-            yield (0, getProvider_1.getProvider)(signer).waitForTransaction(allowanceProcess.txHash);
+            await (0, getProvider_1.getProvider)(signer).waitForTransaction(allowanceProcess.txHash);
             allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
         }
         else {
-            const approved = yield (0, utils_1.getApproved)(signer, step.action.fromToken.address, step.estimate.approvalAddress);
+            const approved = await (0, utils_1.getApproved)(signer, step.action.fromToken.address, step.estimate.approvalAddress);
             if (new bignumber_js_1.default(step.action.fromAmount).gt(approved)) {
                 if (!allowUserInteraction) {
                     return;
@@ -40,13 +31,13 @@ const checkAllowance = (signer, step, statusManager, settings, chain, allowUserI
                 const approvalAmount = settings.infiniteApproval
                     ? ethers_1.constants.MaxUint256.toString()
                     : step.action.fromAmount;
-                const approveTx = yield (0, utils_1.setApproval)(signer, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount);
+                const approveTx = await (0, utils_1.setApproval)(signer, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount);
                 allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING', {
                     txHash: approveTx.hash,
                     txLink: chain.metamask.blockExplorerUrls[0] + 'tx/' + approveTx.hash,
                 });
                 // Wait for the transcation
-                yield approveTx.wait();
+                await approveTx.wait();
                 allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
             }
             else {
@@ -56,10 +47,10 @@ const checkAllowance = (signer, step, statusManager, settings, chain, allowUserI
     }
     catch (e) {
         if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
-            yield transactionReplaced(e.replacement, allowanceProcess, step, chain, statusManager);
+            await transactionReplaced(e.replacement, allowanceProcess, step, chain, statusManager);
         }
         else {
-            const error = yield (0, parseError_1.parseError)(e, step, allowanceProcess);
+            const error = await (0, parseError_1.parseError)(e, step, allowanceProcess);
             allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'FAILED', {
                 error: {
                     message: error.message,
@@ -71,21 +62,21 @@ const checkAllowance = (signer, step, statusManager, settings, chain, allowUserI
             throw error;
         }
     }
-});
+};
 exports.checkAllowance = checkAllowance;
-const transactionReplaced = (replacementTx, allowanceProcess, step, chain, statusManager) => __awaiter(void 0, void 0, void 0, function* () {
+const transactionReplaced = async (replacementTx, allowanceProcess, step, chain, statusManager) => {
     try {
         allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING', {
             txHash: replacementTx.hash,
             txLink: chain.metamask.blockExplorerUrls[0] + 'tx/' + replacementTx.hash,
         });
-        yield replacementTx.wait();
+        await replacementTx.wait();
         allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
     }
     catch (e) {
         if (e.code === 'TRANSACTION_REPLACED' && e.replacement) {
-            yield transactionReplaced(e.replacement, allowanceProcess, step, chain, statusManager);
+            await transactionReplaced(e.replacement, allowanceProcess, step, chain, statusManager);
         }
         throw e;
     }
-});
+};

package/dist/cjs/allowance/tokenApproval.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 };
 };
@@ -18,26 +9,26 @@ const ethers_1 = require("ethers");
 const helpers_1 = require("../helpers");
 const utils_1 = require("../utils/utils");
 const utils_2 = require("./utils");
-const getTokenApproval = (signer, token, approvalAddress) => __awaiter(void 0, void 0, void 0, function* () {
+const getTokenApproval = async (signer, token, approvalAddress) => {
     // native token don't need approval
     if ((0, utils_1.isNativeTokenAddress)(token.address)) {
         return;
     }
-    const approved = yield (0, utils_2.getApproved)(signer, token.address, approvalAddress);
-    return approved.toString();
-});
+    const approved = await (0, utils_2.getApproved)(signer, token.address, approvalAddress);
+    return approved.toFixed(0);
+};
 exports.getTokenApproval = getTokenApproval;
-const bulkGetTokenApproval = (signer, tokenData) => __awaiter(void 0, void 0, void 0, function* () {
+const bulkGetTokenApproval = async (signer, tokenData) => {
     // filter out native tokens
     const filteredTokenData = tokenData.filter(({ token }) => !(0, utils_1.isNativeTokenAddress)(token.address));
     // group by chain
     const tokenDataByChain = (0, utils_2.groupByChain)(filteredTokenData);
-    const approvalPromises = Object.keys(tokenDataByChain).map((chainId) => __awaiter(void 0, void 0, void 0, function* () {
+    const approvalPromises = Object.keys(tokenDataByChain).map(async (chainId) => {
         const parsedChainId = Number.parseInt(chainId);
         // get allowances for current chain and token list
         return (0, utils_2.getAllowanceViaMulticall)(signer, parsedChainId, tokenDataByChain[parsedChainId]);
-    }));
-    const approvalsByChain = yield Promise.all(approvalPromises);
+    });
+    const approvalsByChain = await Promise.all(approvalPromises);
     const approvals = approvalsByChain.flat();
     return tokenData.map(({ token }) => {
         // native token don't need approval
@@ -45,34 +36,34 @@ const bulkGetTokenApproval = (signer, tokenData) => __awaiter(void 0, void 0, vo
             return { token, approval: undefined };
         }
         const approved = approvals.find((approval) => (0, helpers_1.isSameToken)(approval.token, token));
-        return { token, approval: approved === null || approved === void 0 ? void 0 : approved.approvedAmount.toString() };
+        return { token, approval: approved?.approvedAmount.toString() };
     });
-});
+};
 exports.bulkGetTokenApproval = bulkGetTokenApproval;
-const approveToken = ({ signer, token, approvalAddress, amount, infiniteApproval = false, }) => __awaiter(void 0, void 0, void 0, function* () {
+const approveToken = async ({ signer, token, approvalAddress, amount, infiniteApproval = false, }) => {
     // native token don't need approval
     if ((0, utils_1.isNativeTokenAddress)(token.address)) {
         return;
     }
-    const approvedAmount = yield (0, utils_2.getApproved)(signer, token.address, approvalAddress);
+    const approvedAmount = await (0, utils_2.getApproved)(signer, token.address, approvalAddress);
     if (new bignumber_js_1.default(amount).gt(approvedAmount)) {
         const approvalAmount = infiniteApproval
             ? ethers_1.constants.MaxUint256.toString()
             : amount;
-        const approveTx = yield (0, utils_2.setApproval)(signer, token.address, approvalAddress, approvalAmount);
-        yield approveTx.wait();
+        const approveTx = await (0, utils_2.setApproval)(signer, token.address, approvalAddress, approvalAmount);
+        await approveTx.wait();
     }
-});
+};
 exports.approveToken = approveToken;
-const revokeTokenApproval = ({ signer, token, approvalAddress, }) => __awaiter(void 0, void 0, void 0, function* () {
+const revokeTokenApproval = async ({ signer, token, approvalAddress, }) => {
     // native token don't need approval
     if ((0, utils_1.isNativeTokenAddress)(token.address)) {
         return;
     }
-    const approvedAmount = yield (0, utils_2.getApproved)(signer, token.address, approvalAddress);
+    const approvedAmount = await (0, utils_2.getApproved)(signer, token.address, approvalAddress);
     if (!approvedAmount.isZero()) {
-        const approveTx = yield (0, utils_2.setApproval)(signer, token.address, approvalAddress, '0');
-        yield approveTx.wait();
+        const approveTx = await (0, utils_2.setApproval)(signer, token.address, approvalAddress, '0');
+        await approveTx.wait();
     }
-});
+};
 exports.revokeTokenApproval = revokeTokenApproval;