@exponent-labs/exponent-sdk 0.9.0 → 0.9.2

package/src/exponentVaults/vault.ts

@@ -31,12 +31,10 @@ import {
   ExponentPrices,
   ExponentVault as ExponentVaultAccountType,
   ExponentVault as ExponentVaultType,
-  ExponentVaultsFetcher,
   OrderbookEntry,
   PriceId,
   TokenAccountEntry,
   TokenEntry,
-  transformAnchorData,
 } from "@exponent-labs/exponent-vaults-fetcher"
 import { PROGRAM_ID as EXPONENT_VAULTS_PROGRAM_ID } from "@exponent-labs/exponent-vaults-idl"
 import { ExponentVaultsPDA, SeedId, SquadsPDA } from "@exponent-labs/exponent-vaults-pda"
@@ -44,9 +42,13 @@ import { ExponentVaultsPDA, SeedId, SquadsPDA } from "@exponent-labs/exponent-va
 import { fetchAllMaybeMarketThreeAccounts } from "../client/clmm/accounts/marketThree"
 import * as exponentVaults from "../client/vaults"
 import { Environment, LOCAL_ENV } from "../environment"
-import { emitEventAuthority } from "../utils"
+import { emitEventAuthority, uniqueRemainingAccounts } from "../utils"
 import { AumCalculator } from "./aumCalculator"
+import { deserializeExponentStrategyVaultFetcherShape, ExponentVaultsFetcher } from "./fetcher"
+import { getKaminoFarmScopePricesAddress, decodeKaminoFarmState } from "./kamino-farms"
+import { extractPriceIds } from "./pricePathResolver"
 import { SquadsVaultTxnResolver } from "./squadsVaultTxnResolver"
+import { getKaminoFarmsObligationFarm } from "./../../../kamino-lend-standard/src/constants"
 
 type Numeric = bigint | number
 
