@metamask/assets-controllers 73.1.0 → 73.3.0

package/dist/multi-chain-accounts-service/types.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.cjs","sourceRoot":"","sources":["../../src/multi-chain-accounts-service/types.ts"],"names":[],"mappings":"","sourcesContent":["export type GetSupportedNetworksResponse = {\n  fullSupport: number[];\n  partialSupport: {\n    balances: number[];\n  };\n};\n\nexport type GetBalancesQueryParams = {\n  /** Comma-separated network/chain IDs */\n  networks?: string;\n  /** Whether or not to filter the assets to contain only the tokens existing in the Token API */\n  filterSupportedTokens?: boolean;\n  /** Specific token addresses to fetch balances for across specified network(s) */\n  includeTokenAddresses?: string;\n  /** Whether to include balances of the account's staked asset balances */\n  includeStakedAssets?: boolean;\n};\n\nexport type GetBalancesResponse = {\n  count: number;\n  balances: {\n    /** Underlying object type. Seems to be always `token` */\n    object: string;\n    /** Token Type: This is only supplied as `native` to native chain tokens (e.g. - ETH, POL) */\n    type?: string;\n    /** Timestamp is only provided for `native` chain tokens */\n    timestamp?: string;\n    address: string;\n    symbol: string;\n    name: string;\n    decimals: number;\n    chainId: number;\n    /** string representation of the balance in decimal format (decimals adjusted). e.g. - 123.456789 */\n    balance: string;\n  }[];\n  /** networks that failed to process, if no network is processed, returns HTTP 422  */\n  unprocessedNetworks: number[];\n};\n"]}
+{"version":3,"file":"types.cjs","sourceRoot":"","sources":["../../src/multi-chain-accounts-service/types.ts"],"names":[],"mappings":"","sourcesContent":["export type GetSupportedNetworksResponse = {\n  fullSupport: number[];\n  partialSupport: {\n    balances: number[];\n  };\n};\n\nexport type GetBalancesQueryParams = {\n  /** Comma-separated network/chain IDs */\n  networks?: string;\n  /** Whether or not to filter the assets to contain only the tokens existing in the Token API */\n  filterSupportedTokens?: boolean;\n  /** Specific token addresses to fetch balances for across specified network(s) */\n  includeTokenAddresses?: string;\n  /** Whether to include balances of the account's staked asset balances */\n  includeStakedAssets?: boolean;\n};\n\nexport type GetBalancesQueryParamsV4 = {\n  /** Comma-separated network/chain IDs */\n  networks?: string;\n\n  /** Comma-separated account addresses */\n  accountAddresses?: string;\n};\n\nexport type GetBalancesResponse = {\n  count: number;\n  balances: {\n    /** Underlying object type. Seems to be always `token` */\n    object: string;\n    /** Token Type: This is only supplied as `native` to native chain tokens (e.g. - ETH, POL) */\n    type?: string;\n    /** Timestamp is only provided for `native` chain tokens */\n    timestamp?: string;\n    address: string;\n    symbol: string;\n    name: string;\n    decimals: number;\n    chainId: number;\n    /** string representation of the balance in decimal format (decimals adjusted). e.g. - 123.456789 */\n    balance: string;\n    /** Account address for V4 API responses */\n    accountAddress?: string;\n  }[];\n  /** networks that failed to process, if no network is processed, returns HTTP 422  */\n  unprocessedNetworks: number[];\n};\n"]}

package/dist/multi-chain-accounts-service/types.d.cts

@@ -14,6 +14,12 @@ export type GetBalancesQueryParams = {
     /** Whether to include balances of the account's staked asset balances */
     includeStakedAssets?: boolean;
 };
