@defisaver/positions-sdk 2.1.168-stable-pair-dev → 2.1.169-portfolio-api-dev

package/src/portfolio/lendingProtocols.ts

@@ -0,0 +1,281 @@
+import Dec from 'decimal.js';
+import { Client } from 'viem';
+import { EthAddress, NetworkNumber } from '../types/common';
+import {
+  AaveMarkets,
+  AaveV4Spokes,
+  CompoundMarkets,
+  CrvUsdMarkets,
+  LlamaLendMarkets,
+  MorphoBlueMarkets,
+  MorphoMidnightMarkets,
+  SparkMarkets,
+} from '../markets';
+import {
+  AaveMarketInfo,
+  AaveV4SpokeInfo,
+  AaveVersions,
+  CompoundMarketData,
+  CompoundVersions,
+  CrvUSDMarketData,
+  LlamaLendMarketData,
+  MorphoBlueMarketData,
+  MorphoMidnightMarketData,
+  PortfolioMarketsData,
+  PortfolioPositionsData,
+  PortfolioPositionsDataForAddress,
+  PortfolioProtocolData,
+  SparkMarketData,
+} from '../types';
+import { _getAaveV3AccountData, _getAaveV3MarketData } from '../aaveV3';
+import { _getAaveV4AccountData, _getAaveV4SpokeData } from '../aaveV4';
+import { _getAaveV2AccountData, _getAaveV2MarketsData } from '../aaveV2';
+import { _getCompoundV2AccountData, _getCompoundV2MarketsData } from '../compoundV2';
+import { _getCompoundV3AccountData, _getCompoundV3MarketsData } from '../compoundV3';
+import { _getCurveUsdGlobalData, _getCurveUsdUserData } from '../curveUsd';
+import { _getLlamaLendGlobalData, _getLlamaLendUserData } from '../llamaLend';
+import { _getMorphoBlueAccountData, _getMorphoBluePortfolioMarketData } from '../morphoBlue';
+import { _getMorphoMidnightAccountData, _getMorphoMidnightMarketData } from '../morphoMidnight';
+import { _getSparkAccountData, _getSparkMarketsData } from '../spark';
+import { ZERO_ADDRESS } from '../constants';
+
+/**
+ * The lending protocols the portfolio reads the same way — a market's data, then each address's position on it — one
+ * entry each. Adding such a protocol is its types (its key in PortfolioPositionsDataForAddress and in
+ * PortfolioMarketsData) and its entry in LENDING_PROTOCOLS; the portfolio reads, errors and options follow. Maker,
+ * Liquity, Fluid and Liquity V2 have shapes of their own and are read by their own code in ./index.ts.
+ */
+
+/** What a position read gets. */
+export interface PortfolioReadContext {
+  client: Client;
+  network: NetworkNumber;
+}
+
+/** What a market read gets: also the default client, on Ethereum (Compound V3 reads its prices there). */
+export interface PortfolioMarketsReadContext extends PortfolioReadContext {
+  defaultClient: Client;
+}
+
+type PositionKey = keyof PortfolioPositionsDataForAddress;
+type MarketsKey = keyof PortfolioMarketsData;
+type PositionsOf<K extends PositionKey> = NonNullable<PortfolioPositionsDataForAddress[K]>;
+
+/** The data of one of a protocol's positions: what positions[address][K][market] holds as `{ error, data }`. */
+export type LendingPositionData<K extends PositionKey> =
+  NonNullable<PositionsOf<K>[keyof PositionsOf<K>]> extends PortfolioProtocolData<infer D> ? D : never;
+
+export interface LendingProtocol<K extends PositionKey, M extends MarketsKey, Market extends { value: string }> {
+  /** Its key in PortfolioMarketsData. */
+  marketsKey: M;
+  /** Its name in error messages. */
+  label: string;
+  /** Its markets on a network; none where it is not deployed. */
+  markets: (network: NetworkNumber) => Market[];
+  readMarket: (context: PortfolioMarketsReadContext, market: Market) => Promise<PortfolioMarketsData[M][string]>;
+  /** An address's position on a market; undefined when the market can hold none. */
+  readPosition: (
+    context: PortfolioReadContext,
+    address: EthAddress,
+    market: Market,
+    marketData: PortfolioMarketsData[M][string],
+  ) => Promise<LendingPositionData<K> | undefined>;
+  /** Whether there is a position to list: an address without one gets no entry for that market. */
+  holds: (position: LendingPositionData<K>) => boolean;
+}
+
+/**
+ * A market's data, or a throw that the caller's catch turns into the position's error entry: read against a missing
+ * market, a position would otherwise come back empty and read as "no position".
+ */
+export const requireMarket = <T>(marketsData: Record<string, T>, market: string): T => {
+  const marketData = marketsData[market];
+  if (!marketData) throw new Error(`Market data for ${market} is not available`);
+  return marketData;
+};
+
+/** requireMarket for one protocol's key, typed by that key's market data. */
+const requireMarketOf = <M extends MarketsKey>(marketsData: PortfolioMarketsData, key: M, market: string): PortfolioMarketsData[M][string] => {
+  // TypeScript reads marketsData[key][market] as any protocol's market data; the key's own is what is stored there.
+  const marketData = (marketsData[key] as Record<string, PortfolioMarketsData[M][string] | undefined>)[market];
+  if (!marketData) throw new Error(`Market data for ${market} is not available`);
+  return marketData;
+};
+
+/** A protocol's entry with its reads, typed by its own market and position types. */
+const lendingProtocol = <K extends PositionKey, M extends MarketsKey, Market extends { value: string }>(
+  key: K,
+  protocol: LendingProtocol<K, M, Market>,
+) => {
+  /** Every market of the protocol into `markets`; resolves to the ones that failed (left out), with their errors. */
+  const readMarkets = async (context: PortfolioMarketsReadContext, markets: PortfolioMarketsData): Promise<Record<string, string>> => {
+    const protocolMarkets = markets[protocol.marketsKey];
+    const failed: Record<string, string> = {};
+    await Promise.all(protocol.markets(context.network).map(async (market) => {
+      try {
+        protocolMarkets[market.value] = await protocol.readMarket(context, market);
+      } catch (error) {
+        console.error(`Error fetching ${protocol.marketsKey} for market ${market.value}:`, error);
+        failed[market.value] = `Error fetching ${protocol.marketsKey} for market ${market.value}`;
+      }
+    }));
+    return failed;
+  };
+
+  /**
+   * Every address's position on every market into `positions`, each read once its market is in: an entry with the data
+   * where the address holds a position, an entry with an error where the read or its market failed, none otherwise.
+   */
+  const readPositions = (
+    context: PortfolioReadContext,
+    addresses: EthAddress[],
+    marketsData: Promise<PortfolioMarketsData>,
+    positions: PortfolioPositionsData,
+  ): Promise<void>[] => protocol.markets(context.network).flatMap((market) => addresses.map(async (address) => {
+    // Keyed by the protocol's market type in PortfolioPositionsDataForAddress; written here by market.value.
+    const byMarket = positions[address.toLowerCase() as EthAddress][key] as Record<string, PortfolioProtocolData<LendingPositionData<K>>>;
+    try {
+      const marketData = requireMarketOf(await marketsData, protocol.marketsKey, market.value);
+      const position = await protocol.readPosition(context, address, market, marketData);
+      if (position && protocol.holds(position)) byMarket[market.value] = { error: '', data: position };
+    } catch (error) {
+      console.error(`Error fetching ${protocol.label} account data for address ${address} on market ${market.value}:`, error);
+      byMarket[market.value] = { error: `Error fetching ${protocol.label} account data for address ${address} on market ${market.value}`, data: null };
+    }
+  }));
+
+  return {
+    key, marketsKey: protocol.marketsKey, markets: protocol.markets, readMarkets, readPositions,
+  };
+};
+
+const onNetwork = <Market extends { chainIds: NetworkNumber[] }>(network: NetworkNumber, markets: Market[]) => markets.filter((market) => market.chainIds.includes(network));
+
+const suppliesAnything = (position: { suppliedUsd: string }) => new Dec(position.suppliedUsd).gt(0);
+const suppliesOrBorrowsAnything = (position: { suppliedUsd: string, borrowedUsd: string }) => new Dec(position.suppliedUsd).gt(0) || new Dec(position.borrowedUsd).gt(0);
+
+export const aaveV3Lending = lendingProtocol('aaveV3', {
+  marketsKey: 'aaveV3MarketsData',
+  label: 'AaveV3',
+  markets: (network): AaveMarketInfo[] => onNetwork(network, [AaveVersions.AaveV3, AaveVersions.AaveV3Lido, AaveVersions.AaveV3Etherfi].map((version) => AaveMarkets(network)[version])),
+  readMarket: ({ client, network }, market) => _getAaveV3MarketData(client, network, market),
+  readPosition: ({ client, network }, address, market, marketData) => _getAaveV3AccountData(client, network, address, { selectedMarket: market, ...marketData }),
+  holds: suppliesAnything,
+});
+
+export const aaveV4Lending = lendingProtocol('aaveV4', {
+  marketsKey: 'aaveV4SpokesData',
+  label: 'AaveV4',
+  markets: (network): AaveV4SpokeInfo[] => onNetwork(network, Object.values(AaveV4Spokes(network))),
+  readMarket: ({ client, network }, spoke) => _getAaveV4SpokeData(client, network, spoke),
+  readPosition: ({ client, network }, address, _spoke, spokeData) => _getAaveV4AccountData(client, network, spokeData, address),
+  holds: suppliesAnything,
+});
+
+export const morphoBlueLending = lendingProtocol('morphoBlue', {
+  marketsKey: 'morphoMarketsData',
+  label: 'MorphoBlue',
+  markets: (network): MorphoBlueMarketData[] => onNetwork(network, Object.values(MorphoBlueMarkets(network))),
+  readMarket: ({ client, network }, market) => _getMorphoBluePortfolioMarketData(client, network, market),
+  readPosition: ({ client, network }, address, market, marketData) => _getMorphoBlueAccountData(client, network, address, market, marketData),
+  holds: suppliesAnything,
+});
+
+export const morphoMidnightLending = lendingProtocol('morphoMidnight', {
+  marketsKey: 'morphoMidnightMarketsData',
+  label: 'MorphoMidnight',
+  markets: (network): MorphoMidnightMarketData[] => onNetwork(network, Object.values(MorphoMidnightMarkets(network))),
+  readMarket: ({ client, network }, market) => _getMorphoMidnightMarketData(client, network, market),
+  // Markets are created lazily on the first position, so an uncreated one can hold no position.
+  readPosition: async ({ client, network }, address, market, marketData) => (marketData.isCreated
+    ? _getMorphoMidnightAccountData(client, network, address, market, marketData)
+    : undefined),
+  holds: suppliesAnything,
+});
+
+export const compoundV3Lending = lendingProtocol('compoundV3', {
+  marketsKey: 'compoundV3MarketsData',
+  label: 'CompoundV3',
+  markets: (network): CompoundMarketData[] => onNetwork(network, Object.values(CompoundMarkets(network)).filter((market) => market.value !== CompoundVersions.CompoundV2)),
+  readMarket: ({ client, defaultClient, network }, market) => _getCompoundV3MarketsData(client, network, market, defaultClient),
+  readPosition: ({ client, network }, address, market, marketData) => _getCompoundV3AccountData(client, network, address, ZERO_ADDRESS, { selectedMarket: market, assetsData: marketData.assetsData }),
+  holds: suppliesAnything,
+});
+
+export const sparkLending = lendingProtocol('spark', {
+  marketsKey: 'sparkMarketsData',
+  label: 'Spark',
+  markets: (network): SparkMarketData[] => onNetwork(network, Object.values(SparkMarkets(network))),
+  readMarket: ({ client, network }, market) => _getSparkMarketsData(client, network, market),
+  readPosition: ({ client, network }, address, market, marketData) => _getSparkAccountData(client, network, address, {
+    selectedMarket: market, assetsData: marketData.assetsData, eModeCategoriesData: marketData.eModeCategoriesData,
+  }),
+  holds: suppliesAnything,
+});
+
+export const aaveV2Lending = lendingProtocol('aaveV2', {
+  marketsKey: 'aaveV2MarketsData',
+  label: 'AaveV2',
+  markets: (network): AaveMarketInfo[] => onNetwork(network, [AaveMarkets(network)[AaveVersions.AaveV2]]),
+  readMarket: ({ client, network }, market) => _getAaveV2MarketsData(client, network, market),
+  readPosition: ({ client, network }, address, market, marketData) => _getAaveV2AccountData(client, network, address, marketData.assetsData, market),
+  holds: suppliesAnything,
+});
+
+export const compoundV2Lending = lendingProtocol('compoundV2', {
+  marketsKey: 'compoundV2MarketsData',
+  label: 'CompoundV2',
+  markets: (network): CompoundMarketData[] => onNetwork(network, [CompoundMarkets(network)[CompoundVersions.CompoundV2]]),
+  readMarket: ({ client, network }) => _getCompoundV2MarketsData(client, network),
+  readPosition: ({ client, network }, address, _market, marketData) => _getCompoundV2AccountData(client, network, address, marketData.assetsData),
+  holds: suppliesAnything,
+});
+
+export const crvUsdLending = lendingProtocol('crvUsd', {
+  marketsKey: 'crvUsdMarketsData',
+  label: 'Curve USD',
+  markets: (network): CrvUSDMarketData[] => onNetwork(network, Object.values(CrvUsdMarkets(network))),
+  readMarket: ({ client, network }, market) => _getCurveUsdGlobalData(client, network, market),
+  // The market's borrow rate is passed in, so the read does not fetch it again.
+  readPosition: ({ client, network }, address, market, marketData) => _getCurveUsdUserData(client, network, address, market, marketData.activeBand, marketData.borrowRate),
+  holds: suppliesOrBorrowsAnything,
+});
+
+export const llamaLendLending = lendingProtocol('llamaLend', {
+  marketsKey: 'llamaLendMarketsData',
+  label: 'LlamaLend',
+  markets: (network): LlamaLendMarketData[] => ([NetworkNumber.Eth, NetworkNumber.Arb].includes(network) ? onNetwork(network, Object.values(LlamaLendMarkets(network))) : []),
+  readMarket: ({ client, network }, market) => _getLlamaLendGlobalData(client, network, market),
+  readPosition: async ({ client, network }, address, market, marketData) => ({
+    ...await _getLlamaLendUserData(client, network, address, market, marketData),
+    borrowRate: marketData.borrowRate,
+  }),
+  holds: suppliesOrBorrowsAnything,
+});
+
+/** Every lending protocol read through its entry, in the order positions list them. */
+export const LENDING_PROTOCOLS = [
+  aaveV3Lending,
+  aaveV4Lending,
+  morphoBlueLending,
+  morphoMidnightLending,
+  compoundV3Lending,
+  sparkLending,
+  aaveV2Lending,
+  compoundV2Lending,
+  crvUsdLending,
+  llamaLendLending,
+] as const;
+
+export type LendingKey = typeof LENDING_PROTOCOLS[number]['key'];
+
+/** The keys ./index.ts reads with code of its own. */
+export type SpecialPositionKey = 'maker' | 'liquity' | 'fluid' | 'liquityV2';
+type SpecialMarketsKey = 'liquityV2MarketsData';
+
+// Every position key and every markets key is read by an entry here or by its own code in ./index.ts: one added to
+// PortfolioPositionsDataForAddress or PortfolioMarketsData with neither is a compile error on these lines, naming it.
+type UnreadPositionKey = Exclude<PositionKey, LendingKey | SpecialPositionKey>;
+type UnreadMarketsKey = Exclude<MarketsKey, typeof LENDING_PROTOCOLS[number]['marketsKey'] | SpecialMarketsKey>;
+export const EVERY_POSITION_KEY_IS_READ: [UnreadPositionKey] extends [never] ? true : UnreadPositionKey = true;
+export const EVERY_MARKETS_KEY_IS_READ: [UnreadMarketsKey] extends [never] ? true : UnreadMarketsKey = true;

