@factordao/governance 1.0.9 → 1.1.0

package/dist/mjs/utils/rewards-multicall.js

@@ -0,0 +1,682 @@
+import { createPublicClient, http, fallback, keccak256, encodeAbiParameters, parseAbiParameters, toHex, } from 'viem';
+import { ChainId } from '@factordao/tokenlist';
+import { ChainIdToViemChain } from './viem';
+// Storage slot constants for Scale rewards calculation
+const REWARD_MANAGER_SLOT = keccak256(toHex('factor.base.RewardManager.storage'));
+const FACTOR_GAUGE_SLOT = keccak256(toHex('factor.base.gauge.storage'));
+// Minimal ABI for Scale/Boost reward functions
+const REWARDS_ABI = [
+    // Scale functions
+    {
+        name: 'getRewardTokens',
+        type: 'function',
+        inputs: [],
+        outputs: [{ type: 'address[]' }],
+        stateMutability: 'view',
+    },
+    {
+        name: 'totalActiveSupply',
+        type: 'function',
+        inputs: [],
+        outputs: [{ type: 'uint256' }],
+        stateMutability: 'view',
+    },
+    {
+        name: 'activeBalance',
+        type: 'function',
+        inputs: [{ name: 'user', type: 'address' }],
+        outputs: [{ type: 'uint256' }],
+        stateMutability: 'view',
+    },
+    // Boost functions
+    {
+        name: 'getAllRewardTokens',
+        type: 'function',
+        inputs: [],
+        outputs: [{ type: 'address[]' }],
+        stateMutability: 'view',
+    },
+    {
+        name: 'rewardData',
+        type: 'function',
+        inputs: [{ name: 'token', type: 'address' }],
+        outputs: [
+            { name: 'periodFinish', type: 'uint256' },
+            { name: 'rewardRate', type: 'uint256' },
+            { name: 'lastUpdateTime', type: 'uint256' },
+            { name: 'rewardPerTokenStored', type: 'uint256' },
+        ],
+        stateMutability: 'view',
+    },
+    {
+        name: 'earned',
+        type: 'function',
+        inputs: [
+            { name: 'user', type: 'address' },
+            { name: 'token', type: 'address' },
+        ],
+        outputs: [{ type: 'uint256' }],
+        stateMutability: 'view',
+    },
+    {
+        name: 'getRewardForDuration',
+        type: 'function',
+        inputs: [{ name: 'token', type: 'address' }],
+        outputs: [{ type: 'uint256' }],
+        stateMutability: 'view',
+    },
+];
+// ERC20 ABI for token metadata
+const ERC20_ABI = [
+    {
+        name: 'symbol',
+        type: 'function',
+        inputs: [],
+        outputs: [{ type: 'string' }],
+        stateMutability: 'view',
+    },
+    {
+        name: 'decimals',
+        type: 'function',
+        inputs: [],
+        outputs: [{ type: 'uint8' }],
+        stateMutability: 'view',
+    },
+];
+// Gauge Controller ABI for Scale rewards
+const GAUGE_CONTROLLER_ABI = [
+    {
+        name: 'rewardData',
+        type: 'function',
+        inputs: [{ name: 'vault', type: 'address' }],
+        outputs: [
+            { name: 'fctrPerSec', type: 'uint128' },
+            { name: 'accumulatedFctr', type: 'uint128' },
+            { name: 'lastUpdated', type: 'uint128' },
+            { name: 'incentiveEndsAt', type: 'uint128' },
+        ],
+        stateMutability: 'view',
+    },
+];
+// Multicall3 ABI for batching getStorageAt calls
+const MULTICALL3_ABI = [
+    {
+        name: 'aggregate3',
+        type: 'function',
+        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' },
+                ],
+            },
+        ],
+        stateMutability: 'view',
+    },
+];
+// Multicall3 is deployed at the same address on all chains
+const MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
+// Multicall3 getEthBalance can be used to batch reads, but for storage we need a different approach
+// We'll use the standard eth_getStorageAt but batch with Promise.all since viem batches RPC calls
+// Helper to calculate storage slot for mapping(address => value)
+function getMappingSlot(key, baseSlot) {
+    return keccak256(encodeAbiParameters(parseAbiParameters('address, bytes32'), [
+        key,
+        baseSlot,
+    ]));
+}
+// Helper to calculate storage slot for nested mapping(address => mapping(address => value))
+function getNestedMappingSlot(outerKey, innerKey, baseSlot) {
+    const outerSlot = getMappingSlot(outerKey, baseSlot);
+    return getMappingSlot(innerKey, outerSlot);
+}
+// Public RPCs with fallback support
+const PUBLIC_RPCS = {
+    [ChainId.ARBITRUM_ONE]: [
+        'https://arb1.arbitrum.io/rpc',
+        'https://arbitrum.llamarpc.com',
+        'https://arbitrum-one-rpc.publicnode.com',
+    ],
+    [ChainId.BASE]: [
+        'https://base.llamarpc.com',
+        'https://base-rpc.publicnode.com',
+        'https://base.gateway.tenderly.co',
+    ],
+    [ChainId.OPTIMISM]: [
+        'https://optimism.llamarpc.com',
+        'https://optimism-rpc.publicnode.com',
+    ],
+    [ChainId.SONIC]: [
+        'https://rpc.soniclabs.com',
+        'https://sonic.drpc.org',
+        'https://sonic-rpc.publicnode.com',
+    ],
+};
+// Alchemy RPC URLs
+const ALCHEMY_RPCS = {
+    [ChainId.ARBITRUM_ONE]: 'https://arb-mainnet.g.alchemy.com/v2',
+    [ChainId.BASE]: 'https://base-mainnet.g.alchemy.com/v2',
+    [ChainId.OPTIMISM]: 'https://opt-mainnet.g.alchemy.com/v2',
+    [ChainId.SONIC]: 'https://sonic-mainnet.g.alchemy.com/v2',
+};
+export function createClientForChain(chainId, alchemyApiKey) {
+    const chain = ChainIdToViemChain(chainId);
+    const publicRpcs = PUBLIC_RPCS[chainId] || [];
+    // Enable JSON-RPC batching for better performance
+    const httpOptions = { batch: true };
+    let transports = publicRpcs.map((url) => http(url, httpOptions));
+    // If Alchemy key provided, use it as primary
+    if (alchemyApiKey && ALCHEMY_RPCS[chainId]) {
+        const alchemyUrl = `${ALCHEMY_RPCS[chainId]}/${alchemyApiKey}`;
+        transports = [http(alchemyUrl, httpOptions), ...transports];
+    }
+    return createPublicClient({
+        chain,
+        transport: transports.length > 1 ? fallback(transports) : transports[0],
+        batch: {
+            multicall: true,
+        },
+    });
+}
+// Format bigint with decimals
+function formatWithDecimals(value, decimals) {
+    if (value === 0n)
+        return '0';
+    const divisor = 10n ** BigInt(decimals);
+    const whole = value / divisor;
+    const remainder = value % divisor;
+    if (remainder === 0n) {
+        return whole.toString();
+    }
+    const remainderStr = remainder.toString().padStart(decimals, '0');
+    const trimmed = remainderStr.replace(/0+$/, '');
+    return `${whole}.${trimmed}`;
+}
+export async function fetchVaultRewardsForChain(client, vaults, userAddress) {
+    if (vaults.length === 0) {
+        return [];
+    }
+    // Stage 1: Get reward tokens and total active supply for all vaults
+    const stage1Contracts = vaults.flatMap((vault) => [
+        {
+            address: vault.id,
+            abi: REWARDS_ABI,
+            functionName: 'getRewardTokens',
+        },
+        {
+            address: vault.id,
+            abi: REWARDS_ABI,
+            functionName: 'getAllRewardTokens',
+        },
+        {
+            address: vault.id,
+            abi: REWARDS_ABI,
+            functionName: 'totalActiveSupply',
+        },
+    ]);
+    const stage1Results = await client.multicall({
+        contracts: stage1Contracts,
+        allowFailure: true,
+    });
+    // Parse Stage 1 results
+    const stage1Data = [];
+    for (let i = 0; i < vaults.length; i++) {
+        const baseIndex = i * 3;
+        const scaleTokensResult = stage1Results[baseIndex];
+        const boostTokensResult = stage1Results[baseIndex + 1];
+        const totalActiveSupplyResult = stage1Results[baseIndex + 2];
+        stage1Data.push({
+            vaultAddress: vaults[i].id,
+            scaleTokens: scaleTokensResult.status === 'success'
+                ? scaleTokensResult.result
+                : [],
+            boostTokens: boostTokensResult.status === 'success'
+                ? boostTokensResult.result
+                : [],
+            totalActiveSupply: totalActiveSupplyResult.status === 'success'
+                ? totalActiveSupplyResult.result
+                : 0n,
+        });
+    }
+    // Collect all unique tokens for metadata fetching
+    const allTokens = new Set();
+    for (const data of stage1Data) {
+        data.scaleTokens.forEach((t) => allTokens.add(t));
+        data.boostTokens.forEach((t) => allTokens.add(t));
+    }
+    const uniqueTokens = Array.from(allTokens);
+    // Stage 1.5: Fetch token metadata (symbol, decimals)
+    const tokenMetadataContracts = uniqueTokens.flatMap((token) => [
+        { address: token, abi: ERC20_ABI, functionName: 'symbol' },
+        { address: token, abi: ERC20_ABI, functionName: 'decimals' },
+    ]);
+    let tokenMetadataResults = [];
+    if (tokenMetadataContracts.length > 0) {
+        tokenMetadataResults = await client.multicall({
+            contracts: tokenMetadataContracts,
+            allowFailure: true,
+        });
+    }
+    // Build token metadata map
+    const tokenMetadata = {};
+    for (let i = 0; i < uniqueTokens.length; i++) {
+        const tokenKey = uniqueTokens[i].toLowerCase();
+        const symbolResult = tokenMetadataResults[i * 2];
+        const decimalsResult = tokenMetadataResults[i * 2 + 1];
+        tokenMetadata[tokenKey] = {
+            symbol: symbolResult.status === 'success'
+                ? (symbolResult.result ?? null)
+                : null,
+            decimals: decimalsResult.status === 'success'
+                ? (decimalsResult.result ?? 18)
+                : 18,
+        };
+    }
+    // Stage 2: Get reward data and getRewardForDuration for all tokens
+    const stage2Contracts = [];
+    // Track which tokens belong to which vault and type
+    const tokenMapping = [];
+    for (let i = 0; i < stage1Data.length; i++) {
+        const data = stage1Data[i];
+        // Add scale tokens - rewardData + getRewardForDuration
+        for (const token of data.scaleTokens) {
+            stage2Contracts.push({
+                address: data.vaultAddress,
+                abi: REWARDS_ABI,
+                functionName: 'rewardData',
+                args: [token],
+            });
+            tokenMapping.push({
+                vaultIndex: i,
+                token,
+                type: 'scale',
+                callType: 'rewardData',
+            });
+            stage2Contracts.push({
+                address: data.vaultAddress,
+                abi: REWARDS_ABI,
+                functionName: 'getRewardForDuration',
+                args: [token],
+            });
+            tokenMapping.push({
+                vaultIndex: i,
+                token,
+                type: 'scale',
+                callType: 'rewardForDuration',
+            });
+        }
+        // Add boost tokens - rewardData + getRewardForDuration
+        for (const token of data.boostTokens) {
+            stage2Contracts.push({
+                address: data.vaultAddress,
+                abi: REWARDS_ABI,
+                functionName: 'rewardData',
+                args: [token],
+            });
+            tokenMapping.push({
+                vaultIndex: i,
+                token,
+                type: 'boost',
+                callType: 'rewardData',
+            });
+            stage2Contracts.push({
+                address: data.vaultAddress,
+                abi: REWARDS_ABI,
+                functionName: 'getRewardForDuration',
+                args: [token],
+            });
+            tokenMapping.push({
+                vaultIndex: i,
+                token,
+                type: 'boost',
+                callType: 'rewardForDuration',
+            });
+        }
+    }
+    let stage2Results = [];
+    if (stage2Contracts.length > 0) {
+        stage2Results = await client.multicall({
+            contracts: stage2Contracts,
+            allowFailure: true,
+        });
+    }
+    // Parse Stage 2 results and build reward data maps
+    const vaultRewardData = stage1Data.map(() => ({
+        scaleRewardsData: {},
+        boostRewardsData: {},
+    }));
+    for (let i = 0; i < tokenMapping.length; i++) {
+        const mapping = tokenMapping[i];
+        const tokenKey = mapping.token.toLowerCase();
+        const targetMap = mapping.type === 'scale'
+            ? vaultRewardData[mapping.vaultIndex].scaleRewardsData
+            : vaultRewardData[mapping.vaultIndex].boostRewardsData;
+        // Initialize if not exists
+        if (!targetMap[tokenKey]) {
+            targetMap[tokenKey] = {
+                periodFinish: 0n,
+                rewardRate: 0n,
+                lastUpdateTime: 0n,
+                rewardPerTokenStored: 0n,
+                rewardForDuration: 0n,
+            };
+        }
+        const result = stage2Results[i];
+        if (result.status === 'success' && result.result !== undefined) {
+            if (mapping.callType === 'rewardData') {
+                const [periodFinish, rewardRate, lastUpdateTime, rewardPerTokenStored] = result.result;
+                targetMap[tokenKey].periodFinish = periodFinish;
+                targetMap[tokenKey].rewardRate = rewardRate;
+                targetMap[tokenKey].lastUpdateTime = lastUpdateTime;
+                targetMap[tokenKey].rewardPerTokenStored = rewardPerTokenStored;
+            }
+            else {
+                targetMap[tokenKey].rewardForDuration = result.result;
+            }
+        }
+    }
+    // Stage 3 (Optional): User data including Scale pending rewards
+    let userDataMap = {};
+    if (userAddress) {
+        // Stage 3a: Get basic user data (activeBalance for Scale, earned for Boost)
+        const stage3Contracts = [];
+        const userDataMapping = [];
+        for (let i = 0; i < stage1Data.length; i++) {
+            const data = stage1Data[i];
+            // Active balance for Scale
+            stage3Contracts.push({
+                address: data.vaultAddress,
+                abi: REWARDS_ABI,
+                functionName: 'activeBalance',
+                args: [userAddress],
+            });
+            userDataMapping.push({ vaultIndex: i, type: 'activeBalance' });
+            // Earned for each boost token
+            for (const token of data.boostTokens) {
+                stage3Contracts.push({
+                    address: data.vaultAddress,
+                    abi: REWARDS_ABI,
+                    functionName: 'earned',
+                    args: [userAddress, token],
+                });
+                userDataMapping.push({ vaultIndex: i, type: 'earned', token });
+            }
+        }
+        // Initialize user data map
+        for (let i = 0; i < stage1Data.length; i++) {
+            userDataMap[i] = {
+                activeBalance: 0n,
+                scalePendingByToken: {},
+                earnedByToken: {},
+            };
+        }
+        if (stage3Contracts.length > 0) {
+            const stage3Results = await client.multicall({
+                contracts: stage3Contracts,
+                allowFailure: true,
+            });
+            // Parse Stage 3 results
+            for (let i = 0; i < userDataMapping.length; i++) {
+                const mapping = userDataMapping[i];
+                const result = stage3Results[i];
+                if (result.status === 'success') {
+                    if (mapping.type === 'activeBalance') {
+                        userDataMap[mapping.vaultIndex].activeBalance =
+                            result.result;
+                    }
+                    else if (mapping.type === 'earned' && mapping.token) {
+                        userDataMap[mapping.vaultIndex].earnedByToken[mapping.token.toLowerCase()] = result.result;
+                    }
+                }
+            }
+        }
+        // Stage 3b: Calculate Scale pending rewards via storage slots
+        // JSON-RPC batching is enabled in the client, so Promise.all will batch automatically
+        // First, read gauge controller addresses from vault storage
+        const gaugeControllerSlot = toHex(BigInt(FACTOR_GAUGE_SLOT) + 2n, {
+            size: 32,
+        });
+        const gaugeControllerResults = await Promise.all(stage1Data.map((data) => client.getStorageAt({
+            address: data.vaultAddress,
+            slot: gaugeControllerSlot,
+        })));
+        const gaugeControllers = gaugeControllerResults.map((result) => {
+            if (!result ||
+                result ===
+                    '0x0000000000000000000000000000000000000000000000000000000000000000') {
+                return null;
+            }
+            return ('0x' + result.slice(-40));
+        });
+        // Get gauge controller reward data for all vaults
+        const gaugeControllerContracts = stage1Data
+            .map((data, i) => {
+            const gc = gaugeControllers[i];
+            if (!gc)
+                return null;
+            return {
+                address: gc,
+                abi: GAUGE_CONTROLLER_ABI,
+                functionName: 'rewardData',
+                args: [data.vaultAddress],
+            };
+        })
+            .filter((c) => c !== null);
+        const gcIndexMap = [];
+        stage1Data.forEach((_, i) => {
+            if (gaugeControllers[i]) {
+                gcIndexMap.push(i);
+            }
+        });
+        let gcRewardDataResults = [];
+        if (gaugeControllerContracts.length > 0) {
+            gcRewardDataResults = await client.multicall({
+                contracts: gaugeControllerContracts,
+                allowFailure: true,
+            });
+        }
+        const gcRewardData = {};
+        for (let i = 0; i < gcRewardDataResults.length; i++) {
+            const vaultIndex = gcIndexMap[i];
+            const result = gcRewardDataResults[i];
+            if (result.status === 'success' && result.result) {
+                const [fctrPerSec, accumulatedFctr, lastUpdated, incentiveEndsAt] = result.result;
+                gcRewardData[vaultIndex] = {
+                    fctrPerSec,
+                    accumulatedFctr,
+                    lastUpdated,
+                    incentiveEndsAt,
+                };
+            }
+        }
+        // Read storage slots for reward state and user reward
+        const storageReadPromises = [];
+        for (let i = 0; i < stage1Data.length; i++) {
+            const data = stage1Data[i];
+            for (const token of data.scaleTokens) {
+                const rewardStateBaseSlot = toHex(BigInt(REWARD_MANAGER_SLOT) + 2n, {
+                    size: 32,
+                });
+                const rewardStateSlot = getMappingSlot(token, rewardStateBaseSlot);
+                const userRewardBaseSlot = toHex(BigInt(REWARD_MANAGER_SLOT) + 1n, {
+                    size: 32,
+                });
+                const userRewardSlot = getNestedMappingSlot(token, userAddress, userRewardBaseSlot);
+                storageReadPromises.push(Promise.all([
+                    client.getStorageAt({
+                        address: data.vaultAddress,
+                        slot: rewardStateSlot,
+                    }),
+                    client.getStorageAt({
+                        address: data.vaultAddress,
+                        slot: userRewardSlot,
+                    }),
+                ]).then(([rewardStateData, userRewardData]) => ({
+                    vaultIndex: i,
+                    token,
+                    rewardStateData,
+                    userRewardData,
+                })));
+            }
+        }
+        const storageResults = await Promise.all(storageReadPromises);
+        // Calculate Scale pending rewards for each vault/token
+        const WAD = 10n ** 18n;
+        const INITIAL_REWARD_INDEX = 1n;
+        const currentTime = BigInt(Math.floor(Date.now() / 1000));
+        for (const storageResult of storageResults) {
+            const { vaultIndex, token, rewardStateData, userRewardData } = storageResult;
+            const tokenKey = token.toLowerCase();
+            const gcData = gcRewardData[vaultIndex];
+            const totalActiveSupply = stage1Data[vaultIndex].totalActiveSupply;
+            const userActiveBalance = userDataMap[vaultIndex].activeBalance;
+            if (!gcData) {
+                userDataMap[vaultIndex].scalePendingByToken[tokenKey] = 0n;
+                continue;
+            }
+            // Parse packed structs
+            const rewardStateValue = BigInt(rewardStateData || '0x0');
+            const globalIndex = rewardStateValue & ((1n << 128n) - 1n);
+            const userRewardValue = BigInt(userRewardData || '0x0');
+            const userIndex = userRewardValue & ((1n << 128n) - 1n);
+            const userAccrued = userRewardValue >> 128n;
+            // Calculate new accumulated from gauge controller
+            const effectiveTime = currentTime < gcData.incentiveEndsAt
+                ? currentTime
+                : gcData.incentiveEndsAt;
+            let newAccumulatedFromController = gcData.accumulatedFctr;
+            if (effectiveTime > gcData.lastUpdated) {
+                newAccumulatedFromController +=
+                    gcData.fctrPerSec * (effectiveTime - gcData.lastUpdated);
+            }
+            // Calculate new global index
+            let index = globalIndex;
+            if (index === 0n)
+                index = INITIAL_REWARD_INDEX;
+            if (totalActiveSupply > 0n) {
+                index += (newAccumulatedFromController * WAD) / totalActiveSupply;
+            }
+            // Calculate user reward
+            let effectiveUserIndex = userIndex;
+            if (effectiveUserIndex === 0n)
+                effectiveUserIndex = INITIAL_REWARD_INDEX;
+            const deltaIndex = index > effectiveUserIndex ? index - effectiveUserIndex : 0n;
+            const rewardDelta = (userActiveBalance * deltaIndex) / WAD;
+            const pendingRewards = userAccrued + rewardDelta;
+            userDataMap[vaultIndex].scalePendingByToken[tokenKey] = pendingRewards;
+        }
+    }
+    // Build final results with formatted values
+    const results = [];
+    for (let i = 0; i < stage1Data.length; i++) {
+        const data = stage1Data[i];
+        const rawRewardData = vaultRewardData[i];
+        // Build Scale reward tokens with metadata
+        const scaleTokenInfos = data.scaleTokens.map((t) => {
+            const tokenKey = t.toLowerCase();
+            const meta = tokenMetadata[tokenKey] || { symbol: null, decimals: 18 };
+            return {
+                address: tokenKey,
+                symbol: meta.symbol,
+                decimals: meta.decimals,
+            };
+        });
+        // Build Boost reward tokens with metadata
+        const boostTokenInfos = data.boostTokens.map((t) => {
+            const tokenKey = t.toLowerCase();
+            const meta = tokenMetadata[tokenKey] || { symbol: null, decimals: 18 };
+            return {
+                address: tokenKey,
+                symbol: meta.symbol,
+                decimals: meta.decimals,
+            };
+        });
+        // Format Scale rewards data
+        const scaleRewardsData = {};
+        for (const [tokenKey, raw] of Object.entries(rawRewardData.scaleRewardsData)) {
+            const decimals = tokenMetadata[tokenKey]?.decimals ?? 18;
+            scaleRewardsData[tokenKey] = {
+                periodFinish: raw.periodFinish,
+                periodFinishDate: raw.periodFinish > 0n
+                    ? new Date(Number(raw.periodFinish) * 1000)
+                    : null,
+                rewardRate: raw.rewardRate,
+                rewardRateFmt: formatWithDecimals(raw.rewardRate, decimals),
+                lastUpdateTime: raw.lastUpdateTime,
+                rewardPerTokenStored: raw.rewardPerTokenStored,
+                rewardForDuration: raw.rewardForDuration,
+                rewardForDurationFmt: formatWithDecimals(raw.rewardForDuration, decimals),
+            };
+        }
+        // Format Boost rewards data
+        const boostRewardsData = {};
+        for (const [tokenKey, raw] of Object.entries(rawRewardData.boostRewardsData)) {
+            const decimals = tokenMetadata[tokenKey]?.decimals ?? 18;
+            boostRewardsData[tokenKey] = {
+                periodFinish: raw.periodFinish,
+                periodFinishDate: raw.periodFinish > 0n
+                    ? new Date(Number(raw.periodFinish) * 1000)
+                    : null,
+                rewardRate: raw.rewardRate,
+                rewardRateFmt: formatWithDecimals(raw.rewardRate, decimals),
+                lastUpdateTime: raw.lastUpdateTime,
+                rewardPerTokenStored: raw.rewardPerTokenStored,
+                rewardForDuration: raw.rewardForDuration,
+                rewardForDurationFmt: formatWithDecimals(raw.rewardForDuration, decimals),
+            };
+        }
+        const result = {
+            vaultAddress: data.vaultAddress,
+            chainId: vaults[i].chainId,
+            scale: {
+                rewardTokens: scaleTokenInfos,
+                totalActiveSupply: data.totalActiveSupply,
+                totalActiveSupplyFmt: formatWithDecimals(data.totalActiveSupply, 18), // vault shares are 18 decimals
+                rewardsData: scaleRewardsData,
+            },
+            boost: {
+                rewardTokens: boostTokenInfos,
+                rewardsData: boostRewardsData,
+            },
+        };
+        if (userAddress && userDataMap[i]) {
+            const userData = userDataMap[i];
+            // Format Scale pending rewards
+            const scalePendingByTokenFmt = {};
+            for (const [tokenKey, pending] of Object.entries(userData.scalePendingByToken)) {
+                const decimals = tokenMetadata[tokenKey]?.decimals ?? 18;
+                scalePendingByTokenFmt[tokenKey] = formatWithDecimals(pending, decimals);
+            }
+            // Format Boost earned rewards
+            const earnedByTokenFmt = {};
+            for (const [tokenKey, earned] of Object.entries(userData.earnedByToken)) {
+                const decimals = tokenMetadata[tokenKey]?.decimals ?? 18;
+                earnedByTokenFmt[tokenKey] = formatWithDecimals(earned, decimals);
+            }
+            result.user = {
+                activeBalance: userData.activeBalance,
+                activeBalanceFmt: formatWithDecimals(userData.activeBalance, 18), // vault shares are 18 decimals
+                scalePendingByToken: userData.scalePendingByToken,
+                scalePendingByTokenFmt,
+                earnedByToken: userData.earnedByToken,
+                earnedByTokenFmt,
+            };
+        }
+        results.push(result);
+    }
+    return results;
+}
+//# sourceMappingURL=rewards-multicall.js.map