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

package/cjs/types/portfolio.d.ts

@@ -1,20 +1,47 @@
-import { AaveV2MarketData, AaveV2PositionData, AaveV3MarketData, AaveV3PositionData, AaveVersions } from './aave';
+import { AaveV2MarketData, AaveV2PositionData, AaveV3MarketData, AaveV3PositionData, AaveVersions, StakeAaveData, UmbrellaStakingData } from './aave';
 import { AaveV4AccountData, AaveV4SpokeData, AaveV4SpokesType } from './aaveV4';
+import { AaveRewardsClaimableToken, EthenaAirdropClaimableToken, KingRewardsClaimableToken, MerklRewardsClaimableToken, SparkAirdropClaimableToken, SparkRewardsClaimableToken, UniswapAirdropClaimableToken } from './claiming';
 import { EthAddress } from './common';
 import { CompoundV2MarketsData, CompoundV2PositionData, CompoundV3MarketsData, CompoundV3PositionData, CompoundVersions } from './compound';
 import { CrvUSDGlobalMarketData, CrvUSDUserData, CrvUSDVersions } from './curveUsd';
-import { FluidVaultData } from './fluid';
-import { LiquityTroveInfo } from './liquity';
-import { LiquityV2MarketData } from './liquityV2';
+import { FluidEarnPositionData, FluidMarketData, FluidVaultData } from './fluid';
+import { LiquityStakingData, LiquityTroveInfo } from './liquity';
+import { LiquityV2MarketData, LiquityV2SBoldYBoldData, LiquityV2StakingData, LiquityV2TroveData, LiquityV2Versions } from './liquityV2';
 import { LlamaLendGlobalMarketData, LlamaLendUserData, LlamaLendVersionsType } from './llamaLend';
-import { CdpData } from './maker';
-import { MorphoBlueMarketInfo, MorphoBluePositionData, MorphoBlueVersions } from './morphoBlue';
+import { CdpData, IlkInfo } from './maker';
+import { MorphoBlueEarnData, MorphoBlueMarketInfo, MorphoBluePositionData, MorphoBlueVersions } from './morphoBlue';
 import { MorphoMidnightMarketInfo, MorphoMidnightPositionData, MorphoMidnightVersions } from './morphoMidnight';
 import { SparkMarketsData, SparkPositionData, SparkVersions } from './spark';
 export interface PortfolioProtocolData<T> {
     error: string;
     data: T | null;
 }
