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

package/esm/aaveV2/index.js

@@ -167,6 +167,8 @@ export const _getAaveV2AccountData = (provider, network, address, assetsData, ma
     payload.collRatio = payload.borrowedUsd && payload.borrowedUsd !== '0'
         ? new Dec(payload.suppliedCollateralUsd).div(payload.borrowedUsd).mul(100).toString()
         : '0';
+    // Aave v2 has no LTV-0 fallback (AaveV3View only), so its safety ratio is the plain ratio.
+    payload.safetyRatio = payload.ratio;
     // Calculate borrow limits per asset
     Object.values(payload.usedAssets).forEach((item) => {
         if (item.isBorrowed) {

package/esm/aaveV3/index.d.ts

@@ -32,6 +32,45 @@ export declare const EMPTY_AAVE_DATA: {
 };
 export declare const _getAaveV3AccountBalances: (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;
 export declare const getAaveV3AccountBalances: (provider: EthereumProvider, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress) => Promise<PositionBalances>;
+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 declare const _getAaveV3ReserveTokenAddresses: (provider: Client, network: NetworkNumber, market: AaveMarketInfo) => Promise<AaveV3ReserveTokenAddresses>;
+export declare const getAaveV3ReserveTokenAddresses: (provider: EthereumProvider, network: NetworkNumber, market: AaveMarketInfo) => Promise<AaveV3ReserveTokenAddresses>;
+/**
+ * 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 declare const _getAaveV3OracleAddress: (provider: Client, network: NetworkNumber, market: AaveMarketInfo, block?: Blockish) => Promise<EthAddress>;
+export declare const getAaveV3OracleAddress: (provider: EthereumProvider, network: NetworkNumber, market: AaveMarketInfo, block?: Blockish) => Promise<EthAddress>;
+/**
+ * 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 declare const _getAaveV3HistoricalBalance: (provider: Client, network: NetworkNumber, market: AaveMarketInfo, address: EthAddress, block: number, reserveTokens?: AaveV3ReserveTokenAddresses, oracleAddress?: EthAddress) => Promise<AaveV3HistoricalBalance>;
+export declare const getAaveV3HistoricalBalance: (provider: EthereumProvider, network: NetworkNumber, market: AaveMarketInfo, address: EthAddress, block: number, reserveTokens?: AaveV3ReserveTokenAddresses, oracleAddress?: EthAddress) => Promise<AaveV3HistoricalBalance>;
 export declare const _getAaveV3AccountData: (provider: Client, network: NetworkNumber, address: EthAddress, extractedState: any, blockNumber?: "latest" | number) => Promise<AaveV3PositionData>;
 export declare const getAaveV3AccountData: (provider: EthereumProvider, network: NetworkNumber, address: EthAddress, extractedState: any, blockNumber?: "latest" | number) => Promise<AaveV3PositionData>;
 export declare const getAaveV3FullPositionData: (provider: EthereumProvider, network: NetworkNumber, address: EthAddress, market: AaveMarketInfo) => Promise<AaveV3PositionData>;

package/esm/aaveV3/index.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { assetAmountInEth, assetAmountInWei, getAssetInfo } from '@defisaver/tokens';
 import Dec from 'decimal.js';
-import { AaveIncentiveDataProviderV3ContractViem, AaveIncentivesControllerViem, AaveV3ViewContractViem, createViemContractFromConfigFunc, StkAAVEViem, } from '../contracts';
+import { AaveIncentiveDataProviderV3ContractViem, AaveIncentivesControllerViem, AaveV3ViewContractViem, createViemContractFromConfigFunc, getConfigContractAbi, StkAAVEViem, } from '../contracts';
 import { aaveAnyGetAggregatedPositionData, aaveV3IsInIsolationMode, aaveV3IsInSiloedMode } from '../helpers/aaveHelpers';
 import { AAVE_V3 } from '../markets/aave';
 import { aprToApy, calculateBorrowingAssetLimit } from '../moneymarket';
@@ -31,7 +31,10 @@ export const aaveV3EmodeCategoriesMapping = (extractedState, usedAssets) => {
             : !usedAssetsValues.filter(u => u.isBorrowed && !e.borrowAssets.includes(u.symbol)).length;
         const afterEnteringCategory = aaveAnyGetAggregatedPositionData(Object.assign(Object.assign({}, 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),
@@ -48,6 +51,7 @@ export const aaveV3EmodeCategoriesMapping = (extractedState, usedAssets) => {
 };
 export function _getAaveV3MarketData(provider_1, network_1, market_1) {
     return __awaiter(this, arguments, void 0, function* (provider, network, market, blockNumber = 'latest') {
+        var _a;
         const _addresses = market.assets.map(a => getAssetInfo(getWrappedNativeAssetFromUnwrapped(a), network).address);
         const loanInfoContract = AaveV3ViewContractViem(provider, network);
         const aaveIncentivesContract = AaveIncentiveDataProviderV3ContractViem(provider, network);
@@ -81,6 +85,7 @@ export function _getAaveV3MarketData(provider_1, network_1, market_1) {
                     borrowableBitmap: eModesInfo[i].borrowableBitmap.toString(),
                     collateralBitmap: eModesInfo[i].collateralBitmap.toString(),
                     ltvzeroBitmap: eModesInfo[i].ltvzeroBitmap.toString(),
+                    isolated: (_a = eModesInfo[i].isolated) !== null && _a !== void 0 ? _a : false,
                     borrowAssets: [],
                     collateralAssets: [],
                     ltvZeroAssets: [],
@@ -296,6 +301,7 @@ export function _getAaveV3MarketData(provider_1, network_1, market_1) {
             collateralAssets: assetsData.map((a) => a.symbol),
             borrowAssets: assetsData.map((a) => a.symbol),
             ltvZeroAssets: [],
+            isolated: false,
         };
         return { assetsData: payload, eModeCategoriesData };
     });
@@ -362,6 +368,229 @@ export const _getAaveV3AccountBalances = (provider, network, block, addressMappi
     return balances;
 });
 export const getAaveV3AccountBalances = (provider, network, block, addressMapping, address) => __awaiter(void 0, void 0, void 0, function* () { return _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 = 250000;
+// 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',
+    },
+];
+/**
+ * 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 = (provider, network, market) => __awaiter(void 0, void 0, void 0, function* () {
+    const symbols = market.assets;
+    const underlyingAddresses = symbols.map((a) => getAssetInfo(getWrappedNativeAssetFromUnwrapped(a), network).address);
+    // @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,
+        abi: dataProviderAbi,
+        functionName: 'getReserveTokensAddresses',
+        args: [underlying],
+    }));
+    // @ts-ignore
+    const results = yield provider.multicall({ contracts, allowFailure: true, batchSize: HISTORICAL_MULTICALL_BATCH_SIZE });
+    const mapping = {};
+    results.forEach((res, i) => {
+        if (res.status !== 'success' || !res.result)
+            return;
+        // outputs order: [aTokenAddress, stableDebtTokenAddress, variableDebtTokenAddress]
+        const [aTokenAddress, stableDebtTokenAddress, variableDebtTokenAddress] = res.result;
+        mapping[symbols[i]] = {
+            symbol: symbols[i],
+            underlyingAddress: underlyingAddresses[i],
+            aTokenAddress,
+            stableDebtTokenAddress,
+            variableDebtTokenAddress,
+        };
+    });
+    return mapping;
+});
+export const getAaveV3ReserveTokenAddresses = (provider, network, market) => __awaiter(void 0, void 0, void 0, function* () { return _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 = (provider_1, network_1, market_1, ...args_1) => __awaiter(void 0, [provider_1, network_1, market_1, ...args_1], void 0, function* (provider, network, market, block = 'latest') {
+    // @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 = yield provider.readContract(Object.assign({ address: market.providerAddress, abi: providerAbi, functionName: 'getPriceOracle' }, setViemBlockNumber(block)));
+    if (!oracleAddress)
+        throw new Error(`AaveV3 oracle unavailable at block ${block}`);
+    return oracleAddress;
+});
+export const getAaveV3OracleAddress = (provider_1, network_1, market_1, ...args_1) => __awaiter(void 0, [provider_1, network_1, market_1, ...args_1], void 0, function* (provider, network, market, block = 'latest') { return _getAaveV3OracleAddress(getViemProvider(provider, network, { batch: { multicall: true } }), network, market, block); });
+// supply = aToken.balanceOf, debt = variableDebtToken.balanceOf + stableDebtToken.balanceOf — three reads per reserve
+const getHistoricalBalanceContracts = (entries, address) => {
+    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, underlyingAddress) => ({
+    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, balanceResults, block) => {
+    const anyBalanceRead = balanceResults.some((r) => (r === null || r === void 0 ? void 0 : 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 === null || supplyRes === void 0 ? void 0 : supplyRes.status) === 'success' ? supplyRes.result.toString() : '0';
+        const varDebt = (varDebtRes === null || varDebtRes === void 0 ? void 0 : varDebtRes.status) === 'success' ? varDebtRes.result.toString() : '0';
+        const stableDebt = (stableDebtRes === null || stableDebtRes === void 0 ? void 0 : stableDebtRes.status) === 'success' ? stableDebtRes.result.toString() : '0';
+        const debt = new Dec(varDebt).add(stableDebt).toString();
+        return Object.assign(Object.assign({}, 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, priceResBySymbol, block) => {
+    const anyPriceRead = activeAssets.some((a) => { var _a; return ((_a = priceResBySymbol[a.symbol]) === null || _a === void 0 ? void 0 : _a.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 === null || priceRes === void 0 ? void 0 : priceRes.status) !== 'success')
+            return;
+        const priceUsd = new Dec(priceRes.result.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 = (provider, entries, address, block, oracleAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const balanceContracts = getHistoricalBalanceContracts(entries, address);
+    const priceContracts = entries.map((e) => getAssetPriceContract(oracleAddress, e.underlyingAddress));
+    // @ts-ignore
+    const results = yield 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 = {};
+    results.slice(balanceContracts.length).forEach((res, i) => {
+        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 = (provider, network, market, entries, address, block) => __awaiter(void 0, void 0, void 0, function* () {
+    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,
+        abi: providerAbi,
+        functionName: 'getPriceOracle',
+    };
+    const blockNumber = BigInt(block);
+    // @ts-ignore
+    const results = yield provider.multicall({
+        contracts: [...balanceContracts, oracleContract], allowFailure: true, blockNumber, batchSize: HISTORICAL_MULTICALL_BATCH_SIZE,
+    });
+    const oracleRes = results[balanceContracts.length];
+    if ((oracleRes === null || oracleRes === void 0 ? void 0 : 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, a.underlyingAddress));
+    // @ts-ignore
+    const priceResults = yield provider.multicall({
+        contracts: priceContracts, allowFailure: true, blockNumber, batchSize: HISTORICAL_MULTICALL_BATCH_SIZE,
+    });
+    const priceResBySymbol = {};
+    priceResults.forEach((res, i) => {
+        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 = (provider, network, market, address, block, reserveTokens, oracleAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const empty = {
+        block, suppliedUsd: '0', borrowedUsd: '0', netUsd: '0',
+    };
+    if (!address)
+        return empty;
+    const tokens = reserveTokens || (yield _getAaveV3ReserveTokenAddresses(provider, network, market));
+    const entries = Object.values(tokens);
+    if (!entries.length)
+        return empty;
+    const { activeAssets, priceResBySymbol } = oracleAddress
+        ? yield fetchHistoricalPointWithOracle(provider, entries, address, block, oracleAddress)
+        : yield fetchHistoricalPointResolvingOracle(provider, network, market, entries, address, block);
+    if (!activeAssets.length)
+        return empty;
+    return sumHistoricalUsd(activeAssets, priceResBySymbol, block);
+});
+export const getAaveV3HistoricalBalance = (provider, network, market, address, block, reserveTokens, oracleAddress) => __awaiter(void 0, void 0, void 0, function* () { return _getAaveV3HistoricalBalance(getViemProvider(provider, network, { batch: { multicall: true } }), network, market, address, block, reserveTokens, oracleAddress); });
 export const _getAaveV3AccountData = (provider_1, network_1, address_1, extractedState_1, ...args_1) => __awaiter(void 0, [provider_1, network_1, address_1, extractedState_1, ...args_1], void 0, function* (provider, network, address, extractedState, blockNumber = 'latest') {
     const { selectedMarket: market, assetsData, eModeCategoriesData, } = extractedState;
     let payload = Object.assign(Object.assign({}, EMPTY_AAVE_DATA), { lastUpdated: Date.now() });

package/esm/aaveV4/lend.d.ts

@@ -1,53 +1,12 @@
 import { EthAddress, EthereumProvider, NetworkNumber } from '../types/common';
-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;
-}
+import { AaveV4TokenizationSpokeDataParsed } from '../types/aaveV4';
+export type { AaveV4TokenizationSpokeData, AaveV4TokenizationSpokeDataParsed } from '../types/aaveV4';
 export declare const AAVE_V4_TOKENIZED_SPOKES: Record<string, EthAddress>;
 export declare const AAVE_V4_TOKENIZED_SPOKE_ADDRESSES: Partial<Record<NetworkNumber, EthAddress[]>>;
 export type AaveV4TokenizedHubKey = 'CORE' | 'PLUS' | 'PRIME' | 'PAXOS';
 export declare const aaveV4GetTokenizedHubKey: (hubNameOrKey?: string | null) => AaveV4TokenizedHubKey | null;
 export declare const aaveV4GetTokenizedVaultKey: (symbol: string, hubNameOrKey?: string | null) => string | null;
 export declare const aaveV4GetTokenizedVaultAddress: (network: NetworkNumber, symbol: string, hubNameOrKey?: string | null) => EthAddress | undefined;
-/** Parsed tokenization spoke data with human-readable supplied amounts for display */
-export interface AaveV4TokenizationSpokeDataParsed {
-    vaultAddress: EthAddress;
-    key: string | null;
-    symbol: string;
-    hubKey: string;
-    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;
-    /** Available hub liquidity in asset units (wei string) */
-    hubLiquidity: string;
-    /** The conversion rate from assets to shares expressed in asset units. */
-    convertToShares: string;
-    userSuppliedAssetsEth: string;
-    userSuppliedSharesEth: string;
-    userSuppliedAssets: string;
-    userSuppliedShares: string;
-    underlyingAsset: EthAddress;
-    spoke: EthAddress;
-    decimals: number;
-}
 /**
  * Fetches tokenization vault data for the given user via getTokenizationSpokesData.
  * Returns parsed data including userSuppliedAssets in human-readable form for each vault.

package/esm/curveUsd/index.d.ts

@@ -5,6 +5,9 @@ export declare const _getCurveUsdGlobalData: (provider: Client, network: Network
 export declare const getCurveUsdGlobalData: (provider: EthereumProvider, network: NetworkNumber, selectedMarket: CrvUSDMarketData) => Promise<CrvUSDGlobalMarketData>;
 export declare const _getCrvUsdAccountBalances: (provider: Client, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, controllerAddress: EthAddress) => Promise<PositionBalances>;
 export declare const getCrvUsdAccountBalances: (provider: EthereumProvider, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress, controllerAddress: EthAddress) => Promise<PositionBalances>;
-export declare const _getCurveUsdUserData: (provider: Client, network: NetworkNumber, address: EthAddress, selectedMarket: CrvUSDMarketData, activeBand: string) => Promise<CrvUSDUserData>;
-export declare const getCurveUsdUserData: (provider: EthereumProvider, 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 declare const _getCurveUsdUserData: (provider: Client, network: NetworkNumber, address: EthAddress, selectedMarket: CrvUSDMarketData, activeBand: string, borrowRate?: string) => Promise<CrvUSDUserData>;
+export declare const getCurveUsdUserData: (provider: EthereumProvider, network: NetworkNumber, address: EthAddress, selectedMarket: CrvUSDMarketData, activeBand: string, borrowRate?: string) => Promise<CrvUSDUserData>;
 export declare const getCurveUsdFullPositionData: (provider: EthereumProvider, network: NetworkNumber, address: EthAddress, selectedMarket: CrvUSDMarketData) => Promise<CrvUSDUserData>;

package/esm/curveUsd/index.js

@@ -16,6 +16,12 @@ 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) => {
+    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 = (provider, network, selectedMarket, _minBand, _maxBand) => __awaiter(void 0, void 0, void 0, function* () {
     const contract = CrvUSDViewContractViem(provider, network);
     const minBand = parseInt(_minBand, 10);
@@ -65,14 +71,8 @@ export const _getCurveUsdGlobalData = (provider, network, selectedMarket) => __a
     // all prices are in 18 decimals
     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 = yield getAndFormatBands(provider, network, selectedMarket, data.minBand.toString(), data.maxBand.toString());
     const leftToBorrow = new Dec(debtCeiling.toString()).minus(totalDebt).toString();
     const loanDiscount = assetAmountInEth(loanDiscountWei.toString(), debtAsset);
@@ -121,11 +121,20 @@ export const _getCrvUsdAccountBalances = (provider, network, block, addressMappi
     return balances;
 });
 export const getCrvUsdAccountBalances = (provider, network, block, addressMapping, address, controllerAddress) => __awaiter(void 0, void 0, void 0, function* () { return _getCrvUsdAccountBalances(getViemProvider(provider, network), network, block, addressMapping, address, controllerAddress); });
-export const _getCurveUsdUserData = (provider, network, address, selectedMarket, activeBand) => __awaiter(void 0, void 0, void 0, function* () {
+/**
+ * @param borrowRate market borrow APY in % (`CrvUSDGlobalMarketData.borrowRate`); when omitted it is read from the view contract
+ */
+export const _getCurveUsdUserData = (provider, network, address, selectedMarket, activeBand, borrowRate) => __awaiter(void 0, void 0, void 0, function* () {
     const contract = CrvUSDViewContractViem(provider, network);
-    const data = yield contract.read.userData([selectedMarket.controllerAddress, address]);
     const collAsset = selectedMarket.collAsset;
     const debtAsset = selectedMarket.baseAsset;
+    const [data, collStakingApy, marketBorrowRate] = yield 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);
@@ -156,7 +165,7 @@ export const _getCurveUsdUserData = (provider, network, address, selectedMarket,
             isBorrowed: new Dec(debtBorrowed).gt('0'),
             symbol: 'crvUSD',
             price: '1',
-            interestRate: '0',
+            interestRate: marketBorrowRate,
         },
     } : {};
     const priceHigh = assetAmountInEth(data.priceHigh.toString());
@@ -168,13 +177,19 @@ export const _getCurveUsdUserData = (provider, network, address, selectedMarket,
         healthPercent,
         priceHigh,
         priceLow, liquidationDiscount: assetAmountInEth(data.liquidationDiscount.toString()), numOfBands: data.N.toString(), usedAssets,
-        status }), getCrvUsdAggregatedData({
-        loanExists: data.loanExists, usedAssets, network: NetworkNumber.Eth, selectedMarket, numOfBands: data.N.toString(),
+        status, borrowRate: marketBorrowRate }), getCrvUsdAggregatedData({
+        loanExists: data.loanExists,
+        usedAssets,
+        network: NetworkNumber.Eth,
+        selectedMarket,
+        numOfBands: data.N.toString(),
+        borrowRate: marketBorrowRate,
+        collStakingApy,
     })), { userBands });
 });