+export type GetBalancesQueryParamsV4 = {
+    /** Comma-separated network/chain IDs */
+    networks?: string;
+    /** Comma-separated account addresses */
+    accountAddresses?: string;
+};
 export type GetBalancesResponse = {
     count: number;
     balances: {
@@ -30,6 +36,8 @@ export type GetBalancesResponse = {
         chainId: number;
         /** string representation of the balance in decimal format (decimals adjusted). e.g. - 123.456789 */
         balance: string;
+        /** Account address for V4 API responses */
+        accountAddress?: string;
     }[];
     /** networks that failed to process, if no network is processed, returns HTTP 422  */
     unprocessedNetworks: number[];

package/dist/multi-chain-accounts-service/types.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","sourceRoot":"","sources":["../../src/multi-chain-accounts-service/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,4BAA4B,GAAG;IACzC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,EAAE;QACd,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+FAA+F;IAC/F,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,iFAAiF;IACjF,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,yEAAyE;IACzE,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE;QACR,yDAAyD;QACzD,MAAM,EAAE,MAAM,CAAC;QACf,6FAA6F;QAC7F,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,2DAA2D;QAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,oGAAoG;QACpG,OAAO,EAAE,MAAM,CAAC;KACjB,EAAE,CAAC;IACJ,qFAAqF;IACrF,mBAAmB,EAAE,MAAM,EAAE,CAAC;CAC/B,CAAC"}
+{"version":3,"file":"types.d.cts","sourceRoot":"","sources":["../../src/multi-chain-accounts-service/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,4BAA4B,GAAG;IACzC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,EAAE;QACd,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+FAA+F;IAC/F,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,iFAAiF;IACjF,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,yEAAyE;IACzE,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,wCAAwC;IACxC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE;QACR,yDAAyD;QACzD,MAAM,EAAE,MAAM,CAAC;QACf,6FAA6F;QAC7F,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,2DAA2D;QAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,oGAAoG;QACpG,OAAO,EAAE,MAAM,CAAC;QAChB,2CAA2C;QAC3C,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,EAAE,CAAC;IACJ,qFAAqF;IACrF,mBAAmB,EAAE,MAAM,EAAE,CAAC;CAC/B,CAAC"}

package/dist/multi-chain-accounts-service/types.d.mts

@@ -14,6 +14,12 @@ export type GetBalancesQueryParams = {
     /** Whether to include balances of the account's staked asset balances */
     includeStakedAssets?: boolean;
 };
+export type GetBalancesQueryParamsV4 = {
+    /** Comma-separated network/chain IDs */
+    networks?: string;
+    /** Comma-separated account addresses */
+    accountAddresses?: string;
+};
 export type GetBalancesResponse = {
     count: number;
     balances: {
@@ -30,6 +36,8 @@ export type GetBalancesResponse = {
         chainId: number;
         /** string representation of the balance in decimal format (decimals adjusted). e.g. - 123.456789 */
         balance: string;
+        /** Account address for V4 API responses */
+        accountAddress?: string;
     }[];
     /** networks that failed to process, if no network is processed, returns HTTP 422  */
     unprocessedNetworks: number[];

package/dist/multi-chain-accounts-service/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","sourceRoot":"","sources":["../../src/multi-chain-accounts-service/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,4BAA4B,GAAG;IACzC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,EAAE;QACd,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+FAA+F;IAC/F,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,iFAAiF;IACjF,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,yEAAyE;IACzE,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE;QACR,yDAAyD;QACzD,MAAM,EAAE,MAAM,CAAC;QACf,6FAA6F;QAC7F,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,2DAA2D;QAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,oGAAoG;QACpG,OAAO,EAAE,MAAM,CAAC;KACjB,EAAE,CAAC;IACJ,qFAAqF;IACrF,mBAAmB,EAAE,MAAM,EAAE,CAAC;CAC/B,CAAC"}
+{"version":3,"file":"types.d.mts","sourceRoot":"","sources":["../../src/multi-chain-accounts-service/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,4BAA4B,GAAG;IACzC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,EAAE;QACd,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+FAA+F;IAC/F,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,iFAAiF;IACjF,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,yEAAyE;IACzE,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,wCAAwC;IACxC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE;QACR,yDAAyD;QACzD,MAAM,EAAE,MAAM,CAAC;QACf,6FAA6F;QAC7F,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,2DAA2D;QAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,oGAAoG;QACpG,OAAO,EAAE,MAAM,CAAC;QAChB,2CAA2C;QAC3C,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,EAAE,CAAC;IACJ,qFAAqF;IACrF,mBAAmB,EAAE,MAAM,EAAE,CAAC;CAC/B,CAAC"}

package/dist/multi-chain-accounts-service/types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.mjs","sourceRoot":"","sources":["../../src/multi-chain-accounts-service/types.ts"],"names":[],"mappings":"","sourcesContent":["export type GetSupportedNetworksResponse = {\n  fullSupport: number[];\n  partialSupport: {\n    balances: number[];\n  };\n};\n\nexport type GetBalancesQueryParams = {\n  /** Comma-separated network/chain IDs */\n  networks?: string;\n  /** Whether or not to filter the assets to contain only the tokens existing in the Token API */\n  filterSupportedTokens?: boolean;\n  /** Specific token addresses to fetch balances for across specified network(s) */\n  includeTokenAddresses?: string;\n  /** Whether to include balances of the account's staked asset balances */\n  includeStakedAssets?: boolean;\n};\n\nexport type GetBalancesResponse = {\n  count: number;\n  balances: {\n    /** Underlying object type. Seems to be always `token` */\n    object: string;\n    /** Token Type: This is only supplied as `native` to native chain tokens (e.g. - ETH, POL) */\n    type?: string;\n    /** Timestamp is only provided for `native` chain tokens */\n    timestamp?: string;\n    address: string;\n    symbol: string;\n    name: string;\n    decimals: number;\n    chainId: number;\n    /** string representation of the balance in decimal format (decimals adjusted). e.g. - 123.456789 */\n    balance: string;\n  }[];\n  /** networks that failed to process, if no network is processed, returns HTTP 422  */\n  unprocessedNetworks: number[];\n};\n"]}
+{"version":3,"file":"types.mjs","sourceRoot":"","sources":["../../src/multi-chain-accounts-service/types.ts"],"names":[],"mappings":"","sourcesContent":["export type GetSupportedNetworksResponse = {\n  fullSupport: number[];\n  partialSupport: {\n    balances: number[];\n  };\n};\n\nexport type GetBalancesQueryParams = {\n  /** Comma-separated network/chain IDs */\n  networks?: string;\n  /** Whether or not to filter the assets to contain only the tokens existing in the Token API */\n  filterSupportedTokens?: boolean;\n  /** Specific token addresses to fetch balances for across specified network(s) */\n  includeTokenAddresses?: string;\n  /** Whether to include balances of the account's staked asset balances */\n  includeStakedAssets?: boolean;\n};\n\nexport type GetBalancesQueryParamsV4 = {\n  /** Comma-separated network/chain IDs */\n  networks?: string;\n\n  /** Comma-separated account addresses */\n  accountAddresses?: string;\n};\n\nexport type GetBalancesResponse = {\n  count: number;\n  balances: {\n    /** Underlying object type. Seems to be always `token` */\n    object: string;\n    /** Token Type: This is only supplied as `native` to native chain tokens (e.g. - ETH, POL) */\n    type?: string;\n    /** Timestamp is only provided for `native` chain tokens */\n    timestamp?: string;\n    address: string;\n    symbol: string;\n    name: string;\n    decimals: number;\n    chainId: number;\n    /** string representation of the balance in decimal format (decimals adjusted). e.g. - 123.456789 */\n    balance: string;\n    /** Account address for V4 API responses */\n    accountAddress?: string;\n  }[];\n  /** networks that failed to process, if no network is processed, returns HTTP 422  */\n  unprocessedNetworks: number[];\n};\n"]}

package/dist/multicall.cjs

@@ -1,7 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.multicallOrFallback = void 0;
+exports.getTokenBalancesForMultipleAddresses = exports.getStakedBalancesForAddresses = exports.aggregate3 = exports.multicallOrFallback = void 0;
 const contracts_1 = require("@ethersproject/contracts");
+const bn_js_1 = __importDefault(require("bn.js"));
+const AssetsContractController_1 = require("./AssetsContractController.cjs");
 const assetsUtil_1 = require("./assetsUtil.cjs");
 // https://github.com/mds1/multicall/blob/main/deployments.json
 const MULTICALL_CONTRACT_BY_CHAINID = {
@@ -285,6 +290,78 @@ const multicallAbi = [
         ],
     },
 ];
+// Multicall3 ABI for aggregate3 function
+const multicall3Abi = [
+    {
+        name: 'aggregate3',
+        type: 'function',
+        stateMutability: 'payable',
+        inputs: [
+            {
+                name: 'calls',
+                type: 'tuple[]',
+                components: [
+                    { name: 'target', type: 'address' },
+                    { name: 'allowFailure', type: 'bool' },
+                    { name: 'callData', type: 'bytes' },
+                ],
+            },
+        ],
+        outputs: [
+            {
+                name: 'returnData',
+                type: 'tuple[]',
+                components: [
+                    { name: 'success', type: 'bool' },
+                    { name: 'returnData', type: 'bytes' },
+                ],
+            },
+        ],
+    },
+];
+// Constants for encoded strings and addresses
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+const BALANCE_OF_FUNCTION = 'balanceOf(address)';
+const GET_ETH_BALANCE_FUNCTION = 'getEthBalance';
+const GET_SHARES_FUNCTION = 'getShares';
+const CONVERT_TO_ASSETS_FUNCTION = 'convertToAssets';
+// ERC20 balanceOf ABI
+const ERC20_BALANCE_OF_ABI = [
+    {
+        name: 'balanceOf',
+        type: 'function',
+        inputs: [{ name: 'account', type: 'address' }],
+        outputs: [{ name: '', type: 'uint256' }],
+        stateMutability: 'view',
+    },
+];
+// Multicall3 getEthBalance ABI
+const MULTICALL3_GET_ETH_BALANCE_ABI = [
+    {
+        name: 'getEthBalance',
+        type: 'function',
+        inputs: [{ name: 'addr', type: 'address' }],
+        outputs: [{ name: 'balance', type: 'uint256' }],
+        stateMutability: 'view',
+    },
+];
+// Staking contract ABI with both getShares and convertToAssets
+const STAKING_CONTRACT_ABI = [
+    {
+        inputs: [{ internalType: 'address', name: 'account', type: 'address' }],
+        name: 'getShares',
+        outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [{ internalType: 'uint256', name: 'shares', type: 'uint256' }],
+        name: 'convertToAssets',
+        outputs: [{ internalType: 'uint256', name: 'assets', type: 'uint256' }],
+        stateMutability: 'view',
+        type: 'function',
+    },
+];
 const multicall = async (calls, multicallAddress, provider, maxCallsPerMulticall) => {
     const multicallContract = new contracts_1.Contract(multicallAddress, multicallAbi, provider);
     return await (0, assetsUtil_1.reduceInBatchesSerially)({
@@ -330,6 +407,7 @@ const fallback = async (calls, maxCallsParallel) => {
  * Executes an array of contract calls. If the chain supports multicalls,
  * the calls will be executed in single RPC requests (up to maxCallsPerMulticall).
  * Otherwise the calls will be executed separately in parallel (up to maxCallsParallel).
+ *
  * @param calls - An array of contract calls to execute.
  * @param chainId - The hexadecimal chain id.
  * @param provider - An ethers rpc provider.
@@ -360,4 +438,382 @@ const multicallOrFallback = async (calls, chainId, provider, maxCallsPerMultical
     return await fallback(calls, maxCallsParallel);
 };
 exports.multicallOrFallback = multicallOrFallback;
+/**
+ * Execute multiple contract calls using Multicall3's aggregate3 function.
+ * This allows for more efficient batch calls with individual failure handling.
+ *
+ * @param calls - Array of calls to execute via aggregate3
+ * @param chainId - The hexadecimal chain id
+ * @param provider - An ethers rpc provider
+ * @returns Promise resolving to array of results from aggregate3
+ */
+const aggregate3 = async (calls, chainId, provider) => {
+    if (calls.length === 0) {
+        return [];
+    }
+    const multicall3Address = MULTICALL_CONTRACT_BY_CHAINID[chainId];
+    const multicall3Contract = new contracts_1.Contract(multicall3Address, multicall3Abi, provider);
+    return await multicall3Contract.callStatic.aggregate3(calls);
+};
+exports.aggregate3 = aggregate3;
+/**
+ * Processes and decodes balance results from aggregate3 calls
+ *
+ * @param results - Array of results from aggregate3 calls
+ * @param callMapping - Array mapping call indices to token and user addresses
+ * @param chainId - The hexadecimal chain id
+ * @param provider - An ethers rpc provider
+ * @param includeStaked - Whether to include staked balances
+ * @returns Map of token address to map of user address to balance
+ */
+const processBalanceResults = (results, callMapping, chainId, provider, includeStaked) => {
+    const balanceMap = {};
+    const stakedBalanceMap = {};
+    // Create contract instances for decoding
+    const erc20Contract = new contracts_1.Contract(ZERO_ADDRESS, ERC20_BALANCE_OF_ABI, provider);
+    const multicall3Address = MULTICALL_CONTRACT_BY_CHAINID[chainId];
+    const multicall3Contract = new contracts_1.Contract(multicall3Address, MULTICALL3_GET_ETH_BALANCE_ABI, provider);
+    // Staking contracts are now handled separately in two-step process
+    results.forEach((result, index) => {
+        if (result.success) {
+            const { tokenAddress, userAddress, callType } = callMapping[index];
+            let balance;
+            if (callType === 'native') {
+                // For native token, decode the getEthBalance result
+                balance = multicall3Contract.interface.decodeFunctionResult(GET_ETH_BALANCE_FUNCTION, result.returnData)[0];
+                if (!balanceMap[tokenAddress]) {
+                    balanceMap[tokenAddress] = {};
+                }
+                balanceMap[tokenAddress][userAddress] = balance;
+            }
+            else if (callType === 'staking') {
+                // Staking is now handled separately in two-step process
+                // This case should not occur anymore
+                console.warn('Staking callType found in main processing - this should not happen');
+            }
+            else {
+                // For ERC20 tokens, decode the balanceOf result
+                balance = erc20Contract.interface.decodeFunctionResult(BALANCE_OF_FUNCTION, result.returnData)[0];
+                if (!balanceMap[tokenAddress]) {
+                    balanceMap[tokenAddress] = {};
+                }
+                balanceMap[tokenAddress][userAddress] = balance;
+            }
+        }
+    });
+    const result = { tokenBalances: balanceMap };
+    if (includeStaked && Object.keys(stakedBalanceMap).length > 0) {
+        result.stakedBalances = stakedBalanceMap;
+    }
+    return result;
+};
+/**
+ * Fallback function to get native token balances using individual eth_getBalance calls
+ * when Multicall3 is not supported on the chain.
+ *
+ * @param userAddresses - Array of user addresses to check balances for
+ * @param provider - An ethers rpc provider
+ * @param maxCallsParallel - Maximum number of parallel calls (default: 20)
+ * @returns Promise resolving to map of user address to balance
+ */
+const getNativeBalancesFallback = async (userAddresses, provider, maxCallsParallel = 20) => {
+    const balanceMap = {};
+    await (0, assetsUtil_1.reduceInBatchesSerially)({
+        values: userAddresses,
+        batchSize: maxCallsParallel,
+        initialResult: undefined,
+        eachBatch: async (_, batch) => {
+            const results = await Promise.allSettled(batch.map(async (userAddress) => {
+                const balance = await provider.getBalance(userAddress);
+                return {
+                    success: true,
+                    balance: new bn_js_1.default(balance.toString()),
+                    userAddress,
+                };
+            }));
+            results.forEach((result) => {
+                if (result.status === 'fulfilled' &&
+                    result.value.success &&
+                    result.value.balance !== null) {
+                    balanceMap[result.value.userAddress] = result.value.balance;
+                }
+            });
+        },
+    });
+    return balanceMap;
+};
+/**
+ * Fallback function to get token balances using individual calls
+ * when Multicall3 is not supported or when aggregate3 calls fail.
+ *
+ * @param tokenAddresses - Array of ERC20 token contract addresses
+ * @param userAddresses - Array of user addresses to check balances for
+ * @param provider - An ethers rpc provider
+ * @param includeNative - Whether to include native token balances (default: true)
+ * @param maxCallsParallel - Maximum number of parallel calls (default: 20)
+ * @returns Promise resolving to map of token address to map of user address to balance
+ */
+const getTokenBalancesFallback = async (tokenAddresses, userAddresses, provider, includeNative, maxCallsParallel) => {
+    const balanceMap = {};
+    // Handle ERC20 token balances using the existing fallback function
+    if (tokenAddresses.length > 0) {
+        const erc20Calls = [];
+        const callMapping = [];
+        tokenAddresses.forEach((tokenAddress) => {
+            userAddresses.forEach((userAddress) => {
+                const contract = new contracts_1.Contract(tokenAddress, ERC20_BALANCE_OF_ABI, provider);
+                erc20Calls.push({
+                    contract,
+                    functionSignature: BALANCE_OF_FUNCTION,
+                    arguments: [userAddress],
+                });
+                callMapping.push({ tokenAddress, userAddress });
+            });
+        });
+        const erc20Results = await fallback(erc20Calls, maxCallsParallel);
+        erc20Results.forEach((result, index) => {
+            if (result.success) {
+                const { tokenAddress, userAddress } = callMapping[index];
+                if (!balanceMap[tokenAddress]) {
+                    balanceMap[tokenAddress] = {};
+                }
+                balanceMap[tokenAddress][userAddress] = result.value;
+            }
+        });
+    }
+    // Handle native token balances using the native fallback function
+    if (includeNative) {
+        const nativeBalances = await getNativeBalancesFallback(userAddresses, provider, maxCallsParallel);
+        if (Object.keys(nativeBalances).length > 0) {
+            balanceMap[ZERO_ADDRESS] = nativeBalances;
+        }
+    }
+    return balanceMap;
+};
+/**
+ * Fallback function to get staked balances using individual calls
+ * when Multicall3 is not supported or when aggregate3 calls fail.
+ *
+ * @param userAddresses - Array of user addresses to check staked balances for
+ * @param chainId - The hexadecimal chain id
+ * @param provider - An ethers rpc provider
+ * @param maxCallsParallel - Maximum number of parallel calls (default: 20)
+ * @returns Promise resolving to map of user address to staked balance
+ */
+const getStakedBalancesFallback = async (userAddresses, chainId, provider, maxCallsParallel) => {
+    const stakedBalanceMap = {};
+    const stakingContractAddress = AssetsContractController_1.STAKING_CONTRACT_ADDRESS_BY_CHAINID[chainId];
+    if (!stakingContractAddress) {
+        // No staking support for this chain
+        return stakedBalanceMap;
+    }
+    const stakingCalls = [];
+    const callMapping = [];
+    userAddresses.forEach((userAddress) => {
+        const contract = new contracts_1.Contract(stakingContractAddress, STAKING_CONTRACT_ABI, provider);
+        stakingCalls.push({
+            contract,
+            functionSignature: GET_SHARES_FUNCTION,
+            arguments: [userAddress],
+        });
+        callMapping.push({ userAddress });
+    });
+    const stakingResults = await fallback(stakingCalls, maxCallsParallel);
+    stakingResults.forEach((result, index) => {
+        if (result.success) {
+            const { userAddress } = callMapping[index];
+            stakedBalanceMap[userAddress] = result.value;
+        }
+    });
+    return stakedBalanceMap;
+};
+/**
+ * Get staked balances for multiple addresses using two-step process:
+ * 1. Get shares for all addresses
+ * 2. Convert non-zero shares to assets
+ *
+ * @param userAddresses - Array of user addresses to check
+ * @param chainId - Chain ID as hex string
+ * @param provider - Ethers provider
+ * @returns Promise resolving to map of user address to staked balance
+ */
+const getStakedBalancesForAddresses = async (userAddresses, chainId, provider) => {
+    const stakingContractAddress = AssetsContractController_1.STAKING_CONTRACT_ADDRESS_BY_CHAINID[chainId];
+    if (!stakingContractAddress) {
+        return {};
+    }
+    const stakingContract = new contracts_1.Contract(stakingContractAddress, STAKING_CONTRACT_ABI, provider);
+    try {
+        // Step 1: Get shares for all addresses
+        const shareCalls = userAddresses.map((userAddress) => ({
+            target: stakingContractAddress,
+            allowFailure: true,
+            callData: stakingContract.interface.encodeFunctionData(GET_SHARES_FUNCTION, [userAddress]),
+        }));
+        const shareResults = await (0, exports.aggregate3)(shareCalls, chainId, provider);
+        // Step 2: For addresses with non-zero shares, convert to assets
+        const nonZeroSharesData = [];
+        shareResults.forEach((result, index) => {
+            if (result.success) {
+                const sharesRaw = stakingContract.interface.decodeFunctionResult(GET_SHARES_FUNCTION, result.returnData)[0];
+                const shares = new bn_js_1.default(sharesRaw.toString());
+                if (shares.gt(new bn_js_1.default(0))) {
+                    nonZeroSharesData.push({
+                        address: userAddresses[index],
+                        shares,
+                    });
+                }
+            }
+        });
+        if (nonZeroSharesData.length === 0) {
+            return {};
+        }
+        // Step 3: Convert shares to assets for addresses with non-zero shares
+        const assetCalls = nonZeroSharesData.map(({ shares }) => ({
+            target: stakingContractAddress,
+            allowFailure: true,
+            callData: stakingContract.interface.encodeFunctionData(CONVERT_TO_ASSETS_FUNCTION, [shares.toString()]),
+        }));
+        const assetResults = await (0, exports.aggregate3)(assetCalls, chainId, provider);
+        // Step 4: Build final result mapping
+        const result = {};
+        assetResults.forEach((assetResult, index) => {
+            if (assetResult.success) {
+                const assetsRaw = stakingContract.interface.decodeFunctionResult(CONVERT_TO_ASSETS_FUNCTION, assetResult.returnData)[0];
+                const assets = new bn_js_1.default(assetsRaw.toString());
+                const { address } = nonZeroSharesData[index];
+                result[address] = assets;
+            }
+        });
+        return result;
+    }
+    catch (error) {
+        console.error('Error fetching staked balances:', error);
+        return {};
+    }
+};
+exports.getStakedBalancesForAddresses = getStakedBalancesForAddresses;
+/**
+ * Get token balances (both ERC20 and native) for multiple addresses using aggregate3.
+ * This is more efficient than individual balanceOf calls for multiple addresses and tokens.
+ * Native token balances are mapped to the zero address (0x0000000000000000000000000000000000000000).
+ *
+ * @param accountTokenGroups - Array of objects containing account addresses and their associated token addresses
+ * @param chainId - The hexadecimal chain id
+ * @param provider - An ethers rpc provider
+ * @param includeNative - Whether to include native token balances (default: true)
+ * @param includeStaked - Whether to include staked balances from supported staking contracts (default: false)
+ * @returns Promise resolving to object containing tokenBalances map and optional stakedBalances map
+ */
+const getTokenBalancesForMultipleAddresses = async (accountTokenGroups, chainId, provider, includeNative, includeStaked) => {
+    // Return early if no groups provided
+    if (accountTokenGroups.length === 0 && !includeNative && !includeStaked) {
+        return { tokenBalances: {} };
+    }
+    // Extract unique token addresses and user addresses from groups
+    const uniqueTokenAddresses = Array.from(new Set(accountTokenGroups.flatMap((group) => group.tokenAddresses))).filter((tokenAddress) => tokenAddress !== ZERO_ADDRESS); // Exclude native token from ERC20 calls
+    const uniqueUserAddresses = Array.from(new Set(accountTokenGroups.map((group) => group.accountAddress)));
+    // Check if Multicall3 is supported on this chain
+    if (!MULTICALL_CONTRACT_BY_CHAINID[chainId]) {
+        // Fallback to individual balance calls when Multicall3 is not supported
+        const tokenBalances = await getTokenBalancesFallback(uniqueTokenAddresses, uniqueUserAddresses, provider, includeNative, 20);
+        const result = { tokenBalances };
+        // Handle staked balances fallback if requested
+        if (includeStaked) {
+            const stakedBalances = await getStakedBalancesFallback(uniqueUserAddresses, chainId, provider, 20);
+            if (Object.keys(stakedBalances).length > 0) {
+                result.stakedBalances = stakedBalances;
+            }
+        }
+        return result;
+    }
+    try {
+        // Create calls directly from pairs
+        const allCalls = [];
+        const allCallMapping = [];
+        // Create a temporary ERC20 contract for encoding
+        const tempERC20Contract = new contracts_1.Contract(ZERO_ADDRESS, ERC20_BALANCE_OF_ABI, provider);
+        // Create ERC20 balance calls for all account-token combinations
+        accountTokenGroups.forEach((group) => {
+            group.tokenAddresses
+                .filter((tokenAddress) => tokenAddress !== ZERO_ADDRESS)
+                .forEach((tokenAddress) => {
+                allCalls.push({
+                    target: tokenAddress,
+                    allowFailure: true,
+                    callData: tempERC20Contract.interface.encodeFunctionData(BALANCE_OF_FUNCTION, [group.accountAddress]),
+                });
+                allCallMapping.push({
+                    tokenAddress,
+                    userAddress: group.accountAddress,
+                    callType: 'erc20',
+                });
+            });
+        });
+        // Add native token balance calls if requested
+        if (includeNative) {
+            const multicall3Address = MULTICALL_CONTRACT_BY_CHAINID[chainId];
+            const multicall3TempContract = new contracts_1.Contract(multicall3Address, MULTICALL3_GET_ETH_BALANCE_ABI, provider);
+            uniqueUserAddresses.forEach((userAddress) => {
+                allCalls.push({
+                    target: multicall3Address,
+                    allowFailure: true,
+                    callData: multicall3TempContract.interface.encodeFunctionData(GET_ETH_BALANCE_FUNCTION, [userAddress]),
+                });
+                allCallMapping.push({
+                    tokenAddress: ZERO_ADDRESS,
+                    userAddress,
+                    callType: 'native',
+                });
+            });
+        }
+        // Note: Staking balances will be handled separately in two steps after token/native calls
+        // Execute all calls in batches
+        const maxCallsPerBatch = 300; // Limit calls per batch to avoid gas/size limits
+        const allResults = [];
+        await (0, assetsUtil_1.reduceInBatchesSerially)({
+            values: allCalls,
+            batchSize: maxCallsPerBatch,
+            initialResult: undefined,
+            eachBatch: async (_, batch) => {
+                const batchResults = await (0, exports.aggregate3)(batch, chainId, provider);
+                allResults.push(...batchResults);
+            },
+        });
+        // Handle staking balances in two steps if requested
+        let stakedBalances = {};
+        if (includeStaked) {
+            stakedBalances = await (0, exports.getStakedBalancesForAddresses)(uniqueUserAddresses, chainId, provider);
+        }
+        // Process and return results
+        const result = processBalanceResults(allResults, allCallMapping, chainId, provider, false);
+        // Add staked balances to result
+        if (includeStaked && Object.keys(stakedBalances).length > 0) {
+            result.stakedBalances = stakedBalances;
+        }
+        return result;
+    }
+    catch (error) {
+        // Fallback only on revert
+        // https://docs.ethers.org/v5/troubleshooting/errors/#help-CALL_EXCEPTION
+        if (!error ||
+            typeof error !== 'object' ||
+            !('code' in error) ||
+            error.code !== 'CALL_EXCEPTION') {
+            throw error;
+        }
+        // Fallback to individual balance calls when aggregate3 fails
+        const tokenBalances = await getTokenBalancesFallback(uniqueTokenAddresses, uniqueUserAddresses, provider, includeNative, 20);
+        const result = { tokenBalances };
+        // Handle staked balances fallback if requested
+        if (includeStaked) {
+            const stakedBalances = await getStakedBalancesFallback(uniqueUserAddresses, chainId, provider, 20);
+            if (Object.keys(stakedBalances).length > 0) {
+                result.stakedBalances = stakedBalances;
+            }
+        }
+        return result;
+    }
+};
+exports.getTokenBalancesForMultipleAddresses = getTokenBalancesForMultipleAddresses;
 //# sourceMappingURL=multicall.cjs.map