feat/get all balances

package.json

@@ -33,11 +33,12 @@
     "release:dry": "release-it --dry-run"
   },
   "dependencies": {
-    "axios": "^0.27.2",
-    "ethers": "^5.7.1",
     "@cosmjs/encoding": "^0.31.0",
     "@cosmjs/stargate": "^0.31.0",
-    "cosmjs-types": "^0.8.0"
+    "axios": "^0.27.2",
+    "cosmjs-types": "^0.8.0",
+    "ethereum-multicall": "2.21.0",
+    "ethers": "^5.7.1"
   },
   "resolutions": {
     "semver": "^7.5.4"

src/constants/index.ts

@@ -2,3 +2,28 @@ export const uint256MaxValue =
   "115792089237316195423570985008687907853269984665640564039457584007913129639935";
 
 export const nativeTokenConstant = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+
+export const NATIVE_EVM_TOKEN_ADDRESS =
+  "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+export const MULTICALL_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+export const multicallAbi = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "account",
+        type: "address"
+      }
+    ],
+    name: "getEthBalance",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];

src/index.ts

@@ -10,6 +10,7 @@ import { MsgExecuteContract } from "cosmjs-types/cosmwasm/wasm/v1/tx";
 import { BigNumber, ethers, UnsignedTransaction } from "ethers";
 
 import {
+  AllBalancesResult,
   Allowance,
   Approve,
   ApproveRoute,
@@ -26,6 +27,7 @@ import {
   RouteParamsData,
   RouteResponse,
   StatusResponse,
+  TokenBalance,
   TokenData,
   TransactionRequest,
   ValidateBalanceAndApproval,
@@ -42,6 +44,7 @@ import { nativeTokenConstant, uint256MaxValue } from "./constants";
 import { ErrorType, SquidError } from "./error";
 import { getChainData, getTokenData } from "./utils";
 import { setAxiosInterceptors } from "./utils/setAxiosInterceptors";
+import { getAllEvmTokensBalance } from "./services/getEvmBalances";
 
 const baseUrl = "https://testnet.api.0xsquid.com/";
 
@@ -730,6 +733,19 @@ export class Squid {
 
     return response.data.price;
   }
+
+  public async getAllEvmBalances({
+    userAddress,
+    chains
+  }: {
+    userAddress: string;
+    chains: number[];
+  }): Promise<TokenBalance[]> {
+    return getAllEvmTokensBalance(
+      this.tokens.filter(t => chains.includes(Number(t.chainId))),
+      userAddress
+    );
+  }
 }
 
 export * from "./types";

src/services/getEvmBalances.ts

@@ -0,0 +1,197 @@
+import { ethers } from "ethers";
+import { Multicall, ContractCallContext } from "ethereum-multicall";
+import { TokenBalance, TokenData } from "types";
+import {
+  NATIVE_EVM_TOKEN_ADDRESS,
+  multicallAbi,
+  MULTICALL_ADDRESS
+} from "../constants";
+
+type ContractAddress = `0x${string}`;
+
+const CHAINS_WITHOUT_MULTICALL = [314, 3141]; // Filecoin, & Filecoin testnet
+const CHAINS_WITHOUT_MULTICALL_RPC_URLS: Record<number, string> = {
+  314: "https://rpc.ankr.com/filecoin",
+  3141: "https://rpc.ankr.com/filecoin"
+};
+
+const getTokensBalanceSupportingMultiCall = async (
+  tokens: TokenData[],
+  userAddress?: ContractAddress
+): Promise<TokenBalance[]> => {
+  if (!userAddress) return [];
+
+  const ETHEREUM_RPC_URL = "https://eth.meowrpc.com";
+  const provider = new ethers.providers.JsonRpcProvider(ETHEREUM_RPC_URL);
+
+  const contractCallContext: ContractCallContext[] = tokens.map(token => {
+    const isNativeToken =
+      token.address.toLowerCase() === NATIVE_EVM_TOKEN_ADDRESS.toLowerCase();
+
+    return {
+      abi: isNativeToken
+        ? multicallAbi
+        : [
+            {
+              name: "balanceOf",
+              type: "function",
+              inputs: [{ name: "_owner", type: "address" }],
+              outputs: [{ name: "balance", type: "uint256" }],
+              stateMutability: "view"
+            }
+          ],
+      contractAddress: isNativeToken ? MULTICALL_ADDRESS : token.address,
+      reference: token.symbol,
+      calls: [
+        {
+          reference: isNativeToken ? "getEthBalance" : "balanceOf",
+          methodName: isNativeToken ? "getEthBalance" : "balanceOf",
+          methodParameters: [userAddress]
+        }
+      ]
+    };
+  });
+
+  const multicallInstance = new Multicall({
+    ethersProvider: provider,
+    tryAggregate: true
+  });
+
+  const { results } = (await multicallInstance.call(contractCallContext)) ?? {
+    results: {}
+  };
+
+  const tokenBalances: TokenBalance[] = [];
+
+  for (const symbol in results) {
+    const data = results[symbol].callsReturnContext[0] ?? {};
+
+    const { decimals = 18, address = "0x" } =
+      tokens.find(t => t.symbol === symbol) ?? {};
+
+    const balanceInDecimal = ethers.utils.formatUnits(
+      data.returnValues[0]?.hex ?? "0x000",
+      decimals
+    );
+
+    const mappedBalance: TokenBalance = {
+      symbol,
+      address,
+      decimals,
+      balanceInDecimal
+    };
+
+    tokenBalances.push(mappedBalance);
+  }
+
+  return tokenBalances;
+};
+
+const getTokensBalanceWithoutMultiCall = async (
+  tokens: TokenData[],
+  userAddress: ContractAddress
+): Promise<TokenBalance[]> => {
+  const balances: (TokenBalance | null)[] = await Promise.all(
+    tokens.map(async t => {
+      let balance: TokenBalance | null;
+      try {
+        if (t.address === NATIVE_EVM_TOKEN_ADDRESS) {
+          balance = await fetchBalance({
+            token: t,
+            userAddress
+          });
+        } else {
+          balance = await fetchBalance({
+            token: t,
+            userAddress
+          });
+        }
+
+        return balance;
+      } catch (error) {
+        return null;
+      }
+    })
+  );
+
+  // filter out null values
+  return balances.filter(Boolean) as TokenBalance[];
+};
+
+export const getAllEvmTokensBalance = async (
+  evmTokens: TokenData[],
+  userAddress: string
+): Promise<TokenBalance[]> => {
+  try {
+    // Some tokens don't support multicall, so we need to fetch them with Promise.all
+    // TODO: Once we support multicall on all chains, we can remove this split
+    const splittedTokensByMultiCallSupport = evmTokens.reduce(
+      (acc, token) => {
+        if (CHAINS_WITHOUT_MULTICALL.includes(Number(token.chainId))) {
+          acc[0].push(token);
+        } else {
+          acc[1].push(token);
+        }
+        return acc;
+      },
+      [[], []] as TokenData[][]
+    );
+
+    const tokensNotSupportingMulticall = splittedTokensByMultiCallSupport[0];
+    const tokensSupportingMulticall = splittedTokensByMultiCallSupport[1];
+
+    const tokensMulticall = await getTokensBalanceSupportingMultiCall(
+      tokensSupportingMulticall,
+      userAddress as ContractAddress
+    );
+
+    const tokensNotMultiCall = await getTokensBalanceWithoutMultiCall(
+      tokensNotSupportingMulticall,
+      userAddress as ContractAddress
+    );
+
+    return [...tokensMulticall, ...tokensNotMultiCall];
+  } catch (error) {
+    console.error(error);
+    return [];
+  }
+};
+
+type FetchBalanceParams = {
+  token: TokenData;
+  userAddress: ContractAddress;
+};
+
+async function fetchBalance({
+  token,
+  userAddress
+}: FetchBalanceParams): Promise<TokenBalance | null> {
+  try {
+    const provider = new ethers.providers.JsonRpcProvider(
+      CHAINS_WITHOUT_MULTICALL_RPC_URLS[Number(token.chainId)]
+    );
+
+    const tokenAbi = ["function balanceOf(address) view returns (uint256)"];
+    const tokenContract = new ethers.Contract(
+      token.address ?? "",
+      tokenAbi,
+      provider
+    );
+
+    const balance = await tokenContract.balanceOf(userAddress);
+
+    if (!token) return null;
+
+    const { decimals, symbol, address } = token;
+
+    return {
+      address,
+      balanceInDecimal: balance.toString(),
+      decimals,
+      symbol
+    };
+  } catch (error) {
+    console.error("Error fetching token balance:", error);
+    return null;
+  }
+}

src/types/index.ts

@@ -503,3 +503,15 @@ export type CoinTypeAddress = {
 
 export const IBC_TRANSFER_TYPE = "/ibc.applications.transfer.v1.MsgTransfer";
 export const WASM_TYPE = "/cosmwasm.wasm.v1.MsgExecuteContract";
+
+export type TokenBalance = {
+  symbol: string;
+  address: string;
+  decimals: number;
+  balanceInDecimal: string;
+};
+
+export type AllBalancesResult = {
+  cosmosBalances: TokenBalance[];
+  evmBalances: TokenBalance[];
+};