@@ -54,6 +56,8 @@ export const SYNTHETIC_USD_MINT = new PublicKey("USD1111111111111111111111111111
 export const SYNTHETIC_USD_DECIMALS = 6
 export const SYNTHETIC_USD9_MINT = new PublicKey("USD1111111111111111111111111111111111111119")
 export const SYNTHETIC_USD9_DECIMALS = 9
+const LOCAL_UPDATE_PRICE_DISCRIMINATOR = Buffer.from([7])
+const KAMINO_FARMS_PROGRAM_ID = new PublicKey("FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr")
 
 export const getSyntheticMintDecimals = (mint: PublicKey): number | null => {
   if (mint.equals(SYNTHETIC_USD_MINT)) return SYNTHETIC_USD_DECIMALS
@@ -61,6 +65,103 @@ export const getSyntheticMintDecimals = (mint: PublicKey): number | null => {
   return null
 }
 
+function unwrapTupleLikeValue(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value[0]
+  }
+  if (value && typeof value === "object" && "0" in value) {
+    return (value as { 0?: unknown })[0]
+  }
+  return value ?? undefined
+}
+
+function addTrackedPriceIds(target: Set<number>, priceIdValue: unknown) {
+  for (const id of extractPriceIds(priceIdValue)) {
+    const numericId = Number(id)
+    if (numericId !== 0) {
+      target.add(numericId)
+    }
+  }
+}
+
+export function collectTrackedStrategyVaultPriceIds(state: {
+  tokenEntries: Array<{ priceId: unknown }>
+  strategyPositions: Array<Record<string, unknown>>
+}): Set<number> {
+  const allPriceIds = new Set<number>()
+
+  for (const entry of state.tokenEntries) {
+    addTrackedPriceIds(allPriceIds, entry.priceId)
+  }
+
+  for (const position of state.strategyPositions) {
+    if ("orderbook" in position) {
+      const orderbook = unwrapTupleLikeValue(position.orderbook) as { priceIdPt?: unknown } | undefined
+      if (orderbook?.priceIdPt) {
+        addTrackedPriceIds(allPriceIds, orderbook.priceIdPt)
+      }
+      continue
+    }
+
+    if ("tokenAccount" in position) {
+      const tokenAccount = unwrapTupleLikeValue(position.tokenAccount) as {
+        balances?: Array<{ priceId?: unknown }>
+      } | undefined
+      for (const balance of tokenAccount?.balances ?? []) {
+        if (balance.priceId) {
+          addTrackedPriceIds(allPriceIds, balance.priceId)
+        }
+      }
+      continue
+    }
+
+    if ("yieldPosition" in position) {
+      const yieldPosition = unwrapTupleLikeValue(position.yieldPosition) as { priceIdPt?: unknown } | undefined
+      if (yieldPosition?.priceIdPt) {
+        addTrackedPriceIds(allPriceIds, yieldPosition.priceIdPt)
+      }
+      continue
+    }
+
+    if ("clmmPosition" in position) {
+      const clmmPosition = unwrapTupleLikeValue(position.clmmPosition) as {
+        priceIdPt?: unknown
+        priceIdSy?: unknown
+      } | undefined
+      if (clmmPosition?.priceIdPt) {
+        addTrackedPriceIds(allPriceIds, clmmPosition.priceIdPt)
+      }
+      if (clmmPosition?.priceIdSy) {
+        addTrackedPriceIds(allPriceIds, clmmPosition.priceIdSy)
+      }
+      continue
+    }
+
+    if ("obligation" in position) {
+      const rawObligation = position.obligation as Record<string, unknown> | Array<unknown>
+      const inner = unwrapTupleLikeValue(rawObligation as unknown[] | { 0?: unknown })
+      const kaminoVariant =
+        inner && typeof inner === "object" && "kaminoObligation" in inner
+          ? (inner as { kaminoObligation?: unknown }).kaminoObligation
+          : inner
+      const kaminoEntry = unwrapTupleLikeValue(kaminoVariant) as {
+        quotePriceId?: unknown
+        reservePriceMappings?: Array<{ reservePriceId?: unknown }>
+      } | undefined
+      if (kaminoEntry?.quotePriceId) {
+        addTrackedPriceIds(allPriceIds, kaminoEntry.quotePriceId)
+      }
+      for (const mapping of kaminoEntry?.reservePriceMappings ?? []) {
+        if (mapping.reservePriceId) {
+          addTrackedPriceIds(allPriceIds, mapping.reservePriceId)
+        }
+      }
+    }
+  }
+
+  return allPriceIds
+}
+
 const getMintDecimals = async (connection: Connection, mint: PublicKey): Promise<number> => {
   const syntheticDecimals = getSyntheticMintDecimals(mint)
   if (syntheticDecimals !== null) {
@@ -76,6 +177,15 @@ const pushPriceMintAccount = (remainingAccounts: AccountMeta[], mint: PublicKey)
   remainingAccounts.push({ pubkey: mint, isSigner: false, isWritable: false })
 }
 
+const isLocalRpcEndpoint = (rpcEndpoint: string): boolean => {
+  try {
+    const hostname = new URL(rpcEndpoint).hostname
+    return hostname === "127.0.0.1" || hostname === "localhost"
+  } catch {
+    return rpcEndpoint.includes("127.0.0.1") || rpcEndpoint.includes("localhost")
+  }
+}
+
 // ============================================================================
 // Policy Types (matching on-chain structures)
 // ============================================================================
@@ -403,6 +513,11 @@ export interface UpdatePriceParams {
   priceId: number
 }
 
+export interface UpdateStrategyVaultPricesOptions {
+  manager?: PublicKey
+  priceIds?: Iterable<number>
+}
+
 export interface QueueWithdrawalParams {
   depositor: PublicKey
   lpAmount: Numeric
@@ -691,6 +806,29 @@ export interface WrapperManagerUpdatePositionParams {
   systemProgram?: PublicKey
 }
 
+export interface WrapperAddKaminoObligationPositionParams {
+  manager: PublicKey
+  obligation: PublicKey
+  lendingProgramId: PublicKey
+  quotePriceId: exponentVaults.PriceId
+  reservePriceMappings: exponentVaults.ReservePriceMapping[]
+  reserveFarmMappings?: exponentVaults.ReserveFarmMapping[]
+  minPriceStatusFlags: number
+  remainingAccounts?: AccountMeta[]
+  exponentPrices?: PublicKey
+  systemProgram?: PublicKey
+}
+
+export interface WrapperUpsertKaminoObligationReservePriceMappingsParams {
+  manager: PublicKey
+  obligation: PublicKey
+  reservePriceMappings: exponentVaults.ReservePriceMapping[]
+  reserveFarmMappings?: exponentVaults.ReserveFarmMapping[]
+  remainingAccounts?: AccountMeta[]
+  exponentPrices?: PublicKey
+  systemProgram?: PublicKey
+}
+
 export type WrapperAddPolicyParams = AddPolicyParams
 
 export type WrapperRemovePolicyParams = RemovePolicyParams
@@ -722,6 +860,8 @@ export class ExponentVault {
   public pda: ExponentVaultsPDA
   public aumCalculator: AumCalculator
   private clmmTicksMap: Map<string, PublicKey> = new Map()
+  private kaminoFarmAuxAccountsMap: Map<string, AccountMeta[]> = new Map()
+  private kaminoObligationFarmUserStates: Set<string> = new Set()
   static squadsVaultTxnResolver = new SquadsVaultTxnResolver()
 
   constructor(params: {
@@ -755,7 +895,10 @@ export class ExponentVault {
       connection: params.connection,
       programId: fetcher.programId,
     })
-    await vault.populateClmmTicksCache(params.connection)
+    await Promise.all([
+      vault.populateClmmTicksCache(params.connection),
+      vault.populateKaminoFarmAuxAccountsCache(params.connection),
+    ])
     return vault
   }
 
@@ -776,7 +919,12 @@ export class ExponentVault {
           programId: fetcher.programId,
         }),
     )
-    await Promise.all(results.map((v) => v.populateClmmTicksCache(params.connection)))
+    await Promise.all(
+      results.flatMap((vault) => [
+        vault.populateClmmTicksCache(params.connection),
+        vault.populateKaminoFarmAuxAccountsCache(params.connection),
+      ]),
+    )
     return results
   }
 
@@ -784,6 +932,8 @@ export class ExponentVault {
     const refreshed = await ExponentVault.load({ env: this.env, connection, address: this.selfAddress })
     this.state = refreshed.state
     this.clmmTicksMap = refreshed.clmmTicksMap
+    this.kaminoFarmAuxAccountsMap = refreshed.kaminoFarmAuxAccountsMap
+    this.kaminoObligationFarmUserStates = refreshed.kaminoObligationFarmUserStates
     this.connection = connection
     this.aumCalculator = new AumCalculator(this.state, this.connection, this.env)
     return refreshed
@@ -810,6 +960,128 @@ export class ExponentVault {
     }
   }
 
+  private async populateKaminoFarmAuxAccountsCache(connection: Connection): Promise<void> {
+    this.kaminoFarmAuxAccountsMap.clear()
+    this.kaminoObligationFarmUserStates.clear()
+
+    const farmStates: PublicKey[] = []
+    const delegatedFarmUsers: Array<{ obligation: PublicKey; farmState: PublicKey; userState: PublicKey }> = []
+    for (const pos of this.state.strategyPositions) {
+      if ("kaminoFarm" in pos && pos.kaminoFarm && typeof pos.kaminoFarm === "object") {
+        const entry = (pos as { kaminoFarm: { 0: { farmState: PublicKey } } }).kaminoFarm[0]
+        if (!farmStates.some((farmState) => farmState.equals(entry.farmState))) {
+          farmStates.push(entry.farmState)
+        }
+        continue
+      }
+
+      if (!("obligation" in pos) || !pos.obligation || typeof pos.obligation !== "object") {
+        continue
+      }
+
+      const rawObligation = pos["obligation"] as Record<string, unknown> | Array<unknown>
+      const inner = Array.isArray(rawObligation)
+        ? (rawObligation[0] as Record<string, unknown> | undefined)
+        : rawObligation && typeof rawObligation === "object" && "0" in rawObligation
+          ? (rawObligation[0] as Record<string, unknown> | undefined)
+          : (rawObligation as Record<string, unknown> | undefined)
+      const kaminoVariant = inner && "kaminoObligation" in inner ? (inner.kaminoObligation as unknown) : inner
+      const entry = Array.isArray(kaminoVariant)
+        ? (kaminoVariant[0] as
+            | {
+                obligation?: PublicKey
+                reserveFarmMappings?: Array<{ farmState: PublicKey }>
+              }
+            | undefined)
+        : kaminoVariant && typeof kaminoVariant === "object" && "0" in (kaminoVariant as Record<string, unknown>)
+          ? ((
+              kaminoVariant as {
+                0?: {
+                  obligation?: PublicKey
+                  reserveFarmMappings?: Array<{ farmState: PublicKey }>
+                }
+              }
+            )[0] ?? undefined)
+          : (kaminoVariant as
+              | {
+                  obligation?: PublicKey
+                  reserveFarmMappings?: Array<{ farmState: PublicKey }>
+                }
+              | undefined)
+      if (!(entry?.obligation instanceof PublicKey)) {
+        continue
+      }
+
+      for (const mapping of entry.reserveFarmMappings ?? []) {
+        if (!farmStates.some((farmState) => farmState.equals(mapping.farmState))) {
+          farmStates.push(mapping.farmState)
+        }
+        delegatedFarmUsers.push({
+          obligation: entry.obligation,
+          farmState: mapping.farmState,
+          userState: getKaminoFarmsObligationFarm(entry.obligation, mapping.farmState, KAMINO_FARMS_PROGRAM_ID),
+        })
+      }
+    }
+
+    if (farmStates.length === 0) {
+      return
+    }
+
+    const farmInfos = await connection.getMultipleAccountsInfo(farmStates)
+    for (const [index, farmInfo] of farmInfos.entries()) {
+      const farmState = farmStates[index]
+      if (!farmState || !farmInfo?.data) {
+        if (ExponentVault.debugAum && farmState) {
+          console.log("[VAULT_AUM] kaminoFarmAux: missing farm info", farmState.toBase58())
+        }
+        continue
+      }
+
+      const farm = decodeKaminoFarmState(Buffer.from(farmInfo.data))
+      const auxAccounts: AccountMeta[] = [{ pubkey: farm.globalConfig, isSigner: false, isWritable: false }]
+      const scopePrices = getKaminoFarmScopePricesAddress(farm)
+      if (scopePrices) {
+        auxAccounts.push({ pubkey: scopePrices, isSigner: false, isWritable: false })
+      }
+
+      this.kaminoFarmAuxAccountsMap.set(farmState.toBase58(), auxAccounts)
+      if (ExponentVault.debugAum) {
+        console.log(
+          "[VAULT_AUM] kaminoFarmAux:",
+          farmState.toBase58(),
+          auxAccounts.map((account) => account.pubkey.toBase58()).join(", "),
+        )
+      }
+    }
+
+    if (delegatedFarmUsers.length === 0) {
+      return
+    }
+
+    const uniqueUsers = Array.from(
+      new Map(
+        delegatedFarmUsers.map((entry) => [
+          `${entry.obligation.toBase58()}:${entry.farmState.toBase58()}`,
+          entry,
+        ]),
+      ).values(),
+    )
+    const userInfos = await connection.getMultipleAccountsInfo(uniqueUsers.map((entry) => entry.userState))
+    for (const [index, userInfo] of userInfos.entries()) {
+      if (!userInfo?.data) {
+        continue
+      }
+
+      const entry = uniqueUsers[index]
+      if (!entry) {
+        continue
+      }
+
+      this.kaminoObligationFarmUserStates.add(`${entry.obligation.toBase58()}:${entry.farmState.toBase58()}`)
+    }
+  }
+
   /**
    * Derive the PDA for a vault using its 8-byte seed identifier.
    */
@@ -898,13 +1170,19 @@ export class ExponentVault {
           }
         }
       } else if ("obligation" in pos && pos.obligation && typeof pos.obligation === "object") {
-        const inner = pos["obligation"][0] as Record<string, unknown> | undefined
+        const rawObligation = pos["obligation"] as Record<string, unknown> | Array<unknown>
+        const inner = Array.isArray(rawObligation)
+          ? (rawObligation[0] as Record<string, unknown> | undefined)
+          : rawObligation && typeof rawObligation === "object" && "0" in rawObligation
+            ? (rawObligation[0] as Record<string, unknown> | undefined)
+            : (rawObligation as Record<string, unknown> | undefined)
         const kaminoVariant = inner && "kaminoObligation" in inner ? (inner.kaminoObligation as unknown) : inner
         const entry = Array.isArray(kaminoVariant)
           ? (kaminoVariant[0] as
               | {
                   obligation?: PublicKey
                   reservePriceMappings?: Array<{ reserve: PublicKey }>
+                  reserveFarmMappings?: Array<{ farmState: PublicKey }>
                 }
               | undefined)
           : kaminoVariant && typeof kaminoVariant === "object" && "0" in (kaminoVariant as Record<string, unknown>)
@@ -913,6 +1191,7 @@ export class ExponentVault {
                   0?: {
                     obligation?: PublicKey
                     reservePriceMappings?: Array<{ reserve: PublicKey }>
+                    reserveFarmMappings?: Array<{ farmState: PublicKey }>
                   }
                 }
               )[0] ?? undefined)