-export const getCurveUsdUserData = (provider, network, address, selectedMarket, activeBand) => __awaiter(void 0, void 0, void 0, function* () { return _getCurveUsdUserData(getViemProvider(provider, network), network, address, selectedMarket, activeBand); });
+export const getCurveUsdUserData = (provider, network, address, selectedMarket, activeBand, borrowRate) => __awaiter(void 0, void 0, void 0, function* () { return _getCurveUsdUserData(getViemProvider(provider, network), network, address, selectedMarket, activeBand, borrowRate); });
 export const getCurveUsdFullPositionData = (provider, network, address, selectedMarket) => __awaiter(void 0, void 0, void 0, function* () {
     const marketData = yield getCurveUsdGlobalData(provider, network, selectedMarket);
-    const positionData = yield getCurveUsdUserData(provider, network, address, selectedMarket, marketData.activeBand);
+    const positionData = yield getCurveUsdUserData(provider, network, address, selectedMarket, marketData.activeBand, marketData.borrowRate);
     return positionData;
 });

package/esm/fluid/index.d.ts

@@ -89,6 +89,7 @@ export declare const _getUserPositions: (provider: PublicClient, network: Networ
         merklBorrowIncentives: import("../types").IncentiveData[];
         ratio: string;
         collRatio: string;
+        safetyRatio: string;
         minRatio: string;
         totalInterestUsd: string;
         leveragedType?: import("../types").LeverageType;
@@ -123,6 +124,7 @@ export declare const getUserPositions: (provider: EthereumProvider, network: Net
         merklBorrowIncentives: import("../types").IncentiveData[];
         ratio: string;
         collRatio: string;
+        safetyRatio: string;
         minRatio: string;
         totalInterestUsd: string;
         leveragedType?: import("../types").LeverageType;
@@ -157,6 +159,7 @@ export declare const _getUserPositionsPortfolio: (provider: PublicClient, networ
         merklBorrowIncentives: import("../types").IncentiveData[];
         ratio: string;
         collRatio: string;
+        safetyRatio: string;
         minRatio: string;
         totalInterestUsd: string;
         leveragedType?: import("../types").LeverageType;
@@ -177,3 +180,5 @@ export declare const _getUserPositionsPortfolio: (provider: PublicClient, networ
         nftId: string;
     } | undefined;
 }[]>;
+export declare const _getAllFluidMarketDataPortfolio: (provider: PublicClient, network: NetworkNumber) => Promise<Record<string, FluidMarketData>>;
+export declare const getAllFluidMarketDataPortfolio: (provider: EthereumProvider, network: NetworkNumber) => Promise<Record<string, FluidMarketData>>;

package/esm/fluid/index.js

@@ -1381,3 +1381,36 @@ export const _getUserPositionsPortfolio = (provider, network, user) => __awaiter
         userData: userData[i],
     })).filter(md => md.marketData !== undefined);
 });
