@lifi/sdk 1.7.2 → 2.0.0-beta.1

package/dist/allowance/utils.js

@@ -1,40 +1,31 @@
-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 { Contract } from 'ethers';
 import ChainsService from '../services/ChainsService';
 import { ERC20_ABI } from '../types';
 import { ServerError } from '../utils/errors';
 import { fetchDataUsingMulticall } from '../utils/multicall';
-export const getApproved = (signer, tokenAddress, contractAddress) => __awaiter(void 0, void 0, void 0, function* () {
-    const signerAddress = yield signer.getAddress();
+export const getApproved = async (signer, tokenAddress, contractAddress) => {
+    const signerAddress = await signer.getAddress();
     const erc20 = new Contract(tokenAddress, ERC20_ABI, signer);
     try {
-        const approved = yield erc20.allowance(signerAddress, contractAddress);
+        const approved = await erc20.allowance(signerAddress, contractAddress);
         return new BigNumber(approved.toString());
     }
     catch (e) {
         return new BigNumber(0);
     }
-});
+};
 export const setApproval = (signer, tokenAddress, contractAddress, amount) => {
     const erc20 = new Contract(tokenAddress, ERC20_ABI, signer);
     return erc20.approve(contractAddress, amount);
 };
-export const getAllowanceViaMulticall = (signer, chainId, tokenData) => __awaiter(void 0, void 0, void 0, function* () {
+export const getAllowanceViaMulticall = async (signer, chainId, tokenData) => {
     const chainsService = ChainsService.getInstance();
-    const chain = yield chainsService.getChainById(chainId);
+    const chain = await chainsService.getChainById(chainId);
     if (!chain.multicallAddress) {
         throw new 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({
@@ -43,22 +34,19 @@ export const getAllowanceViaMulticall = (signer, chainId, tokenData) => __awaite
             params: [ownerAddress, approvalAddress],
         });
     });
-    const result = yield fetchDataUsingMulticall(calls, ERC20_ABI, chainId, chain.multicallAddress);
+    const result = await fetchDataUsingMulticall(calls, ERC20_ABI, chainId, chain.multicallAddress);
     if (!result.length) {
         throw new 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(0),
-        });
-    });
+    const parsedResult = result.map(({ data }) => ({
+        approvalAmount: data ?? new BigNumber(0),
+    }));
     return tokenData.map(({ token, approvalAddress }, i) => ({
         token,
         approvalAddress,
         approvedAmount: parsedResult[i].approvalAmount,
     }));
-});
+};
 export const groupByChain = (tokenDataList) => {
     // group by chain
     const tokenDataByChain = {};

package/dist/balance/checkBalance.js

@@ -1,26 +1,17 @@
-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 { BalanceError } from '../utils/errors';
 import { getTokenBalance } from './getTokenBalance';
-export const checkBalance = (signer, step, depth = 0) => __awaiter(void 0, void 0, void 0, function* () {
-    const tokenAmount = yield getTokenBalance(yield signer.getAddress(), step.action.fromToken);
+export const checkBalance = async (signer, step, depth = 0) => {
+    const tokenAmount = await getTokenBalance(await signer.getAddress(), step.action.fromToken);
     if (tokenAmount) {
         const currentBalance = new BigNumber(tokenAmount.amount).shiftedBy(tokenAmount.decimals);
         const neededBalance = new BigNumber(step.action.fromAmount);
         if (currentBalance.lt(neededBalance)) {
             if (depth <= 3) {
-                yield new Promise((resolve) => {
+                await new Promise((resolve) => {
                     setTimeout(resolve, 200);
                 });
-                yield checkBalance(signer, step, depth + 1);
+                await checkBalance(signer, step, depth + 1);
             }
             else if (neededBalance.multipliedBy(1 - step.action.slippage).lte(currentBalance)) {
                 // adjust amount in slippage limits
@@ -44,4 +35,4 @@ export const checkBalance = (signer, step, depth = 0) => __awaiter(void 0, void
             }
         }
     }
-});
+};

package/dist/balance/getTokenBalance.js

@@ -1,18 +1,9 @@
-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 utils from './utils';
-export const getTokenBalance = (walletAddress, token) => __awaiter(void 0, void 0, void 0, function* () {
-    const tokenAmounts = yield getTokenBalances(walletAddress, [token]);
+export const getTokenBalance = async (walletAddress, token) => {
+    const tokenAmounts = await getTokenBalances(walletAddress, [token]);
     return tokenAmounts.length ? tokenAmounts[0] : null;
-});
-export const getTokenBalances = (walletAddress, tokens) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export const getTokenBalances = async (walletAddress, tokens) => {
     // split by chain
     const tokensByChain = {};
     tokens.forEach((token) => {
@@ -21,16 +12,16 @@ export const getTokenBalances = (walletAddress, tokens) => __awaiter(void 0, voi
         }
         tokensByChain[token.chainId].push(token);
     });
-    const tokenAmountsByChain = yield getTokenBalancesForChains(walletAddress, tokensByChain);
+    const tokenAmountsByChain = await getTokenBalancesForChains(walletAddress, tokensByChain);
     return Object.values(tokenAmountsByChain).flat();
-});
-export const getTokenBalancesForChains = (walletAddress, tokensByChain) => __awaiter(void 0, void 0, void 0, function* () {
+};
+export 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.getBalances(walletAddress, tokensByChain[chainId]);
+        const tokenAmounts = await utils.getBalances(walletAddress, tokensByChain[chainId]);
         tokenAmountsByChain[chainId] = tokenAmounts;
-    }));
-    yield Promise.allSettled(promises);
+    });
+    await Promise.allSettled(promises);
     return tokenAmountsByChain;
