@defisaver/positions-sdk 2.1.161-portfolio-api-2-dev → 2.1.161-portfolio-api-3-dev

package/src/aaveV3/index.ts

@@ -6,6 +6,7 @@ import {
   AaveIncentivesControllerViem,
   AaveV3ViewContractViem,
   createViemContractFromConfigFunc,
+  getConfigContractAbi,
   StkAAVEViem,
 } from '../contracts';
 import { aaveAnyGetAggregatedPositionData, aaveV3IsInIsolationMode, aaveV3IsInSiloedMode } from '../helpers/aaveHelpers';
@@ -62,7 +63,10 @@ export const aaveV3EmodeCategoriesMapping = (extractedState: any, usedAssets: Aa
       ...extractedState, usedAssets, eModeCategory: e.id,
     });
     const willStayOverCollateralized = new Dec(afterEnteringCategory.ratio === 'NaN' ? '0' : afterEnteringCategory.ratio).eq(0) || new Dec(afterEnteringCategory.ratio).gt(afterEnteringCategory.liqPercent);
-    const enteringTerms = [borrowingOnlyFromCategory, willStayOverCollateralized];
+    const collateralOnlyFromCategory = e.id === 0 || !e.isolated
+      ? true
+      : !usedAssetsValues.filter(u => u.isSupplied && u.collateral && !e.collateralAssets.includes(u.symbol)).length;
+    const enteringTerms = [borrowingOnlyFromCategory, willStayOverCollateralized, collateralOnlyFromCategory];
     categoriesMapping[e.id] = {
       enteringTerms,
       canEnterCategory: !enteringTerms.includes(false),
@@ -119,6 +123,7 @@ export async function _getAaveV3MarketData(provider: Client, network: NetworkNum
         borrowableBitmap: eModesInfo[i].borrowableBitmap.toString(),
         collateralBitmap: eModesInfo[i].collateralBitmap.toString(),
         ltvzeroBitmap: eModesInfo[i].ltvzeroBitmap.toString(),
+        isolated: eModesInfo[i].isolated ?? false,
         borrowAssets: [],
         collateralAssets: [],
         ltvZeroAssets: [],
@@ -346,6 +351,7 @@ export async function _getAaveV3MarketData(provider: Client, network: NetworkNum
     collateralAssets: assetsData.map((a) => a.symbol),
     borrowAssets: assetsData.map((a) => a.symbol),
     ltvZeroAssets: [],
+    isolated: false,
   };
 
   return { assetsData: payload, eModeCategoriesData };
@@ -431,6 +437,290 @@ export const _getAaveV3AccountBalances = async (provider: Client, network: Netwo
 
 export const getAaveV3AccountBalances = async (provider: EthereumProvider, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress): Promise<PositionBalances> => _getAaveV3AccountBalances(getViemProvider(provider, network), network, block, addressMapping, address);
 
+/**
+ * Historical net-balance helpers that bypass the AaveV3View contract.
+ *
+ * The View contract (and therefore `getAaveV3AccountData` / `getAaveV3AccountBalances`) can only be
+ * queried from its deployment block onwards, so it cannot read balances for positions older than that.
+ * The aTokens/debt tokens, the ProtocolDataProvider and the Aave price oracle all exist from Aave v3
+ * launch, so reading `balanceOf` on those tokens + the oracle price directly reaches much further back
+ * and costs ~1 multicall per point. Used to build a position balance-history chart.
+ */
+
+// matches morphoVaults' batchSize; stays under the 500k portfolio discovery allows on simulation fork RPCs
+const HISTORICAL_MULTICALL_BATCH_SIZE = 250_000;
+
+// Minimal Aave price oracle ABI (getAssetPrice returns the asset price in the market base currency).
+const AAVE_ORACLE_ABI = [
+  {
+    inputs: [{ internalType: 'address', name: 'asset', type: 'address' }],
+    name: 'getAssetPrice',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const;
+
+export interface AaveV3ReserveTokenAddresses {
+  [symbol: string]: {
+    symbol: string,
+    underlyingAddress: EthAddress,
+    aTokenAddress: EthAddress,
+    stableDebtTokenAddress: EthAddress,
+    variableDebtTokenAddress: EthAddress,
+  };
+}
+
+export interface AaveV3HistoricalBalance {
+  block: number,
+  suppliedUsd: string,
+  borrowedUsd: string,
+  netUsd: string,
+}
+
+/**
+ * Fetches the aToken / stable-debt / variable-debt token addresses for every asset in the market.
+ * These are effectively immutable per reserve, so fetch once and reuse across all history points.
+ */
+export const _getAaveV3ReserveTokenAddresses = async (provider: Client, network: NetworkNumber, market: AaveMarketInfo): Promise<AaveV3ReserveTokenAddresses> => {
+  const symbols = market.assets;
+  const underlyingAddresses = symbols.map((a: string) => getAssetInfo(getWrappedNativeAssetFromUnwrapped(a), network).address as EthAddress);
+  // @ts-ignore market.protocolData is a valid config key at runtime
+  const dataProviderAbi = getConfigContractAbi(market.protocolData, network);
+
+  const contracts = underlyingAddresses.map((underlying) => ({
+    address: market.protocolDataAddress as EthAddress,
+    abi: dataProviderAbi,
+    functionName: 'getReserveTokensAddresses',
+    args: [underlying],
+  }));
+
+  // @ts-ignore
+  const results = await provider.multicall({ contracts, allowFailure: true, batchSize: HISTORICAL_MULTICALL_BATCH_SIZE });
+
+  const mapping: AaveV3ReserveTokenAddresses = {};
+  results.forEach((res: any, i: number) => {
+    if (res.status !== 'success' || !res.result) return;
+    // outputs order: [aTokenAddress, stableDebtTokenAddress, variableDebtTokenAddress]
+    const [aTokenAddress, stableDebtTokenAddress, variableDebtTokenAddress] = res.result as [EthAddress, EthAddress, EthAddress];
+    mapping[symbols[i]] = {
+      symbol: symbols[i],
+      underlyingAddress: underlyingAddresses[i],
+      aTokenAddress,
+      stableDebtTokenAddress,
+      variableDebtTokenAddress,
+    };
+  });
+
+  return mapping;
+};
+
+export const getAaveV3ReserveTokenAddresses = async (provider: EthereumProvider, network: NetworkNumber, market: AaveMarketInfo): Promise<AaveV3ReserveTokenAddresses> => _getAaveV3ReserveTokenAddresses(getViemProvider(provider, network, { batch: { multicall: true } }), network, market);
+
+/**
+ * Resolves the price oracle the market's addresses provider points at (at `block`, or latest).
+ * Aave can rotate the oracle over time, so a caller hoisting one address across many historical
+ * points must resolve it at both ends of its block range and only reuse it when the two agree —
+ * otherwise leave `oracleAddress` unset on _getAaveV3HistoricalBalance and it resolves per block.
+ */
+export const _getAaveV3OracleAddress = async (provider: Client, network: NetworkNumber, market: AaveMarketInfo, block: Blockish = 'latest'): Promise<EthAddress> => {
+  // @ts-ignore market.provider is a valid config key at runtime
+  const providerAbi = getConfigContractAbi(market.provider, network);
+  // @ts-ignore readContract exists on the public client returned by getViemProvider
+  const oracleAddress = await provider.readContract({
+    address: market.providerAddress as EthAddress,
+    abi: providerAbi as any,
+    functionName: 'getPriceOracle',
+    ...setViemBlockNumber(block),
+  });
+  if (!oracleAddress) throw new Error(`AaveV3 oracle unavailable at block ${block}`);
+  return oracleAddress as EthAddress;
+};
+
+export const getAaveV3OracleAddress = async (provider: EthereumProvider, network: NetworkNumber, market: AaveMarketInfo, block: Blockish = 'latest'): Promise<EthAddress> => _getAaveV3OracleAddress(getViemProvider(provider, network, { batch: { multicall: true } }), network, market, block);
+
+type AaveV3ReserveTokenEntry = AaveV3ReserveTokenAddresses[string];
+type AaveV3ActiveHistoricalAsset = AaveV3ReserveTokenEntry & { supplied: string, debt: string };
+// raw getAssetPrice multicall result per asset symbol
+type AaveV3PriceResultsBySymbol = Record<string, any>;
+
+// supply = aToken.balanceOf, debt = variableDebtToken.balanceOf + stableDebtToken.balanceOf — three reads per reserve
+const getHistoricalBalanceContracts = (entries: AaveV3ReserveTokenEntry[], address: EthAddress) => {
+  const erc20Abi = getConfigContractAbi('Erc20');
+  return entries.flatMap((e) => ([
+    {
+      address: e.aTokenAddress, abi: erc20Abi, functionName: 'balanceOf', args: [address],
+    },
+    {
+      address: e.variableDebtTokenAddress, abi: erc20Abi, functionName: 'balanceOf', args: [address],
+    },
+    {
+      address: e.stableDebtTokenAddress, abi: erc20Abi, functionName: 'balanceOf', args: [address],
+    },
+  ]));
+};
+
+const getAssetPriceContract = (oracle: EthAddress, underlyingAddress: EthAddress) => ({
+  address: oracle,
+  abi: AAVE_ORACLE_ABI,
+  functionName: 'getAssetPrice',
+  args: [underlyingAddress],
+});
+
+/**
+ * Pairs each reserve with its three balance reads and keeps the assets the wallet actually held.
+ * Throws when every read failed — a totally failed fetch must not masquerade as a real $0 balance,
+ * so the caller can distinguish "fetch failed" (gap) from "position was empty" (genuine 0).
+ */
+const toActiveHistoricalAssets = (entries: AaveV3ReserveTokenEntry[], balanceResults: any[], block: number): AaveV3ActiveHistoricalAsset[] => {
+  const anyBalanceRead = balanceResults.some((r) => r?.status === 'success');
+  if (!anyBalanceRead) throw new Error(`AaveV3 historical balance: all balance reads failed at block ${block}`);
+
+  return entries.map((e, i) => {
+    const supplyRes = balanceResults[i * 3];
+    const varDebtRes = balanceResults[(i * 3) + 1];
+    const stableDebtRes = balanceResults[(i * 3) + 2];
+    const supplied = supplyRes?.status === 'success' ? (supplyRes.result as bigint).toString() : '0';
+    const varDebt = varDebtRes?.status === 'success' ? (varDebtRes.result as bigint).toString() : '0';
+    const stableDebt = stableDebtRes?.status === 'success' ? (stableDebtRes.result as bigint).toString() : '0';
+    const debt = new Dec(varDebt).add(stableDebt).toString();
+    return { ...e, supplied, debt };
+  }).filter((a) => a.supplied !== '0' || a.debt !== '0');
+};
+
+/**
+ * Sums the active assets into the point's USD totals. Throws when every price read failed — the
+ * oracle couldn't serve this block (pruned state, or a hoisted oracle that wasn't deployed yet back
+ * then), and totalling it up anyway would return a fake near-$0 balance. A single asset's price
+ * failure still just skips that asset, matching the live data path.
+ */
+const sumHistoricalUsd = (activeAssets: AaveV3ActiveHistoricalAsset[], priceResBySymbol: AaveV3PriceResultsBySymbol, block: number): AaveV3HistoricalBalance => {
+  const anyPriceRead = activeAssets.some((a) => priceResBySymbol[a.symbol]?.status === 'success');
+  if (!anyPriceRead) throw new Error(`AaveV3 historical balance: all price reads failed at block ${block}`);
+
+  let suppliedUsd = new Dec(0);
+  let borrowedUsd = new Dec(0);
+  activeAssets.forEach((a) => {
+    const priceRes = priceResBySymbol[a.symbol];
+    if (priceRes?.status !== 'success') return;
+    const priceUsd = new Dec((priceRes.result as bigint).toString()).div(1e8); // Aave v3 base currency is USD with 8 decimals
+    if (a.supplied !== '0') suppliedUsd = suppliedUsd.add(new Dec(assetAmountInEth(a.supplied, a.symbol)).mul(priceUsd));
+    if (a.debt !== '0') borrowedUsd = borrowedUsd.add(new Dec(assetAmountInEth(a.debt, a.symbol)).mul(priceUsd));
+  });
+
+  return {
+    block,
+    suppliedUsd: suppliedUsd.toString(),
+    borrowedUsd: borrowedUsd.toString(),
+    netUsd: suppliedUsd.minus(borrowedUsd).toString(),
+  };
+};
+
+/**
+ * Fast path, ONE multicall: balances plus a price read for every reserve through the caller-hoisted
+ * oracle. Prices are read for all reserves because which assets are active isn't known until the
+ * balances come back — extra reads inside an already-paid multicall are nearly free.
+ */
+const fetchHistoricalPointWithOracle = async (provider: Client, entries: AaveV3ReserveTokenEntry[], address: EthAddress, block: number, oracleAddress: EthAddress) => {
+  const balanceContracts = getHistoricalBalanceContracts(entries, address);
+  const priceContracts = entries.map((e) => getAssetPriceContract(oracleAddress, e.underlyingAddress));
+
+  // @ts-ignore
+  const results = await provider.multicall({
+    contracts: [...balanceContracts, ...priceContracts], allowFailure: true, blockNumber: BigInt(block), batchSize: HISTORICAL_MULTICALL_BATCH_SIZE,
+  });
+
+  const activeAssets = toActiveHistoricalAssets(entries, results.slice(0, balanceContracts.length), block);
+  const priceResBySymbol: AaveV3PriceResultsBySymbol = {};
+  results.slice(balanceContracts.length).forEach((res: any, i: number) => {
+    priceResBySymbol[entries[i].symbol] = res;
+  });
+  return { activeAssets, priceResBySymbol };
+};
+
+/**
+ * Fallback path, TWO multicalls: balances plus getPriceOracle (resolving the oracle that was active
+ * AT the block — Aave can rotate it over time), then prices for just the active assets. The oracle
+ * read has no fallback: if it fails (bad archive node, rate limit, ...) the failure must surface
+ * rather than silently returning $0 — the caller renders a gap instead of a misleading zero.
+ */
+const fetchHistoricalPointResolvingOracle = async (provider: Client, network: NetworkNumber, market: AaveMarketInfo, entries: AaveV3ReserveTokenEntry[], address: EthAddress, block: number) => {
+  const balanceContracts = getHistoricalBalanceContracts(entries, address);
+  // @ts-ignore market.provider is a valid config key at runtime
+  const providerAbi = getConfigContractAbi(market.provider, network);
+  const oracleContract = {
+    address: market.providerAddress as EthAddress,
+    abi: providerAbi,
+    functionName: 'getPriceOracle',
+  };
+  const blockNumber = BigInt(block);
+
+  // @ts-ignore
+  const results = await provider.multicall({
+    contracts: [...balanceContracts, oracleContract], allowFailure: true, blockNumber, batchSize: HISTORICAL_MULTICALL_BATCH_SIZE,
+  });
+  const oracleRes = results[balanceContracts.length];
+  if (oracleRes?.status !== 'success' || !oracleRes.result) throw new Error(`AaveV3 historical balance: oracle unavailable at block ${block}`);
+
+  const activeAssets = toActiveHistoricalAssets(entries, results.slice(0, balanceContracts.length), block);
+  if (!activeAssets.length) return { activeAssets, priceResBySymbol: {} };
+
+  const priceContracts = activeAssets.map((a) => getAssetPriceContract(oracleRes.result as EthAddress, a.underlyingAddress));
+  // @ts-ignore
+  const priceResults = await provider.multicall({
+    contracts: priceContracts, allowFailure: true, blockNumber, batchSize: HISTORICAL_MULTICALL_BATCH_SIZE,
+  });
+  const priceResBySymbol: AaveV3PriceResultsBySymbol = {};
+  priceResults.forEach((res: any, i: number) => {
+    priceResBySymbol[activeAssets[i].symbol] = res;
+  });
+  return { activeAssets, priceResBySymbol };
+};
+
+/**
+ * Computes a user's Aave v3 net USD balance (supplied collateral - borrowed debt) at a historical block,
+ * without touching the AaveV3View contract. Pass `reserveTokens` (from getAaveV3ReserveTokenAddresses)
+ * to avoid refetching token addresses for every point, and `oracleAddress` (from getAaveV3OracleAddress,
+ * verified identical at both ends of the sampled range) to collapse the point into a single multicall —
+ * with it the balances and all prices ride one request; without it the oracle is resolved at the block
+ * inside the balance multicall and the active assets are priced in a second one.
+ */
+export const _getAaveV3HistoricalBalance = async (
+  provider: Client,
+  network: NetworkNumber,
+  market: AaveMarketInfo,
+  address: EthAddress,
+  block: number,
+  reserveTokens?: AaveV3ReserveTokenAddresses,
+  oracleAddress?: EthAddress,
+): Promise<AaveV3HistoricalBalance> => {
+  const empty: AaveV3HistoricalBalance = {
+    block, suppliedUsd: '0', borrowedUsd: '0', netUsd: '0',
+  };
+  if (!address) return empty;
+
+  const tokens = reserveTokens || await _getAaveV3ReserveTokenAddresses(provider, network, market);
+  const entries = Object.values(tokens);
+  if (!entries.length) return empty;
+
+  const { activeAssets, priceResBySymbol } = oracleAddress
+    ? await fetchHistoricalPointWithOracle(provider, entries, address, block, oracleAddress)
+    : await fetchHistoricalPointResolvingOracle(provider, network, market, entries, address, block);
+
+  if (!activeAssets.length) return empty;
+  return sumHistoricalUsd(activeAssets, priceResBySymbol, block);
+};
+
+export const getAaveV3HistoricalBalance = async (
+  provider: EthereumProvider,
+  network: NetworkNumber,
+  market: AaveMarketInfo,
+  address: EthAddress,
+  block: number,
+  reserveTokens?: AaveV3ReserveTokenAddresses,
+  oracleAddress?: EthAddress,
+): Promise<AaveV3HistoricalBalance> => _getAaveV3HistoricalBalance(getViemProvider(provider, network, { batch: { multicall: true } }), network, market, address, block, reserveTokens, oracleAddress);
+
 export const _getAaveV3AccountData = async (provider: Client, network: NetworkNumber, address: EthAddress, extractedState: any, blockNumber: 'latest' | number = 'latest'): Promise<AaveV3PositionData> => {
   const {
     selectedMarket: market, assetsData, eModeCategoriesData,

package/src/aaveV4/lend.ts

@@ -7,26 +7,9 @@ import {
   EthereumProvider,
   NetworkNumber,
 } from '../types/common';
+import { AaveV4TokenizationSpokeDataParsed } from '../types/aaveV4';
 
-export interface AaveV4TokenizationSpokeData {
-  underlyingAsset: EthAddress;
-  assetId: string;
-  decimals: number;
-  spoke: EthAddress;
-  spokeActive: boolean;
-  spokeHalted: boolean;
-  spokeDepositCap: string;
-  spokeTotalAssets: string;
-  spokeTotalShares: string;
-  hub: EthAddress;
-  hubLiquidity: string;
-  hubDrawnRate: string;
-  convertToShares: string;
-  convertToAssets: string;
-  user: EthAddress;
-  userSuppliedAssets: string;
-  userSuppliedShares: string;
-}
+export type { AaveV4TokenizationSpokeData, AaveV4TokenizationSpokeDataParsed } from '../types/aaveV4';
 
 export const AAVE_V4_TOKENIZED_SPOKES: Record<string, EthAddress> = {
   EURC_CORE: '0x6D9e2Cdd61CaF69af99b275704B6e272C41c6718',
@@ -102,34 +85,6 @@ export const aaveV4GetTokenizedVaultAddress = (
   return AAVE_V4_TOKENIZED_SPOKES[key];
 };
 
-/** Parsed tokenization spoke data with human-readable supplied amounts for display */
-export interface AaveV4TokenizationSpokeDataParsed {
-  vaultAddress: EthAddress;
-  key: string | null;
-  symbol: string;
-  hubKey: string;
-  // ---- Spoke ----
-  spokeActive: boolean;
-  spokeHalted: boolean;
-  /** Deposit cap in asset units (wei string) */
-  spokeDepositCap: string;
-  /** Total assets currently in spoke in asset units (wei string) */
-  spokeTotalAssets: string;
-  // ---- Hub ----
-  /** Available hub liquidity in asset units (wei string) */
-  hubLiquidity: string;
-  /** The conversion rate from assets to shares expressed in asset units. */
-  convertToShares: string;
-  // ---- User ----
-  userSuppliedAssetsEth: string;
-  userSuppliedSharesEth: string;
-  userSuppliedAssets: string;
-  userSuppliedShares: string;
-  underlyingAsset: EthAddress;
-  spoke: EthAddress;
-  decimals: number;
-}
-
 const AAVE_V4_TOKENIZED_SPOKE_ADDRESS_TO_KEY: Record<string, string> = Object.entries(
   AAVE_V4_TOKENIZED_SPOKES,
 ).reduce((acc, [k, v]) => {
@@ -189,4 +144,3 @@ export async function getAaveV4TokenizationSpokesData(
   }).filter(item => item != null);
 }
 
-

package/src/curveUsd/index.ts

@@ -14,6 +14,13 @@ import { getCrvUsdAggregatedData } from '../helpers/curveUsdHelpers';
 import { CrvUsdMarkets } from '../markets';
 import { wethToEth } from '../services/utils';
 import { getViemProvider, setViemBlockNumber } from '../services/viem';
+import { getStakingApy, STAKING_ASSETS } from '../staking';
+
+/** Converts a per-second AMM rate (wei, 18 decimals) into a yearly compounded borrow APY in %. */
+const ammRateToBorrowApy = (rateWei: string) => {
+  const exponent = new Dec(assetAmountInEth(rateWei)).mul(365).mul(86400);
+  return new Dec(new Dec(2.718281828459).pow(exponent).minus(1)).mul(100).toString();
+};
 
 const getAndFormatBands = async (provider: Client, network: NetworkNumber, selectedMarket: CrvUSDMarketData, _minBand: string, _maxBand: string) => {
   const contract = CrvUSDViewContractViem(provider, network);
@@ -69,15 +76,8 @@ export const _getCurveUsdGlobalData = async (provider: Client, network: NetworkN
   const totalDebt = assetAmountInEth(data.totalDebt.toString(), debtAsset);
   const ammPrice = assetAmountInEth(data.ammPrice.toString(), debtAsset);
 
-  const rate = assetAmountInEth(data.ammRate.toString());
-  const futureRate = assetAmountInEth(data.monetaryPolicyRate.toString());
-
-  const exponentRate = new Dec(rate).mul(365).mul(86400);
-  const exponentFutureRate = new Dec(futureRate).mul(365).mul(86400);
-  const borrowRate = new Dec(new Dec(2.718281828459).pow(exponentRate).minus(1)).mul(100)
-    .toString();
-  const futureBorrowRate = new Dec(new Dec(2.718281828459).pow(exponentFutureRate).minus(1)).mul(100)
-    .toString();
+  const borrowRate = ammRateToBorrowApy(data.ammRate.toString());
+  const futureBorrowRate = ammRateToBorrowApy(data.monetaryPolicyRate.toString());
 
   const bandsData = await getAndFormatBands(provider, network, selectedMarket, data.minBand.toString(), data.maxBand.toString());
 
@@ -164,13 +164,22 @@ export const getCrvUsdAccountBalances = async (
   controllerAddress: EthAddress,
 ): Promise<PositionBalances> => _getCrvUsdAccountBalances(getViemProvider(provider, network), network, block, addressMapping, address, controllerAddress);
 
-export const _getCurveUsdUserData = async (provider: Client, network: NetworkNumber, address: EthAddress, selectedMarket: CrvUSDMarketData, activeBand: string): Promise<CrvUSDUserData> => {
+/**
+ * @param borrowRate market borrow APY in % (`CrvUSDGlobalMarketData.borrowRate`); when omitted it is read from the view contract
+ */
+export const _getCurveUsdUserData = async (provider: Client, network: NetworkNumber, address: EthAddress, selectedMarket: CrvUSDMarketData, activeBand: string, borrowRate?: string): Promise<CrvUSDUserData> => {
   const contract = CrvUSDViewContractViem(provider, network);
-
-  const data = await contract.read.userData([selectedMarket.controllerAddress, address]);
   const collAsset = selectedMarket.collAsset;
   const debtAsset = selectedMarket.baseAsset;
 
+  const [data, collStakingApy, marketBorrowRate] = await Promise.all([
+    contract.read.userData([selectedMarket.controllerAddress, address]),
+    STAKING_ASSETS.includes(collAsset) ? getStakingApy(collAsset) : Promise.resolve('0'),
+    borrowRate !== undefined
+      ? Promise.resolve(borrowRate)
+      : contract.read.globalData([selectedMarket.controllerAddress]).then((globalData) => ammRateToBorrowApy(globalData.ammRate.toString())),
+  ]);
+
   const health = assetAmountInEth(data.health.toString());
   const healthPercent = new Dec(health).mul(100).toString();
   const collPrice = assetAmountInEth(data.collateralPrice.toString(), debtAsset);
@@ -202,7 +211,7 @@ export const _getCurveUsdUserData = async (provider: Client, network: NetworkNum
       isBorrowed: new Dec(debtBorrowed).gt('0'),
       symbol: 'crvUSD',
       price: '1',
-      interestRate: '0',
+      interestRate: marketBorrowRate,
     },
   } : {};
 
@@ -232,8 +241,15 @@ export const _getCurveUsdUserData = async (provider: Client, network: NetworkNum
     numOfBands: data.N.toString(),
     usedAssets,
     status,
+    borrowRate: marketBorrowRate,
     ...getCrvUsdAggregatedData({
-      loanExists: data.loanExists, usedAssets, network: NetworkNumber.Eth, selectedMarket, numOfBands: data.N.toString(),
+      loanExists: data.loanExists,
+      usedAssets,
+      network: NetworkNumber.Eth,
+      selectedMarket,
+      numOfBands: data.N.toString(),
+      borrowRate: marketBorrowRate,
+      collStakingApy,
     }),
     userBands,
   };
@@ -245,10 +261,11 @@ export const getCurveUsdUserData = async (
   address: EthAddress,
   selectedMarket: CrvUSDMarketData,
   activeBand: string,
-): Promise<CrvUSDUserData> => _getCurveUsdUserData(getViemProvider(provider, network), network, address, selectedMarket, activeBand);
+  borrowRate?: string,
+): Promise<CrvUSDUserData> => _getCurveUsdUserData(getViemProvider(provider, network), network, address, selectedMarket, activeBand, borrowRate);
 
 export const getCurveUsdFullPositionData = async (provider: EthereumProvider, network: NetworkNumber, address: EthAddress, selectedMarket: CrvUSDMarketData): Promise<CrvUSDUserData> => {
   const marketData = await getCurveUsdGlobalData(provider, network, selectedMarket);
-  const positionData = await getCurveUsdUserData(provider, network, address, selectedMarket, marketData.activeBand);
+  const positionData = await getCurveUsdUserData(provider, network, address, selectedMarket, marketData.activeBand, marketData.borrowRate);
   return positionData;
 };

package/src/fluid/index.ts

@@ -1831,3 +1831,43 @@ export const _getUserPositionsPortfolio = async (provider: PublicClient, network
     userData: userData[i],
   })).filter(md => md.marketData !== undefined);
 };
+
+
+export const _getAllFluidMarketDataPortfolio = async (provider: PublicClient, network: NetworkNumber): Promise<Record<string, FluidMarketData>> => {
+  const versions = getFluidVersionsDataForNetwork(network);
+  if (versions.length === 0) return {};
+
+  const view = FluidViewContractViem(provider, network);
+  const vaultsData = await Promise.all(versions.map((version) => view.read.getVaultData([version.marketAddress])));
+
+  const tokens = Array.from(new Set(vaultsData.map((vaultData) => {
+    const vaultTokens = [getAssetInfoByAddress(vaultData.supplyToken0, network).symbol, getAssetInfoByAddress(vaultData.borrowToken0, network).symbol];
+    if (vaultData.supplyToken1 && !compareAddresses(ZERO_ADDRESS, vaultData.supplyToken1)) vaultTokens.push(getAssetInfoByAddress(vaultData.supplyToken1, network).symbol);
+    if (vaultData.borrowToken1 && !compareAddresses(ZERO_ADDRESS, vaultData.borrowToken1)) vaultTokens.push(getAssetInfoByAddress(vaultData.borrowToken1, network).symbol);
+    return vaultTokens;
+  }).flat()));
+
+  // ETH and WBTC needed for other tokens prices
+  if (!tokens.includes('ETH')) tokens.push('ETH');
+  if (!tokens.includes('WBTC')) tokens.push('WBTC');
+
+  const [tokenPrices, merklCampaigns] = await Promise.all([
+    getTokensPricesForPortfolio(tokens, provider, network),
+    getFluidMerklCampaigns(network),
+  ]);
+
+  const parsedMarketsData = await Promise.all(vaultsData.map(async (vaultData) => parseMarketData(provider, vaultData, network, tokenPrices)));
+
+  const marketsData: Record<string, FluidMarketData> = {};
+  parsedMarketsData.forEach((marketData, i) => {
+    if (!marketData) return;
+    marketsData[versions[i].value] = attachFluidMerklIncentives(marketData, merklCampaigns);
+  });
+
+  return marketsData;
+};
+
+export const getAllFluidMarketDataPortfolio = async (
+  provider: EthereumProvider,
+  network: NetworkNumber,
+): Promise<Record<string, FluidMarketData>> => _getAllFluidMarketDataPortfolio(getViemProvider(provider, network, { batch: { multicall: true } }), network);

package/src/helpers/aaveHelpers/index.ts

@@ -2,7 +2,7 @@ import Dec from 'decimal.js';
 import { assetAmountInWei, getAssetInfo, getAssetInfoByAddress } from '@defisaver/tokens';
 import { Client } from 'viem';
 import {
-  AaveAssetData, AaveHelperCommon, AaveMarketInfo, AaveV3AggregatedPositionData, AaveV3AssetsData, AaveV3UsedAsset, AaveV3UsedAssets, AaveVersions,
+  AaveAssetData, AaveHelperCommon, AaveMarketInfo, AaveV3AggregatedPositionData, AaveV3AssetsData, AaveV3UsedAsset, AaveV3UsedAssets, AaveVersions, EModeCategoriesData,
 } from '../../types';
 import { getNativeAssetFromWrapped, getWrappedNativeAssetFromUnwrapped } from '../../services/utils';
 import {
@@ -24,6 +24,13 @@ export const isAaveV3 = ({ selectedMarket }: { selectedMarket: Partial<AaveMarke
 export const aaveV3IsInIsolationMode = ({ usedAssets, assetsData }: { usedAssets: AaveV3UsedAssets, assetsData: AaveV3AssetsData }) => Object.values(usedAssets).some(({ symbol, collateral }) => collateral && assetsData[symbol].isIsolated);
 export const aaveV3IsInSiloedMode = ({ usedAssets, assetsData }: { usedAssets: AaveV3UsedAssets, assetsData: AaveV3AssetsData }) => Object.values(usedAssets).some(({ symbol, debt }) => debt && assetsData[symbol].isSiloed);
 
+export const aaveV3IsEmodeIsolated = ({ eModeCategory, eModeCategoriesData }: { eModeCategory: number, eModeCategoriesData?: EModeCategoriesData }) => eModeCategory !== 0 && !!eModeCategoriesData?.[eModeCategory]?.isolated;
+
+export const aaveV3CanBeCollateralInEmode = ({ eModeCategory, eModeCategoriesData }: { eModeCategory: number, eModeCategoriesData?: EModeCategoriesData }, _asset: string) => {
+  if (!aaveV3IsEmodeIsolated({ eModeCategory, eModeCategoriesData })) return true;
+  return eModeCategoriesData![eModeCategory].collateralAssets.includes(getNativeAssetFromWrapped(_asset));
+};
+
 export const aaveAnyGetCollSuppliedAssets = ({ usedAssets }: { usedAssets: AaveV3UsedAssets }) => Object.values(usedAssets)
   .filter(({ isSupplied, collateral }: { isSupplied: boolean, collateral: boolean }) => isSupplied && collateral);
 
@@ -37,14 +44,18 @@ export const aaveAnyGetSuppliableAssets = ({
   const collAccountAssets = aaveAnyGetCollSuppliedAssets(data);
   const marketAssets = Object.values(assetsData) as AaveAssetData[];
 
-  if (collAccountAssets.length === 0 || !isAaveV3(data)) return marketAssets.filter(({ canBeSupplied }) => canBeSupplied).map(({ symbol }) => ({ symbol, canBeCollateral: true }));
+  if (!isAaveV3(data)) return marketAssets.filter(({ canBeSupplied }) => canBeSupplied).map(({ symbol }) => ({ symbol, canBeCollateral: true }));
+
+  const canBeCollateralInEmode = (symbol: string) => aaveV3CanBeCollateralInEmode(data, symbol);
+
+  if (collAccountAssets.length === 0) return marketAssets.filter(({ canBeSupplied }) => canBeSupplied).map(({ symbol }) => ({ symbol, canBeCollateral: canBeCollateralInEmode(symbol) }));
 
   if (aaveV3IsInIsolationMode(data)) {
     const collAsset = collAccountAssets[0].symbol;
-    return marketAssets.filter(d => d.canBeSupplied).map(({ symbol }) => ({ symbol, canBeCollateral: symbol === collAsset }));
+    return marketAssets.filter(d => d.canBeSupplied).map(({ symbol }) => ({ symbol, canBeCollateral: symbol === collAsset && canBeCollateralInEmode(symbol) }));
   }
 
-  return marketAssets.filter(d => d.canBeSupplied).map(({ symbol, isIsolated }) => ({ symbol, canBeCollateral: !isIsolated }));
+  return marketAssets.filter(d => d.canBeSupplied).map(({ symbol, isIsolated }) => ({ symbol, canBeCollateral: !isIsolated && canBeCollateralInEmode(symbol) }));
 };
 
 export const aaveAnyGetSuppliableAsCollAssets = ({
@@ -62,8 +73,8 @@ export const aaveAnyGetEmodeMutableProps = (
   const asset = getNativeAssetFromWrapped(_asset);
 
   const assetData = assetsData[asset];
-  const eModeCategoryData: { collateralAssets: string[], collateralFactor: string, liquidationRatio: string, ltvZeroAssets: string[] } = eModeCategoriesData?.[eModeCategory] || {
-    collateralAssets: [], ltvZeroAssets: [], collateralFactor: '0', liquidationRatio: '0',
+  const eModeCategoryData: { collateralAssets: string[], collateralFactor: string, liquidationRatio: string, ltvZeroAssets: string[], isolated?: boolean } = eModeCategoriesData?.[eModeCategory] || {
+    collateralAssets: [], ltvZeroAssets: [], collateralFactor: '0', liquidationRatio: '0', isolated: false,
   };
 
   if (
@@ -72,6 +83,9 @@ export const aaveAnyGetEmodeMutableProps = (
     || new Dec(eModeCategoryData.collateralFactor || 0).eq(0)
   ) {
     const { liquidationRatio, collateralFactor } = assetData;
+    if (eModeCategory !== 0 && eModeCategoryData.isolated && !eModeCategoryData.collateralAssets.includes(asset)) {
+      return ({ liquidationRatio, collateralFactor: '0' });
+    }
     return ({ liquidationRatio, collateralFactor });
   }
   if (eModeCategoryData.ltvZeroAssets.includes(asset)) return ({ liquidationRatio: '0', collateralFactor: '0' });
@@ -118,7 +132,10 @@ export const aaveAnyGetUserReserveLtvAndLltv = (
     || !eModeCategoryData.collateralAssets.includes(asset)
     || new Dec(eModeCategoryData.collateralFactor || 0).eq(0)
   ) {
-    return { ltv: assetData.collateralFactor, lltv: assetData.liquidationRatio };
+    const ltv = eModeCategory !== 0 && eModeCategoryData?.isolated && !eModeCategoryData.collateralAssets.includes(asset)
+      ? '0'
+      : assetData.collateralFactor;
+    return { ltv, lltv: assetData.liquidationRatio };
   }
 
   const ltv = eModeCategoryData.ltvZeroAssets.includes(asset) ? '0' : eModeCategoryData.collateralFactor;
@@ -169,6 +186,9 @@ export const aaveAnyGetAggregatedPositionData = ({
     },
   );
   payload.safetyRatioWithLtvZeroFallback = +payload.suppliedUsd ? new Dec(payload.borrowLimitWithLtvZeroFallbackUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
+  // Normalised safety ratio (100 = liquidation on every protocol): the automation ratio above, falling back
+  // to the regular ratio when the fallback carries its '0' placeholder.
+  payload.safetyRatio = +payload.safetyRatioWithLtvZeroFallback ? payload.safetyRatioWithLtvZeroFallback : payload.ratio;
   payload.liqRatio = new Dec(payload.borrowLimitUsd).div(payload.liquidationLimitUsd).toString();
   payload.liqPercent = new Dec(payload.borrowLimitUsd).div(payload.liquidationLimitUsd).mul(100).toString();
   const { leveragedType, leveragedAsset } = isLeveragedPos(usedAssets);

package/src/helpers/aaveV4Helpers/index.ts

@@ -270,6 +270,7 @@ export const aaveV4GetAggregatedPositionData = ({
   payload.ratio = +payload.suppliedUsd ? new Dec(payload.borrowLimitUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
   payload.minRatio = '100';
   payload.collRatio = +payload.suppliedUsd ? new Dec(payload.suppliedCollateralUsd).div(payload.borrowedUsd).mul(100).toString() : '0';
+  payload.safetyRatio = payload.ratio;
   payload.liqRatio = new Dec(payload.borrowLimitUsd).div(payload.liquidationLimitUsd).toString();
   payload.liqPercent = new Dec(payload.borrowLimitUsd).div(payload.liquidationLimitUsd).mul(100).toString();
   const { leveragedType, leveragedAsset } = isLeveragedPosAaveV4(usedAssets);

package/src/helpers/compoundHelpers/index.ts

@@ -139,6 +139,7 @@ export const getCompoundV2AggregatedData = ({
   payload.collRatio = payload.borrowedUsd && payload.borrowedUsd !== '0'
     ? new Dec(payload.suppliedCollateralUsd).div(payload.borrowedUsd).mul(100).toString()
     : '0';
+  payload.safetyRatio = payload.ratio;
 
   // Calculate borrow limits per asset
   Object.values(usedAssets).forEach((item) => {
@@ -185,6 +186,7 @@ export const getCompoundV3AggregatedData = ({
   payload.incentiveUsd = incentiveUsd;
   payload.totalInterestUsd = totalInterestUsd;
   payload.minRatio = '100';
+  payload.safetyRatio = payload.ratio;
   payload.liqRatio = new Dec(payload.borrowLimitUsd).div(payload.liquidationLimitUsd).toString();
   payload.liqPercent = new Dec(payload.borrowLimitUsd).div(payload.liquidationLimitUsd).mul(100).toString();
   payload.minDebt = assetsData[selectedMarket.baseAsset].minDebt;