+export const _getAllFluidMarketDataPortfolio = (provider, network) => __awaiter(void 0, void 0, void 0, function* () {
+    const versions = getFluidVersionsDataForNetwork(network);
+    if (versions.length === 0)
+        return {};
+    const view = FluidViewContractViem(provider, network);
+    const vaultsData = yield 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] = yield Promise.all([
+        getTokensPricesForPortfolio(tokens, provider, network),
+        getFluidMerklCampaigns(network),
+    ]);
+    const parsedMarketsData = yield Promise.all(vaultsData.map((vaultData) => __awaiter(void 0, void 0, void 0, function* () { return parseMarketData(provider, vaultData, network, tokenPrices); })));
+    const marketsData = {};
+    parsedMarketsData.forEach((marketData, i) => {
+        if (!marketData)
+            return;
+        marketsData[versions[i].value] = attachFluidMerklIncentives(marketData, merklCampaigns);
+    });
+    return marketsData;
+});
+export const getAllFluidMarketDataPortfolio = (provider, network) => __awaiter(void 0, void 0, void 0, function* () { return _getAllFluidMarketDataPortfolio(getViemProvider(provider, network, { batch: { multicall: true } }), network); });

package/esm/helpers/aaveHelpers/index.d.ts

@@ -1,4 +1,4 @@
-import { AaveHelperCommon, AaveMarketInfo, AaveV3AggregatedPositionData, AaveV3AssetsData, AaveV3UsedAsset, AaveV3UsedAssets, AaveVersions } from '../../types';
+import { AaveHelperCommon, AaveMarketInfo, AaveV3AggregatedPositionData, AaveV3AssetsData, AaveV3UsedAsset, AaveV3UsedAssets, AaveVersions, EModeCategoriesData } from '../../types';
 import { EthereumProvider, NetworkNumber } from '../../types/common';
 export declare const AAVE_V3_MARKETS: AaveVersions[];
 export declare const isAaveV2: ({ selectedMarket }: {
@@ -15,6 +15,14 @@ export declare const aaveV3IsInSiloedMode: ({ usedAssets, assetsData }: {
     usedAssets: AaveV3UsedAssets;
     assetsData: AaveV3AssetsData;
 }) => boolean;
+export declare const aaveV3IsEmodeIsolated: ({ eModeCategory, eModeCategoriesData }: {
+    eModeCategory: number;
+    eModeCategoriesData?: EModeCategoriesData;
+}) => boolean;
+export declare const aaveV3CanBeCollateralInEmode: ({ eModeCategory, eModeCategoriesData }: {
+    eModeCategory: number;
+    eModeCategoriesData?: EModeCategoriesData;
+}, _asset: string) => boolean;
 export declare const aaveAnyGetCollSuppliedAssets: ({ usedAssets }: {
     usedAssets: AaveV3UsedAssets;
 }) => AaveV3UsedAsset[];