@lifi/sdk 1.7.2 → 2.0.0-beta.1

package/dist/Lifi.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 { approveToken, bulkGetTokenApproval, getTokenApproval, revokeTokenApproval, } from './allowance';
 import * as balance from './balance';
 import { getRpcProvider } from './connectors';
@@ -19,7 +10,6 @@ import ConfigService from './services/ConfigService';
 import { isToken } from './typeguards';
 import { ValidationError } from './utils/errors';
 import { handlePreRestart } from './utils/preRestart';
-import { deepClone } from './utils/utils';
 import { name, version } from './version';
 export default class LIFI {
     constructor(configUpdate) {
@@ -61,84 +51,84 @@ export default 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.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.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.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.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.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.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.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.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.getStepTransaction(step, options);
-        });
+        };
         /**
          * Stops the execution of an active route.
          * @param {Route} route - A route that is currently in execution.
@@ -148,7 +138,8 @@ export default 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,
@@ -164,14 +155,17 @@ export default 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.
@@ -179,18 +173,21 @@ export default 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.
@@ -200,16 +197,21 @@ export default 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 = 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.
@@ -218,62 +220,70 @@ export default 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 = 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;
                 }
             }
             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(route, this.activeRouteDictionary[route.id].settings, (route) => {
+            const { executionData } = this.activeRouteDictionary[route.id];
+            const statusManager = new 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(statusManager, activeRoute.settings);
-                    activeRoute.executors.push(stepExecutor);
+                    const stepExecutor = new 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
@@ -289,7 +299,7 @@ export default 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.
@@ -301,14 +311,17 @@ export default class LIFI {
                 throw new 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.
@@ -316,8 +329,7 @@ export default 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.
@@ -326,7 +338,7 @@ export default 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 ValidationError('Missing walletAddress.');
             }
@@ -334,7 +346,7 @@ export default class LIFI {
                 throw new 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.
@@ -342,7 +354,7 @@ export default 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 ValidationError('Missing walletAddress.');
             }
@@ -351,7 +363,7 @@ export default class LIFI {
                 throw new 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.
@@ -359,7 +371,7 @@ export default 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 ValidationError('Missing walletAddress.');
             }
@@ -369,24 +381,24 @@ export default class LIFI {
                 throw new 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 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 bulkGetTokenApproval(signer, tokenData);
-        });
+        };
         /**
          * Set approval for a certain token and amount.
          * @param { ApproveTokenRequest } request - The approval request
@@ -410,6 +422,6 @@ export default class LIFI {
         this.chainsService.getChains().then((chains) => {
             this.configService.updateChains(chains);
         });
-        checkPackageUpdates(name, version, configUpdate === null || configUpdate === void 0 ? void 0 : configUpdate.disableVersionCheck);
+        checkPackageUpdates(name, version, configUpdate?.disableVersionCheck);
     }
 }

package/dist/allowance/checkAllowance.js

@@ -1,19 +1,10 @@
-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());
-    });
-};
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import BigNumber from 'bignumber.js';
 import { constants } from 'ethers';
 import { getApproved, setApproval } from '../allowance/utils';
 import { getProvider } from '../utils/getProvider';
 import { parseError } from '../utils/parseError';
-export const checkAllowance = (signer, step, statusManager, settings, chain, allowUserInteraction = false) => __awaiter(void 0, void 0, void 0, function* () {
+export 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
@@ -22,11 +13,11 @@ export const checkAllowance = (signer, step, statusManager, settings, chain, all
             if (allowanceProcess.status !== 'PENDING') {
                 allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'PENDING');
             }
-            yield getProvider(signer).waitForTransaction(allowanceProcess.txHash);
+            await getProvider(signer).waitForTransaction(allowanceProcess.txHash);
             allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'DONE');
         }
         else {
-            const approved = yield getApproved(signer, step.action.fromToken.address, step.estimate.approvalAddress);
+            const approved = await getApproved(signer, step.action.fromToken.address, step.estimate.approvalAddress);
             if (new BigNumber(step.action.fromAmount).gt(approved)) {
                 if (!allowUserInteraction) {
                     return;
@@ -34,13 +25,13 @@ export const checkAllowance = (signer, step, statusManager, settings, chain, all
                 const approvalAmount = settings.infiniteApproval
                     ? constants.MaxUint256.toString()
                     : step.action.fromAmount;
-                const approveTx = yield setApproval(signer, step.action.fromToken.address, step.estimate.approvalAddress, approvalAmount);
+                const approveTx = await 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 {
@@ -50,10 +41,10 @@ export const checkAllowance = (signer, step, statusManager, settings, chain, all
     }
     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 parseError(e, step, allowanceProcess);
+            const error = await parseError(e, step, allowanceProcess);
             allowanceProcess = statusManager.updateProcess(step, allowanceProcess.type, 'FAILED', {
                 error: {
                     message: error.message,
@@ -65,20 +56,20 @@ export const checkAllowance = (signer, step, statusManager, settings, chain, all
             throw error;
         }
     }
-});
-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/allowance/tokenApproval.js

@@ -1,36 +1,27 @@
-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 BigNumber from 'bignumber.js';
 import { constants } from 'ethers';
 import { isSameToken } from '../helpers';
 import { isNativeTokenAddress } from '../utils/utils';
 import { getAllowanceViaMulticall, getApproved, groupByChain, setApproval, } from './utils';
-export const getTokenApproval = (signer, token, approvalAddress) => __awaiter(void 0, void 0, void 0, function* () {
+export const getTokenApproval = async (signer, token, approvalAddress) => {
     // native token don't need approval
     if (isNativeTokenAddress(token.address)) {
         return;
     }
-    const approved = yield getApproved(signer, token.address, approvalAddress);
-    return approved.toString();
-});
-export const bulkGetTokenApproval = (signer, tokenData) => __awaiter(void 0, void 0, void 0, function* () {
+    const approved = await getApproved(signer, token.address, approvalAddress);
+    return approved.toFixed(0);
+};
+export const bulkGetTokenApproval = async (signer, tokenData) => {
     // filter out native tokens
     const filteredTokenData = tokenData.filter(({ token }) => !isNativeTokenAddress(token.address));
     // group by chain
     const tokenDataByChain = 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 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
@@ -38,31 +29,31 @@ export const bulkGetTokenApproval = (signer, tokenData) => __awaiter(void 0, voi
             return { token, approval: undefined };
         }
         const approved = approvals.find((approval) => isSameToken(approval.token, token));
-        return { token, approval: approved === null || approved === void 0 ? void 0 : approved.approvedAmount.toString() };
+        return { token, approval: approved?.approvedAmount.toString() };
     });
-});
-export const approveToken = ({ signer, token, approvalAddress, amount, infiniteApproval = false, }) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const approveToken = async ({ signer, token, approvalAddress, amount, infiniteApproval = false, }) => {
     // native token don't need approval
     if (isNativeTokenAddress(token.address)) {
         return;
     }
-    const approvedAmount = yield getApproved(signer, token.address, approvalAddress);
+    const approvedAmount = await getApproved(signer, token.address, approvalAddress);
     if (new BigNumber(amount).gt(approvedAmount)) {
         const approvalAmount = infiniteApproval
             ? constants.MaxUint256.toString()
             : amount;
-        const approveTx = yield setApproval(signer, token.address, approvalAddress, approvalAmount);
-        yield approveTx.wait();
+        const approveTx = await setApproval(signer, token.address, approvalAddress, approvalAmount);
+        await approveTx.wait();
     }
-});
-export const revokeTokenApproval = ({ signer, token, approvalAddress, }) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const revokeTokenApproval = async ({ signer, token, approvalAddress, }) => {
     // native token don't need approval
     if (isNativeTokenAddress(token.address)) {
         return;
     }
-    const approvedAmount = yield getApproved(signer, token.address, approvalAddress);
+    const approvedAmount = await getApproved(signer, token.address, approvalAddress);
     if (!approvedAmount.isZero()) {
-        const approveTx = yield setApproval(signer, token.address, approvalAddress, '0');
-        yield approveTx.wait();
+        const approveTx = await setApproval(signer, token.address, approvalAddress, '0');
+        await approveTx.wait();
     }
-});
+};