@@ -920,6 +1199,7 @@ export class ExponentVault {
                 | {
                     obligation?: PublicKey
                     reservePriceMappings?: Array<{ reserve: PublicKey }>
+                    reserveFarmMappings?: Array<{ farmState: PublicKey }>
                   }
                 | undefined)
         if (entry?.obligation instanceof PublicKey) {
@@ -935,11 +1215,30 @@ export class ExponentVault {
               isWritable: false,
             })
           }
+          for (const mapping of entry.reserveFarmMappings ?? []) {
+            metas.push({
+              pubkey: mapping.farmState,
+              isSigner: false,
+              isWritable: false,
+            })
+            const obligationFarmUserKey = `${entry.obligation.toBase58()}:${mapping.farmState.toBase58()}`
+            if (this.kaminoObligationFarmUserStates.has(obligationFarmUserKey)) {
+              metas.push({
+                pubkey: getKaminoFarmsObligationFarm(entry.obligation, mapping.farmState, KAMINO_FARMS_PROGRAM_ID),
+                isSigner: false,
+                isWritable: false,
+              })
+            }
+            metas.push(...(this.kaminoFarmAuxAccountsMap.get(mapping.farmState.toBase58()) ?? []))
+          }
           if (ExponentVault.debugAum) {
             console.log("[VAULT_AUM] strategyPosition: Obligation", entry.obligation.toBase58())
             for (const mapping of entry.reservePriceMappings ?? []) {
               console.log("[VAULT_AUM] strategyPosition: Kamino reserve", mapping.reserve.toBase58())
             }
+            for (const mapping of entry.reserveFarmMappings ?? []) {
+              console.log("[VAULT_AUM] strategyPosition: Kamino delegated farm", mapping.farmState.toBase58())
+            }
           }
         }
       } else if ("yieldPosition" in pos && pos.yieldPosition && typeof pos.yieldPosition === "object") {
@@ -990,6 +1289,31 @@ export class ExponentVault {
             ticksKey ? ticksKey.toBase58() : "(ticks not cached)",
           )
         }
