@exponent-labs/exponent-fetcher 0.1.8 → 0.9.0

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"
@@ -90,12 +92,6 @@ export function serializeAnchorizedPNumFromJson(pnum: AnchorizedPNum): Anchorize
   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 +406,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 +418,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 +447,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 +522,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 +532,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 +630,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 +712,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 +741,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 +804,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 +865,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 +880,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 +930,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 +981,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 +1011,7 @@ function deserializeOrderbook(data: Buffer): Orderbook {
     offset += 5 // reserved padding
     if (userVaultPointer === 0) continue
     offers.push({
+      offerIndex: i + 1,
       nextOfferPointer,
       amount,
       userVaultPointer,
@@ -929,7 +1043,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 +1060,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 +1090,14 @@ function deserializeOrderbook(data: Buffer): Orderbook {
     tokenEscrowYt,
     tokenEscrowPt,
     cpiAccountOrderbook,
+    lastSyExchangeRate: lastSyExchangeRateRaw,
     financials,
     prices,
     configurationOptions,
     offers,
     userEscrows,
+    offersBumpIndex,
+    offersFreeListHead,
   }
 }
 
@@ -1161,6 +1283,7 @@ export interface MarketThree {
     }[]
   }
   liquidityNetBalanceLimits: LiquidityNetBalanceLimits
+  seedId: number[]
 }
 
 export interface Ticks {
@@ -1195,12 +1318,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 +1500,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 +1584,7 @@ interface LpPositionCLMMRaw {
       tickIdx: number
       rightTickIdx: number
       splitEpoch: BN
-      lpShare: BN
+      lpShare: AnchorizedPNum
       emissions: { trackers: { staged: BN; lastSeenIndex: AnchorizedPNum }[] }
     }[]
   }
@@ -1648,7 +1779,7 @@ export interface OfferNodeRaw {
 
 export interface UserEscrowNodeRaw {
   user: web3.PublicKey
-  yieldIndex: BN
+  yieldIndex: number
   ptAmount: BN
   syAmount: BN
   ytAmount: BN
@@ -1659,6 +1790,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,
@@ -2073,7 +2214,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 +2284,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
+}

package/src/index.ts

@@ -11,3 +11,4 @@ export * from "./utils/kamino"
 export * from "./utils/perena"
 export * from "./utils/jito"
 export * from "./utils/ore"
+export * from "./constants"

package/tsconfig.json

@@ -38,6 +38,7 @@
     { "path": "../jupiter-lend-idl" },
     { "path": "../kamino-vault-idl" },
     { "path": "../jupiter-perps-idl" },
-    { "path": "../solstice-idl" }
+    { "path": "../solstice-idl" },
+    { "path": "../chainlink-idl" }
   ]
 }