@defisaver/positions-sdk 2.1.169-custom-fetching-dev → 2.1.169-custom-fetching-3-dev

package/src/aaveV2/index.ts

@@ -18,13 +18,13 @@ import { aaveAnyGetAggregatedPositionData } from '../helpers/aaveHelpers';
 import { getEthPrice } from '../services/priceService';
 import { getViemProvider, setViemBlockNumber } from '../services/viem';
 
-export const _getAaveV2MarketsData = async (provider: Client, network: NetworkNumber, selectedMarket: AaveMarketInfo) => {
+export const _getAaveV2MarketsData = async (provider: Client, network: NetworkNumber, selectedMarket: AaveMarketInfo, blockNumber: Blockish = 'latest') => {
   const _addresses = selectedMarket.assets.map(a => getAssetInfo(ethToWeth(a)).address);
   const loanInfoContract = AaveLoanInfoV2ContractViem(provider, network);
   const marketAddress = selectedMarket.providerAddress;
   const [loanInfo, ethPrice] = await Promise.all([
-    loanInfoContract.read.getFullTokensInfo([marketAddress, _addresses as EthAddress[]]),
-    getEthPrice(provider),
+    loanInfoContract.read.getFullTokensInfo([marketAddress, _addresses as EthAddress[]], setViemBlockNumber(blockNumber)),
+    getEthPrice(provider, blockNumber),
   ]);
   const markets: AaveV2AssetData[] = loanInfo
     .map((market, i) => ({
@@ -87,7 +87,7 @@ export const _getAaveV2MarketsData = async (provider: Client, network: NetworkNu
   return { assetsData: payload };
 };
 
-export const getAaveV2MarketsData = async (provider: EthereumProvider, network: NetworkNumber, selectedMarket: AaveMarketInfo) => _getAaveV2MarketsData(getViemProvider(provider, network), network, selectedMarket);
+export const getAaveV2MarketsData = async (provider: EthereumProvider, network: NetworkNumber, selectedMarket: AaveMarketInfo, blockNumber: Blockish = 'latest') => _getAaveV2MarketsData(getViemProvider(provider, network), network, selectedMarket, blockNumber);
 
 export const _getAaveV2AccountBalances = async (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress): Promise<PositionBalances> => {
   const balances = await getAaveLikeBalances(provider, network, block, addressMapping, address, AAVE_V2, 'AaveLoanInfoV2');
@@ -100,7 +100,7 @@ export const _getAaveV2AccountBalances = async (provider: Client, network: Netwo
 
 export const getAaveV2AccountBalances = async (provider: EthereumProvider, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress): Promise<PositionBalances> => _getAaveV2AccountBalances(getViemProvider(provider, network), network, block, addressMapping, address);
 
-export const _getAaveV2AccountData = async (provider: Client, network: NetworkNumber, address: EthAddress, assetsData: AaveV2AssetsData, market: AaveMarketInfo): Promise<AaveV2PositionData> => {
+export const _getAaveV2AccountData = async (provider: Client, network: NetworkNumber, address: EthAddress, assetsData: AaveV2AssetsData, market: AaveMarketInfo, blockNumber: Blockish = 'latest'): Promise<AaveV2PositionData> => {
   if (!address) throw new Error('Address is required');
 
   let payload: AaveV2PositionData = {
@@ -111,7 +111,7 @@ export const _getAaveV2AccountData = async (provider: Client, network: NetworkNu
   const loanInfoContract = AaveLoanInfoV2ContractViem(provider, network);
   const marketAddress = market.providerAddress;
   const _addresses = market.assets.map(a => getAssetInfo(ethToWeth(a)).address);
-  const loanInfo = await loanInfoContract.read.getTokenBalances([marketAddress, address, _addresses as EthAddress[]]);
+  const loanInfo = await loanInfoContract.read.getTokenBalances([marketAddress, address, _addresses as EthAddress[]], setViemBlockNumber(blockNumber));
   const usedAssets = {} as AaveV2UsedAssets;
   loanInfo.forEach((_tokenInfo, i) => {
     const asset = market.assets[i];
@@ -193,7 +193,7 @@ export const _getAaveV2AccountData = async (provider: Client, network: NetworkNu
   return payload;
 };
 
-export const getAaveV2AccountData = async (provider: EthereumProvider, network: NetworkNumber, address: EthAddress, assetsData: AaveV2AssetsData, market: AaveMarketInfo): Promise<AaveV2PositionData> => _getAaveV2AccountData(getViemProvider(provider, network), network, address, assetsData, market);
+export const getAaveV2AccountData = async (provider: EthereumProvider, network: NetworkNumber, address: EthAddress, assetsData: AaveV2AssetsData, market: AaveMarketInfo, blockNumber: Blockish = 'latest'): Promise<AaveV2PositionData> => _getAaveV2AccountData(getViemProvider(provider, network), network, address, assetsData, market, blockNumber);
 
 export const getAaveV2FullPositionData = async (provider: EthereumProvider, network: NetworkNumber, address: EthAddress, market: AaveMarketInfo): Promise<AaveV2PositionData> => {
   const marketData = await getAaveV2MarketsData(provider, network, market);

package/src/aaveV3/index.ts

@@ -42,7 +42,7 @@ import {
   PositionBalances,
   HexString,
 } from '../types/common';
-import { getViemProvider, setViemBlockNumber } from '../services/viem';
+import { getBlockTimestamp, getViemProvider, setViemBlockNumber } from '../services/viem';
 import { getMeritCampaigns } from './merit';
 import { getAaveUnderlyingSymbol, getMerkleCampaigns } from './merkl';
 import { getSghoData } from './sgho';
@@ -81,7 +81,8 @@ export const aaveV3EmodeCategoriesMapping = (extractedState: any, usedAssets: Aa
   return categoriesMapping;
 };
 
-export async function _getAaveV3MarketData(provider: Client, network: NetworkNumber, market: AaveMarketInfo, blockNumber: 'latest' | number = 'latest'): Promise<AaveV3MarketData> {
+/** `blockTimestamp` (unix seconds) is the historical block's timestamp when already known; otherwise it is read from the block. */
+export async function _getAaveV3MarketData(provider: Client, network: NetworkNumber, market: AaveMarketInfo, blockNumber: 'latest' | number = 'latest', blockTimestamp?: number): Promise<AaveV3MarketData> {
   const _addresses = market.assets.map(a => getAssetInfo(getWrappedNativeAssetFromUnwrapped(a), network).address);
 
   const loanInfoContract = AaveV3ViewContractViem(provider, network);
@@ -100,12 +101,15 @@ export async function _getAaveV3MarketData(provider: Client, network: NetworkNum
     [marketAddress, addresses],
     setViemBlockNumber(blockNumber),
   ))).then((loanInfoChunks) => loanInfoChunks.flat());
+  // Merkl rewards are keyed by time, so a historical block resolves to its timestamp first (one
+  // RPC call unless given, none for 'latest') and the rewards in force at that moment are attached.
+  const merkleRewardsPromise = getBlockTimestamp(provider, blockNumber, blockTimestamp).then((asOfTimestamp) => getMerkleCampaigns(network, asOfTimestamp));
   // eslint-disable-next-line prefer-const
   let [loanInfo, eModesInfo, rewardInfo, merkleRewardsMap, meritRewardsMap] = await Promise.all([
     loanInfoPromise,
     loanInfoContract.read.getAllEmodes([marketAddress], setViemBlockNumber(blockNumber)),
     networksWithIncentives.includes(network) ? aaveIncentivesContract.read.getReservesIncentivesData([marketAddress], setViemBlockNumber(blockNumber)) : null,
-    getMerkleCampaigns(network),
+    merkleRewardsPromise,
     getMeritCampaigns(network, market.value),
   ]);
   // same break logic as view contract
@@ -356,8 +360,8 @@ export async function _getAaveV3MarketData(provider: Client, network: NetworkNum
   return { assetsData: payload, eModeCategoriesData };
 }
 
-export async function getAaveV3MarketData(provider: EthereumProvider, network: NetworkNumber, market: AaveMarketInfo, blockNumber: 'latest' | number = 'latest'): Promise<AaveV3MarketData> {
-  return _getAaveV3MarketData(getViemProvider(provider, network), network, market, blockNumber);
+export async function getAaveV3MarketData(provider: EthereumProvider, network: NetworkNumber, market: AaveMarketInfo, blockNumber: 'latest' | number = 'latest', blockTimestamp?: number): Promise<AaveV3MarketData> {
+  return _getAaveV3MarketData(getViemProvider(provider, network), network, market, blockNumber, blockTimestamp);
 }
 
 export const EMPTY_AAVE_DATA = {
@@ -852,7 +856,7 @@ export const fetchYearlyMeritApyForStakingGho = async () => {
   }
 };
 
-export const getStakeAaveData = async (provider: Client, network: NetworkNumber, address: EthAddress) => {
+export const getStakeAaveData = async (provider: Client, network: NetworkNumber, address: EthAddress, blockNumber: Blockish = 'latest') => {
   const stkGhoAddress = getAssetInfo('stkGHO').address as HexString;
   const stkAaveAddress = getAssetInfo('stkAAVE').address as HexString;
 
@@ -862,11 +866,11 @@ export const getStakeAaveData = async (provider: Client, network: NetworkNumber,
 
 
   const [aaveRewardsBalance, emissionsPerSecond, stkAAVEBalance, stkAAVETotalSupply, stkGHOBalance, ghoMeritApy, sgho] = await Promise.all([
-    AaveIncentivesController.read.getRewardsBalance([REWARDABLE_ASSETS, address]),
-    stkAAVE.read.assets([stkAaveAddress]),
-    stkAAVE.read.balanceOf([address]),
-    stkAAVE.read.totalSupply(),
-    stkGHO.read.balanceOf([address]),
+    AaveIncentivesController.read.getRewardsBalance([REWARDABLE_ASSETS, address], setViemBlockNumber(blockNumber)),
+    stkAAVE.read.assets([stkAaveAddress], setViemBlockNumber(blockNumber)),
+    stkAAVE.read.balanceOf([address], setViemBlockNumber(blockNumber)),
+    stkAAVE.read.totalSupply(setViemBlockNumber(blockNumber)),
+    stkGHO.read.balanceOf([address], setViemBlockNumber(blockNumber)),
     fetchYearlyMeritApyForStakingGho(),
     getSghoData(network, address),
   ]);

package/src/aaveV3/merkl.ts

@@ -1,5 +1,5 @@
 import { aprToApy } from '../moneymarket';
-import { fetchAllMerklOpportunities } from '../services/merkl';
+import { fetchMerklOpportunities } from '../services/merkl';
 import { wethToEth } from '../services/utils';
 import {
   MerkleRewardMap, MerklOpportunity, OpportunityAction, OpportunityStatus,
@@ -30,12 +30,17 @@ export const formatAaveAsset = (_symbol: string) => {
   return _symbol;
 };
 
-export const getMerkleCampaigns = async (chainId: NetworkNumber): Promise<MerkleRewardMap> => {
+/**
+ * Live Merkl reward campaigns for Aave V3 on the chain, keyed by aToken. With `asOfTimestamp` (unix
+ * seconds) the campaigns and APRs are the ones Merkl had at that moment instead.
+ */
+export const getMerkleCampaigns = async (chainId: NetworkNumber, asOfTimestamp?: number): Promise<MerkleRewardMap> => {
   try {
-    const opportunities = await fetchAllMerklOpportunities({
+    const opportunities = await fetchMerklOpportunities({
       mainProtocolId: 'aave',
+      chainId: chainId.toString(),
       status: OpportunityStatus.LIVE,
-    });
+    }, asOfTimestamp);
     const relevantOpportunities = opportunities
       .filter((o: MerklOpportunity) => o.chainId === chainId)
       .filter((o: MerklOpportunity) => o.status === OpportunityStatus.LIVE);

package/src/aaveV4/index.ts

@@ -1,7 +1,7 @@
 import { Client } from 'viem';
 import Dec from 'decimal.js';
 import { assetAmountInEth, assetAmountInWei, getAssetInfoByAddress } from '@defisaver/tokens';
-import { getViemProvider, setViemBlockNumber } from '../services/viem';
+import { getBlockTimestamp, getViemProvider, setViemBlockNumber } from '../services/viem';
 import {
   AaveV4AccountData,
   AaveV4HubAssetOnChainData,
@@ -32,8 +32,8 @@ import { attachAaveV4MerklIncentives, getAaveV4MerkleCampaigns } from './merkl';
 export * as lend from './lend';
 export { getAaveV4MerkleCampaigns } from './merkl';
 
-const fetchHubData = async (viewContract: ReturnType<typeof AaveV4ViewContractViem>, hubAddress: EthAddress): Promise<AaveV4HubOnChainData> => {
-  const hubData = await viewContract.read.getHubAllAssetsData([hubAddress]);
+const fetchHubData = async (viewContract: ReturnType<typeof AaveV4ViewContractViem>, hubAddress: EthAddress, blockNumber: Blockish = 'latest'): Promise<AaveV4HubOnChainData> => {
+  const hubData = await viewContract.read.getHubAllAssetsData([hubAddress], setViemBlockNumber(blockNumber));
   return {
     assets: hubData.reduce((acc: Record<number, AaveV4HubAssetOnChainData>, assetOnChainData) => {
       acc[assetOnChainData.assetId] = {
@@ -162,19 +162,22 @@ const formatReserveAsset = async (reserveAsset: AaveV4ReserveAssetOnChain, hubAs
   });
 };
 
-export async function _getAaveV4SpokeData(provider: Client, network: NetworkNumber, market: AaveV4SpokeInfo, blockNumber: 'latest' | number = 'latest'): Promise<AaveV4SpokeData> {
+/** `blockTimestamp` (unix seconds) is the historical block's timestamp when already known; otherwise it is read from the block. */
+export async function _getAaveV4SpokeData(provider: Client, network: NetworkNumber, market: AaveV4SpokeInfo, blockNumber: 'latest' | number = 'latest', blockTimestamp?: number): Promise<AaveV4SpokeData> {
   const viewContract = AaveV4ViewContractViem(provider, network, blockNumber);
 
   const hubsData: Record<string, AaveV4HubOnChainData> = {};
   const loadHubData = async (hubAddress: EthAddress) => {
-    hubsData[hubAddress.toLowerCase()] = await fetchHubData(viewContract, hubAddress);
+    hubsData[hubAddress.toLowerCase()] = await fetchHubData(viewContract, hubAddress, blockNumber);
   };
 
   // market.hubs is only a prefetch hint (lets known hubs load in parallel with the spoke data), so
   // failures are tolerated here — any hub the reserves actually reference is (re)fetched below.
   const [spokeData, merklCampaigns] = await Promise.all([
-    viewContract.read.getSpokeDataFull([market.address]),
-    getAaveV4MerkleCampaigns(network),
+    viewContract.read.getSpokeDataFull([market.address], setViemBlockNumber(blockNumber)),
+    // Merkl rewards are keyed by time: a historical block resolves to its timestamp first (one RPC
+    // call unless given, none for 'latest') so the rewards in force at that moment are attached.
+    getBlockTimestamp(provider, blockNumber, blockTimestamp).then((asOfTimestamp) => getAaveV4MerkleCampaigns(network, asOfTimestamp)),
     ...market.hubs.map((hubAddress) => loadHubData(hubAddress).catch(() => {})),
   ]);
 
@@ -205,14 +208,14 @@ export async function _getAaveV4SpokeData(provider: Client, network: NetworkNumb
   };
 }
 
-export async function getAaveV4SpokeData(provider: EthereumProvider, network: NetworkNumber, spoke: AaveV4SpokeInfo, blockNumber: 'latest' | number = 'latest'): Promise<AaveV4SpokeData> {
-  return _getAaveV4SpokeData(getViemProvider(provider, network), network, spoke, blockNumber);
+export async function getAaveV4SpokeData(provider: EthereumProvider, network: NetworkNumber, spoke: AaveV4SpokeInfo, blockNumber: 'latest' | number = 'latest', blockTimestamp?: number): Promise<AaveV4SpokeData> {
+  return _getAaveV4SpokeData(getViemProvider(provider, network), network, spoke, blockNumber, blockTimestamp);
 }
 
 export async function _getAaveV4AccountData(provider: Client, network: NetworkNumber, spokeData: AaveV4SpokeData, address: EthAddress, blockNumber: 'latest' | number = 'latest'): Promise<AaveV4AccountData> {
   const viewContract = AaveV4ViewContractViem(provider, network, blockNumber);
 
-  const loanData = await viewContract.read.getLoanData([spokeData.address, address]);
+  const loanData = await viewContract.read.getLoanData([spokeData.address, address], setViemBlockNumber(blockNumber));
 
   const healthFactorFromContract = new Dec(loanData.healthFactor.toString());
   const healthFactor = isMaxUint(healthFactorFromContract.toString()) ? 'Infinity' : healthFactorFromContract.div(1e18).toString();
@@ -297,7 +300,7 @@ export const _getAaveV4AccountHasAnyBalance = async (
   const blockNumber = block === 'latest' ? 'latest' : Number(block);
   const viewContract = AaveV4ViewContractViem(provider, network, blockNumber);
 
-  const loanData = await viewContract.read.getLoanData([spokeAddress, address]);
+  const loanData = await viewContract.read.getLoanData([spokeAddress, address], setViemBlockNumber(blockNumber));
   const reserves = loanData?.reserves || [];
 
   return reserves.some((reserveAsset) => {
@@ -379,14 +382,14 @@ export const getAaveV4AccountBalances = async (
   spokeData,
 );
 
-const _getAaveV4UnderlyingFromReserveId = async (provider: Client, network: NetworkNumber, spoke: EthAddress, reserveId: number): Promise<any> => {
-  const viewContract = AaveV4ViewContractViem(provider, network);
+const _getAaveV4UnderlyingFromReserveId = async (provider: Client, network: NetworkNumber, spoke: EthAddress, reserveId: number, blockNumber: Blockish = 'latest'): Promise<any> => {
+  const viewContract = AaveV4ViewContractViem(provider, network, blockNumber);
 
-  const reserveData = await viewContract.read.getReserveData([spoke, BigInt(reserveId)]);
+  const reserveData = await viewContract.read.getReserveData([spoke, BigInt(reserveId)], setViemBlockNumber(blockNumber));
 
   return reserveData.underlying;
 };
 
-export async function getAaveV4UnderlyingFromReserveId(provider: EthereumProvider, network: NetworkNumber, spoke: EthAddress, reserveId: number): Promise<any> {
-  return _getAaveV4UnderlyingFromReserveId(getViemProvider(provider, network), network, spoke, reserveId);
+export async function getAaveV4UnderlyingFromReserveId(provider: EthereumProvider, network: NetworkNumber, spoke: EthAddress, reserveId: number, blockNumber: Blockish = 'latest'): Promise<any> {
+  return _getAaveV4UnderlyingFromReserveId(getViemProvider(provider, network), network, spoke, reserveId, blockNumber);
 }

package/src/aaveV4/merkl.ts

@@ -1,6 +1,6 @@
 import Dec from 'decimal.js';
 import { aprToApy } from '../moneymarket';
-import { fetchAllMerklOpportunities } from '../services/merkl';
+import { fetchMerklOpportunities } from '../services/merkl';
 import {
   AaveV4MerklRewardMap,
   AaveV4MerklIncentive,
@@ -46,7 +46,11 @@ const buildIncentive = (opportunity: MerklOpportunity): IncentiveData => {
   };
 };
 
-export const buildAaveV4MerklRewardMap = (opportunities: MerklOpportunity[], chainId: NetworkNumber): AaveV4MerklRewardMap => {
+/**
+ * `asOfTimestamp` (unix seconds, defaults to now) decides which of an opportunity's campaigns count
+ * as running, so historical opportunity lists are judged at their own moment rather than today's.
+ */
+export const buildAaveV4MerklRewardMap = (opportunities: MerklOpportunity[], chainId: NetworkNumber, asOfTimestamp: number = Date.now() / 1000): AaveV4MerklRewardMap => {
   const result: AaveV4MerklRewardMap = { hub: {}, spoke: {} };
 
   const endByCampaignId: Record<string, number> = {};
@@ -64,7 +68,7 @@ export const buildAaveV4MerklRewardMap = (opportunities: MerklOpportunity[], cha
     .filter((o) => typeof o.type === 'string' && o.type.startsWith('AAVE_V4_'))
     .forEach((o) => {
       const side = o.action === OpportunityAction.BORROW ? IncentiveSide.Borrow : IncentiveSide.Supply;
-      const now = Date.now() / 1000;
+      const now = asOfTimestamp;
       const methods = o.campaigns
         ?.filter((c) => (c.startTimestamp === undefined || c.startTimestamp <= now)
           && (c.endTimestamp === undefined || c.endTimestamp > now))
@@ -136,15 +140,20 @@ export const buildAaveV4MerklRewardMap = (opportunities: MerklOpportunity[], cha
   return result;
 };
 
-export const getAaveV4MerkleCampaigns = async (chainId: NetworkNumber): Promise<AaveV4MerklRewardMap> => {
+/**
+ * Live Aave V4 Merkl reward campaigns for the chain, split by hub/spoke scope. With `asOfTimestamp`
+ * (unix seconds) the campaigns and APRs are the ones Merkl had at that moment instead.
+ */
+export const getAaveV4MerkleCampaigns = async (chainId: NetworkNumber, asOfTimestamp?: number): Promise<AaveV4MerklRewardMap> => {
   try {
-    const opportunities = await fetchAllMerklOpportunities({
+    const opportunities = await fetchMerklOpportunities({
       mainProtocolId: 'aave',
+      chainId: chainId.toString(),
       type: 'AAVE_V4_HUB_SUPPLY,AAVE_V4_HUB_BORROW,AAVE_V4_SPOKE_SUPPLY,AAVE_V4_SPOKE_BORROW,AAVE_V4_HUB_NET_LENDING,AAVE_V4_HUB_NET_BORROWING,AAVE_V4_SPOKE_NET_LENDING,AAVE_V4_SPOKE_NET_BORROWING',
       status: OpportunityStatus.LIVE,
       campaigns: 'true',
-    });
-    return buildAaveV4MerklRewardMap(opportunities, chainId);
+    }, asOfTimestamp);
+    return buildAaveV4MerklRewardMap(opportunities, chainId, asOfTimestamp);
   } catch (e) {
     console.error('Failed to fetch Aave V4 Merkle campaigns', e);
     return { hub: {}, spoke: {} };

package/src/claiming/aaveV3.ts

@@ -1,12 +1,13 @@
 import { Client } from 'viem';
 import Dec from 'decimal.js';
-import { EthAddress, NetworkNumber } from '../types';
+import { Blockish, EthAddress, NetworkNumber } from '../types';
 import { ClaimableToken, ClaimType, MerklRewardsClaimableToken } from '../types/claiming';
 import {
   AaveIncentiveDataProviderV3ContractViem,
   AaveRewardsControllerViem,
 } from '../contracts';
 import { compareAddresses, getEthAmountForDecimals, LONGER_TIMEOUT } from '../services/utils';
+import { setViemBlockNumber } from '../services/viem';
 import { getAaveUnderlyingSymbol } from '../helpers/aaveHelpers';
 
 type AaveReward = {
@@ -37,9 +38,10 @@ export async function getUnclaimedRewardsForAllMarkets(
   network: NetworkNumber,
   walletAddress: EthAddress,
   marketAddress: EthAddress,
+  blockNumber: Blockish = 'latest',
 ): Promise<ClaimableToken[]> {
   const contract = AaveIncentiveDataProviderV3ContractViem(provider, network);
-  const tokensData = await contract.read.getUserReservesIncentivesData([marketAddress, walletAddress]);
+  const tokensData = await contract.read.getUserReservesIncentivesData([marketAddress, walletAddress], setViemBlockNumber(blockNumber));
   const allTokensDataArrays = tokensData.reduce((acc: any[], val) => {
     acc.push(val.aTokenIncentivesUserData.userRewardsInformation);
     acc.push(val.vTokenIncentivesUserData.userRewardsInformation);
@@ -54,7 +56,7 @@ export async function getUnclaimedRewardsForAllMarkets(
   // reward can be any token like wstETH, but also aToken like aWETH
   const aaveRewardsController = AaveRewardsControllerViem(provider, network);
   const rewardsPerAAsset = await Promise.all(allATokens.map(
-    (token: string) => aaveRewardsController.read.getAllUserRewards([[token as EthAddress], walletAddress])));
+    (token: string) => aaveRewardsController.read.getAllUserRewards([[token as EthAddress], walletAddress], setViemBlockNumber(blockNumber))));
 
   // match amounts to token symbol, parse decimal amounts
   const rewardsPerAAssetWithInfo = rewardsPerAAsset.map((rewardForAAsset, aaIndex) => {

package/src/claiming/king.ts

@@ -2,7 +2,10 @@ import Dec from 'decimal.js';
 import { assetAmountInEth } from '@defisaver/tokens';
 import { Client } from 'viem';
 import { UUPSViem } from '../contracts';
-import { EthAddress, HexString, NetworkNumber } from '../types/common';
+import {
+  Blockish, EthAddress, HexString, NetworkNumber,
+} from '../types/common';
+import { setViemBlockNumber } from '../services/viem';
 import { ClaimType } from '../types/claiming';
 
 export const fetchKingRewards = async (walletAddress: EthAddress) => {
@@ -19,14 +22,14 @@ export const fetchKingRewards = async (walletAddress: EthAddress) => {
   }
 };
 
-export const getKingRewards = async (provider: Client, network: NetworkNumber, walletAddresses: EthAddress[]) => {
+export const getKingRewards = async (provider: Client, network: NetworkNumber, walletAddresses: EthAddress[], blockNumber: Blockish = 'latest') => {
   // Fetch all API data in parallel (these are external API calls, can't be batched with multicall)
   const apiDataPromises = walletAddresses.map(address => fetchKingRewards(address));
   const apiDataArray = await Promise.all(apiDataPromises);
 
   // Batch all contract calls using multicall
   const contract = UUPSViem(provider, network);
-  const cumulativePromises = walletAddresses.map(address => contract.read.cumulativeClaimed([address]),
+  const cumulativePromises = walletAddresses.map(address => contract.read.cumulativeClaimed([address], setViemBlockNumber(blockNumber)),
   );
   const cumulativeResults = await Promise.all(cumulativePromises);
 

package/src/claiming/spark.ts

@@ -6,9 +6,10 @@ import {
   SparkIncentiveDataProviderContractViem,
   SparkRewardsControllerViem,
 } from '../contracts';
-import { EthAddress, NetworkNumber } from '../types/common';
+import { Blockish, EthAddress, NetworkNumber } from '../types/common';
 import { ClaimType, SparkAirdropType, SparkRewardsClaimableToken } from '../types/claiming';
 import { compareAddresses, getEthAmountForDecimals } from '../services/utils';
+import { setViemBlockNumber } from '../services/viem';
 
 const IGNITION_REWARDS = '0xCBA0C0a2a0B6Bb11233ec4EA85C5bFfea33e724d';
 const PFL3_REWARDS = '0x7ac96180C4d6b2A328D3a19ac059D0E7Fc3C6d41';
@@ -31,7 +32,7 @@ type CumulativeClaimedSpkAirdropFuncProp = {
   user: string, tokenAddress: string, epoch: number, type: SparkAirdropType,
 };
 
-const getCumulativeClaimedSpkAirdrop = async (provider: Client, network: NetworkNumber, data: CumulativeClaimedSpkAirdropFuncProp[]) => {
+const getCumulativeClaimedSpkAirdrop = async (provider: Client, network: NetworkNumber, data: CumulativeClaimedSpkAirdropFuncProp[], blockNumber: Blockish = 'latest') => {
   const contractIgnition = createViemContractFromConfigFunc('SparkAirdrop', IGNITION_REWARDS)(provider, network);
   const contractPFL = createViemContractFromConfigFunc('SparkAirdrop', PFL3_REWARDS)(provider, network);
 
@@ -40,7 +41,7 @@ const getCumulativeClaimedSpkAirdrop = async (provider: Client, network: Network
       user, tokenAddress, epoch, type,
     } = airdrop;
     const contract = type === SparkAirdropType.SPARK_IGNITION ? contractIgnition : contractPFL;
-    return contract.read.cumulativeClaimed([user as EthAddress, tokenAddress as EthAddress, BigInt(epoch)]);
+    return contract.read.cumulativeClaimed([user as EthAddress, tokenAddress as EthAddress, BigInt(epoch)], setViemBlockNumber(blockNumber));
   }));
 
   return cumulativeAmounts.map((amount: bigint, i: number) => assetAmountInEth(amount.toString(), getAssetInfoByAddress(data[i].tokenAddress).symbol).toString());
@@ -50,6 +51,7 @@ export const fetchSparkAirdropRewards = async (
   provider: Client,
   network: NetworkNumber,
   walletAddresses: EthAddress[],
+  blockNumber: Blockish = 'latest',
 ) => {
   // Fetch all API data in parallel (these are external API calls, can't be batched with multicall)
   const apiDataPromises = walletAddresses.map(address => fetchSpkAirdropRewards(address));
@@ -89,7 +91,7 @@ export const fetchSparkAirdropRewards = async (
   }
 
   // Batch all contract calls
-  const cumulativeClaimedAmounts = await getCumulativeClaimedSpkAirdrop(provider, network, contractCallsData);
+  const cumulativeClaimedAmounts = await getCumulativeClaimedSpkAirdrop(provider, network, contractCallsData, blockNumber);
 
   // Process results
   const results: Record<string, any[]> = {};
@@ -142,9 +144,10 @@ export const fetchSparkRewards = async (
   network: NetworkNumber,
   walletAddress: EthAddress,
   marketAddress: EthAddress,
+  blockNumber: Blockish = 'latest',
 ): Promise<SparkRewardsClaimableToken[]> => {
   const contract = SparkIncentiveDataProviderContractViem(provider, network);
-  const tokensData = await contract.read.getUserReservesIncentivesData([marketAddress, walletAddress]);
+  const tokensData = await contract.read.getUserReservesIncentivesData([marketAddress, walletAddress], setViemBlockNumber(blockNumber));
   const allTokensDataArrays = tokensData.reduce((acc: any[], val) => {
     acc.push(val.aTokenIncentivesUserData.userRewardsInformation);
     acc.push(val.vTokenIncentivesUserData.userRewardsInformation);
@@ -165,7 +168,7 @@ export const fetchSparkRewards = async (
   };
   const rewardsPerAAsset = await Promise.all(allATokens.map((token: EthAddress) => {
     const sparkRewardsContract = SparkRewardsControllerViem(provider, network);
-    return sparkRewardsContract.read.getAllUserRewards([[token], walletAddress]);
+    return sparkRewardsContract.read.getAllUserRewards([[token], walletAddress], setViemBlockNumber(blockNumber));
   }));
 
   // match amounts to token symbol, parse decimal amounts

package/src/claiming/uniswap.ts

@@ -1,7 +1,8 @@
 import Dec from 'decimal.js';
 import { Client } from 'viem';
 import { assetAmountInEth } from '@defisaver/tokens';
-import { EthAddress, NetworkNumber } from '../types';
+import { Blockish, EthAddress, NetworkNumber } from '../types';
+import { setViemBlockNumber } from '../services/viem';
 import { UniswapTokenDistributorViem } from '../contracts';
 import { ClaimType, UniswapAirdropClaimableToken } from '../types/claiming';
 
@@ -25,14 +26,14 @@ export const fetchUniswapRewardsData = async (walletAddress: EthAddress) => {
   }
 };
 
-export const getUniswapRewards = async (provider: Client, network: NetworkNumber, walletAddresses: EthAddress[]): Promise<Record<string, UniswapAirdropClaimableToken[]>> => {
+export const getUniswapRewards = async (provider: Client, network: NetworkNumber, walletAddresses: EthAddress[], blockNumber: Blockish = 'latest'): Promise<Record<string, UniswapAirdropClaimableToken[]>> => {
   // Fetch all API data in parallel (these are external API calls, can't be batched with multicall)
   const apiDataPromises = walletAddresses.map(address => fetchUniswapRewardsData(address));
   const apiDataArray = await Promise.all(apiDataPromises);
 
   // Batch all contract calls using multicall
   const contract = UniswapTokenDistributorViem(provider, network);
-  const cumulativePromises = apiDataArray.map(data => (data.index ? contract.read.isClaimed([data.index]) : Promise.resolve(false)),
+  const cumulativePromises = apiDataArray.map(data => (data.index ? contract.read.isClaimed([data.index], setViemBlockNumber(blockNumber)) : Promise.resolve(false)),
   );
   const cumulativeResults = await Promise.all(cumulativePromises);
 

package/src/compoundV2/index.ts

@@ -17,11 +17,11 @@ import { getViemProvider, setViemBlockNumber } from '../services/viem';
 
 const compAddress = '0xc00e94cb662c3520282e6f5717214004a7f26888';
 
-export const _getCompoundV2MarketsData = async (provider: Client, network: NetworkNumber): Promise<CompoundV2MarketsData> => {
+export const _getCompoundV2MarketsData = async (provider: Client, network: NetworkNumber, blockNumber: Blockish = 'latest'): Promise<CompoundV2MarketsData> => {
   const cAddresses = compoundV2CollateralAssets.map(a => a.address);
 
   const loanInfoContract = CompoundLoanInfoContractViem(provider, network);
-  const loanInfo = await loanInfoContract.read.getFullTokensInfo([cAddresses as EthAddress[]]);
+  const loanInfo = await loanInfoContract.read.getFullTokensInfo([cAddresses as EthAddress[]], setViemBlockNumber(blockNumber));
 
   const compPrice = loanInfo.find(m => compareAddresses(m.underlyingTokenAddress, compAddress))!.price.toString();
 
@@ -86,7 +86,7 @@ export const _getCompoundV2MarketsData = async (provider: Client, network: Netwo
   return { assetsData: payload };
 };
 
-export const getCompoundV2MarketsData = async (provider: EthereumProvider, network: NetworkNumber): Promise<CompoundV2MarketsData> => _getCompoundV2MarketsData(getViemProvider(provider, network), network);
+export const getCompoundV2MarketsData = async (provider: EthereumProvider, network: NetworkNumber, blockNumber: Blockish = 'latest'): Promise<CompoundV2MarketsData> => _getCompoundV2MarketsData(getViemProvider(provider, network), network, blockNumber);
 
 export const EMPTY_COMPOUND_DATA = {
   usedAssets: {},
@@ -103,10 +103,10 @@ export const EMPTY_COMPOUND_DATA = {
   exposure: 'N/A',
 };
 
-const getCollateralAssetsAddresses = async (provider: Client, network: NetworkNumber, account: EthAddress) => {
+const getCollateralAssetsAddresses = async (provider: Client, network: NetworkNumber, account: EthAddress, blockNumber: Blockish = 'latest') => {
   const contract = ComptrollerContractViem(provider, network);
 
-  return contract.read.getAssetsIn([account]);
+  return contract.read.getAssetsIn([account], setViemBlockNumber(blockNumber));
 };
 
 const getAllMarketAddresses = async (provider: Client, network: NetworkNumber, block: Blockish) => {
@@ -172,15 +172,15 @@ export const getCompoundV2AccountBalances = async (
   address: EthAddress,
 ): Promise<PositionBalances> => _getCompoundV2AccountBalances(getViemProvider(provider, network), network, block, addressMapping, address);
 
-export const _getCompoundV2AccountData = async (provider: Client, network: NetworkNumber, address: EthAddress, assetsData: CompoundV2AssetsData): Promise<CompoundV2PositionData> => {
+export const _getCompoundV2AccountData = async (provider: Client, network: NetworkNumber, address: EthAddress, assetsData: CompoundV2AssetsData, blockNumber: Blockish = 'latest'): Promise<CompoundV2PositionData> => {
   if (!address) throw new Error('No address provided');
 
   let payload = { ...EMPTY_COMPOUND_DATA, lastUpdated: Date.now() };
 
   const loanInfoContract = CompoundLoanInfoContractViem(provider, network);
   const [loanInfo, collateralAssetsAddresses] = await Promise.all([
-    loanInfoContract.read.getTokenBalances([address, compoundV2CollateralAssets.map(a => a.address) as EthAddress[]]),
-    getCollateralAssetsAddresses(provider, network, address),
+    loanInfoContract.read.getTokenBalances([address, compoundV2CollateralAssets.map(a => a.address) as EthAddress[]], setViemBlockNumber(blockNumber)),
+    getCollateralAssetsAddresses(provider, network, address, blockNumber),
   ]);
 
   const usedAssets = {} as CompoundV2UsedAssets;
@@ -236,7 +236,8 @@ export const getCompoundV2AccountData = async (
   network: NetworkNumber,
   address: EthAddress,
   assetsData: CompoundV2AssetsData,
-): Promise<CompoundV2PositionData> => _getCompoundV2AccountData(getViemProvider(provider, network), network, address, assetsData);
+  blockNumber: Blockish = 'latest',
+): Promise<CompoundV2PositionData> => _getCompoundV2AccountData(getViemProvider(provider, network), network, address, assetsData, blockNumber);
 
 export const getCompoundV2FullPositionData = async (provider: EthereumProvider, network: NetworkNumber, address: EthAddress): Promise<CompoundV2PositionData> => {
   const marketData = await getCompoundV2MarketsData(provider, network);

package/src/compoundV3/index.ts

@@ -23,17 +23,18 @@ import { CompoundMarkets } from '../markets/compound';
 import {
   getEthPrice, getCompPrice, getUSDCPrice, getWstETHPrice,
 } from '../services/priceService';
-import { getViemProvider, setViemBlockNumber } from '../services/viem';
+import { getBlockTimestamp, getViemProvider, setViemBlockNumber } from '../services/viem';
 import { attachCompoundV3MerklIncentives, getCompoundV3MerklOpportunities } from './merkl';
 
 export { getCompoundV3MerklOpportunities, attachCompoundV3MerklIncentives } from './merkl';
 
 const getSupportedAssetsAddressesForMarket = (selectedMarket: CompoundMarketData, network: NetworkNumber) => selectedMarket.collAssets.map(asset => getAssetInfo(ethToWeth(asset), network)).map(addr => addr.address.toLowerCase());
 
-const getBaseAssetPriceFunction = (asset: string) => {
+// Every branch takes (client, block) so the caller can pin the price read to the market block.
+const getBaseAssetPriceFunction = (asset: string): ((client: Client, block: Blockish) => Promise<string>) => {
   switch (asset) {
     case 'wstETH':
-      return getWstETHPrice;
+      return (client, block) => getWstETHPrice(client, NetworkNumber.Eth, block);
     case 'ETH':
       return getEthPrice;
     default:
@@ -41,16 +42,19 @@ const getBaseAssetPriceFunction = (asset: string) => {
   }
 };
 
-export const _getCompoundV3MarketsData = async (provider: Client, network: NetworkNumber, selectedMarket: CompoundMarketData, defaultProvider: Client): Promise<CompoundV3MarketsData> => {
+/** `blockTimestamp` (unix seconds) is the historical block's timestamp when already known; otherwise it is read from the block. */
+export const _getCompoundV3MarketsData = async (provider: Client, network: NetworkNumber, selectedMarket: CompoundMarketData, defaultProvider: Client, blockNumber: Blockish = 'latest', blockTimestamp?: number): Promise<CompoundV3MarketsData> => {
   const contract = CompV3ViewContractViem(provider, network);
 
   const [baseAssetPrice, compPrice, baseTokenInfo, collInfos, govInfo, merklOpportunities] = await Promise.all([
-    getBaseAssetPriceFunction(selectedMarket.baseAsset)(defaultProvider),
-    getCompPrice(defaultProvider),
-    contract.read.getFullBaseTokenInfo([selectedMarket.baseMarketAddress]),
-    contract.read.getFullCollInfos([selectedMarket.baseMarketAddress]),
-    contract.read.getGovernanceInfoFull([selectedMarket.baseMarketAddress]),
-    getCompoundV3MerklOpportunities(),
+    getBaseAssetPriceFunction(selectedMarket.baseAsset)(defaultProvider, blockNumber),
+    getCompPrice(defaultProvider, blockNumber),
+    contract.read.getFullBaseTokenInfo([selectedMarket.baseMarketAddress], setViemBlockNumber(blockNumber)),
+    contract.read.getFullCollInfos([selectedMarket.baseMarketAddress], setViemBlockNumber(blockNumber)),
+    contract.read.getGovernanceInfoFull([selectedMarket.baseMarketAddress], setViemBlockNumber(blockNumber)),
+    // Merkl rewards are keyed by time: a historical block resolves to its timestamp first (one RPC
+    // call unless given, none for 'latest') so the rewards in force at that moment are attached.
+    getBlockTimestamp(provider, blockNumber, blockTimestamp).then((asOfTimestamp) => getCompoundV3MerklOpportunities(asOfTimestamp, network)),
   ]);
 
   const { isSupplyPaused, isWithdrawPaused } = govInfo;
@@ -95,7 +99,7 @@ export const _getCompoundV3MarketsData = async (provider: Client, network: Netwo
   };
 };
 
-export const getCompoundV3MarketsData = async (provider: EthereumProvider, network: NetworkNumber, selectedMarket: CompoundMarketData, defaultProvider: EthereumProvider): Promise<CompoundV3MarketsData> => _getCompoundV3MarketsData(getViemProvider(provider, network), network, selectedMarket, getViemProvider(defaultProvider, network));
+export const getCompoundV3MarketsData = async (provider: EthereumProvider, network: NetworkNumber, selectedMarket: CompoundMarketData, defaultProvider: EthereumProvider, blockNumber: Blockish = 'latest', blockTimestamp?: number): Promise<CompoundV3MarketsData> => _getCompoundV3MarketsData(getViemProvider(provider, network), network, selectedMarket, getViemProvider(defaultProvider, network), blockNumber, blockTimestamp);
 
 export const EMPTY_COMPOUND_V3_DATA = {
   usedAssets: {},
@@ -183,6 +187,7 @@ export const _getCompoundV3AccountData = async (
     selectedMarket: CompoundMarketData,
     assetsData: CompoundV3AssetsData,
   }),
+  blockNumber: Blockish = 'latest',
 ): Promise<CompoundV3PositionData> => {
   if (!address) throw new Error('No address provided');
   const {
@@ -198,8 +203,8 @@ export const _getCompoundV3AccountData = async (
 
 
   const [loanData, isAllowed] = await Promise.all([
-    contract.read.getLoanData([selectedMarket.baseMarketAddress, address]),
-    contract.read.isAllowed([selectedMarket.baseMarketAddress, address, (proxyAddress || ZERO_ADDRESS)]),
+    contract.read.getLoanData([selectedMarket.baseMarketAddress, address], setViemBlockNumber(blockNumber)),
+    contract.read.isAllowed([selectedMarket.baseMarketAddress, address, (proxyAddress || ZERO_ADDRESS)], setViemBlockNumber(blockNumber)),
   ]);
 
   const usedAssets: CompoundV3UsedAssets = {};
@@ -274,7 +279,8 @@ export const getCompoundV3AccountData = async (
     selectedMarket: CompoundMarketData,
     assetsData: CompoundV3AssetsData,
   }),
-): Promise<CompoundV3PositionData> => _getCompoundV3AccountData(getViemProvider(provider, network), network, address, proxyAddress, extractedState);
+  blockNumber: Blockish = 'latest',
+): Promise<CompoundV3PositionData> => _getCompoundV3AccountData(getViemProvider(provider, network), network, address, proxyAddress, extractedState, blockNumber);
 
 export const getCompoundV3FullPositionData = async (provider: EthereumProvider, network: NetworkNumber, address: EthAddress, proxyAddress: EthAddress, selectedMarket: CompoundMarketData, defaultProvider: EthereumProvider): Promise<CompoundV3PositionData> => {
   const marketData = await getCompoundV3MarketsData(provider, network, selectedMarket, defaultProvider);