@metamask-previews/assets-controllers 73.0.1-preview-bf50b46b → 73.0.1-preview-e4e5ca5c

package/dist/multicall.mjs

@@ -1,13 +1,4 @@
-function $importDefault(module) {
-    if (module?.__esModule) {
-        return module.default;
-    }
-    return module;
-}
 import { Contract } from "@ethersproject/contracts";
-import $BN from "bn.js";
-const BN = $importDefault($BN);
-import { STAKING_CONTRACT_ADDRESS_BY_CHAINID } from "./AssetsContractController.mjs";
 import { reduceInBatchesSerially } from "./assetsUtil.mjs";
 // https://github.com/mds1/multicall/blob/main/deployments.json
 const MULTICALL_CONTRACT_BY_CHAINID = {
@@ -136,7 +127,7 @@ const MULTICALL_CONTRACT_BY_CHAINID = {
     '0x96f': '0xcA11bde05977b3631167028862bE2a173976CA11',
     '0x3cc5': '0xcA11bde05977b3631167028862bE2a173976CA11',
     '0x4571': '0xcA11bde05977b3631167028862bE2a173976CA11',
-    '0xe99': '0xca11bde05977b3631167028862be2a173976ca11',
+    '0xe99': '0xcA11bde05977b3631167028862bE2a173976CA11',
     '0x7d0': '0xcA11bde05977b3631167028862bE2a173976CA11',
     '0x1297': '0xcA11bde05977b3631167028862bE2a173976CA11',
     '0x1d5e': '0xcA11bde05977b3631167028862bE2a173976CA11',
@@ -198,11 +189,30 @@ const MULTICALL_CONTRACT_BY_CHAINID = {
     '0xa1337': '0xcA11bde05977b3631167028862bE2a173976CA11',
     '0x1f2b': '0xcA11bde05977b3631167028862bE2a173976CA11',
     '0xf63': '0xcA11bde05977b3631167028862bE2a173976CA11',
-    '0x144': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0x144': '0xF9cda624FBC7e059355ce98a31693d299FACd963',
     '0x118': '0xF9cda624FBC7e059355ce98a31693d299FACd963',
     '0x12c': '0xF9cda624FBC7e059355ce98a31693d299FACd963',
     '0x18995f': '0xF9cda624FBC7e059355ce98a31693d299FACd963',
     '0x2b74': '0xF9cda624FBC7e059355ce98a31693d299FACd963',
+    '0xfc': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0x9da': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0x137': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0x13ed': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0x24b1': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0xba9302': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0x7c8': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0x138d5': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0x6d': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0x343b': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0x34a1': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0x3109': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0x91b': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0xa96': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0x22c3': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0x2be3': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0xbf03': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0x1b254': '0xcA11bde05977b3631167028862bE2a173976CA11',
+    '0xa7b14': '0xcA11bde05977b3631167028862bE2a173976CA11',
     '0x2276': '0xcA11bde05977b3631167028862bE2a173976CA11',
     '0x1b9e': '0xcA11bde05977b3631167028862bE2a173976CA11',
     '0x6a63bb8': '0xcA11bde05977b3631167028862bE2a173976CA11',
@@ -272,70 +282,6 @@ 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 Contract(multicallAddress, multicallAbi, provider);
     return await reduceInBatchesSerially({
@@ -410,327 +356,4 @@ export const multicallOrFallback = async (calls, chainId, provider, maxCallsPerM
     }
     return await fallback(calls, maxCallsParallel);
 };
-/**
- * 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
- */
-export const aggregate3 = async (calls, chainId, provider) => {
-    if (calls.length === 0) {
-        return [];
-    }
-    const multicall3Address = MULTICALL_CONTRACT_BY_CHAINID[chainId];
-    const multicall3Contract = new Contract(multicall3Address, multicall3Abi, provider);
-    return await multicall3Contract.callStatic.aggregate3(calls);
-};
-/**
- * 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 Contract(ZERO_ADDRESS, ERC20_BALANCE_OF_ABI, provider);
-    const multicall3Address = MULTICALL_CONTRACT_BY_CHAINID[chainId];
-    const multicall3Contract = new Contract(multicall3Address, MULTICALL3_GET_ETH_BALANCE_ABI, provider);
-    const stakingContractAddress = STAKING_CONTRACT_ADDRESS_BY_CHAINID[chainId];
-    const stakingContract = stakingContractAddress
-        ? new 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 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(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 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 = 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 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
- */
-export 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 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 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 = STAKING_CONTRACT_ADDRESS_BY_CHAINID[chainId];
-            if (stakingContractAddress) {
-                const stakingContract = new 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 reduceInBatchesSerially({
-            values: allCalls,
-            batchSize: maxCallsPerBatch,
-            initialResult: undefined,
-            eachBatch: async (_, batch) => {
-                const batchResults = await 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;
-    }
-};
 //# sourceMappingURL=multicall.mjs.map