@exponent-labs/exponent-sdk 0.1.8 → 0.9.0

package/src/exponentVaults/aumCalculator.ts

@@ -0,0 +1,1013 @@
+import { MintLayout } from "@solana/spl-token"
+import { Connection, PublicKey } from "@solana/web3.js"
+import BN from "bn.js"
+import Decimal from "decimal.js"
+
+import { ExponentFetcher } from "@exponent-labs/exponent-fetcher"
+import { ExponentPDA } from "@exponent-labs/exponent-pda"
+import type {
+  ExponentPrice,
+  ExponentPrices,
+  ExponentVault as ExponentVaultAccountType,
+  PriceId,
+  StrategyPosition,
+} from "@exponent-labs/exponent-vaults-fetcher"
+import { Fraction, Obligation, Reserve } from "@exponent-labs/kamino-reserve-deserializer"
+import { Loan as LoopscaleLoan, Strategy as LoopscaleStrategy } from "@exponent-labs/loopscale-deserializer"
+
+import { Environment, LOCAL_ENV } from "../environment"
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export enum PositionType {
+  Reserves = "reserves",
+  TokenAccount = "tokenAccount",
+  Orderbook = "orderbook",
+  YieldPosition = "yieldPosition",
+  KaminoObligation = "kaminoObligation",
+  ClmmPosition = "clmmPosition",
+  LoopscaleLoan = "loopscaleLoan",
+  LoopscaleStrategy = "loopscaleStrategy",
+}
+
+export type AumResult = {
+  positionType: PositionType
+  mint: string
+  aum: bigint
+  /** Exists only for PositionType.KaminoObligation  */
+  kaminoObligationExposure?: Array<{
+    mint: string
+    amount: bigint // negative for borrowed, positive for supplied; value is in raw base units like `aum`
+  }>
+  /** Exists only for PositionType.LoopscaleLoan */
+  loopscaleLoanExposure?: Array<{
+    mint: string
+    amount: bigint // negative for debt, positive for collateral; value is in raw base units like `aum`
+  }>
+}
+
+type TokenAccountEntryTyped = {
+  tokenMint: PublicKey
+  balances: Array<{ tokenAccount: PublicKey; priceId: PriceId }>
+}
+
+type OrderbookEntryTyped = {
+  orderbook: PublicKey
+  mint: PublicKey
+  offerIdxVec: number[]
+  priceIdPt: PriceId
+  baseMint: PublicKey
+}
+
+type YieldPositionEntryTyped = {
+  yieldPosition: PublicKey
+  vault: PublicKey
+  priceIdPt: PriceId
+}
+
+type ObligationEntryTyped = {
+  obligation: PublicKey
+  lendingProgramId: PublicKey
+  quotePriceId: PriceId
+  reservePriceMappings: Array<{ reserve: PublicKey; reservePriceId: PriceId }>
+  remainingAccountsAmount: bigint
+  minPriceStatusFlags: number
+}
+
+type ClmmPositionEntryTyped = {
+  lpPosition: PublicKey
+  market: PublicKey
+  priceIdPt: PriceId
+  priceIdSy: PriceId
+}
+
+type LoopscaleLoanEntryTyped = {
+  loan: PublicKey
+}
+
+type LoopscaleStrategyEntryTyped = {
+  strategy: PublicKey
+}
+
+type TokenEntryTyped = {
+  mint: PublicKey
+  priceId: PriceId
+  tokenSquadsAccount: PublicKey
+  tokenAccountVault: PublicKey
+}
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+const PRECISE_NUMBER_DECIMALS = 12
+const PRECISE_NUMBER_SCALE = new Decimal(10).pow(PRECISE_NUMBER_DECIMALS)
+
+// ============================================================================
+// AumCalculator
+// ============================================================================
+
+export class AumCalculator {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private clmmMarketCache = new Map<string, Promise<any>>()
+  private mintDecimalsCache = new Map<string, Promise<number>>()
+
+  constructor(
+    private state: ExponentVaultAccountType,
+    private connection: Connection,
+    private env: Environment = LOCAL_ENV,
+  ) {}
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private async loadClmmMarket(market: PublicKey): Promise<any> {
+    const key = market.toBase58()
+    let cached = this.clmmMarketCache.get(key)
+    if (!cached) {
+      cached = (async () => {
+        const { MarketThree } = await import("../marketThree")
+        return MarketThree.load(this.env, this.connection, market)
+      })()
+      this.clmmMarketCache.set(key, cached)
+    }
+    return cached
+  }
+
+  /**
+   * Total AUM: on-chain tracked base value + value held in strategy positions.
+   */
+  getTotalAum(): bigint {
+    return (
+      BigInt(this.state.financials.aumInBase.toString()) + BigInt(this.state.financials.aumInBaseInPositions.toString())
+    )
+  }
+
+  // ==========================================================================
+  // Price resolution
+  // ==========================================================================
+
+  static priceEntryToDecimal(entry: ExponentPrice): Decimal {
+    const [n0, n1, n2, n3] = entry.price[0]
+    const raw =
+      BigInt(n0.toString()) +
+      (BigInt(n1.toString()) << BigInt(64)) +
+      (BigInt(n2.toString()) << BigInt(128)) +
+      (BigInt(n3.toString()) << BigInt(192))
+    return new Decimal(raw.toString()).div(PRECISE_NUMBER_SCALE)
+  }
+
+  static resolvePrice(priceId: PriceId, prices: ExponentPrices): Decimal {
+    const getPrice = (id: bigint): Decimal => {
+      const entry = prices.prices[Number(id)]
+      if (!entry) {
+        throw new Error(`Price not found for id ${id}`)
+      }
+      return AumCalculator.priceEntryToDecimal(entry)
+    }
+
+    if ("simple" in priceId) {
+      return getPrice(priceId.simple.priceId)
+    }
+    if ("multiply" in priceId) {
+      const ids = priceId.multiply.priceIds
+      if (ids.length === 0) {
+        throw new Error("Multiply priceIds cannot be empty")
+      }
+      let acc = getPrice(ids[0])
+      for (const id of ids.slice(1)) {
+        acc = acc.mul(getPrice(id))
+      }
+      return acc
+    }
+    throw new Error("Unknown PriceId variant")
+  }
+
+  static getPriceIds(priceId: PriceId): bigint[] {
+    if ("simple" in priceId) {
+      return [priceId.simple.priceId]
+    }
+    if ("multiply" in priceId) {
+      const ids = priceId.multiply.priceIds
+      if (ids.length === 0) {
+        throw new Error("Multiply priceIds cannot be empty")
+      }
+      return ids
+    }
+    throw new Error("Unknown PriceId variant")
+  }
+
+  static projectYieldPositionClaimableInterestAfterFee(
+    yieldPosition: { ytBalance: bigint; interest: { staged: bigint; lastSeenIndex: number } },
+    coreVault: { finalSyExchangeRate: number; lastSeenSyExchangeRate: number; interestBpsFee: number },
+  ): bigint {
+    const projectedUnstagedInterest = AumCalculator.scaleSyToCurrentRate(
+      AumCalculator.calcEarnedSy(
+        yieldPosition.ytBalance,
+        yieldPosition.interest.lastSeenIndex,
+        coreVault.finalSyExchangeRate,
+      ),
+      coreVault.finalSyExchangeRate,
+      coreVault.lastSeenSyExchangeRate,
+    )
+    const grossClaimableInterest = yieldPosition.interest.staged + projectedUnstagedInterest
+    const treasuryAmount = (grossClaimableInterest * BigInt(coreVault.interestBpsFee) + BigInt(9_999)) / BigInt(10_000)
+    return grossClaimableInterest - treasuryAmount
+  }
+
+  static calcEarnedSy(ytBalance: bigint, lastSeenRate: number, currentRate: number): bigint {
+    if (ytBalance === BigInt(0) || lastSeenRate >= currentRate || lastSeenRate === 0) {
+      return BigInt(0)
+    }
+
+    const delta = new Decimal(1).div(lastSeenRate).sub(new Decimal(1).div(currentRate))
+    return BigInt(delta.mul(ytBalance.toString()).floor().toString())
+  }
+
+  static scaleSyToCurrentRate(syAmount: bigint, finalRate: number, currentRate: number): bigint {
+    if (syAmount === BigInt(0) || currentRate <= finalRate) {
+      return syAmount
+    }
+
+    return BigInt(new Decimal(syAmount.toString()).mul(finalRate).div(currentRate).floor().toString())
+  }
+
+  private async loadMintDecimals(mint: PublicKey): Promise<number> {
+    const key = mint.toBase58()
+    let cached = this.mintDecimalsCache.get(key)
+    if (!cached) {
+      cached = (async () => {
+        const mintInfo = await this.connection.getAccountInfo(mint)
+        if (!mintInfo?.data) {
+          throw new Error(`Mint not found: ${mint.toBase58()}`)
+        }
+        return MintLayout.decode(Buffer.from(mintInfo.data)).decimals
+      })()
+      this.mintDecimalsCache.set(key, cached)
+    }
+    return cached
+  }
+
+  private getPriceInputMint(priceId: PriceId, prices: ExponentPrices): PublicKey {
+    const ids = AumCalculator.getPriceIds(priceId)
+    const lastEntry = prices.prices[Number(ids[ids.length - 1])]
+    if (!lastEntry) {
+      throw new Error(`Price not found for id ${ids[ids.length - 1]}`)
+    }
+    return lastEntry.priceMint
+  }
+
+  private async resolveInputAmountScale(priceId: PriceId, prices: ExponentPrices): Promise<Decimal> {
+    const inputMint = this.getPriceInputMint(priceId, prices)
+    const inputDecimals = await this.loadMintDecimals(inputMint)
+    return new Decimal(10).pow(inputDecimals)
+  }
+
+  // ==========================================================================
+  // Token account balance parsing
+  // ==========================================================================
+
+  /** Read SPL token amount from account data (offset 64 = after mint(32) + owner(32)) */
+  static parseTokenAccountAmount(data: Buffer | Uint8Array): bigint {
+    const u8 = data instanceof Uint8Array ? data : new Uint8Array(data)
+    if (u8.byteLength < 72) {
+      throw new Error("SPL token account data too short")
+    }
+    return new DataView(u8.buffer, u8.byteOffset, u8.byteLength).getBigUint64(64, true)
+  }
+
+  // ==========================================================================
+  // AUM calculation per position type
+  // ==========================================================================
+
+  /**
+   * TokenAccount position AUM.
+   * Fetches each token account balance and multiplies by resolved price.
+   */
+  async calculateTokenAccountAum(entry: TokenAccountEntryTyped, prices: ExponentPrices): Promise<AumResult[]> {
+    const results: AumResult[] = []
+
+    if (entry.balances.length === 0) {
+      return results
+    }
+
+    const accountKeys = entry.balances.map((b) => b.tokenAccount)
+    const accountInfos = await this.connection.getMultipleAccountsInfo(accountKeys)
+
+    let totalAum = BigInt(0)
+    for (let i = 0; i < entry.balances.length; i++) {
+      const balance = entry.balances[i]
+      const info = accountInfos[i]
+      if (!info?.data) {
+        continue
+      }
+
+      try {
+        const tokenAmount = AumCalculator.parseTokenAccountAmount(Buffer.from(info.data))
+        const price = AumCalculator.resolvePrice(balance.priceId, prices)
+        const valueInBase = new Decimal(tokenAmount.toString()).mul(price)
+        totalAum += BigInt(valueInBase.floor().toString())
+      } catch {
+        // Skip if price resolution fails
+      }
+    }
+
+    results.push({ positionType: PositionType.TokenAccount, mint: entry.tokenMint.toBase58(), aum: totalAum })
+    return results
+  }
+
+  /**
+   * Orderbook position AUM.
+   * Reads SY exchange rate from raw bytes, iterates tracked offers,
+   * and calculates SY value per offer following the Rust logic.
+   */
+  async calculateOrderbookAum(entry: OrderbookEntryTyped, prices: ExponentPrices): Promise<AumResult[]> {
+    try {
+      const fetcher = new ExponentFetcher({ connection: this.connection })
+      const orderbook = await fetcher.fetchOrderbook(entry.orderbook)
+
+      const syPrice = new Decimal(orderbook.lastSyExchangeRate.toString()).div(PRECISE_NUMBER_SCALE)
+      const ptPrice = AumCalculator.resolvePrice(entry.priceIdPt, prices)
+      const ytPrice = Decimal.max(new Decimal(1).sub(ptPrice), new Decimal(0))
+      const mintPt = new ExponentPDA().mintPt({ vault: orderbook.vault }).toBase58()
+      const mintYt = new ExponentPDA().mintYt({ vault: orderbook.vault }).toBase58()
+
+      // Find vault's user escrow indices by matching squadsVault address
+      const vaultEscrowIndices = new Set<number>()
+      for (let i = 0; i < orderbook.userEscrows.length; i++) {
+        if (orderbook.userEscrows[i].user.equals(this.state.squadsVault)) {
+          vaultEscrowIndices.add(i + 1)
+        }
+      }
+
+      const aumByMint = new Map<string, Decimal>()
+
+      for (const offerIdx of entry.offerIdxVec) {
+        const offer = orderbook.offers.find((o) => o.offerIndex === offerIdx)
+        if (!offer) {
+          continue
+        }
+        if (!vaultEscrowIndices.has(offer.userVaultPointer)) {
+          continue
+        }
+
+        const offerMint = entry.mint.toBase58()
+
+        const syInOffer = AumCalculator.getSyInOffer(offer, ptPrice, syPrice)
+        const valueInBase = syInOffer.mul(syPrice)
+        aumByMint.set(offerMint, (aumByMint.get(offerMint) ?? new Decimal(0)).add(valueInBase))
+      }
+
+      const userEscrow = orderbook.userEscrows.find((escrow) => escrow.user.equals(this.state.squadsVault))
+      if (userEscrow) {
+        const stagedSy = AumCalculator.projectOrderbookStagedSy(userEscrow, syPrice)
+        AumCalculator.addOrderbookEscrowValue(aumByMint, entry.mint.toBase58(), userEscrow.syAmount + stagedSy, syPrice)
+        AumCalculator.addOrderbookEscrowValue(aumByMint, mintPt, userEscrow.ptAmount, ptPrice)
+        AumCalculator.addOrderbookEscrowValue(aumByMint, mintYt, userEscrow.ytAmount, ytPrice)
+      }
+
+      return Array.from(aumByMint.entries()).map(([mint, aum]) => ({
+        positionType: PositionType.Orderbook,
+        mint,
+        aum: BigInt(aum.floor().toString()),
+      }))
+    } catch (e) {
+      console.warn("Failed to calculate orderbook AUM:", e)
+      return []
+    }
+  }
+
+  private static addOrderbookEscrowValue(
+    aumByMint: Map<string, Decimal>,
+    mint: string,
+    amount: bigint,
+    price: Decimal,
+  ): void {
+    if (amount <= BigInt(0) || price.lte(0)) {
+      return
+    }
+
+    const valueInBase = new Decimal(amount.toString()).mul(price)
+    aumByMint.set(mint, (aumByMint.get(mint) ?? new Decimal(0)).add(valueInBase))
+  }
+
+  private static projectOrderbookStagedSy(
+    userEscrow: {
+      staged: bigint
+      stakedYtAmount: bigint
+      yieldIndex: number
+    },
+    currentSyRate: Decimal,
+  ): bigint {
+    if (userEscrow.staged < BigInt(0)) {
+      return BigInt(0)
+    }
+
+    const lastSeenSyRate = userEscrow.yieldIndex
+    if (lastSeenSyRate <= 0) {
+      return userEscrow.staged
+    }
+
+    const currentSyRateNumber = currentSyRate.toNumber()
+    if (currentSyRateNumber <= lastSeenSyRate) {
+      return userEscrow.staged
+    }
+
+    const rateDelta = 1 / lastSeenSyRate - 1 / currentSyRateNumber
+    const interestEarned = Math.floor(rateDelta * Number(userEscrow.stakedYtAmount))
+    return userEscrow.staged + BigInt(Math.max(interestEarned, 0))
+  }
+
+  /**
+   * Calculate the SY-equivalent amount in an offer.
+   * Mirrors Rust get_sy_in_offer() logic.
+   */
+  static getSyInOffer(
+    offer: { amount: bigint; virtualOffer: boolean; orderTypeFlag: number },
+    ptPrice: Decimal,
+    syExchangeRate: Decimal,
+  ): Decimal {
+    const amount = new Decimal(offer.amount.toString())
+    const isBuyYt = offer.orderTypeFlag === 2
+
+    if (offer.virtualOffer) {
+      if (isBuyYt) {
+        // PT in offer -> convert to SY
+        return amount.mul(ptPrice).div(syExchangeRate)
+      } else {
+        // SY in offer directly
+        return amount
+      }
+    } else {
+      if (isBuyYt) {
+        // SY in offer directly
+        return amount
+      } else {
+        // YT in offer -> convert to SY
+        const ytToSyRate = new Decimal(1).sub(ptPrice).div(syExchangeRate)
+        return amount.mul(ytToSyRate)
+      }
+    }
+  }
+
+  /**
+   * YieldPosition AUM (Exponent core YT).
+   * YT value = yt_balance * (1 - pt_price)
+   */
+  async calculateYieldPositionAum(entry: YieldPositionEntryTyped, prices: ExponentPrices): Promise<AumResult> {
+    const ytMint = new ExponentPDA().mintYt({ vault: entry.vault }).toBase58()
+
+    try {
+      const fetcher = new ExponentFetcher({ connection: this.connection })
+      const [yieldPosition, coreVault] = await Promise.all([
+        fetcher.fetchYtPosition(entry.yieldPosition),
+        fetcher.fetchVault(entry.vault),
+      ])
+
+      if (!yieldPosition) {
+        return { positionType: PositionType.YieldPosition, mint: ytMint, aum: BigInt(0) }
+      }
+
+      const ptPrice = AumCalculator.resolvePrice(entry.priceIdPt, prices)
+      const ytValueFactor = new Decimal(1).sub(ptPrice)
+      let valueInBase = new Decimal(0)
+
+      if (ytValueFactor.gt(0)) {
+        valueInBase = valueInBase.add(new Decimal(yieldPosition.ytBalance.toString()).mul(ytValueFactor))
+      }
+
+      if (yieldPosition.ytBalance > BigInt(0) || yieldPosition.interest.staged > BigInt(0)) {
+        const netClaimableInterest = AumCalculator.projectYieldPositionClaimableInterestAfterFee(
+          yieldPosition,
+          coreVault,
+        )
+        valueInBase = valueInBase.add(
+          new Decimal(netClaimableInterest.toString()).mul(new Decimal(coreVault.lastSeenSyExchangeRate.toString())),
+        )
+      }
+
+      return { positionType: PositionType.YieldPosition, mint: ytMint, aum: BigInt(valueInBase.floor().toString()) }
+    } catch (e) {
+      console.warn("Failed to calculate yield position AUM:", e)
+      return { positionType: PositionType.YieldPosition, mint: ytMint, aum: BigInt(0) }
+    }
+  }
+
+  /**
+   * Kamino obligation position AUM.
+   * AUM = sum(collateral market values in base) - sum(debt market values in base).
+   *
+   * In practice, obligation marketValueSf values are stale for our use case, so
+   * we derive each side directly from the current Kamino Reserve accounts.
+   */
+  async calculateObligationAum(entry: ObligationEntryTyped, prices: ExponentPrices): Promise<AumResult> {
+    try {
+      const obligation = await Obligation.fetch(this.connection, entry.obligation, entry.lendingProgramId)
+      if (!obligation) {
+        return {
+          positionType: PositionType.KaminoObligation,
+          mint: this.state.underlyingMint.toBase58(),
+          aum: BigInt(0),
+        }
+      }
+
+      const defaultKey = PublicKey.default
+
+      // Filter active deposits (collateral)
+      const collateralValues = obligation.deposits
+        .filter((d) => !d.depositReserve.equals(defaultKey) && !d.depositedAmount.isZero())
+        .map((d) => ({
+          reserve: d.depositReserve,
+          rawAmount: d.depositedAmount,
+          isDeposit: true as const,
+        }))
+
+      // Filter active borrows (debt)
+      const debtValues = obligation.borrows
+        .filter((b) => !b.borrowReserve.equals(defaultKey) && !b.borrowedAmountSf.isZero())
+        .map((b) => ({
+          reserve: b.borrowReserve,
+          rawAmount: b.borrowedAmountSf,
+          isDeposit: false as const,
+        }))
+
+      const allValues = [...collateralValues, ...debtValues]
+      let reserveMap: Map<string, Reserve> | undefined
+      if (allValues.length > 0) {
+        const uniqueReserves = Array.from(new Set(allValues.map((v) => v.reserve.toBase58())))
+        const reserveKeys = uniqueReserves.map((k) => new PublicKey(k))
+        const reserves = await Reserve.fetchMultiple(this.connection, reserveKeys, entry.lendingProgramId)
+        reserveMap = new Map()
+        for (let i = 0; i < reserveKeys.length; i++) {
+          if (reserves[i]) {
+            reserveMap.set(reserveKeys[i].toBase58(), reserves[i]!)
+          }
+        }
+      }
+
+      const kaminoObligationExposure = await this.buildKaminoObligationExposure(
+        obligation.deposits,
+        obligation.borrows,
+        entry,
+        prices,
+        reserveMap,
+      )
+      const collateralBase = await this.calculateSideInBase(collateralValues, entry, prices, reserveMap)
+      const debtBase = await this.calculateSideInBase(debtValues, entry, prices, reserveMap)
+
+      const aumDecimal = Decimal.max(collateralBase.sub(debtBase), new Decimal(0))
+
+      return {
+        positionType: PositionType.KaminoObligation,
+        mint: this.state.underlyingMint.toBase58(),
+        aum: BigInt(aumDecimal.floor().toString()),
+        kaminoObligationExposure,
+      }
+    } catch (e) {
+      console.warn("Failed to calculate obligation AUM:", e)
+      return {
+        positionType: PositionType.KaminoObligation,
+        mint: this.state.underlyingMint.toBase58(),
+        aum: BigInt(0),
+      }
+    }
+  }
+
+  private async buildKaminoObligationExposure(
+    deposits: Obligation["deposits"],
+    borrows: Obligation["borrows"],
+    entry: ObligationEntryTyped,
+    prices: ExponentPrices,
+    reserveMap?: Map<string, Reserve>,
+  ): Promise<Array<{ mint: string; amount: bigint }>> {
+    const exposureByMint = new Map<string, bigint>()
+    const defaultKey = PublicKey.default
+    const quotePrice = AumCalculator.resolvePrice(entry.quotePriceId, prices)
+    const quoteInputMint = this.getPriceInputMint(entry.quotePriceId, prices)
+
+    for (const deposit of deposits) {
+      if (deposit.depositReserve.equals(defaultKey) || deposit.depositedAmount.isZero()) {
+        continue
+      }
+
+      const reserve = reserveMap?.get(deposit.depositReserve.toBase58())
+      if (!reserve) {
+        continue
+      }
+      const mapping = entry.reservePriceMappings.find((candidate) => candidate.reserve.equals(deposit.depositReserve))
+      if (!mapping) {
+        continue
+      }
+
+      const mint = reserve.liquidity.mintPubkey.toBase58()
+      const amount = BigInt(
+        this.calculateReserveAmountInBase(
+          reserve,
+          deposit.depositedAmount,
+          true,
+          mapping,
+          prices,
+          quotePrice,
+          quoteInputMint,
+        )
+          .floor()
+          .toString(),
+      )
+      exposureByMint.set(mint, (exposureByMint.get(mint) ?? BigInt(0)) + amount)
+    }
+
+    for (const borrow of borrows) {
+      if (borrow.borrowReserve.equals(defaultKey) || borrow.borrowedAmountSf.isZero()) {
+        continue
+      }
+
+      const reserve = reserveMap?.get(borrow.borrowReserve.toBase58())
+      if (!reserve) {
+        continue
+      }
+      const mapping = entry.reservePriceMappings.find((candidate) => candidate.reserve.equals(borrow.borrowReserve))
+      if (!mapping) {
+        continue
+      }
+
+      const mint = reserve.liquidity.mintPubkey.toBase58()
+      const amount = BigInt(
+        this.calculateReserveAmountInBase(
+          reserve,
+          borrow.borrowedAmountSf,
+          false,
+          mapping,
+          prices,
+          quotePrice,
+          quoteInputMint,
+        )
+          .floor()
+          .toString(),
+      )
+      exposureByMint.set(mint, (exposureByMint.get(mint) ?? BigInt(0)) - amount)
+    }
+
+    return Array.from(exposureByMint.entries()).map(([mint, amount]) => ({ mint, amount }))
+  }
+
+  /**
+   * CLMM position AUM.
+   * Uses MarketThree.getPtAndSyOnWithdrawLiquidity to keep parity with
+   * existing frontend CLMM valuation logic, plus uncollected fees.
+   */
+  async calculateClmmPositionAum(entry: ClmmPositionEntryTyped, prices: ExponentPrices): Promise<AumResult> {
+    const zeroResult: AumResult = {
+      positionType: PositionType.ClmmPosition,
+      mint: this.state.underlyingMint.toBase58(),
+      aum: BigInt(0),
+    }
+
+    try {
+      const fetcher = new ExponentFetcher({ connection: this.connection })
+
+      const [lpPosition, marketThree] = await Promise.all([
+        fetcher.fetchLpPositionCLMM(entry.lpPosition),
+        this.loadClmmMarket(entry.market),
+      ])
+
+      if (!lpPosition.market.equals(entry.market)) {
+        return zeroResult
+      }
+
+      if (lpPosition.lpBalance === BigInt(0)) {
+        return zeroResult
+      }
+
+      const { totalPtOut, totalSyOut } = marketThree.getPtAndSyOnWithdrawLiquidity(lpPosition)
+
+      // Add uncollected fees
+      const finalPt = totalPtOut + lpPosition.tokensOwedPt
+      const finalSy = totalSyOut + lpPosition.tokensOwedSy
+
+      const ptPrice = AumCalculator.resolvePrice(entry.priceIdPt, prices)
+      const syPrice = AumCalculator.resolvePrice(entry.priceIdSy, prices)
+
+      const ptValue = new Decimal(finalPt.toString()).mul(ptPrice)
+      const syValue = new Decimal(finalSy.toString()).mul(syPrice)
+      const totalValue = ptValue.add(syValue)
+
+      return {
+        positionType: PositionType.ClmmPosition,
+        mint: this.state.underlyingMint.toBase58(),
+        aum: BigInt(totalValue.floor().toString()),
+      }
+    } catch (e) {
+      console.warn("Failed to calculate CLMM position AUM:", e)
+      return zeroResult
+    }
+  }
+
+  /**
+   * Calculate one side (collateral or debt) of a Kamino obligation in base units.
+   * For SDK-side valuation we derive the current reserve value directly from
+   * Kamino Reserve accounts and convert the resulting human base amount into raw
+   * base units at the end.
+   */
+  private async calculateSideInBase(
+    reserveValues: Array<{ reserve: PublicKey; rawAmount: BN; isDeposit: boolean }>,
+    entry: ObligationEntryTyped,
+    prices: ExponentPrices,
+    reserveMap?: Map<string, Reserve>,
+  ): Promise<Decimal> {
+    if (reserveValues.length === 0) {
+      return new Decimal(0)
+    }
+
+    const quotePrice = AumCalculator.resolvePrice(entry.quotePriceId, prices)
+    const quoteInputMint = this.getPriceInputMint(entry.quotePriceId, prices)
+
+    let aggregateBaseValue = new Decimal(0)
+    for (const rv of reserveValues) {
+      const mapping = entry.reservePriceMappings.find((candidate) => candidate.reserve.equals(rv.reserve))
+      if (!mapping) {
+        throw new Error(`Missing Kamino reserve mapping for ${rv.reserve.toBase58()}`)
+      }
+
+      const reserve = reserveMap?.get(rv.reserve.toBase58())
+      if (!reserve) {
+        throw new Error(`Reserve not found for ${rv.reserve.toBase58()}, cannot compute market value`)
+      }
+
+      aggregateBaseValue = aggregateBaseValue.add(
+        this.calculateReserveAmountInBase(
+          reserve,
+          rv.rawAmount,
+          rv.isDeposit,
+          mapping,
+          prices,
+          quotePrice,
+          quoteInputMint,
+        ),
+      )
+    }
+
+    return aggregateBaseValue
+  }
+
+  private calculateReserveAmountInBase(
+    reserve: Reserve,
+    rawAmount: BN,
+    isDeposit: boolean,
+    mapping: { reservePriceId: PriceId },
+    prices: ExponentPrices,
+    quotePrice: Decimal,
+    quoteInputMint: PublicKey,
+  ): Decimal {
+    let liquidityAmountRaw: Decimal
+    if (isDeposit) {
+      // cTokens -> liquidity token raw amount via collateral exchange rate
+      liquidityAmountRaw = new Decimal(rawAmount.toString()).mul(reserve.getCollateralExchangeRate())
+    } else {
+      // borrowedAmountSf decodes into liquidity token raw amount
+      liquidityAmountRaw = new Fraction(rawAmount).toDecimal()
+    }
+
+    if (reserve.liquidity.mintPubkey.equals(quoteInputMint)) {
+      return liquidityAmountRaw.mul(quotePrice)
+    }
+
+    const reservePriceId = mapping.reservePriceId
+    if (!reservePriceId || ("simple" in reservePriceId && reservePriceId.simple.priceId === 0n)) {
+      // Passthrough — no price conversion, treat as 1:1
+      return liquidityAmountRaw.mul(quotePrice)
+    }
+
+    return liquidityAmountRaw.mul(AumCalculator.resolvePrice(reservePriceId, prices)).mul(quotePrice)
+  }
+
+  /**
+   * Loopscale Loan AUM (BORROWER side).
+   * AUM = sum(collateral_value) - sum(outstanding_debt).
+   */
+  async calculateLoopscaleLoanAum(entry: LoopscaleLoanEntryTyped, prices: ExponentPrices): Promise<AumResult> {
+    const mint = this.state.underlyingMint.toBase58()
+
+    try {
+      const loan = await LoopscaleLoan.fetch(this.connection, entry.loan)
+      if (!loan) {
+        return { positionType: PositionType.LoopscaleLoan, mint, aum: BigInt(0) }
+      }
+
+      const tokenEntries = this.state.tokenEntries as unknown as TokenEntryTyped[]
+      const mintPriceMap = new Map<string, PriceId>()
+      for (const te of tokenEntries) {
+        mintPriceMap.set(te.mint.toBase58(), te.priceId)
+      }
+
+      const exposureByMint = new Map<string, bigint>()
+
+      let collateralValue = new Decimal(0)
+      for (const collateral of loan.collateral) {
+        const assetMint = collateral.assetMint.toBase58()
+        const amount = BigInt(collateral.amount.toString())
+        if (collateral.assetMint.equals(PublicKey.default) || amount === BigInt(0)) {
+          continue
+        }
+        const priceId = mintPriceMap.get(assetMint)
+        if (!priceId) {
+          continue
+        }
+        const price = AumCalculator.resolvePrice(priceId, prices)
+        const valueInBase = BigInt(new Decimal(amount.toString()).mul(price).floor().toString())
+        collateralValue = collateralValue.add(new Decimal(amount.toString()).mul(price))
+        exposureByMint.set(assetMint, (exposureByMint.get(assetMint) ?? BigInt(0)) + valueInBase)
+      }
+
+      let debtValue = new Decimal(0)
+      for (const ledger of loan.ledgers) {
+        const principalDue = BigInt(ledger.principalDue.toString())
+        const principalRepaid = BigInt(ledger.principalRepaid.toString())
+        const interestOutstanding = BigInt(ledger.interestOutstanding.toString())
+        const outstanding = principalDue - principalRepaid + interestOutstanding
+        if (outstanding <= BigInt(0)) {
+          continue
+        }
+        const ledgerMint = ledger.principalMint.toBase58()
+        const priceId = mintPriceMap.get(ledgerMint)
+        if (!priceId) {
+          continue
+        }
+        const price = AumCalculator.resolvePrice(priceId, prices)
+        const valueInBase = BigInt(new Decimal(outstanding.toString()).mul(price).floor().toString())
+        debtValue = debtValue.add(new Decimal(outstanding.toString()).mul(price))
+        exposureByMint.set(ledgerMint, (exposureByMint.get(ledgerMint) ?? BigInt(0)) - valueInBase)
+      }
+
+      const loopscaleLoanExposure = Array.from(exposureByMint.entries()).map(([m, amount]) => ({ mint: m, amount }))
+      const aum = Decimal.max(collateralValue.sub(debtValue), new Decimal(0))
+      return {
+        positionType: PositionType.LoopscaleLoan,
+        mint,
+        aum: BigInt(aum.floor().toString()),
+        loopscaleLoanExposure,
+      }
+    } catch (e) {
+      console.warn("Failed to calculate Loopscale loan AUM:", e)
+      return { positionType: PositionType.LoopscaleLoan, mint, aum: BigInt(0) }
+    }
+  }
+
+  /**
+   * Loopscale Strategy AUM (LENDER side).
+   * AUM = (tokenBalance + currentDeployedAmount + outstandingInterestAmount) × price.
+   */
+  async calculateLoopscaleStrategyAum(entry: LoopscaleStrategyEntryTyped, prices: ExponentPrices): Promise<AumResult> {
+    const underlyingMint = this.state.underlyingMint.toBase58()
+
+    try {
+      const strategy = await LoopscaleStrategy.fetch(this.connection, entry.strategy)
+      if (!strategy) {
+        return { positionType: PositionType.LoopscaleStrategy, mint: underlyingMint, aum: BigInt(0) }
+      }
+
+      const principalMint = strategy.principalMint.toBase58()
+
+      const tokenBalance = BigInt(strategy.tokenBalance.toString())
+      const currentDeployedAmount = BigInt(strategy.currentDeployedAmount.toString())
+      const outstandingInterestAmount = BigInt(strategy.outstandingInterestAmount.toString())
+      const totalValue = tokenBalance + currentDeployedAmount + outstandingInterestAmount
+
+      if (totalValue === BigInt(0)) {
+        return { positionType: PositionType.LoopscaleStrategy, mint: principalMint, aum: BigInt(0) }
+      }
+
+      const tokenEntries = this.state.tokenEntries as unknown as TokenEntryTyped[]
+      const priceId = tokenEntries.find((te) => te.mint.toBase58() === principalMint)?.priceId
+      if (!priceId) {
+        return { positionType: PositionType.LoopscaleStrategy, mint: principalMint, aum: BigInt(0) }
+      }
+
+      const price = AumCalculator.resolvePrice(priceId, prices)
+      const aum = new Decimal(totalValue.toString()).mul(price)
+      const amount = BigInt(aum.floor().toString())
+      return {
+        positionType: PositionType.LoopscaleStrategy,
+        mint: principalMint,
+        aum: amount,
+        loopscaleLoanExposure: [{ mint: principalMint, amount }],
+      }
+    } catch (e) {
+      console.warn("Failed to calculate Loopscale strategy AUM:", e)
+      return { positionType: PositionType.LoopscaleStrategy, mint: underlyingMint, aum: BigInt(0) }
+    }
+  }
+
+  /**
+   * Reserve tokens AUM (funds in vault token accounts - "Instant Liquidity").
+   */
+  async calculateReserveTokensAum(prices: ExponentPrices): Promise<AumResult[]> {
+    const tokenEntries = this.state.tokenEntries as unknown as TokenEntryTyped[]
+    const results: AumResult[] = []
+
+    const allAccounts = tokenEntries.map((e) => e.tokenSquadsAccount)
+    const accountInfos = await this.connection.getMultipleAccountsInfo(allAccounts)
+
+    for (let i = 0; i < tokenEntries.length; i++) {
+      const entry = tokenEntries[i]
+      const squadsInfo = accountInfos[i * 2]
+      const vaultInfo = accountInfos[i * 2 + 1]
+
+      let balance = BigInt(0)
+      if (squadsInfo?.data) {
+        balance += AumCalculator.parseTokenAccountAmount(Buffer.from(squadsInfo.data))
+      }
+      if (vaultInfo?.data) {
+        balance += AumCalculator.parseTokenAccountAmount(Buffer.from(vaultInfo.data))
+      }
+
+      if (balance === BigInt(0)) {
+        continue
+      }
+
+      try {
+        const price = AumCalculator.resolvePrice(entry.priceId, prices)
+        const valueInBase = new Decimal(balance.toString()).mul(price)
+        results.push({
+          positionType: PositionType.Reserves,
+          mint: entry.mint.toBase58(),
+          aum: BigInt(valueInBase.floor().toString()),
+        })
+      } catch {
+        // Skip if price resolution fails
+      }
+    }
+
+    return results
+  }
+
+  // ==========================================================================
+  // Convenience: calculate all position AUMs
+  // ==========================================================================
+
+  /**
+   * Calculate AUM for a single strategy position.
+   * Returns array of AumResults (may be multiple for tokenAccount positions).
+   */
+  async calculatePositionAum(position: StrategyPosition, prices: ExponentPrices): Promise<AumResult[]> {
+    if ("tokenAccount" in position) {
+      const entry = (position as { tokenAccount: { 0: TokenAccountEntryTyped } }).tokenAccount[0]
+      return this.calculateTokenAccountAum(entry, prices)
+    }
+    if ("orderbook" in position) {
+      const entry = (position as { orderbook: { 0: OrderbookEntryTyped } }).orderbook[0]
+      const result = await this.calculateOrderbookAum(entry, prices)
+      return result
+    }
+    if ("yieldPosition" in position) {
+      const entry = (position as { yieldPosition: { 0: YieldPositionEntryTyped } }).yieldPosition[0]
+      const result = await this.calculateYieldPositionAum(entry, prices)
+      return [result]
+    }
+    if ("obligation" in position) {
+      const inner = (position as { obligation: { 0: Record<string, unknown> } }).obligation[0]
+      if (inner && "kaminoObligation" in inner) {
+        const kaminoVariant = inner.kaminoObligation as unknown
+        const entry = Array.isArray(kaminoVariant)
+          ? (kaminoVariant[0] as ObligationEntryTyped | undefined)
+          : kaminoVariant && typeof kaminoVariant === "object" && "0" in (kaminoVariant as Record<string, unknown>)
+            ? ((kaminoVariant as { 0?: ObligationEntryTyped })[0] ?? undefined)
+            : (kaminoVariant as ObligationEntryTyped | undefined)
+        if (entry) {
+          const result = await this.calculateObligationAum(entry, prices)
+          return [result]
+        }
+      }
+    }
+    if ("clmmPosition" in position) {
+      const entry = (position as { clmmPosition: { 0: ClmmPositionEntryTyped } }).clmmPosition[0]
+      const result = await this.calculateClmmPositionAum(entry, prices)
+      return [result]
+    }
+    if ("loopscaleLoan" in position) {
+      const entry = (position as { loopscaleLoan: { 0: LoopscaleLoanEntryTyped } }).loopscaleLoan[0]
+      const result = await this.calculateLoopscaleLoanAum(entry, prices)
+      return [result]
+    }
+    if ("loopscaleStrategy" in position) {
+      const entry = (position as { loopscaleStrategy: { 0: LoopscaleStrategyEntryTyped } }).loopscaleStrategy[0]
+      const result = await this.calculateLoopscaleStrategyAum(entry, prices)
+      return [result]
+    }
+    return []
+  }
+
+  /**
+   * Calculate AUM for all positions: reserve tokens + strategy positions.
+   */
+  async calculatePositionsAum(prices: ExponentPrices): Promise<AumResult[]> {
+    const [reserveResults, ...positionResults] = await Promise.all([
+      this.calculateReserveTokensAum(prices),
+      ...this.state.strategyPositions.map((position) => this.calculatePositionAum(position, prices)),
+    ])
+    return [reserveResults, ...positionResults].flat()
+  }
+
+  get strategyPositions(): StrategyPosition[] {
+    return this.state.strategyPositions
+  }
+}