@exponent-labs/exponent-fetcher 0.1.8 → 0.9.1

package/src/exponentFetcher.ts

@@ -14,6 +14,7 @@ import {
   decodeCustodyAccount,
   decodePoolAndCustodyAccounts,
 } from "@exponent-labs/adrena-idl"
+import { decodeChainlinkPriceAccount } from "@exponent-labs/chainlink-idl"
 import {
   PROGRAM_ID as EXPONENT_CLMM_PROGRAM_ID,
   ExponentClmm,
@@ -75,6 +76,7 @@ import { PerenaStandard } from "@exponent-labs/perena-sy-idl"
 import { PreciseNumber } from "@exponent-labs/precise-number"
 import { decodeYieldPoolAndVestingScheduleAccounts } from "@exponent-labs/solstice-idl"
 
+import { IgnoredClmmEntityError, isMarketIgnored, isTicksIgnored } from "./constants"
 import { calculateAdrenaIndex } from "./utils/adrena"
 import { calculateFragmetricIndex, calculateFragmetricSupportedTokenIndex } from "./utils/fragmetric"
 import { decodeJitoVaultData } from "./utils/jito"
@@ -85,17 +87,13 @@ import { getPerenaLpMint, getPerenaStablePoolData } from "./utils/perena"
 import { calculateSanctumIndex } from "./utils/sanctum"
 import { calculateSolsticeRedemptionRate } from "./utils/solstice"
 
+const KAMINO_VAULT_GLOBAL_CONFIG = new web3.PublicKey("BKyTcUe6daNG8HbgBix2ugdRHbykG2dK9hPBBqhUyoEX")
+
 export function serializeAnchorizedPNumFromJson(pnum: AnchorizedPNum): AnchorizedPNumJson {
   const serializedArray = pnum[0].map((bn) => bn.toString())
   return { 0: serializedArray }
 }
 
-function readU128LE(buf: Buffer, offset: number): bigint {
-  const lo = buf.readBigUInt64LE(offset)
-  const hi = buf.readBigUInt64LE(offset + 8)
-  return (hi << 64n) + lo
-}
-
 export function deserializeAnchorizedPNumFromJson(serialized: AnchorizedPNumJson): AnchorizedPNum {
   const bnArray = serialized[0].map((str) => new BN(str))
   return { 0: bnArray }
@@ -410,6 +408,7 @@ export class ExponentFetcher {
     })
 
     return marketsProgramAccounts
+      .filter(({ pubkey }) => !isMarketIgnored(pubkey.toBase58()))
       .map(({ account, pubkey }) => {
         try {
           return this.exponentClmmProgram.coder.accounts.decode("marketThree", account.data)
@@ -421,11 +420,16 @@ export class ExponentFetcher {
   }
 
   async fetchMarketThree(address: web3.PublicKey): Promise<MarketThree> {
+    const addressStr = address.toBase58()
+    if (isMarketIgnored(addressStr)) {
+      throw new IgnoredClmmEntityError("market", addressStr)
+    }
+
     try {
       const m: MarketThreeRaw = await this.exponentClmmProgram.account.marketThree.fetch(address)
       return deserializeMarketThree(m)
     } catch (e) {
-      console.error(`Error fetching market ${address.toBase58()}`)
+      console.error(`Error fetching market ${addressStr}`)
       console.error(e)
       throw e
     }
@@ -445,25 +449,74 @@ export class ExponentFetcher {
       ],
     })
 
-    return ticksAccounts.map(({ account }) => deserializeMarketThreeTicks(account.data))
+    return ticksAccounts
+      .filter(({ pubkey }) => !isTicksIgnored(pubkey.toBase58()))
+      .map(({ account }) => deserializeMarketThreeTicks(account.data))
   }
 
   async fetchMarketThreeTicks(address: web3.PublicKey): Promise<Ticks> {
+    const addressStr = address.toBase58()
+    if (isTicksIgnored(addressStr)) {
+      throw new IgnoredClmmEntityError("ticks", addressStr)
+    }
+
     try {
       const m = (await this.connection.getAccountInfo(address)).data
       return deserializeMarketThreeTicks(m)
     } catch (e) {
-      console.error(`Error fetching market ${address.toBase58()}`)
+      console.error(`Error fetching ticks ${addressStr}`)
       console.error(e)
       throw e
     }
   }
 }
 
+/**
+ * Deserializes a CLMM Ticks account from raw buffer data.
+ *
+ * Layout matches Rust struct `Ticks` with `RedBlackTree<u32, Tick, 1000>`:
+ * - Discriminator: 8 bytes
+ * - RedBlackTree header: root(4) + padding(12) + size(8) + bump(4) + freeIdx(4) = 32 bytes
+ * - 1000 RBTree nodes, each: nodeHeader(16) + key(4) + padding(4) + Tick = variable bytes
+ * - Ticks footer: market(32) + feeGrowthPt(16) + feeGrowthSy(16) + prefixSum(8) + spotPrice(8) + currentTick(4) + padding(12) = 96 bytes
+ */
 export function deserializeMarketThreeTicks(data: Buffer): Ticks {
-  let offset = 8
-  const MAX_TICK_NODES = 100
-  const PERSONAL_TICK_YIELD_TRACKER_SIZE = 3
+  const MAX_TICK_NODES = 1000
+  const PERSONAL_TICK_YIELD_TRACKER_SIZE = 2
+  let offset = 8 // Skip discriminator
+
+  // ─── Helper functions ─────────────────────────────────────────────────────
+  const readU64 = (): bigint => {
+    const val = data.readBigUInt64LE(offset)
+    offset += 8
+    return val
+  }
+
+  const readU128 = (): bigint => {
+    const lo = data.readBigUInt64LE(offset)
+    const hi = data.readBigUInt64LE(offset + 8)
+    offset += 16
+    return (hi << 64n) + lo
+  }
+
+  const readI128 = (): bigint => {
+    const lo = data.readBigUInt64LE(offset)
+    const hi = data.readBigInt64LE(offset + 8) // High part is signed
+    offset += 16
+    return (hi << 64n) + lo
+  }
+
+  const readF64 = (): number => {
+    const val = data.readDoubleLE(offset)
+    offset += 8
+    return val
+  }
+
+  const readU32 = (): number => {
+    const val = data.readUInt32LE(offset)
+    offset += 4
+    return val
+  }
 
   const readPubkey = (): web3.PublicKey => {
     const pk = new web3.PublicKey(data.slice(offset, offset + 32))
@@ -471,9 +524,9 @@ export function deserializeMarketThreeTicks(data: Buffer): Ticks {
     return pk
   }
 
-  const readNumber = (): number => {
-    // Number is 32 bytes (4 x u64)
-    const nums = []
+  /** Reads a PreciseNumber (Number type in Rust) as float - 32 bytes (4 x u64) */
+  const readPreciseNumberAsFloat = (): number => {
+    const nums: BN[] = []
     for (let i = 0; i < 4; i++) {
       nums.push(new BN(data.slice(offset + i * 8, offset + (i + 1) * 8), undefined, "le"))
     }
@@ -481,108 +534,92 @@ export function deserializeMarketThreeTicks(data: Buffer): Ticks {
     return parseFloat(PreciseNumber.fromRaw(nums).valueString)
   }
 
-  // ─── Parse RedBlackTree slab ───────────────────────────────────────────────
-  // repr(C) gives: root: u32, pad to align NodeAllocator's u64, then the NodeAllocator header
-
-  const root = data.readUInt32LE(offset)
-  offset += 4
-  const padTo8 = 12
-  offset += padTo8
-
-  // NodeAllocator<T=RBNode<u32,PriceNode>, N=MAX_PRICE_NODES, R=3>
-  // header: size:u64, bump_index:u32, free_list_head:u32
-
-  const tickTreeSize = Number(data.readBigUInt64LE(offset))
-  offset += 8
+  /** Reads a PreciseNumber (Number type in Rust) as raw bigint - 32 bytes (4 x u64 = 256 bits) */
+  const readPreciseNumberAsBigint = (): bigint => {
+    let val = 0n
+    for (let i = 0; i < 4; i++) {
+      const chunk = data.readBigUInt64LE(offset + i * 8)
+      val += chunk << BigInt(i * 64)
+    }
+    offset += 32
+    return val
+  }
 
-  const ticksTreeBump = data.readUInt32LE(offset)
-  offset += 4
+  const skip = (bytes: number): void => {
+    offset += bytes
+  }
 
-  const ticksTreeFreeIdx = data.readUInt32LE(offset)
-  offset += 4
+  // ─── Parse RedBlackTree header ────────────────────────────────────────────
+  skip(4) // root: u32
+  skip(12) // padding to align NodeAllocator
+  skip(8) // size: u64
+  skip(4) // bump_index: u32
+  skip(4) // free_list_head: u32
 
+  // ─── Parse tick nodes ─────────────────────────────────────────────────────
   const ticks: Tick[] = []
 
   for (let i = 0; i < MAX_TICK_NODES; i++) {
-    const left = data.readUInt32LE(offset)
-    offset += 4
-    const right = data.readUInt32LE(offset)
-    offset += 4
-    const parent = data.readUInt32LE(offset)
-    offset += 4
-    offset += 4 // skip color
-
-    const apyBasePoints = data.readUInt32LE(offset)
-    offset += 8
-
-    const feeGrowthOutsidePt = readU128LE(data, offset)
-    offset += 16
-    const feeGrowthOutsideSy = readU128LE(data, offset)
-    offset += 16
-    const liquidityNet = data.readBigInt64LE(offset)
-    offset += 8
-    const liquidityGross = data.readBigInt64LE(offset)
-    offset += 8
-    const impliedRate = data.readDoubleLE(offset)
-    offset += 8
-    const principalPt = data.readBigInt64LE(offset)
-    offset += 8
-    const principalSy = data.readBigInt64LE(offset)
-    offset += 8
-    const principalShareSupply = data.readBigInt64LE(offset)
-    offset += 8
-
-    // Parse FarmYieldTrackers (3 trackers x 32 bytes each)
-    const farms = []
+    // RBNode header: left(4) + right(4) + parent(4) + color(4) = 16 bytes
+    skip(16)
+
+    // Key: u32 + padding to 8 bytes
+    const apyBasePoints = readU32()
+    skip(4) // padding
+
+    // Tick value (416 bytes total)
+    const feeGrowthOutsidePt = readU128() // 16 bytes
+    const feeGrowthOutsideSy = readU128() // 16 bytes
+    const liquidityNet = readI128() // 16 bytes
+    const liquidityGross = readU64() // 8 bytes
+    const spotPrice = readF64() // 8 bytes
+    const principalPt = readU64() // 8 bytes
+    const principalSy = readU64() // 8 bytes
+    const principalShareSupply = readPreciseNumberAsBigint() // 32 bytes - kept as bigint for arithmetic
+
+    // FarmYieldTrackers: 2 x FarmYieldTracker(32 bytes) = 64 bytes
+    const farms: { lastSeenIndex: number }[] = []
     for (let j = 0; j < PERSONAL_TICK_YIELD_TRACKER_SIZE; j++) {
-      farms.push({ lastSeenIndex: readNumber() })
+      farms.push({ lastSeenIndex: readPreciseNumberAsFloat() })
     }
 
-    // Parse EmissionYieldTrackers (3 trackers x 64 bytes each)
-    const emissions = []
+    // EmissionYieldTrackers: 2 x EmissionYieldTracker(64 bytes) = 128 bytes
+    const emissions: { lastSeenIndex: number; lastPositionIndex: number }[] = []
     for (let j = 0; j < PERSONAL_TICK_YIELD_TRACKER_SIZE; j++) {
-      const lastSeenIndex = readNumber()
-      const lastPositionIndex = readNumber()
-      emissions.push({ lastSeenIndex, lastPositionIndex })
+      emissions.push({
+        lastSeenIndex: readPreciseNumberAsFloat(),
+        lastPositionIndex: readPreciseNumberAsFloat(),
+      })
     }
 
-    // Parse last_split_epoch (u64)
-    const lastSplitEpoch = data.readBigUInt64LE(offset)
-    offset += 8
-
-    // Skip padding (u64)
-    offset += 8
+    const lastSplitEpoch = readU64() // 8 bytes
+    const frozenLiquidity = readU64() // 8 bytes
 
-    if (apyBasePoints === 0) continue
     ticks.push({
       apyBasePoints,
       liquidityNet,
       feeGrowthOutsidePt,
       feeGrowthOutsideSy,
       liquidityGross,
-      impliedRate,
+      impliedRate: spotPrice, // Legacy field name kept for compatibility
       principalPt,
       principalSy,
       principalShareSupply,
       farms,
       emissions,
       lastSplitEpoch,
+      frozenLiquidity,
     })
-    // console.log(ticks)
   }
 
-  const market = readPubkey()
-  const feeGrowthIndexGlobalPt = readU128LE(data, offset)
-  offset += 16
-  const feeGrowthIndexGlobalSy = readU128LE(data, offset)
-  offset += 16
-  const currentPrefixSum = data.readBigUInt64LE(offset) // Active liquidity at current tick
-  offset += 8
-  const currentSpotPrice = data.readDoubleLE(offset)
-  offset += 8
-  const currentTick = data.readUint32LE(offset)
-  offset += 4
-  offset += 12 // padding
+  // ─── Parse Ticks footer ───────────────────────────────────────────────────
+  const market = readPubkey() // 32 bytes
+  const feeGrowthIndexGlobalPt = readU128() // 16 bytes
+  const feeGrowthIndexGlobalSy = readU128() // 16 bytes
+  const currentPrefixSum = readU64() // 8 bytes
+  const currentSpotPrice = readF64() // 8 bytes
+  const currentTick = readU32() // 4 bytes
+  skip(12) // padding
 
   return {
     ticksTree: ticks,
@@ -595,7 +632,76 @@ export function deserializeMarketThreeTicks(data: Buffer): Ticks {
   }
 }
 
-function deserializeMarketThree(m: MarketThreeRaw): MarketThree {
+/** Decoded account may use snake_case (from JSON IDL); normalize to camelCase for app use. */
+function normalizeCpiContext(a: { altIndex?: number; alt_index?: number; isSigner?: boolean; is_signer?: boolean; isWritable?: boolean; is_writable?: boolean }): { altIndex: number; isSigner: boolean; isWritable: boolean } {
+  return {
+    altIndex: a.altIndex ?? (a as { alt_index?: number }).alt_index ?? 0,
+    isSigner: a.isSigner ?? (a as { is_signer?: boolean }).is_signer ?? false,
+    isWritable: a.isWritable ?? (a as { is_writable?: boolean }).is_writable ?? false,
+  }
+}
+
+function normalizeCpiAccountIndexes(
+  raw: {
+    getSyState?: unknown[]
+    get_sy_state?: unknown[]
+    withdrawSy?: unknown[]
+    withdraw_sy?: unknown[]
+    depositSy?: unknown[]
+    deposit_sy?: unknown[]
+    claimEmission?: unknown[][]
+    claim_emission?: unknown[][]
+    getPositionState?: unknown[]
+    get_position_state?: unknown[]
+  }
+): CpiAccountIndexes {
+  const arr = (key: string, snake: string) => {
+    const a = (raw as Record<string, unknown>)[key] ?? (raw as Record<string, unknown>)[snake]
+    return Array.isArray(a) ? a.map((x) => normalizeCpiContext(x as Record<string, unknown>)) : []
+  }
+  const arr2 = (key: string, snake: string) => {
+    const a = (raw as Record<string, unknown>)[key] ?? (raw as Record<string, unknown>)[snake]
+    return Array.isArray(a) ? a.map((inner) => (Array.isArray(inner) ? inner.map((x) => normalizeCpiContext(x as Record<string, unknown>)) : [])) : []
+  }
+  return {
+    getSyState: arr("getSyState", "get_sy_state"),
+    withdrawSy: arr("withdrawSy", "withdraw_sy"),
+    depositSy: arr("depositSy", "deposit_sy"),
+    claimEmission: arr2("claimEmission", "claim_emission"),
+    getPositionState: arr("getPositionState", "get_position_state"),
+  }
+}
+
+function normalizeMarketCpiCoreIndexes(
+  raw: {
+    stripSy?: unknown[]
+    strip_sy?: unknown[]
+    mergeSy?: unknown[]
+    merge_sy?: unknown[]
+  }
+): MarketCpiCoreIndexes {
+  const arr = (key: string, snake: string) => {
+    const a = (raw as Record<string, unknown>)[key] ?? (raw as Record<string, unknown>)[snake]
+    return Array.isArray(a) ? a.map((x) => normalizeCpiContext(x as Record<string, unknown>)) : []
+  }
+  return {
+    stripSy: arr("stripSy", "strip_sy"),
+    mergeSy: arr("mergeSy", "merge_sy"),
+  }
+}
+
+export function deserializeMarketThree(m: MarketThreeRaw): MarketThree {
+  const rawCpiSy = m.cpiSyAccounts ?? (m as unknown as { cpi_sy_accounts?: unknown }).cpi_sy_accounts
+  const rawCpiCore = m.cpiCoreAccounts ?? (m as unknown as { cpi_core_accounts?: unknown }).cpi_core_accounts
+  const cpiSyAccounts =
+    rawCpiSy != null && typeof rawCpiSy === "object"
+      ? normalizeCpiAccountIndexes(rawCpiSy as Parameters<typeof normalizeCpiAccountIndexes>[0])
+      : (m.cpiSyAccounts ?? { getSyState: [], withdrawSy: [], depositSy: [], claimEmission: [], getPositionState: [] })
+  const cpiCoreAccounts =
+    rawCpiCore != null && typeof rawCpiCore === "object"
+      ? normalizeMarketCpiCoreIndexes(rawCpiCore as Parameters<typeof normalizeMarketCpiCoreIndexes>[0])
+      : (m.cpiCoreAccounts ?? { stripSy: [], mergeSy: [] })
+
   return {
     addressLookupTable: m.addressLookupTable,
     mintSy: m.mintSy,
@@ -608,7 +714,7 @@ function deserializeMarketThree(m: MarketThreeRaw): MarketThree {
     selfAddress: m.selfAddress,
     syProgram: m.syProgram,
     statusFlags: m.statusFlags,
-    cpiSyAccounts: m.cpiSyAccounts,
+    cpiSyAccounts,
     isCurrentFlashSwap: m.isCurrentFlashSwap,
     lpFarm: m.lpFarm,
     mintYt: m.mintYt,
@@ -637,8 +743,9 @@ function deserializeMarketThree(m: MarketThreeRaw): MarketThree {
       syBalance: BigInt(m.financials.syBalance.toString()),
       liquidityBalance: BigInt(m.financials.liquidityBalance.toString()),
     },
-    cpiCoreAccounts: m.cpiCoreAccounts,
+    cpiCoreAccounts,
     exponentCoreProgram: m.exponentCoreProgram,
+    seedId: m.seedId,
   }
 }
 
@@ -699,7 +806,7 @@ function deserializeLpPositionCLMM(x: LpPositionCLMMRaw): LpPositionCLMM {
       tickIdx: tracker.tickIdx,
       rightTickIdx: tracker.rightTickIdx,
       splitEpoch: BigInt(tracker.splitEpoch.toString()),
-      lpShare: BigInt(tracker.lpShare.toString()),
+      lpShare: anchorizedPNumToRawBigint(tracker.lpShare),
       emissions: tracker.emissions.trackers.map((e) => ({
         staged: BigInt(e.staged.toString()),
         lastSeenIndex: parseFloat(PreciseNumber.fromRaw(e.lastSeenIndex[0]).valueString),
@@ -760,8 +867,8 @@ function deserializeOrderbook(data: Buffer): Orderbook {
   offset += 8
   const priceDecimals = data.readUint8(offset)
   offset += 1
-  // Skip ConfigurationOptions padding: _placeholder_one[15] + _placeholder_two[32] + _placeholder_three[32] + _placeholder_four[32] = 111 bytes
-  offset += 111
+  // Skip ConfigurationOptions padding: _placeholder_one[15] + _placeholder_two[32] + _placeholder_three[32] + _placeholder_four[32] + _reserved[1024] = 1135 bytes
+  offset += 1135
 
   // Pubkeys
   const vault = readPubkey()
@@ -775,7 +882,14 @@ function deserializeOrderbook(data: Buffer): Orderbook {
   const cpiAccountOrderbook = readPubkey()
   const admin = readPubkey()
 
-  // Skip last_sy_exchange_rate (Number type = 32 bytes)
+  // last_sy_exchange_rate (Number type = 32 bytes, PreciseNumber with 12 decimals)
+  const lastSyExchangeRateRaw = (() => {
+    let val = 0n
+    for (let i = 0; i < 4; i++) {
+      val += data.readBigUInt64LE(offset + i * 8) << BigInt(i * 64)
+    }
+    return val
+  })()
   offset += 32
 
   // OrderbookFinancials struct
@@ -818,12 +932,13 @@ function deserializeOrderbook(data: Buffer): Orderbook {
   }
   // console.log("financials", financials)
   // ─── Parse RedBlackTree slab ───────────────────────────────────────────────
-  // repr(C) gives: root: u32, pad to align NodeAllocator’s u64, then the NodeAllocator header
+  // RedBlackTree struct: root: u32, _padding: [u32; 3], allocator: NodeAllocator<...>
+  // Total before allocator = 4 + 12 = 16 bytes
 
   const root = data.readUInt32LE(offset)
   offset += 4
-  const padTo8 = 8
-  offset += padTo8
+  const padding = 12 // _padding: [u32; 3] in RedBlackTree struct
+  offset += padding
 
   // NodeAllocator<T=RBNode<u32,PriceNode>, N=MAX_PRICE_NODES, R=3>
   // header: size:u64, bump_index:u32, free_list_head:u32
@@ -868,9 +983,9 @@ function deserializeOrderbook(data: Buffer): Orderbook {
 
   const offersSize = Number(data.readBigUInt64LE(offset))
   offset += 8
-  const _offersBump = data.readUInt32LE(offset)
+  const offersBumpIndex = data.readUInt32LE(offset)
   offset += 4
-  const _offersFreeIdx = data.readUInt32LE(offset)
+  const offersFreeListHead = data.readUInt32LE(offset)
   offset += 4
 
   const offers: OfferNode[] = []
@@ -898,6 +1013,7 @@ function deserializeOrderbook(data: Buffer): Orderbook {
     offset += 5 // reserved padding
     if (userVaultPointer === 0) continue
     offers.push({
+      offerIndex: i + 1,
       nextOfferPointer,
       amount,
       userVaultPointer,
@@ -929,7 +1045,12 @@ function deserializeOrderbook(data: Buffer): Orderbook {
     offset += 4
     const user = new web3.PublicKey(data.slice(offset, offset + 32))
     offset += 32
-    /*const yieldIndex = data.readBigUInt64LE(offset).toString();*/ offset += 32
+    const yieldIndexRaw: AnchorizedPNum = [[new BN(0), new BN(0), new BN(0), new BN(0)]]
+    for (let word = 0; word < 4; word++) {
+      yieldIndexRaw[0][word] = new BN(data.subarray(offset + word * 8, offset + (word + 1) * 8), "le")
+    }
+    const yieldIndex = deserializeAnchorizedPNum(yieldIndexRaw)
+    offset += 32
     const ptAmount = data.readBigUInt64LE(offset)
     offset += 8
     const syAmount = data.readBigUInt64LE(offset)
@@ -941,8 +1062,8 @@ function deserializeOrderbook(data: Buffer): Orderbook {
     const staged = data.readBigInt64LE(offset)
     offset += 8
     offset += 8 // reserved
-    if (user.toBase58() == "11111111111111111111111111111111") continue
-    userEscrows.push({ user, yieldIndex: 0, ptAmount, syAmount, ytAmount, stakedYtAmount, staged })
+    // if (user.toBase58() == "11111111111111111111111111111111") continue
+    userEscrows.push({ user, yieldIndex, ptAmount, syAmount, ytAmount, stakedYtAmount, staged })
   }
 
   // ─── Finally, seed_id + signer_bump + reserved ─────────────────────────────
@@ -971,11 +1092,14 @@ function deserializeOrderbook(data: Buffer): Orderbook {
     tokenEscrowYt,
     tokenEscrowPt,
     cpiAccountOrderbook,
+    lastSyExchangeRate: lastSyExchangeRateRaw,
     financials,
     prices,
     configurationOptions,
     offers,
     userEscrows,
+    offersBumpIndex,
+    offersFreeListHead,
   }
 }
 
@@ -1161,6 +1285,7 @@ export interface MarketThree {
     }[]
   }
   liquidityNetBalanceLimits: LiquidityNetBalanceLimits
+  seedId: number[]
 }
 
 export interface Ticks {
@@ -1195,12 +1320,14 @@ export interface Tick {
   principalSy: bigint
   apyBasePoints: number
   principalShareSupply: bigint
-  /** Farm yield trackers (3 trackers) */
+  /** Farm yield trackers (2 trackers) */
   farms: { lastSeenIndex: number }[]
-  /** Emission yield trackers (3 trackers) */
+  /** Emission yield trackers (2 trackers) */
   emissions: { lastSeenIndex: number; lastPositionIndex: number }[]
   /** Last split epoch for this tick */
   lastSplitEpoch: bigint
+  /** Frozen liquidity that cannot be withdrawn */
+  frozenLiquidity: bigint
 }
 
 export interface MarketThreeRaw {
@@ -1375,11 +1502,17 @@ export interface Orderbook {
   tokenEscrowPt: web3.PublicKey
   cpiAccountOrderbook: web3.PublicKey
   admin: web3.PublicKey
+  /** Raw 256-bit PreciseNumber (12 decimals) for last SY exchange rate */
+  lastSyExchangeRate: bigint
   configurationOptions: ConfigurationOptions
   financials: OrderbookFinancials
   prices: PriceTreeNode[]
   offers: OfferNode[]
   userEscrows: UserEscrowNode[]
+  /** Next offer index that will be allocated (from NodeAllocator free list) */
+  offersFreeListHead: number
+  /** Bump index boundary for offers allocator */
+  offersBumpIndex: number
 }
 
 export interface KaminoSyMeta {
@@ -1453,7 +1586,7 @@ interface LpPositionCLMMRaw {
       tickIdx: number
       rightTickIdx: number
       splitEpoch: BN
-      lpShare: BN
+      lpShare: AnchorizedPNum
       emissions: { trackers: { staged: BN; lastSeenIndex: AnchorizedPNum }[] }
     }[]
   }
@@ -1648,7 +1781,7 @@ export interface OfferNodeRaw {
 
 export interface UserEscrowNodeRaw {
   user: web3.PublicKey
-  yieldIndex: BN
+  yieldIndex: number
   ptAmount: BN
   syAmount: BN
   ytAmount: BN
@@ -1659,6 +1792,16 @@ function deserializeAnchorizedPNum(x: AnchorizedPNum): number {
   return parseFloat(PreciseNumber.fromRaw(x[0]).valueString)
 }
 
+/** Convert PreciseNumber (Number type in Rust) from Anchor format to raw 256-bit bigint */
+export function anchorizedPNumToRawBigint(pnum: AnchorizedPNum): bigint {
+  const bnArray = pnum[0]
+  let val = 0n
+  for (let i = 0; i < 4; i++) {
+    val += BigInt(bnArray[i].toString()) << BigInt(i * 64)
+  }
+  return val
+}
+
 /** Fetch the exchange rate of a JitoRestaking vault's VRT to JitoSOL */
 async function fetchJitoVaultData({
   connection,
@@ -1881,28 +2024,70 @@ export async function fetchKaminoVaultIndex({
 
   const data = coder.accounts.decode("VaultState", account.data)
 
-  const activeReserves = data.vault_allocation_strategy
-    .map((r) => r.reserve)
-    .filter((reserve) => reserve.toBase58() !== web3.PublicKey.default.toBase58())
+  const activeAllocations = data.vault_allocation_strategy
+    .filter((allocation) => allocation.reserve.toBase58() !== web3.PublicKey.default.toBase58())
+  const activeReserves = activeAllocations.map((allocation) => allocation.reserve)
 
-  console.log("activeReserves", activeReserves)
-  const activeReservesData = await connection.getMultipleAccountsInfo(activeReserves)
+  const [activeReservesData, tokenMintInfo, sharesMintInfo] = await Promise.all([
+    connection.getMultipleAccountsInfo(activeReserves),
+    connection.getAccountInfo(data.token_mint),
+    connection.getAccountInfo(data.shares_mint),
+  ])
+  const decodedReserves = activeReservesData.map((accountInfo, index) => {
+    if (!accountInfo?.data) {
+      throw new Error(`Missing Kamino reserve account ${activeReserves[index].toBase58()}`)
+    }
+    return Reserve.decode(accountInfo.data)
+  })
+  const collateralMintInfos = await connection.getMultipleAccountsInfo(
+    decodedReserves.map((reserve) => reserve.collateral.mintPubkey),
+  )
 
   const reserves = activeReserves.map((r, i) => {
-    console.log("r.data", activeReservesData[i].data)
+    const reserveAccount = decodedReserves[i]
+    const allocation = activeAllocations[i]
+    const [lendingMarketAuthority] = web3.PublicKey.findProgramAddressSync(
+      [Buffer.from("lma"), reserveAccount.lendingMarket.toBuffer()],
+      new web3.PublicKey("KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD"),
+    )
+
     return {
       reserveAddress: r,
-      reserve: Reserve.decode(activeReservesData[i].data).lendingMarket,
+      marketAddress: reserveAccount.lendingMarket,
+      ctokenVault: allocation.ctoken_vault,
+      lendingMarketAuthority,
+      pythOracle: reserveAccount.config.tokenInfo.pythConfiguration.price,
+      switchboardPriceOracle: reserveAccount.config.tokenInfo.switchboardConfiguration.priceAggregator,
+      switchboardTwapOracle: reserveAccount.config.tokenInfo.switchboardConfiguration.twapAggregator,
+      scopePrices: reserveAccount.config.tokenInfo.scopeConfiguration.priceFeed,
+      reserveLiquiditySupply: reserveAccount.liquidity.supplyVault,
+      reserveCollateralMint: reserveAccount.collateral.mintPubkey,
+      reserveCollateralTokenProgram: collateralMintInfos[i]?.owner ?? web3.PublicKey.default,
     }
   })
 
-  console.log("reserves", reserves)
   const tokenVault = data.token_vault
   const tokenMint = data.token_mint
   const baseVaultAuthority = data.base_vault_authority
   const sharesMint = data.shares_mint
+  const vaultLookupTable = data.vault_lookup_table ?? web3.PublicKey.default
+  const tokenProgram = tokenMintInfo?.owner ?? web3.PublicKey.default
+  const sharesTokenProgram = sharesMintInfo?.owner ?? web3.PublicKey.default
 
-  return { index: 1, tokenVault, tokenMint, baseVaultAuthority, sharesMint, reserves }
+  return {
+    index: 1,
+    tokenVault,
+    tokenMint,
+    tokenProgram,
+    // Kamino Vault withdraw expects the singleton program global config account.
+    // It is not stored on VaultState, so fetch it from the known program-wide address.
+    globalConfig: KAMINO_VAULT_GLOBAL_CONFIG,
+    baseVaultAuthority,
+    sharesMint,
+    sharesTokenProgram,
+    vaultLookupTable,
+    reserves,
+  }
 }
 
 export async function fetchFragmetricSupportedTokenIndex({
@@ -2073,7 +2258,7 @@ export async function fetchSolsticeRedemptionRate({
 }
 
 const REFLECT_ORACLE_LEN = 17
-const REFLECT_MAX_STALENESS_SLOTS = 150
+const REFLECT_MAX_STALENESS_SLOTS = 15000000
 
 export async function fetchReflectRedemptionRate({
   connection,
@@ -2143,3 +2328,23 @@ export async function fetchOreExchangeRate({
     storeMint: storeMintInfo.data,
   })
 }
+
+export async function fetchChainlinkRate({
+  connection,
+  priceFeed,
+}: {
+  connection: web3.Connection
+  priceFeed: web3.PublicKey
+}): Promise<number> {
+  const accountInfo = await connection.getAccountInfo(priceFeed)
+
+  if (!accountInfo) {
+    throw new Error("Chainlink price feed account not found")
+  }
+
+  const { answer, header } = decodeChainlinkPriceAccount(accountInfo)
+
+  const scale = Math.pow(10, header.decimals)
+
+  return Number(answer) / scale
+}