+/** A failed fetch of a protocol that, when it succeeds, getPortfolioData returns unwrapped rather than as `{ error, data }`. */
+export interface PortfolioProtocolError {
+    error: string;
+    data: null;
+}
+/** What getPortfolioData reads besides markets. */
+export interface PortfolioDataOptions {
+    /** positions (lending); default true. With false it comes back as {} and no lending position is read. */
+    positions?: boolean;
+    /** stakingPositions; default true. With false it comes back as {} and no staking source is read. */
+    staking?: boolean;
+    /** rewardsData; default true. With false it comes back as {} and no rewards source is read. */
+    rewards?: boolean;
+    /**
+     * Liquity V2 troves in positions[address].liquityV2; default false, as the DeFi Saver app reads them on its own.
+     * Mainnet only: elsewhere liquityV2 is {}. Needs positions.
+     */
+    liquityV2?: boolean;
+}
+/** One Liquity V2 market's troves of an address, by trove id — with an error when the ids or any trove failed to load. */
+export interface PortfolioLiquityV2Troves {
+    error: string;
+    data: {
+        [troveId: string]: LiquityV2TroveData;
+    };
+}
 export interface PortfolioPositionsDataForAddress {
     aaveV3: {
         [key in AaveVersions]?: PortfolioProtocolData<AaveV3PositionData>;
@@ -56,10 +83,64 @@ export interface PortfolioPositionsDataForAddress {
     aaveV4: {
         [key in AaveV4SpokesType]?: PortfolioProtocolData<AaveV4AccountData>;
     };
+    /** Only with the liquityV2 option. Every trove the address holds, by market. */
+    liquityV2?: {
+        [key in LiquityV2Versions]?: PortfolioLiquityV2Troves;
+    };
 }
 export interface PortfolioPositionsData {
     [key: EthAddress]: PortfolioPositionsDataForAddress;
 }
+/**
+ * The staking positions getPortfolioData returns for an address. The shapes are uneven, and the DeFi Saver app
+ * parses them as they are: a protocol read once per address comes back unwrapped on success, as
+ * `{ error, data: null }` on failure, and as {} (or Fluid's `{ error: '', data: {} }`) on a network it is not read on.
+ */
+export interface PortfolioStakingPositionsDataForAddress {
+    /** stkAAVE, stkGHO and sGHO; mainnet only. */
+    aaveV3: StakeAaveData | PortfolioProtocolError | {};
+    /** Morpho Blue supply without a borrow (Earn), by market; only markets with a deposit or an error. */
+    morphoBlue: {
+        [key in MorphoBlueVersions]?: PortfolioProtocolData<MorphoBlueEarnData>;
+    };
+    compoundV3: Record<string, never>;
+    spark: Record<string, never>;
+    aaveV2: Record<string, never>;
+    compoundV2: Record<string, never>;
+    /** LQTY staking and the LUSD stability pool; mainnet only. */
+    liquity: LiquityStakingData | PortfolioProtocolError | {};
+    /** Stability pool deposits, by market; mainnet only, legacy markets left out. */
+    liquityV2: {
+        [key in LiquityV2Versions]?: PortfolioProtocolData<LiquityV2StakingData>;
+    };
+    /** Fluid lending (fToken) deposits; `{ error: '', data: {} }` on a network without Fluid. */
+    fluid: FluidEarnPositionData[] | PortfolioProtocolError | {
+        error: string;
+        data: Record<string, never>;
+    };
+    /** Umbrella stakes; absent off mainnet. */
+    umbrella?: UmbrellaStakingData | PortfolioProtocolError;
+    /** sBOLD, yBOLD and stYBOLD; data is null off mainnet. */
+    liquityV2SBoldYBold: PortfolioProtocolData<LiquityV2SBoldYBoldData>;
+}
+export type PortfolioStakingPositionsData = Record<EthAddress, PortfolioStakingPositionsDataForAddress>;
+/** The claimable rewards getPortfolioData returns for an address. Off mainnet only Merkl and Aave V3 are read. */
+export interface PortfolioRewardsDataForAddress {
+    merkl: PortfolioProtocolData<MerklRewardsClaimableToken[]>;
+    aaveV3: {
+        [key in AaveVersions]?: PortfolioProtocolData<AaveRewardsClaimableToken[]>;
+    };
+    spark: {
+        [key in SparkVersions]?: PortfolioProtocolData<SparkRewardsClaimableToken[]>;
+    };
+    /** The SPK airdrop. */
+    spk: PortfolioProtocolData<SparkAirdropClaimableToken[]>;
+    king: PortfolioProtocolData<KingRewardsClaimableToken[]>;
+    /** {} off mainnet. */
+    ethena: PortfolioProtocolData<EthenaAirdropClaimableToken[]> | {};
+    uniswap: PortfolioProtocolData<UniswapAirdropClaimableToken[]>;
+}
+export type PortfolioRewardsData = Record<EthAddress, PortfolioRewardsDataForAddress>;
 /** The `markets` getPortfolioData returns: every market it read, by protocol, keyed by market or spoke. */
 export interface PortfolioMarketsData {
     morphoMarketsData: Record<string, MorphoBlueMarketInfo>;
@@ -74,3 +155,43 @@ export interface PortfolioMarketsData {
     liquityV2MarketsData: Record<string, LiquityV2MarketData>;
     aaveV4SpokesData: Record<string, AaveV4SpokeData>;
 }
+/**
+ * The `markets` getShifterPortfolioData returns: the portfolio's markets, plus Fluid's and Maker's, which the shifter
+ * offers as destinations. Kept apart from PortfolioMarketsData, which getPortfolioData does not fill these into.
+ */
+export interface ShifterPortfolioMarketsData extends PortfolioMarketsData {
+    fluidMarketsData: Record<string, FluidMarketData>;
+    makerMarketsData: Record<string, IlkInfo>;
+}
+/** The markets that could not be read, by their key in PortfolioMarketsData, then by market or spoke: the error. */
+export type PortfolioMarketsErrors = {
+    [key in keyof PortfolioMarketsData]?: Record<string, string>;
+};
+/**
+ * What the portfolio fetch could not read and has no `{ error, data }` entry of its own to report it in. A key is
+ * present only when something under it failed; {} when everything was read.
+ */
+export interface PortfolioErrors {
+    /** Markets missing from `markets`; every position on such a market is an entry with an error. */
+    markets?: PortfolioMarketsErrors;
+    /** Addresses whose Maker vault list could not be read: their `maker` is {}, which would otherwise read as "no vaults". */
+    makerCdps?: Record<EthAddress, string>;
+}
+/** getPortfolioMarketsData's result. */
+export interface PortfolioMarketsResult {
+    /** Every market read; one that failed is missing and named in `errors`. */
+    markets: PortfolioMarketsData;
+    errors: PortfolioMarketsErrors;
+}
+/** getPortfolioUserData's result: what is read per address. */
+export interface PortfolioUserData {
+    positions: PortfolioPositionsData;
+    stakingPositions: PortfolioStakingPositionsData;
+    rewardsData: PortfolioRewardsData;
+    errors: Pick<PortfolioErrors, 'makerCdps'>;
+}
+/** getPortfolioData's result. */
+export interface PortfolioData extends Omit<PortfolioUserData, 'errors'> {
+    markets: PortfolioMarketsData;
+    errors: PortfolioErrors;
+}

package/cjs/types/savings/index.d.ts

@@ -20,4 +20,12 @@ export interface SavingsVaultData {
     asset: string;
     optionType: string;
 }
-export type SavingsData = Partial<Record<MorphoVaultType | YearnVaultType | MakerDsrType | SkySavingsType | SparkSavingsVaultType | SummerVaultType | YearnV3VaultType, SavingsVaultData>>;
+/** The key of every savings vault getSavingsData reads. */
+export type SavingsVaultKey = MorphoVaultType | YearnVaultType | MakerDsrType | SkySavingsType | SparkSavingsVaultType | SummerVaultType | YearnV3VaultType;
+export type SavingsData = Partial<Record<SavingsVaultKey, SavingsVaultData>>;
+/** Why each vault that was read for a network came back without data. */
+export type SavingsErrors = Partial<Record<SavingsVaultKey, string>>;
+export interface SavingsDataWithErrors {
+    data: SavingsData;
+    errors: SavingsErrors;
+}

package/cjs/types/savings/morphoVaults.d.ts

@@ -1,4 +1,4 @@
-import { EthAddress } from '../common';
+import { EthAddress, NetworkNumber } from '../common';
 export declare enum MorphoVaultType {
     MorphoVaultFlagshipEth = "morpho_vault_flagship_eth",
     MorphoVaultGauntletUSDCCore = "morpho_vault_gauntlet_usdc_core",
@@ -17,13 +17,21 @@ export declare enum MorphoVaultType {
     MorphoVaultSteakhousePYUSD = "morpho_vault_steakhouse_pyusd",
     MorphoVaultSmokehouseUSDT = "morpho_vault_smokehouse_usdt",
     MorphoVaultSmokehouseUSDC = "morpho_vault_smokehouse_usdc",
-    MorphoVaultSmokehouseDAI = "morpho_vault_smokehouse_dai"
+    MorphoVaultSmokehouseDAI = "morpho_vault_smokehouse_dai",
+    MorphoVaultGauntletUSDGPremium = "morpho_vault_gauntlet_usdg_premium",
+    MorphoVaultSteakhouseUSDGPro = "morpho_vault_steakhouse_usdg_pro"
+}
+export declare enum MorphoVaultVersion {
+    V1 = 1,
+    V2 = 2
 }
 export interface MorphoVault {
     type: MorphoVaultType;
     name: string;
     address: EthAddress;
     asset: string;
+    network: NetworkNumber;
+    version: MorphoVaultVersion;
     deploymentBlock: number;
     isLegacy: boolean;
 }

package/cjs/types/savings/morphoVaults.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MorphoVaultType = void 0;
+exports.MorphoVaultVersion = exports.MorphoVaultType = void 0;
 var MorphoVaultType;
 (function (MorphoVaultType) {
     MorphoVaultType["MorphoVaultFlagshipEth"] = "morpho_vault_flagship_eth";
@@ -23,4 +23,12 @@ var MorphoVaultType;
     MorphoVaultType["MorphoVaultSmokehouseUSDT"] = "morpho_vault_smokehouse_usdt";
     MorphoVaultType["MorphoVaultSmokehouseUSDC"] = "morpho_vault_smokehouse_usdc";
     MorphoVaultType["MorphoVaultSmokehouseDAI"] = "morpho_vault_smokehouse_dai";
+    // Vault V2
+    MorphoVaultType["MorphoVaultGauntletUSDGPremium"] = "morpho_vault_gauntlet_usdg_premium";
+    MorphoVaultType["MorphoVaultSteakhouseUSDGPro"] = "morpho_vault_steakhouse_usdg_pro";
 })(MorphoVaultType || (exports.MorphoVaultType = MorphoVaultType = {}));
+var MorphoVaultVersion;
+(function (MorphoVaultVersion) {
+    MorphoVaultVersion[MorphoVaultVersion["V1"] = 1] = "V1";
+    MorphoVaultVersion[MorphoVaultVersion["V2"] = 2] = "V2";
+})(MorphoVaultVersion || (exports.MorphoVaultVersion = MorphoVaultVersion = {}));

package/cjs/types/spark.d.ts

@@ -100,6 +100,7 @@ export interface SparkAggregatedPositionData {
     leftToBorrowUsd: string;
     ratio: string;
     collRatio: string;
+    safetyRatio: string;
     netApy: string;
     incentiveUsd: string;
     totalInterestUsd: string;
@@ -124,6 +125,7 @@ export interface SparkPositionData extends MMPositionData, SparkPositionAggregat
     ratio: string;
     minRatio: string;
     collRatio: string;
+    safetyRatio?: string;
     suppliedUsd: string;
     borrowedUsd: string;
     borrowLimitUsd: string;

package/cjs/umbrella/index.d.ts

@@ -1,5 +1,4 @@
 import { Client } from 'viem';
 import { EthAddress, NetworkNumber } from '../types/common';
-export declare const getUmbrellaData: (provider: Client, network: NetworkNumber, address: EthAddress) => Promise<{
-    [k: string]: any;
-}>;
+import { UmbrellaStakingData } from '../types/aave';
+export declare const getUmbrellaData: (provider: Client, network: NetworkNumber, address: EthAddress) => Promise<UmbrellaStakingData>;

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

@@ -1,5 +1,5 @@
 import { Client } from 'viem';
-import { AaveMarketInfo, AaveV3MarketData, AaveV3PositionData, AaveV3UsedAssets, EModeCategoryDataMapping } from '../types';
+import { AaveMarketInfo, AaveV3MarketData, AaveV3PositionData, AaveV3UsedAssets, EModeCategoryDataMapping, StakeAaveData } from '../types';
 import { Blockish, EthAddress, EthereumProvider, NetworkNumber, PositionBalances } from '../types/common';
 import { getMeritCampaigns } from './merit';
 import { getMerkleCampaigns } from './merkl';
@@ -32,22 +32,51 @@ 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>;
 export declare const REWARDABLE_ASSETS: readonly ["0x028171bCA77440897B824Ca71D1c56caC55b68A3", "0x6C3c78838c761c6Ac7bE9F59fe808ea2A6E4379d", "0xD37EE7e4f452C6638c96536e68090De8cBcdb583", "0x279AF5b99540c1A3A7E3CDd326e19659401eF99e", "0xBcca60bB61934080951369a648Fb03DF4F96263C", "0x619beb58998eD2278e08620f97007e1116D5D25b", "0x3Ed3B47Dd13EC9a98b44e6204A523E766B225811", "0x531842cEbbdD378f8ee36D171d6cC9C4fcf475Ec", "0x9ff58f4fFB29fA2266Ab25e75e2A8b3503311656", "0x9c39809Dec7F95F5e0713634a4D0701329B3b4d2", "0x030bA81f1c18d280636F32af80b9AAd02Cf0854e", "0xF63B34710400CAd3e044cFfDcAb00a0f32E33eCf", "0xa06bC25B5805d5F8d82847D191Cb4Af5A3e873E0", "0x0b8f12b1788BFdE65Aa1ca52E3e9F3Ba401be16D", "0x6C5024Cd4F8A59110119C56f8933403A539555EB", "0xdC6a3Ab17299D9C2A412B0e0a4C1f55446AE0817", "0x5165d24277cD063F5ac44Efd447B27025e888f37", "0x7EbD09022Be45AD993BAA1CEc61166Fcc8644d97", "0xF256CC7847E919FAc9B808cC216cAc87CCF2f47a", "0xfAFEDF95E21184E3d880bd56D4806c4b8d31c69A", "0xB9D7CB55f463405CDfBe4E90a6D2Df01C2B92BF1", "0x5BdB050A92CADcCfCDcCCBFC17204a1C9cC0Ab73", "0xc713e5E149D5D0715DcD1c156a020976e7E56B88", "0xba728eAd5e496BE00DCF66F650b6d7758eCB50f8", "0x101cc05f4A51C0319f570d5E146a8C625198e636", "0x01C0eb1f8c6F1C1bF74ae028697ce7AA2a8b0E92", "0xc9BC48c72154ef3e5425641a3c747242112a46AF", "0xB5385132EE8321977FfF44b60cDE9fE9AB0B4e6b", "0x272F97b7a56a387aE942350bBC7Df5700f8a4576", "0x13210D4Fe0d5402bd7Ecbc4B5bC5cFcA3b71adB0", "0x2e8f4bdbe3d47d7d7de490437aea9915d930f1a3", "0xfdb93b3b10936cf81fa59a02a7523b6e2149b2b7", "0xA361718326c15715591c299427c62086F69923D9", "0xbA429f7011c9fa04cDd46a2Da24dc0FF0aC6099c", "0xd4937682df3C8aEF4FE912A96A74121C0829E664", "0xfE8F19B17fFeF0fDbfe2671F248903055AFAA8Ca", "0x683923dB55Fead99A79Fa01A27EeC3cB19679cC3", "0xC2e10006AccAb7B45D9184FcF5b7EC7763f5BaAe", "0x8dAE6Cb04688C62d939ed9B68d32Bc62e49970b1", "0x00ad8eBF64F141f1C81e9f8f792d3d1631c6c684", "0x6F634c6135D2EBD550000ac92F494F9CB8183dAe", "0x4dDff5885a67E4EffeC55875a3977D7E60F82ae0"];
 export declare const fetchYearlyMeritApyForStakingGho: () => Promise<string>;
-export declare const getStakeAaveData: (provider: Client, network: NetworkNumber, address: EthAddress) => Promise<{
-    activatedCooldown: string;
-    activatedCooldownAmount: string;
-    stkAaveRewardsBalance: string;
-    aaveRewardsBalance: string;
-    stkAaveBalance: string;
-    stkGhoBalance: string;
-    ghoMeritApy: string;
-    stkAaveApy: string;
-    sgho: import("./sgho").SghoData;
-}>;
+export declare const getStakeAaveData: (provider: Client, network: NetworkNumber, address: EthAddress) => Promise<StakeAaveData>;
 export { getMeritCampaigns, getMerkleCampaigns, };
 export { getSghoData } from './sgho';
 export type { SghoData, SghoUserData } from './sgho';

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/aaveV3/sgho.d.ts

@@ -1,18 +1,4 @@
 import { EthAddress, NetworkNumber } from '../types/common';
-export interface SghoUserData {
-    shares: string;
-    balance: string;
-    maxDeposit: string;
-    maxWithdraw: string;
-    underlyingBalance: string;
-}
-export interface SghoData {
-    totalAssets: string;
-    totalSupply: string;
-    supplyCap: string;
-    /** Target savings rate as an APY percent (e.g. "4.25" for 4.25%). */
-    targetRate: string;
-    paused: boolean;
-    user: SghoUserData;
-}
+import { SghoData } from '../types/aave';
+export type { SghoData, SghoUserData } from '../types/aave';
 export declare const getSghoData: (network: NetworkNumber, address?: EthAddress) => Promise<SghoData>;