-});
+};

package/dist/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/balance/index.js

@@ -1,2 +1,10 @@
 export * from './checkBalance';
 export * from './getTokenBalance';
+import { checkBalance } from './checkBalance';
+import { getTokenBalance, getTokenBalances, getTokenBalancesForChains, } from './getTokenBalance';
+export default {
+    checkBalance,
+    getTokenBalance,
+    getTokenBalances,
+    getTokenBalancesForChains,
+};

package/dist/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/balance/utils.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 BigNumber from 'bignumber.js';
 import { ethers } from 'ethers';
 import { getMulticallAddress, getRpcProvider } from '../connectors';
@@ -32,7 +23,7 @@ const balanceAbi = [
         type: 'function',
     },
 ];
-const getBalances = (walletAddress, tokens) => __awaiter(void 0, void 0, void 0, function* () {
+export const getBalances = async (walletAddress, tokens) => {
     if (tokens.length === 0) {
         return [];
     }
@@ -44,23 +35,23 @@ const getBalances = (walletAddress, tokens) => __awaiter(void 0, void 0, void 0,
             return [];
         }
     });
-    if ((yield getMulticallAddress(chainId)) && tokens.length > 1) {
+    if ((await 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* () {
+};
+const getBalancesFromProviderUsingMulticall = async (walletAddress, tokens) => {
     // Configuration
     const { chainId } = tokens[0];
-    const multicallAddress = yield getMulticallAddress(chainId);
+    const multicallAddress = await 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) => {
@@ -79,7 +70,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 [];
     }
@@ -87,24 +78,28 @@ const executeMulticall = (walletAddress, tokens, multicallAddress, chainId) => _
         const amount = new BigNumber(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 fetchDataUsingMulticall(calls, abi, chainId, multicallAddress);
+};
+const fetchViaMulticall = async (calls, abi, chainId, multicallAddress) => {
+    const result = await fetchDataUsingMulticall(calls, abi, chainId, multicallAddress);
     return result.map(({ data, blockNumber }) => ({
         amount: data ? data : new BigNumber(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 getRpcProvider(chainId);
-    const tokenAmountPromises = tokens.map((token) => __awaiter(void 0, void 0, void 0, function* () {
+    const rpc = await 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(balance.amount.toString())
                 .shiftedBy(-token.decimals)
                 .toString();
@@ -114,20 +109,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 (isZeroAddress(assetId)) {
-        balance = yield provider.getBalance(walletAddress, blockNumber);
+        balance = await provider.getBalance(walletAddress, blockNumber);
     }
     else {
         const contract = new ethers.Contract(assetId, ['function balanceOf(address owner) view returns (uint256)'], provider);
-        balance = yield contract.balanceOf(walletAddress, {
+        balance = await contract.balanceOf(walletAddress, {
             blockTag: blockNumber,
         });
     }
@@ -135,11 +133,11 @@ const getBalanceFromProvider = (walletAddress, assetId, chainId, provider) => __
         amount: balance,
         blockNumber,
     };
-});
-const getCurrentBlockNumber = (chainId) => __awaiter(void 0, void 0, void 0, function* () {
-    const rpc = yield getRpcProvider(chainId);
+};
+const getCurrentBlockNumber = async (chainId) => {
+    const rpc = await getRpcProvider(chainId);
     return rpc.getBlockNumber();
-});
+};
 export default {
     getBalances,
 };