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 {
+  ChainType,
   Allowance,
   Approve,
   ApproveRoute,
@@ -26,11 +27,15 @@ import {
   RouteParamsData,
   RouteResponse,
   StatusResponse,
+  TokenBalance,
   TokenData,
   TransactionRequest,
   ValidateBalanceAndApproval,
   WASM_TYPE,
-  WasmHookMsg
+  WasmHookMsg,
+  CosmosChain,
+  CosmosAddress,
+  CosmosBalance
 } from "./types";
 
 import { TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
@@ -42,6 +47,8 @@ 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";
+import { getCosmosBalances } from "./services/getCosmosBalances";
 
 const baseUrl = "https://testnet.api.0xsquid.com/";
 
@@ -731,6 +738,116 @@ export class Squid {
     return response.data.price;
   }
 
+  public async getAllEvmBalances({
+    userAddress,
+    chains
+  }: {
+    userAddress: string;
+    chains: (string | number)[];
+  }): Promise<TokenBalance[]> {
+    // remove invalid and duplicate chains and convert to number
+    const filteredChains = new Set(chains.map(Number).filter(c => !isNaN(c)));
+
+    return getAllEvmTokensBalance(
+      this.tokens.filter(t => filteredChains.has(Number(t.chainId))),
+      userAddress
+    );
+  }
+
+  public async getAllCosmosBalances({
+    addresses,
+    chainIds = []
+  }: {
+    addresses: CosmosAddress[];
+    chainIds?: (string | number)[];
+  }) {
+    const cosmosChains = this.chains.filter(c =>
+      c.chainType === ChainType.Cosmos &&
+      // if chainIds is not provided, return all cosmos chains
+      chainIds.length === 0
+        ? true
+        : // else return only chains that are in chainIds
+          chainIds?.includes(c.chainId)
+    ) as CosmosChain[];
+
+    return getCosmosBalances({
+      addresses,
+      cosmosChains
+    });
+  }
+
+  public async getAllBalances({
+    chainIds,
+    cosmosAddresses,
+    evmAddress
+  }: {
+    chainIds?: (string | number)[];
+    cosmosAddresses?: CosmosAddress[];
+    evmAddress?: string;
+  }): Promise<{
+    cosmosBalances?: CosmosBalance[];
+    evmBalances?: TokenBalance[];
+  }> {
+    if (!chainIds) {
+      // fetch balances for all chains compatible with provided addresses
+      const evmBalances = evmAddress
+        ? await this.getAllEvmBalances({
+            chains: this.tokens.map(t => String(t.chainId)),
+            userAddress: evmAddress
+          })
+        : [];
+
+      const cosmosBalances = cosmosAddresses
+        ? await this.getAllCosmosBalances({
+            addresses: cosmosAddresses
+          })
+        : [];
+
+      return {
+        evmBalances,
+        cosmosBalances
+      };
+    }
+
+    const normalizedChainIds = chainIds.map(String);
+
+    // fetch balances for provided chains
+    const [evmChainIds, cosmosChainIds] = this.chains.reduce(
+      (cosmosAndEvmChains, chain) => {
+        if (!normalizedChainIds.includes(String(chain.chainId))) {
+          return cosmosAndEvmChains;
+        }
+
+        if (chain.chainType === ChainType.Cosmos) {
+          cosmosAndEvmChains[1].push(chain.chainId);
+        } else {
+          cosmosAndEvmChains[0].push(chain.chainId);
+        }
+        return cosmosAndEvmChains;
+      },
+
+      [[], []] as [(string | number)[], (string | number)[]]
+    );
+
+    const evmBalances = evmAddress
+      ? await this.getAllEvmBalances({
+          chains: evmChainIds,
+          userAddress: evmAddress
+        })
+      : [];
+
+    const cosmosBalances = cosmosAddresses
+      ? await this.getAllCosmosBalances({
+          addresses: cosmosAddresses,
+          chainIds: cosmosChainIds
+        })
+      : [];
+
+    return {
+      evmBalances,
+      cosmosBalances
+    };
+
   public async getFromAmount({
     fromToken,
     toAmount,

src/services/getCosmosBalances.ts

@@ -0,0 +1,51 @@
+import { StargateClient } from "@cosmjs/stargate";
+import { ChainType, CosmosAddress, CosmosBalance, CosmosChain } from "../types";
+import { fromBech32, toBech32 } from "@cosmjs/encoding";
+
+const deriveCosmosAddress = (chainPrefix: string, address: string): string => {
+  return toBech32(chainPrefix, fromBech32(address).data);
+};
+
+export async function getCosmosBalances({
+  addresses,
+  cosmosChains
+}: {
+  addresses: CosmosAddress[];
+  cosmosChains: CosmosChain[];
+}): Promise<CosmosBalance[]> {
+  const balances: CosmosBalance[] = [];
+
+  for (const chain of cosmosChains) {
+    if (chain.chainType !== ChainType.Cosmos) continue;
+
+    const addressData = addresses.find(
+      address => address.coinType === chain.coinType
+    );
+
+    if (!addressData) continue;
+
+    const cosmosAddress = deriveCosmosAddress(
+      chain.bech32Config.bech32PrefixAccAddr,
+      addressData.address
+    );
+
+    try {
+      const client = await StargateClient.connect(chain.rpc);
+      const [account] = (await client.getAllBalances(cosmosAddress)) ?? [];
+
+      if (!account) continue;
+
+      const { amount, denom } = account;
+
+      balances.push({
+        amount,
+        denom,
+        chainId: String(chain.chainId)
+      });
+    } catch (error) {
+      //
+    }
+  }
+
+  return balances;
+}