@metamask-previews/assets-controllers 73.1.0-preview-c3b78c5 → 73.1.0-preview-343f3d69

package/CHANGELOG.md

@@ -9,8 +9,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- Implement network filtering for aggregated balance selectors across mobile and extension ([#6285](https://github.com/MetaMask/core/pull/6285))
-- Add aggregated portfolio change calculator in core with period support (1d/7d/30d) and unit tests; exposes `calculateAggregatedChangeForAllWallets` for mobile/extension selectors ([#6285](https://github.com/MetaMask/core/pull/6285))
+- Implement balance change calculator and network filtering ([#6285](https://github.com/MetaMask/core/pull/6285))
+  - Add core balance change calculators with period support (1d/7d/30d), network filtering, and group-level computation
+- Add new utility functions for efficient balance fetching using Multicall3 ([#6212](https://github.com/MetaMask/core/pull/6212))
+  - Added `aggregate3` function for direct access to Multicall3's aggregate3 method with individual failure handling
+  - Added `getTokenBalancesForMultipleAddresses` function to efficiently batch ERC20 and native token balance queries for multiple addresses
+  - Supports up to 300 calls per batch with automatic fallback to individual calls on unsupported chains
+  - Returns organized balance data as nested maps for easy consumption by client applications
 
 ### Changed
 

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.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,70 @@ 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';
+// 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 getShares ABI
+const STAKING_GET_SHARES_ABI = [
+    {
+        inputs: [{ internalType: 'address', name: 'account', type: 'address' }],
+        name: 'getShares',
+        outputs: [{ internalType: 'uint256', name: '', 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)({
@@ -360,4 +429,329 @@ 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);
+    const stakingContractAddress = AssetsContractController_1.STAKING_CONTRACT_ADDRESS_BY_CHAINID[chainId];
+    const stakingContract = stakingContractAddress
+        ? new contracts_1.Contract(stakingContractAddress, STAKING_GET_SHARES_ABI, provider)
+        : null;
+    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') {
+                // For staking contract, decode the getShares result
+                if (stakingContract) {
+                    balance = stakingContract.interface.decodeFunctionResult(GET_SHARES_FUNCTION, result.returnData)[0];
+                    stakedBalanceMap[userAddress] = balance;
+                }
+            }
+            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_GET_SHARES_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 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',
+                });
+            });
+        }
+        // Add staking balance calls if requested
+        if (includeStaked) {
+            const stakingContractAddress = AssetsContractController_1.STAKING_CONTRACT_ADDRESS_BY_CHAINID[chainId];
+            if (stakingContractAddress) {
+                const stakingContract = new contracts_1.Contract(stakingContractAddress, STAKING_GET_SHARES_ABI, provider);
+                uniqueUserAddresses.forEach((userAddress) => {
+                    allCalls.push({
+                        target: stakingContractAddress,
+                        allowFailure: true,
+                        callData: stakingContract.interface.encodeFunctionData(GET_SHARES_FUNCTION, [userAddress]),
+                    });
+                    allCallMapping.push({
+                        tokenAddress: stakingContractAddress,
+                        userAddress,
+                        callType: 'staking',
+                    });
+                });
+            }
+        }
+        // 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);
+            },
+        });
+        // Process and return results
+        return processBalanceResults(allResults, allCallMapping, chainId, provider, includeStaked);
+    }
+    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