@exponent-labs/exponent-sdk 0.9.0 → 0.9.2

package/src/client/vaults/types/strategyPosition.ts

@@ -3,6 +3,10 @@ import {
   ClmmPositionEntry,
   clmmPositionEntryCodec,
 } from "../types/clmmPositionEntry";
+import {
+  KaminoFarmEntry,
+  kaminoFarmEntryCodec,
+} from "../types/kaminoFarmEntry";
 import {
   LoopscaleLoanEntry,
   loopscaleLoanEntryCodec,
@@ -34,7 +38,8 @@ export type StrategyPosition =
   | { __kind: "YieldPosition"; fields: [YieldPositionEntry] }
   | { __kind: "ClmmPosition"; fields: [ClmmPositionEntry] }
   | { __kind: "LoopscaleLoan"; fields: [LoopscaleLoanEntry] }
-  | { __kind: "LoopscaleStrategy"; fields: [LoopscaleStrategyEntry] };
+  | { __kind: "LoopscaleStrategy"; fields: [LoopscaleStrategyEntry] }
+  | { __kind: "KaminoFarm"; fields: [KaminoFarmEntry] };
 
 export const strategyPositionCodec = getDiscriminatedUnionCodec([
   [
@@ -65,6 +70,10 @@ export const strategyPositionCodec = getDiscriminatedUnionCodec([
     "LoopscaleStrategy",
     getStructCodec([["fields", getTupleCodec([loopscaleStrategyEntryCodec])]]),
   ],
+  [
+    "KaminoFarm",
+    getStructCodec([["fields", getTupleCodec([kaminoFarmEntryCodec])]]),
+  ],
 ]);
 
 // Data Enum Helpers.
@@ -143,6 +152,14 @@ export function strategyPosition(
   "__kind",
   "LoopscaleStrategy"
 >;
+export function strategyPosition(
+  kind: "KaminoFarm",
+  data: GetDiscriminatedUnionVariantContent<
+    StrategyPosition,
+    "__kind",
+    "KaminoFarm"
+  >["fields"],
+): GetDiscriminatedUnionVariant<StrategyPosition, "__kind", "KaminoFarm">;
 export function strategyPosition<K extends StrategyPosition["__kind"], Data>(
   kind: K,
   data?: Data,

package/src/exponentVaults/aumCalculator.ts

@@ -16,6 +16,19 @@ import { Fraction, Obligation, Reserve } from "@exponent-labs/kamino-reserve-des
 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
@@ -30,6 +43,7 @@ export enum PositionType {
   ClmmPosition = "clmmPosition",
   LoopscaleLoan = "loopscaleLoan",
   LoopscaleStrategy = "loopscaleStrategy",
+  KaminoFarm = "kaminoFarm",
 }
 
 export type AumResult = {
@@ -72,7 +86,11 @@ type ObligationEntryTyped = {
   lendingProgramId: PublicKey
   quotePriceId: PriceId
   reservePriceMappings: Array<{ reserve: PublicKey; reservePriceId: PriceId }>
-  remainingAccountsAmount: bigint
+  reserveFarmMappings: Array<{
+    reserve: PublicKey
+    farmKind: number
+    farmState: PublicKey
+  }>
   minPriceStatusFlags: number
 }
 
@@ -91,6 +109,11 @@ type LoopscaleStrategyEntryTyped = {
   strategy: PublicKey
 }
 
+type KaminoFarmEntryTyped = {
+  farmState: PublicKey
+  userState: PublicKey
+}
+
 type TokenEntryTyped = {
   mint: PublicKey
   priceId: PriceId
@@ -98,12 +121,20 @@ type TokenEntryTyped = {
   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
@@ -183,6 +214,11 @@ export class AumCalculator {
     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]
@@ -221,7 +257,7 @@ export class AumCalculator {
     }
 
     const delta = new Decimal(1).div(lastSeenRate).sub(new Decimal(1).div(currentRate))
-    return BigInt(delta.mul(ytBalance.toString()).floor().toString())
+    return AumCalculator.decimalFloorToBigInt(delta.mul(ytBalance.toString()))
   }
 
   static scaleSyToCurrentRate(syAmount: bigint, finalRate: number, currentRate: number): bigint {
@@ -229,7 +265,7 @@ export class AumCalculator {
       return syAmount
     }
 
-    return BigInt(new Decimal(syAmount.toString()).mul(finalRate).div(currentRate).floor().toString())
+    return AumCalculator.decimalFloorToBigInt(new Decimal(syAmount.toString()).mul(finalRate).div(currentRate))
   }
 
   private async loadMintDecimals(mint: PublicKey): Promise<number> {
@@ -248,6 +284,15 @@ export class AumCalculator {
     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])]
@@ -276,6 +321,12 @@ export class AumCalculator {
     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
   // ==========================================================================
@@ -306,7 +357,7 @@ export class AumCalculator {
         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())
+        totalAum += AumCalculator.decimalFloorToBigInt(valueInBase)
       } catch {
         // Skip if price resolution fails
       }
@@ -369,7 +420,7 @@ export class AumCalculator {
       return Array.from(aumByMint.entries()).map(([mint, aum]) => ({
         positionType: PositionType.Orderbook,
         mint,
-        aum: BigInt(aum.floor().toString()),
+        aum: AumCalculator.decimalFloorToBigInt(aum),
       }))
     } catch (e) {
       console.warn("Failed to calculate orderbook AUM:", e)
@@ -486,7 +537,7 @@ export class AumCalculator {
         )
       }
 
-      return { positionType: PositionType.YieldPosition, mint: ytMint, aum: BigInt(valueInBase.floor().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) }
@@ -500,7 +551,11 @@ export class AumCalculator {
    * 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> {
+  async calculateObligationAum(
+    entry: ObligationEntryTyped,
+    prices: ExponentPrices,
+    valuationClock: ValuationClock,
+  ): Promise<AumResult> {
     try {
       const obligation = await Obligation.fetch(this.connection, entry.obligation, entry.lendingProgramId)
       if (!obligation) {
@@ -533,8 +588,19 @@ export class AumCalculator {
 
       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 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()
@@ -554,13 +620,20 @@ export class AumCalculator {
       )
       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), new Decimal(0))
+      const aumDecimal = Decimal.max(collateralBase.sub(debtBase).add(delegatedRewardBase), new Decimal(0))
 
       return {
         positionType: PositionType.KaminoObligation,
         mint: this.state.underlyingMint.toBase58(),
-        aum: BigInt(aumDecimal.floor().toString()),
+        aum: AumCalculator.decimalFloorToBigInt(aumDecimal),
         kaminoObligationExposure,
       }
     } catch (e) {
@@ -650,6 +723,154 @@ export class AumCalculator {
     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
@@ -694,7 +915,7 @@ export class AumCalculator {
       return {
         positionType: PositionType.ClmmPosition,
         mint: this.state.underlyingMint.toBase58(),
-        aum: BigInt(totalValue.floor().toString()),
+        aum: AumCalculator.decimalFloorToBigInt(totalValue),
       }
     } catch (e) {
       console.warn("Failed to calculate CLMM position AUM:", e)
@@ -702,6 +923,76 @@ export class AumCalculator {
     }
   }
 
+  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
@@ -930,7 +1221,7 @@ export class AumCalculator {
         results.push({
           positionType: PositionType.Reserves,
           mint: entry.mint.toBase58(),
-          aum: BigInt(valueInBase.floor().toString()),
+          aum: AumCalculator.decimalFloorToBigInt(valueInBase),
         })
       } catch {
         // Skip if price resolution fails
@@ -948,7 +1239,11 @@ export class AumCalculator {
    * 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[]> {
+  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)
@@ -973,7 +1268,11 @@ export class AumCalculator {
             ? ((kaminoVariant as { 0?: ObligationEntryTyped })[0] ?? undefined)
             : (kaminoVariant as ObligationEntryTyped | undefined)
         if (entry) {
-          const result = await this.calculateObligationAum(entry, prices)
+          const result = await this.calculateObligationAum(
+            entry,
+            prices,
+            valuationClock ?? await this.getCurrentValuationClock(),
+          )
           return [result]
         }
       }
@@ -993,6 +1292,15 @@ export class AumCalculator {
       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 []
   }
 
@@ -1000,9 +1308,10 @@ export class AumCalculator {
    * 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)),
+      ...this.state.strategyPositions.map((position) => this.calculatePositionAum(position, prices, valuationClock)),
     ])
     return [reserveResults, ...positionResults].flat()
   }
@@ -1010,4 +1319,32 @@ export class AumCalculator {
   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
+  }
 }