@exponent-labs/exponent-sdk 0.9.1 → 0.9.3

package/src/exponentVaults/aumCalculator.ts

@@ -1,1350 +0,0 @@
-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"
-import {
-  KAMINO_FARM_ACCOUNT_DISCRIMINATOR_LEN,
-  KAMINO_FARM_GLOBAL_CONFIG_TREASURY_FEE_BPS_OFFSET,
-  applyKaminoFarmTreasuryFee,
-  calculateKaminoFarmPrincipalAmount,
-  decodeKaminoFarmState,
-  decodeKaminoFarmUserState,
-  decodeKaminoScopeDatedPrice,
-  getKaminoFarmScopePricesAddress,
-  projectKaminoFarmGlobalRewards,
-  projectKaminoFarmUserRewards,
-} from "./kamino-farms"
-import { getKaminoFarmsObligationFarm, KAMINO_FARMS_PROGRAM_ID } from "./../../../kamino-lend-standard/src/constants"
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export enum PositionType {
-  Reserves = "reserves",
-  TokenAccount = "tokenAccount",
-  Orderbook = "orderbook",
-  YieldPosition = "yieldPosition",
-  KaminoObligation = "kaminoObligation",
-  ClmmPosition = "clmmPosition",
-  LoopscaleLoan = "loopscaleLoan",
-  LoopscaleStrategy = "loopscaleStrategy",
-  KaminoFarm = "kaminoFarm",
-}
-
-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 }>
-  reserveFarmMappings: Array<{
-    reserve: PublicKey
-    farmKind: number
-    farmState: PublicKey
-  }>
-  minPriceStatusFlags: number
-}
-
-type ClmmPositionEntryTyped = {
-  lpPosition: PublicKey
-  market: PublicKey
-  priceIdPt: PriceId
-  priceIdSy: PriceId
-}
-
-type LoopscaleLoanEntryTyped = {
-  loan: PublicKey
-}
-
-type LoopscaleStrategyEntryTyped = {
-  strategy: PublicKey
-}
-
-type KaminoFarmEntryTyped = {
-  farmState: PublicKey
-  userState: PublicKey
-}
-
-type TokenEntryTyped = {
-  mint: PublicKey
-  priceId: PriceId
-  tokenSquadsAccount: PublicKey
-  tokenAccountVault: PublicKey
-}
-
-type ValuationClock = {
-  currentSlot: bigint
-  currentUnixTimestamp: bigint
-}
-
-// ============================================================================
-// Constants
-// ============================================================================
-
-const PRECISE_NUMBER_DECIMALS = 12
-const PRECISE_NUMBER_SCALE = new Decimal(10).pow(PRECISE_NUMBER_DECIMALS)
-const DEFAULT_PUBLIC_KEY = PublicKey.default
-const KAMINO_RESERVE_FARM_KIND_COLLATERAL = 0
-const KAMINO_RESERVE_FARM_KIND_DEBT = 1
-
-// ============================================================================
-// 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 decimalFloorToBigInt(value: Decimal | bigint | number | string): bigint {
-    const decimalValue = value instanceof Decimal ? value : new Decimal(value.toString())
-    return BigInt(decimalValue.floor().toFixed(0))
-  }
-
-  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 AumCalculator.decimalFloorToBigInt(delta.mul(ytBalance.toString()))
-  }
-
-  static scaleSyToCurrentRate(syAmount: bigint, finalRate: number, currentRate: number): bigint {
-    if (syAmount === BigInt(0) || currentRate <= finalRate) {
-      return syAmount
-    }
-
-    return AumCalculator.decimalFloorToBigInt(new Decimal(syAmount.toString()).mul(finalRate).div(currentRate))
-  }
-
-  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 async getCurrentValuationClock(): Promise<ValuationClock> {
-    const currentSlot = BigInt(await this.connection.getSlot("confirmed"))
-    const blockTime = await this.connection.getBlockTime(Number(currentSlot))
-    return {
-      currentSlot,
-      currentUnixTimestamp: BigInt(blockTime ?? Math.floor(Date.now() / 1000)),
-    }
-  }
-
-  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)
-  }
-
-  static parseU128LE(data: Buffer, offset: number): bigint {
-    const lo = data.readBigUInt64LE(offset)
-    const hi = data.readBigUInt64LE(offset + 8)
-    return lo + (hi << 64n)
-  }
-
-  // ==========================================================================
-  // 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 += AumCalculator.decimalFloorToBigInt(valueInBase)
-      } 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: AumCalculator.decimalFloorToBigInt(aum),
-      }))
-    } 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: AumCalculator.decimalFloorToBigInt(valueInBase) }
-    } 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,
-    valuationClock: ValuationClock,
-  ): 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
-      const reserveKeysToFetch = new Set<string>()
-      for (const value of allValues) {
-        reserveKeysToFetch.add(value.reserve.toBase58())
-      }
-      for (const mapping of entry.reservePriceMappings) {
-        reserveKeysToFetch.add(mapping.reserve.toBase58())
-      }
-      for (const reserveFarmMapping of entry.reserveFarmMappings ?? []) {
-        reserveKeysToFetch.add(reserveFarmMapping.reserve.toBase58())
-      }
-
-      if (reserveKeysToFetch.size > 0) {
-        const uniqueReserves = Array.from(reserveKeysToFetch)
-        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 delegatedRewardBase = await this.calculateDelegatedFarmRewardAumInBase(
-        entry,
-        obligation,
-        prices,
-        reserveMap,
-        valuationClock,
-      )
-
-      const aumDecimal = Decimal.max(collateralBase.sub(debtBase).add(delegatedRewardBase), new Decimal(0))
-
-      return {
-        positionType: PositionType.KaminoObligation,
-        mint: this.state.underlyingMint.toBase58(),
-        aum: AumCalculator.decimalFloorToBigInt(aumDecimal),
-        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 }))
-  }
-
-  private calculateKaminoFarmRewardValueInBase(params: {
-    farm: ReturnType<typeof decodeKaminoFarmState>
-    user: ReturnType<typeof decodeKaminoFarmUserState>
-    globalConfigData: Buffer
-    scopePriceData?: Buffer | null
-    prices: ExponentPrices
-    valuationClock: ValuationClock
-  }): Decimal {
-    const treasuryFeeBps = params.globalConfigData.readBigUInt64LE(
-      KAMINO_FARM_ACCOUNT_DISCRIMINATOR_LEN + KAMINO_FARM_GLOBAL_CONFIG_TREASURY_FEE_BPS_OFFSET,
-    )
-    const scopePrice = params.scopePriceData
-      ? decodeKaminoScopeDatedPrice(params.scopePriceData, params.farm.scopeOraclePriceId)
-      : null
-    const projectedRewards = projectKaminoFarmUserRewards(
-      params.farm,
-      params.user,
-      projectKaminoFarmGlobalRewards(params.farm, scopePrice, params.valuationClock),
-    )
-
-    let rewardValueInBase = new Decimal(0)
-    for (let rewardIndex = 0; rewardIndex < params.farm.numRewardTokens; rewardIndex += 1) {
-      const rewardMint = projectedRewards.projectedRewardInfos[rewardIndex].rewardMint
-      const rewardPriceId = this.resolveTrackedMintPriceId(rewardMint)
-      if (!rewardPriceId) {
-        throw new Error(`Missing Exponent price for Kamino farm reward mint ${rewardMint.toBase58()}`)
-      }
-
-      const netRewardAmount = applyKaminoFarmTreasuryFee(
-        projectedRewards.projectedRewardsIssuedUnclaimed[rewardIndex],
-        treasuryFeeBps,
-      )
-      rewardValueInBase = rewardValueInBase.add(
-        new Decimal(netRewardAmount.toString()).mul(AumCalculator.resolvePrice(rewardPriceId, params.prices)),
-      )
-    }
-
-    return rewardValueInBase
-  }
-
-  private async calculateDelegatedFarmRewardAumInBase(
-    entry: ObligationEntryTyped,
-    obligation: Obligation,
-    prices: ExponentPrices,
-    reserveMap: Map<string, Reserve> | undefined,
-    valuationClock: ValuationClock,
-  ): Promise<Decimal> {
-    if ((entry.reserveFarmMappings?.length ?? 0) === 0) {
-      return new Decimal(0)
-    }
-
-    const accountKeys = new Map<string, PublicKey>()
-    for (const reserveFarmMapping of entry.reserveFarmMappings) {
-      accountKeys.set(reserveFarmMapping.farmState.toBase58(), reserveFarmMapping.farmState)
-      const userState = getKaminoFarmsObligationFarm(
-        entry.obligation,
-        reserveFarmMapping.farmState,
-        KAMINO_FARMS_PROGRAM_ID,
-      )
-      accountKeys.set(userState.toBase58(), userState)
-    }
-
-    const uniqueAccountKeys = [...accountKeys.values()]
-    const accountInfos = uniqueAccountKeys.length > 0
-      ? await this.connection.getMultipleAccountsInfo(uniqueAccountKeys)
-      : []
-    const accountInfoMap = new Map<string, Buffer | null>()
-    for (let index = 0; index < uniqueAccountKeys.length; index += 1) {
-      accountInfoMap.set(uniqueAccountKeys[index].toBase58(), accountInfos[index]?.data ? Buffer.from(accountInfos[index]!.data) : null)
-    }
-
-    let totalRewardValueInBase = new Decimal(0)
-    for (const reserveFarmMapping of entry.reserveFarmMappings) {
-      let reserve = reserveMap?.get(reserveFarmMapping.reserve.toBase58())
-      if (!reserve) {
-        reserve = await Reserve.fetch(this.connection, reserveFarmMapping.reserve, entry.lendingProgramId) ?? undefined
-        if (reserve) {
-          reserveMap?.set(reserveFarmMapping.reserve.toBase58(), reserve)
-        }
-      }
-      if (!reserve) {
-        throw new Error(`Missing tracked Kamino reserve ${reserveFarmMapping.reserve.toBase58()}`)
-      }
-
-      const expectedFarmState = reserveFarmMapping.farmKind === KAMINO_RESERVE_FARM_KIND_COLLATERAL
-        ? reserve.farmCollateral
-        : reserveFarmMapping.farmKind === KAMINO_RESERVE_FARM_KIND_DEBT
-          ? reserve.farmDebt
-          : null
-      if (!expectedFarmState?.equals(reserveFarmMapping.farmState)) {
-        throw new Error(`Stored reserve farm mapping is stale for reserve ${reserveFarmMapping.reserve.toBase58()}`)
-      }
-
-      const farmData = accountInfoMap.get(reserveFarmMapping.farmState.toBase58())
-      if (!farmData) {
-        throw new Error(`Missing delegated farm account ${reserveFarmMapping.farmState.toBase58()}`)
-      }
-      const farm = decodeKaminoFarmState(farmData)
-      if (!farm.isDelegated) {
-        throw new Error(`Stored farm ${reserveFarmMapping.farmState.toBase58()} is not delegated`)
-      }
-      const userState = getKaminoFarmsObligationFarm(
-        entry.obligation,
-        reserveFarmMapping.farmState,
-        KAMINO_FARMS_PROGRAM_ID,
-      )
-
-      const additionalAccounts = [farm.globalConfig]
-      const scopePrices = getKaminoFarmScopePricesAddress(farm)
-      if (scopePrices) {
-        additionalAccounts.push(scopePrices)
-      }
-      const [globalConfigInfo, scopeInfo] = await this.connection.getMultipleAccountsInfo(additionalAccounts)
-      if (!globalConfigInfo?.data) {
-        throw new Error(`Missing delegated farm global config ${farm.globalConfig.toBase58()}`)
-      }
-      const globalConfigData = Buffer.from(globalConfigInfo.data)
-
-      const userData = accountInfoMap.get(userState.toBase58())
-      if (!userData) {
-        continue
-      }
-      const user = decodeKaminoFarmUserState(userData)
-      if (!user.delegatee.equals(entry.obligation)) {
-        throw new Error(`Delegated farm user ${userState.toBase58()} does not delegate to obligation`)
-      }
-      if (!user.owner.equals(obligation.owner)) {
-        throw new Error(`Delegated farm user ${userState.toBase58()} owner mismatch`)
-      }
-
-      const scopePriceData = scopePrices ? Buffer.from(scopeInfo?.data ?? []) : null
-      if (scopePrices && !scopeInfo?.data) {
-        throw new Error(`Missing delegated farm scope prices ${scopePrices.toBase58()}`)
-      }
-
-      totalRewardValueInBase = totalRewardValueInBase.add(this.calculateKaminoFarmRewardValueInBase({
-        farm,
-        user,
-        globalConfigData,
-        scopePriceData,
-        prices,
-        valuationClock,
-      }))
-    }
-
-    return totalRewardValueInBase
-  }
-
-  /**
-   * 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: AumCalculator.decimalFloorToBigInt(totalValue),
-      }
-    } catch (e) {
-      console.warn("Failed to calculate CLMM position AUM:", e)
-      return zeroResult
-    }
-  }
-
-  async calculateKaminoFarmAum(
-    entry: KaminoFarmEntryTyped,
-    prices: ExponentPrices,
-    valuationClock: ValuationClock,
-  ): Promise<AumResult> {
-    const zeroResult: AumResult = {
-      positionType: PositionType.KaminoFarm,
-      mint: this.state.underlyingMint.toBase58(),
-      aum: 0n,
-    }
-
-    const [farmInfo, userInfo] = await this.connection.getMultipleAccountsInfo([entry.farmState, entry.userState])
-    if (!farmInfo?.data || !userInfo?.data) {
-      return zeroResult
-    }
-
-    const farm = decodeKaminoFarmState(Buffer.from(farmInfo.data))
-    if (farm.isDelegated) {
-      return zeroResult
-    }
-
-    const user = decodeKaminoFarmUserState(Buffer.from(userInfo.data))
-
-    const principalAmount = calculateKaminoFarmPrincipalAmount(farm, user)
-    const principalPriceId = this.resolveTrackedMintPriceId(farm.underlyingMint)
-    if (!principalPriceId) {
-      throw new Error(`Missing Exponent price for Kamino farm underlying mint ${farm.underlyingMint.toBase58()}`)
-    }
-    const principalValueInBase = new Decimal(principalAmount.toString()).mul(
-      AumCalculator.resolvePrice(principalPriceId, prices),
-    )
-
-    if (farm.numRewardTokens === 0) {
-      return {
-        positionType: PositionType.KaminoFarm,
-        mint: farm.underlyingMint.toBase58(),
-        aum: AumCalculator.decimalFloorToBigInt(principalValueInBase),
-      }
-    }
-
-    const additionalAccounts = [farm.globalConfig]
-    const scopePricesAddress = getKaminoFarmScopePricesAddress(farm)
-    if (scopePricesAddress) {
-      additionalAccounts.push(scopePricesAddress)
-    }
-    const additionalInfos = await this.connection.getMultipleAccountsInfo(additionalAccounts)
-    const globalConfigInfo = additionalInfos[0]
-    if (!globalConfigInfo?.data) {
-      throw new Error(`Missing Kamino farm global config ${farm.globalConfig.toBase58()}`)
-    }
-    const scopeInfo = scopePricesAddress ? additionalInfos[1] : null
-    if (scopePricesAddress && !scopeInfo?.data) {
-      throw new Error(`Missing scope prices account ${scopePricesAddress.toBase58()}`)
-    }
-    const rewardValueInBase = this.calculateKaminoFarmRewardValueInBase({
-      farm,
-      user,
-      globalConfigData: Buffer.from(globalConfigInfo.data),
-      scopePriceData: scopeInfo?.data ? Buffer.from(scopeInfo.data) : null,
-      prices,
-      valuationClock,
-    })
-
-    return {
-      positionType: PositionType.KaminoFarm,
-      mint: farm.underlyingMint.toBase58(),
-      aum: AumCalculator.decimalFloorToBigInt(principalValueInBase.add(rewardValueInBase)),
-    }
-  }
-
-  /**
-   * 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: AumCalculator.decimalFloorToBigInt(valueInBase),
-        })
-      } 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,
-    valuationClock?: ValuationClock,
-  ): 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,
-            valuationClock ?? await this.getCurrentValuationClock(),
-          )
-          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]
-    }
-    if ("kaminoFarm" in position) {
-      const entry = (position as { kaminoFarm: { 0: KaminoFarmEntryTyped } }).kaminoFarm[0]
-      const result = await this.calculateKaminoFarmAum(
-        entry,
-        prices,
-        valuationClock ?? await this.getCurrentValuationClock(),
-      )
-      return [result]
-    }
-    return []
-  }
-
-  /**
-   * Calculate AUM for all positions: reserve tokens + strategy positions.
-   */
-  async calculatePositionsAum(prices: ExponentPrices): Promise<AumResult[]> {
-    const valuationClock = await this.getCurrentValuationClock()
-    const [reserveResults, ...positionResults] = await Promise.all([
-      this.calculateReserveTokensAum(prices),
-      ...this.state.strategyPositions.map((position) => this.calculatePositionAum(position, prices, valuationClock)),
-    ])
-    return [reserveResults, ...positionResults].flat()
-  }
-
-  get strategyPositions(): StrategyPosition[] {
-    return this.state.strategyPositions
-  }
-
-  private resolveTrackedMintPriceId(mint: PublicKey): PriceId | null {
-    const tokenEntry = (this.state.tokenEntries as unknown as TokenEntryTyped[]).find((entry) => entry.mint.equals(mint))
-    if (tokenEntry) {
-      return tokenEntry.priceId
-    }
-
-    for (const position of this.state.strategyPositions) {
-      if ("tokenAccount" in position) {
-        const entry = (position as { tokenAccount: { 0: TokenAccountEntryTyped } }).tokenAccount[0]
-        if (entry.tokenMint.equals(mint) && entry.balances.length > 0) {
-          return entry.balances[0].priceId
-        }
-      }
-    }
-
-    return null
-  }
-
-  private static convertKaminoStakeToAmount(stake: bigint, totalStake: bigint, totalAmount: bigint): bigint {
-    if (stake === 0n) {
-      return 0n
-    }
-    if (totalStake === 0n) {
-      return totalAmount
-    }
-    return (stake * totalAmount) / totalStake
-  }
-}