package/src/savings/index.ts

@@ -2,6 +2,9 @@ import {
   MakerDsrType,
   MorphoVaultType,
   SavingsData,
+  SavingsDataWithErrors,
+  SavingsErrors,
+  SavingsVaultKey,
   SkySavingsType,
   SparkSavingsVaultType,
   SummerVaultType,
@@ -27,11 +30,16 @@ export {
   yearnV3Vaults,
 };
 
-export const getSavingsData = async (
+/**
+ * Every savings vault of a network for the given accounts, and, for each vault that came back without data, why — so
+ * a vault that failed is never mistaken for one the accounts have nothing in.
+ */
+export const getSavingsDataWithErrors = async (
   provider: EthereumProvider,
   network: NetworkNumber,
   accounts: EthAddress[],
-) => {
+): Promise<SavingsDataWithErrors> => {
+  const isMainnet = network === NetworkNumber.Eth;
   const morphoVaultsList = (Object.keys(morphoVaults.morphoVaultsOptions.MORPHO_VAULTS) as MorphoVaultType[])
     .filter((key) => morphoVaults.morphoVaultsOptions.getMorphoVault(key).network === network);
   const yearnVaultsList = Object.keys(yearnVaults.yearnVaultsOptions.YEARN_VAULTS) as YearnVaultType[];
@@ -40,7 +48,17 @@ export const getSavingsData = async (
   const summerVaultsList = (Object.keys(summerVaults.summerVaultsOptions.SUMMER_VAULTS) as SummerVaultType[])
     .filter((key) => summerVaults.summerVaultsOptions.getSummerVault(key).network === network);
 
+  // Every vault read on this network, so one left without data or an error can still be reported.
+  const vaultKeys: SavingsVaultKey[] = [
+    ...morphoVaultsList,
+    ...(isMainnet ? [
+      ...yearnVaultsList, ...sparkSavingsVaultsList, ...yearnV3VaultsList, MakerDsrType.MakerDsrVault, SkySavingsType.SkySavings,
+    ] : []),
+    ...summerVaultsList,
+  ];
+
   const savingsData: SavingsData = {};
+  const errors: SavingsErrors = {};
 
   await Promise.all([
     ...(morphoVaultsList.length ? [
@@ -51,10 +69,11 @@ export const getSavingsData = async (
           Object.assign(savingsData, data);
         } catch (err) {
           console.error('[getSavingsData] Error fetching morpho vaults:', err);
+          morphoVaultsList.forEach((vaultKey) => { errors[vaultKey] = `Error fetching morpho vault ${vaultKey}`; });
         }
       })(),
     ] : []),
-    ...(network === NetworkNumber.Eth ? [
+    ...(isMainnet ? [
       ...yearnVaultsList.map(async (vaultKey) => {
         try {
           const vault = yearnVaults.yearnVaultsOptions.getYearnVault(vaultKey);
@@ -62,6 +81,7 @@ export const getSavingsData = async (
           savingsData[vaultKey] = data;
         } catch (err) {
           console.error(`[getSavingsData] Error fetching yearn vault ${vaultKey}:`, err);
+          errors[vaultKey] = `Error fetching yearn vault ${vaultKey}`;
         }
       }),
       ...sparkSavingsVaultsList.map(async (vaultKey) => {
@@ -71,6 +91,7 @@ export const getSavingsData = async (
           savingsData[vaultKey] = data;
         } catch (err) {
           console.error(`[getSavingsData] Error fetching spark savings vault ${vaultKey}:`, err);
+          errors[vaultKey] = `Error fetching spark savings vault ${vaultKey}`;
         }
       }),
       ...yearnV3VaultsList.map(async (vaultKey) => {
@@ -80,6 +101,7 @@ export const getSavingsData = async (
           savingsData[vaultKey] = data;
         } catch (err) {
           console.error(`[getSavingsData] Error fetching yearn v3 vault ${vaultKey}:`, err);
+          errors[vaultKey] = `Error fetching yearn v3 vault ${vaultKey}`;
         }
       }),
       (async () => {
@@ -88,6 +110,7 @@ export const getSavingsData = async (
           savingsData[MakerDsrType.MakerDsrVault] = data;
         } catch (err) {
           console.error('[getSavingsData] Error fetching maker DSR data:', err);
+          errors[MakerDsrType.MakerDsrVault] = 'Error fetching maker DSR data';
         }
       })(),
       (async () => {
@@ -96,6 +119,7 @@ export const getSavingsData = async (
           savingsData[SkySavingsType.SkySavings] = data;
         } catch (err) {
           console.error('[getSavingsData] Error fetching Sky savings data:', err);
+          errors[SkySavingsType.SkySavings] = 'Error fetching Sky savings data';
         }
       })(),
     ] : []),
@@ -106,9 +130,22 @@ export const getSavingsData = async (
         savingsData[vaultKey] = data;
       } catch (err) {
         console.error(`[getSavingsData] Error fetching summer vault ${vaultKey}:`, err);
+        errors[vaultKey] = `Error fetching summer vault ${vaultKey}`;
       }
     }),
   ]);
 
-  return savingsData;
+  // getMorphoVaultsData leaves out, without throwing, a vault whose on-chain reads failed or that the Morpho API did not return.
+  vaultKeys.forEach((vaultKey) => {
+    if (!savingsData[vaultKey] && !errors[vaultKey]) errors[vaultKey] = `No data returned for savings vault ${vaultKey}`;
+  });
+
+  return { data: savingsData, errors };
 };
+
+/** Every savings vault of a network for the given accounts. A vault that failed is left out: use getSavingsDataWithErrors to tell why. */
+export const getSavingsData = async (
+  provider: EthereumProvider,
+  network: NetworkNumber,
+  accounts: EthAddress[],
+): Promise<SavingsData> => (await getSavingsDataWithErrors(provider, network, accounts)).data;

package/src/types/aave.ts

@@ -1,4 +1,5 @@
 import {
+  EthAddress,
   IncentiveData,
   LeverageType,
   MMAssetData, MMPositionData, MMUsedAsset, NetworkNumber,
@@ -97,6 +98,9 @@ export interface AaveV3AssetData extends AaveAssetData {
   liquidationBonus: string,
   supplyIncentives: IncentiveData[];
   borrowIncentives: IncentiveData[];
+  // Set by _getAaveV3MarketData. Optional, so objects built by hand still type-check.
+  aTokenAddress?: EthAddress,
+  vTokenAddress?: EthAddress,
 }
 
 export type EModeCategoriesData = Record<number, EModeCategoryData>;
@@ -138,7 +142,15 @@ export type AaveV2UsedAssets = AaveUsedAssets<AaveV2UsedAsset>;
 
 export type AaveV3UsedAssets = AaveUsedAssets<AaveV3UsedAsset>;
 
-export interface AavePositionData extends MMPositionData {
+/**
+ * Fields aaveAnyGetAggregatedPositionData adds to every Aave V2/V3 position at runtime, on top of those declared
+ * below. Optional, so code that builds a position by hand keeps compiling.
+ */
+export type AavePositionAggregatedFields = Partial<Omit<AaveV3AggregatedPositionData,
+| keyof MMPositionData | 'ratio' | 'collRatio' | 'safetyRatioWithLtvZeroFallback' | 'suppliedUsd' | 'borrowedUsd'
+| 'borrowLimitUsd' | 'suppliedCollateralUsd' | 'incentiveUsd' | 'totalInterestUsd'>>;
+
+export interface AavePositionData extends MMPositionData, AavePositionAggregatedFields {
   ratio: string,
   minRatio: string,
   collRatio: string,
@@ -159,6 +171,11 @@ export interface AavePositionData extends MMPositionData {
 
 export interface AaveV2PositionData extends AavePositionData {
   usedAssets: AaveV2UsedAssets,
+  // Always their empty values: _getAaveV2AccountData starts from Aave V3's EMPTY_AAVE_DATA, which carries them.
+  eModeCategory?: number,
+  isInIsolationMode?: boolean,
+  isInSiloedMode?: boolean,
+  eModeCategories?: { [key: number]: EModeCategoryDataMapping },
 }
 
 export interface AaveV3PositionData extends AavePositionData {
@@ -206,3 +223,89 @@ export interface AaveHelperCommon {
   selectedMarket: Partial<AaveMarketInfo>,
   network?: NetworkNumber,
 }
+
+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;
+}
+
+/** stkAAVE, stkGHO and sGHO of an address, from getStakeAaveData. */
+export interface StakeAaveData {
+  activatedCooldown: string,
+  activatedCooldownAmount: string,
+  stkAaveRewardsBalance: string,
+  aaveRewardsBalance: string,
+  stkAaveBalance: string,
+  stkGhoBalance: string,
+  ghoMeritApy: string,
+  stkAaveApy: string,
+  sgho: SghoData,
+}
+
+export interface UmbrellaTokenInfo {
+  token: EthAddress,
+  /** USD, converted from the oracle's 8 decimals. */
+  price: string,
+  name: string,
+  symbol: string,
+  decimals: number,
+}
+
+export interface UmbrellaRewardTokenData {
+  rewardTokenData: UmbrellaTokenInfo,
+  maxEmissionPerSecond: bigint,
+  distributionEnd: bigint,
+}
+
+export interface UmbrellaStakingAccountData {
+  stakeUserBalance: string,
+  rewardsTokenUserData: { reward: EthAddress, currentReward: string }[],
+  userCooldownAmount: string,
+  // Passed through unconverted: the view's bigint, or '0' when the view returns none.
+  userEndOfCooldown: bigint | string,
+  userWithdrawalWindow: bigint | string,
+}
+
+/**
+ * One Umbrella stake token of an address, from getUmbrellaData: the view contracts' structs merged, with the amounts
+ * the app reads converted to decimal strings. The bigint fields are the views' raw values, as the SDK passes them.
+ */
+export interface UmbrellaStakingTokenData {
+  stakeTokenData: UmbrellaTokenInfo,
+  totalAssets: string,
+  targetLiquidity: string,
+  isStakeConfigured: boolean,
+  rewardsTokenData: UmbrellaRewardTokenData[],
+  stakeToken: EthAddress,
+  stakeUserBalance: bigint,
+  rewardsTokenUserData: { reward: EthAddress, currentReward: bigint }[],
+  stkToken: EthAddress,
+  totalShares: string,
+  stkUnderlyingToken: EthAddress,
+  aToken: EthAddress,
+  cooldownPeriod: bigint,
+  unstakeWindow: bigint,
+  stkTokenToWaTokenRate: string,
+  waTokenToATokenRate: string,
+  rewardsEmissionRates: string[],
+  userCooldownAmount: bigint,
+  userEndOfCooldown: bigint,
+  userWithdrawalWindow: bigint,
+  account: UmbrellaStakingAccountData,
+}
+
+/** Keyed by Umbrella stake (UmbrellaGHO, UmbrellaUSDC, UmbrellaUSDT, UmbrellaETH). */
+export type UmbrellaStakingData = Record<string, UmbrellaStakingTokenData>;

package/src/types/aaveV4.ts

@@ -207,3 +207,52 @@ export interface AaveV4AccountData extends AaveV4AggregatedPositionData {
   healthFactor: string,
   riskPremiumBps: number,
 }
+
+/** One Aave V4 tokenized spoke (Lend vault) as the view contract returns it for a user. */
+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;
+}
+
+/** 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;
+}

package/src/types/common.ts

@@ -26,7 +26,6 @@ export enum LeverageType {
   Short = 'short',
   VolatilePair = 'volatile-pair',
   VolatilePairReverse = 'volatile-pair-reverse',
-  StablePair = 'stable-pair',
   None = '',
 }
 

package/src/types/compound.ts

@@ -70,6 +70,8 @@ export interface CompoundAssetData extends MMAssetData {
 }
 
 export interface CompoundV2AssetData extends CompoundAssetData {
+  // Set by _getCompoundV2MarketsData. Optional, so objects built by hand still type-check.
+  exchangeRate?: string,
 }
 export interface CompoundV3AssetData extends CompoundAssetData {
   borrowCollateralFactor: string,
@@ -81,6 +83,20 @@ export interface CompoundV3AssetData extends CompoundAssetData {
   supplyCap: string,
   priceInBaseAsset: string,
   canBeWithdrawn: boolean,
+  // The rest are set by formatMarketData and formatBaseData, which also spread in the view contract's raw asset
+  // data. Optional, so objects built by hand still type-check.
+  tokenAddr?: EthAddress,
+  // The base asset's only.
+  isBase?: boolean,
+  baseBorrowMin?: string,
+  baseTrackingBorrowRewardsSpeed?: string,
+  baseTrackingSupplyRewardsSpeed?: string,
+  borrowIndex?: string,
+  supplyIndex?: string,
+  trackingBorrowIndex?: string,
+  trackingSupplyIndex?: string,
+  rewardSupplySpeed?: string,
+  rewardBorrowSpeed?: string,
 }
 
 export interface CompoundAssetsData<T> {
@@ -143,10 +159,30 @@ export interface CompoundPositionData extends MMPositionData {
   automationResubscribeRequired?: boolean,
 }
 
-export interface CompoundV2PositionData extends CompoundPositionData {
+/**
+ * Fields getCompoundV2AggregatedData adds to every Compound V2 position at runtime — a subset of
+ * CompoundAggregatedPositionData. Optional, so code that builds a position by hand keeps compiling.
+ */
+export type CompoundV2PositionAggregatedFields = Partial<Pick<CompoundAggregatedPositionData,
+| 'suppliedCollateralUsd' | 'liquidationLimitUsd' | 'leftToBorrowUsd' | 'collRatio' | 'leveragedType'
+| 'leveragedAsset' | 'liquidationPrice'>>;
+
+/**
+ * Fields getCompoundV3AggregatedData adds to every Compound V3 position at runtime, on top of those declared in
+ * CompoundPositionData. Optional, so code that builds a position by hand keeps compiling.
+ */
+export type CompoundV3PositionAggregatedFields = Partial<Omit<CompoundAggregatedPositionData,
+| keyof MMPositionData | 'ratio' | 'minRatio' | 'suppliedUsd' | 'borrowedUsd' | 'borrowLimitUsd' | 'incentiveUsd'
+| 'totalInterestUsd'>>;
+
+export interface CompoundV2PositionData extends CompoundPositionData, CompoundV2PositionAggregatedFields {
   usedAssets: CompoundV2UsedAssets,
+  // Always false: _getCompoundV2AccountData starts from EMPTY_COMPOUND_DATA, which carries it.
+  borrowStableSupplyUnstable?: boolean,
 }
 
-export interface CompoundV3PositionData extends CompoundPositionData {
+export interface CompoundV3PositionData extends CompoundPositionData, CompoundV3PositionAggregatedFields {
   usedAssets: CompoundV3UsedAssets,
+  // Whether the user's smart wallet is allowed to manage the account on Comet (Comet.isAllowed).
+  isAllowed?: boolean,
 }