+      } else if ("kaminoFarm" in pos && pos.kaminoFarm && typeof pos.kaminoFarm === "object") {
+        const entry = (pos as { kaminoFarm: { 0: { farmState: PublicKey; userState: PublicKey } } }).kaminoFarm[0]
+        metas.push({
+          pubkey: entry.farmState,
+          isSigner: false,
+          isWritable: false,
+        })
+        metas.push({
+          pubkey: entry.userState,
+          isSigner: false,
+          isWritable: false,
+        })
+        const auxAccounts = this.kaminoFarmAuxAccountsMap.get(entry.farmState.toBase58()) ?? []
+        metas.push(...auxAccounts)
+        if (ExponentVault.debugAum) {
+          console.log(
+            "[VAULT_AUM] strategyPosition: KaminoFarm",
+            entry.farmState.toBase58(),
+            entry.userState.toBase58(),
+          )
+          console.log(
+            "[VAULT_AUM] strategyPosition: KaminoFarm aux",
+            auxAccounts.map((account) => account.pubkey.toBase58()).join(", ") || "(none)",
+          )
+        }
       } else if ("loopscaleStrategy" in pos && pos.loopscaleStrategy && typeof pos.loopscaleStrategy === "object") {
         const entry = (pos as any).loopscaleStrategy[0]
         if (entry?.strategy instanceof PublicKey) {
@@ -1044,6 +1368,59 @@ export class ExponentVault {
     return [...this.tokenEntryAccountMetas(), ...this.strategyPositionAccountMetas()]
   }
 
+  /**
+   * Returns the readonly account metas required to recalculate the vault's current tracked AUM.
+   * Extra metas can be appended for pending positions or newly introduced Kamino reserves.
+   */
+  getAumRemainingAccountMetas(extraRemainingAccounts: AccountMeta[] = []): AccountMeta[] {
+    return uniqueRemainingAccounts([...this.aumRemainingAccounts(), ...extraRemainingAccounts])
+  }
+
+  private ixManagePriceUpdates({
+    manager,
+    updates,
+  }: {
+    manager?: PublicKey
+    updates: Array<{
+      priceId: number
+      priceType: exponentVaults.PriceType
+      priceInterfaceAccounts?: PublicKey
+    }>
+  }): TransactionInstruction {
+    if (updates.length === 0) {
+      throw new Error("ixManagePriceUpdates requires at least one update")
+    }
+
+    const resolvedManager = manager ?? this.state.roles.manager[0]
+    if (!resolvedManager) {
+      throw new Error("Vault manager not found")
+    }
+
+    const [exponentPrices] = this.pda.exponentPrices()
+    const remainingAccounts: AccountMeta[] = []
+    const actions: exponentVaults.UpdatePriceAction[] = updates.map((update) => {
+      if (!update.priceInterfaceAccounts) {
+        throw new Error(`priceInterfaceAccounts required for priceId ${update.priceId}`)
+      }
+
+      remainingAccounts.push({ pubkey: update.priceInterfaceAccounts, isSigner: false, isWritable: false })
+
+      return {
+        __kind: "UpdatePrice",
+        priceId: BigInt(update.priceId),
+        priceType: update.priceType,
+      }
+    })
+
+    const ix = exponentVaults.createManagePricesInstruction(
+      { manager: resolvedManager, exponentPrices, systemProgram: SystemProgram.programId },
+      { actions },
+      this.programId,
+    )
+    ix.keys.push(...remainingAccounts)
+    return ix
+  }
+
   ixUpdatePrice({
     priceInterfaceAccounts,
     pythPriceFeedId,
@@ -1062,8 +1439,12 @@ export class ExponentVault {
     const ix = exponentVaults.createUpdatePriceInstruction(
       { exponentPrices },
       { updates: [{ priceId: BigInt(priceId), interfaceAccountsIndex: 0 }] },
+      this.programId,
     )
     ix.keys.push(...updateRemainingAccounts)
+    if (isLocalRpcEndpoint(this.connection.rpcEndpoint)) {
+      ix.data = Buffer.concat([LOCAL_UPDATE_PRICE_DISCRIMINATOR, ix.data.subarray(1)])
+    }
     return ix
   }
 
@@ -1084,6 +1465,7 @@ export class ExponentVault {
     const vault = entryTokenVault ?? entry.tokenSquadsAccount
     const lpDst = tokenLpDst ?? defaultTokenAccount(this.state.mintLp, depositor, tokenProgram)
     const exponentPrices = this.pda.exponentPrices()[0]
+    const tokenProgramLp = useLegacyTokenAccounts ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID
 
     const preIxs: TransactionInstruction[] = []
 
@@ -1139,7 +1521,7 @@ export class ExponentVault {
         tokenLpDst: lpDst,
         mintLp: this.state.mintLp,
         tokenProgram,
-        tokenProgramLp: TOKEN_PROGRAM_ID,
+        tokenProgramLp,
         eventAuthority: this.eventAuthority,
         program: this.programId,
       },
@@ -1444,6 +1826,66 @@ export class ExponentVault {
     return ix
   }
 
+  /**
+   * Convenience wrapper for adding a tracked Kamino obligation position.
+   */
+  ixWrapperAddKaminoObligationPosition({
+    manager,
+    obligation,
+    lendingProgramId,
+    quotePriceId,
+    reservePriceMappings,
+    reserveFarmMappings = [],
+    minPriceStatusFlags,
+    remainingAccounts = [],
+    exponentPrices = this.pda.exponentPrices()[0],
+    systemProgram = SystemProgram.programId,
+  }: WrapperAddKaminoObligationPositionParams): TransactionInstruction {
+    const obligationEntry: exponentVaults.KaminoObligationEntry = {
+      obligation,
+      lendingProgramId,
+      quotePriceId,
+      reservePriceMappings,
+      reserveFarmMappings,
+      minPriceStatusFlags,
+    }
+
+    return this.ixWrapperManagerUpdatePosition({
+      manager,
+      exponentPrices,
+      systemProgram,
+      remainingAccounts: this.getAumRemainingAccountMetas(remainingAccounts),
+      update: exponentVaults.positionUpdate("AddKaminoObligationEntry", [
+        obligationEntry,
+      ] as [exponentVaults.KaminoObligationEntry]),
+    })
+  }
+
+  /**
+   * Convenience wrapper for updating tracked reserve price mappings on a Kamino obligation.
+   */
+  ixWrapperUpsertKaminoObligationReservePriceMappings({
+    manager,
+    obligation,
+    reservePriceMappings,
+    reserveFarmMappings = [],
+    remainingAccounts = [],
+    exponentPrices = this.pda.exponentPrices()[0],
+    systemProgram = SystemProgram.programId,
+  }: WrapperUpsertKaminoObligationReservePriceMappingsParams): TransactionInstruction {
+    return this.ixWrapperManagerUpdatePosition({
+      manager,
+      exponentPrices,
+      systemProgram,
+      remainingAccounts: this.getAumRemainingAccountMetas(remainingAccounts),
+      update: exponentVaults.positionUpdate("UpsertKaminoObligationReservePriceMappings", {
+        obligation,
+        reservePriceMappings,
+        reserveFarmMappings,
+      }),
+    })
+  }
+
   // ==========================================================================
   // Policy Management Methods
   // ==========================================================================
@@ -2013,11 +2455,9 @@ export class ExponentVault {
         throw new Error("Jito bundle simulation failed")
       }
 
-      const decoded = this.fetcher.program.account.exponentStrategyVault.coder.accounts.decode(
-        "exponentStrategyVault",
+      const vaultStateAfterSimulations = deserializeExponentStrategyVaultFetcherShape(
         Buffer.from(postVaultAccountData, "base64"),
-      )
-      const vaultStateAfterSimulations = transformAnchorData(decoded) as ExponentVaultType
+      ) as ExponentVaultType
       const aum =
         vaultStateAfterSimulations.financials.aumInBase + vaultStateAfterSimulations.financials.aumInBaseInPositions
 
@@ -2028,64 +2468,35 @@ export class ExponentVault {
     }
   }
 
-  async ixsUpdateStrategyVaultPrices(pricesAccount: ExponentPrices): Promise<TransactionInstruction[]> {
-    type PriceIdValue = { simple: { priceId: bigint } } | { multiply: { priceIds: bigint[] } }
-
-    const extractPriceIds = (priceId: PriceIdValue): number[] => {
-      const ids = "simple" in priceId ? [Number(priceId.simple.priceId)] : priceId.multiply.priceIds.map(Number)
-      return ids.filter((id) => id !== 0) // skip passthrough (price_id 0)
-    }
-
-    const allPriceIds = new Set<number>()
+  async ixsUpdateStrategyVaultPrices(
+    pricesAccount: ExponentPrices,
+    options: UpdateStrategyVaultPricesOptions = {},
+  ): Promise<TransactionInstruction[]> {
+    const trackedPriceIds =
+      options.priceIds ??
+      collectTrackedStrategyVaultPriceIds({
+        tokenEntries: this.state.tokenEntries,
+        strategyPositions: this.state.strategyPositions,
+      })
 
-    for (const entry of this.state.tokenEntries) {
-      extractPriceIds(entry.priceId).forEach((id) => allPriceIds.add(id))
+    const priceIds = [...trackedPriceIds].sort((a, b) => a - b)
+    if (priceIds.length === 0) {
+      return []
     }
 
-    for (const position of this.state.strategyPositions) {
-      if ("orderbook" in position) {
-        const orderbook = position.orderbook[0]
-        extractPriceIds(orderbook.priceIdPt).forEach((id) => allPriceIds.add(id))
-        continue
-      }
-
-      if ("tokenAccount" in position) {
-        for (const balance of position.tokenAccount[0].balances) {
-          extractPriceIds(balance.priceId).forEach((id) => allPriceIds.add(id))
-        }
-        continue
-      }
+    return priceIds.map((priceId) => {
+      const priceEntry = pricesAccount.prices[priceId]
 
-      if ("obligation" in position) {
-        const inner = position.obligation[0]
-        const kaminoEntry =
-          inner && typeof inner === "object" && "kaminoObligation" in inner ? inner.kaminoObligation?.[0] : inner?.[0]
-        if (kaminoEntry?.quotePriceId) {
-          extractPriceIds(kaminoEntry.quotePriceId).forEach((id: number) => allPriceIds.add(id))
-        }
-        for (const mapping of kaminoEntry?.reservePriceMappings ?? []) {
-          if (mapping.reservePriceId) {
-            extractPriceIds(mapping.reservePriceId).forEach((id: number) => allPriceIds.add(id))
-          }
-        }
+      if (!priceEntry) {
+        throw new Error(`Price entry not found for priceId ${priceId}`)
       }
-    }
-
-    return Promise.all(
-      [...allPriceIds].map((priceId) => {
-        const priceEntry = pricesAccount.prices[priceId]
-
-        if (!priceEntry) {
-          throw new Error(`Price entry not found for priceId ${priceId}`)
-        }
 
-        return this.ixUpdatePrice({
-          priceInterfaceAccounts: priceEntry.priceInterfaceAccounts,
-          remainingAccounts: priceEntry.interfaceAccounts,
-          priceId,
-        })
-      }),
-    )
+      return this.ixUpdatePrice({
+        priceId,
+        priceInterfaceAccounts: priceEntry.priceInterfaceAccounts,
+        remainingAccounts: priceEntry.interfaceAccounts,
+      })
+    })
   }
 
   // ==========================================================================