@exponent-labs/exponent-fetcher 0.1.6 → 0.1.8

package/src/exponentFetcher.ts

@@ -1,14 +1,31 @@
-import { AnchorProvider, BN, Idl, Program, Wallet, web3 } from "@coral-xyz/anchor"
+import { AnchorProvider, BN, DISCRIMINATOR_SIZE, Idl, Program, ProgramAccount, Wallet, web3 } from "@coral-xyz/anchor"
 import { BorshCoder } from "@coral-xyz/anchor"
 import { getStakePoolAccount } from "@solana/spl-stake-pool"
 import { getAccount, getMint } from "@solana/spl-token"
-import { MintLayout } from "@solana/spl-token"
+import bs58 from "bs58"
 import Decimal from "decimal.js"
+
+import {
+  CustodyState,
+  FeesStats,
+  PoolState,
+  calculateTotalFeesFromCustodies,
+  decodePoolAccount as decodeAdrenaPoolAccount,
+  decodeCustodyAccount,
+  decodePoolAndCustodyAccounts,
+} from "@exponent-labs/adrena-idl"
+import {
+  PROGRAM_ID as EXPONENT_CLMM_PROGRAM_ID,
+  ExponentClmm,
+  IDL as ExponentClmmIdl,
+} from "@exponent-labs/exponent-clmm-idl"
 import { ExponentCore, IDL, PROGRAM_ID } from "@exponent-labs/exponent-idl"
+import { IDL as EXPONENT_ORDERBOOK_IDL, ExponentOrderbook } from "@exponent-labs/exponent-orderbook-idl"
 import {
   AnchorizedPNum,
   AnchorizedPNumJson,
   CpiAccountIndexes,
+  ExponentCoreCpiIndexes,
   GenericSyMetaAccount,
   GenericSyMetaAccountRaw,
   InterfaceType,
@@ -16,6 +33,7 @@ import {
   JitoRestakingSyMetaAccountRaw,
   MarginfiSyMeta,
   MarginfiSyMetaRaw,
+  MarketCpiCoreIndexes,
   PerenaSyMetaAccount,
   PerenaSyMetaAccountRaw,
   SyEmissionRaw,
@@ -25,50 +43,59 @@ import {
   deserializeJitoRestakingSyMetaAccountRaw,
   deserializePerenaSyMetaAccountRaw,
 } from "@exponent-labs/exponent-types"
-import { IDL as FragmetricIdl } from "@exponent-labs/fragmetric-idl"
-import { IDL as JupiterLendIdl } from "@exponent-labs/jupiter-lend-idl"
-import { IDL as KaminoVaultIdl } from "@exponent-labs/kamino-vault-idl"
+import {
+  MAX_OFFERS,
+  MAX_PRICE_NODES,
+  MAX_USER_ESCROWS,
+  OfferNode,
+  PriceTreeNode,
+  UserEscrowNode,
+} from "@exponent-labs/exponent-types"
 import { GenericStandard } from "@exponent-labs/generic-sy-idl"
 import { PROGRAM_ID as GENERIC_STANDARD_PROGRAM_ID, IDL as GenericStandardIdl } from "@exponent-labs/generic-sy-idl"
 import { PROGRAM_ID as JITO_RESTAKING_SY_PROGRAM_ID } from "@exponent-labs/jito-restaking-sy-idl"
 import { JitoRestakingStandard, IDL as JitoRestakingSyIdl } from "@exponent-labs/jito-restaking-sy-idl"
+// Decode Jupiter Perps pool accounts via helper using Anchor 0.29.0
+import { decodePoolAccount as decodeJupiterPerpsPoolAccount } from "@exponent-labs/jupiter-perps-idl"
 import { Obligation, Reserve } from "@exponent-labs/kamino-reserve-deserializer"
 import { PROGRAM_ID as KAMINO_LEND_PROGRAM_ID } from "@exponent-labs/kamino-reserve-deserializer"
 import { PROGRAM_ID as KAMINO_STANDARD_PROGRAM_ID } from "@exponent-labs/kamino-sy-idl"
 import { KaminoLendStandard } from "@exponent-labs/kamino-sy-idl"
 import { IDL as KaminoSyIdl } from "@exponent-labs/kamino-sy-idl"
+import { IDL as KaminoVaultIdl } from "@exponent-labs/kamino-vault-idl"
 import {
   PROGRAM_ID as MARGINFI_SY_PROGRAM_ID,
   MarginfiStandard,
   IDL as MarginfiSyIdl,
 } from "@exponent-labs/marginfi-sy-idl"
-import { decodePoolAccount, decodeVaultAccount } from "@exponent-labs/meteora-idl"
+import { fetchPoolAccount, fetchVaultAccount } from "@exponent-labs/meteora-idl"
 import { PROGRAM_ID as PERENA_STANDARD_PROGRAM_ID } from "@exponent-labs/perena-sy-idl"
 import { IDL as PerenaSyIdl } from "@exponent-labs/perena-sy-idl"
 import { PerenaStandard } from "@exponent-labs/perena-sy-idl"
 import { PreciseNumber } from "@exponent-labs/precise-number"
-import { decodePoolStateAccount } from "@exponent-labs/sanctum-idl"
-import {
-  decodePoolAccount as decodeAdrenaPoolAccount,
-  decodeCustodyAccount,
-  CustodyState,
-  FeesStats,
-  PoolState,
-  decodePoolAndCustodyAccounts,
-  calculateTotalFeesFromCustodies,
-} from "@exponent-labs/adrena-idl"
 import { decodeYieldPoolAndVestingScheduleAccounts } from "@exponent-labs/solstice-idl"
 
+import { calculateAdrenaIndex } from "./utils/adrena"
+import { calculateFragmetricIndex, calculateFragmetricSupportedTokenIndex } from "./utils/fragmetric"
+import { decodeJitoVaultData } from "./utils/jito"
+import { calculateJupiterLendIndex, calculateJupiterPerpsIndex } from "./utils/jupiter"
 import { computeD, getAmountByShare } from "./utils/meteora"
-import { Adrena } from "@exponent-labs/adrena-idl/src/adrena"
-// Decode Jupiter Perps pool accounts via helper using Anchor 0.29.0
-import { decodePoolAccount as decodeJupiterPerpsPoolAccount } from "@exponent-labs/jupiter-perps-idl"
+import { calculateOreExchangeRate } from "./utils/ore"
+import { getPerenaLpMint, getPerenaStablePoolData } from "./utils/perena"
+import { calculateSanctumIndex } from "./utils/sanctum"
+import { calculateSolsticeRedemptionRate } from "./utils/solstice"
 
 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 }
@@ -111,6 +138,8 @@ export class ExponentFetcher {
   public jitoRestakingSyProgram: Program<JitoRestakingStandard>
   public perenaSyProgram: Program<PerenaStandard>
   public genericStandardProgram: Program<GenericStandard>
+  public exponentClmmProgram: Program<ExponentClmm>
+  public orderbookProgram: Program<ExponentOrderbook>
   public connection: web3.Connection
   public coreProgramId: web3.PublicKey
   public marginfiSyProgramId: web3.PublicKey
@@ -156,6 +185,8 @@ export class ExponentFetcher {
     )
     this.perenaSyProgram = new Program<PerenaStandard>(PerenaSyIdl as PerenaStandard, provider)
     this.genericStandardProgram = new Program<GenericStandard>(GenericStandardIdl, provider)
+    this.exponentClmmProgram = new Program<ExponentClmm>(ExponentClmmIdl as ExponentClmm, provider)
+    this.orderbookProgram = new Program<ExponentOrderbook>(EXPONENT_ORDERBOOK_IDL as ExponentOrderbook, provider)
   }
 
   async fetchVault(address: web3.PublicKey) {
@@ -180,6 +211,30 @@ export class ExponentFetcher {
     }
   }
 
+  async fetchOrderbook(address: web3.PublicKey): Promise<Orderbook> {
+    try {
+      const o = (await this.connection.getAccountInfo(address)).data
+
+      return deserializeOrderbook(o)
+    } catch (e) {
+      console.error(`Error fetching orderbook ${address.toBase58()}`)
+      console.error(e)
+      throw e
+    }
+  }
+
+  async fetchOrderbookCpiAccounts(address: web3.PublicKey): Promise<OrderbookCpiAccountsRaw> {
+    try {
+      const orderbookCpiAccounts: OrderbookCpiAccountsRaw =
+        await this.orderbookProgram.account.cpiAccountsOrderbook.fetch(address)
+      return orderbookCpiAccounts
+    } catch (e) {
+      console.error(`Error fetching orderbook ${address.toBase58()}`)
+      console.error(e)
+      throw e
+    }
+  }
+
   async fetchMarginfiSyMeta(address: web3.PublicKey): Promise<MarginfiSyMeta> {
     const x: MarginfiSyMetaRaw = await this.marginfiSyProgram.account.syMeta.fetch(address)
     return deserializeMarginfiSyMeta(x)
@@ -263,11 +318,62 @@ export class ExponentFetcher {
     return deserializeLpPosition(x)
   }
 
+  async fetchLpPositionCLMM(address: web3.PublicKey) {
+    try {
+      const raw = await this.exponentClmmProgram.account.lpPosition.fetch(address)
+
+      const v: LpPositionCLMMRaw = {
+        owner: raw.owner,
+        market: raw.market,
+        feeInsideLastPt: raw.feeInsideLastPt,
+        feeInsideLastSy: raw.feeInsideLastSy,
+        lpBalance: raw.lpBalance,
+        tokensOwedSy: raw.tokensOwedSy,
+        tokensOwedPt: raw.tokensOwedPt,
+        lowerTickIdx: raw.lowerTickIdx,
+        upperTickIdx: raw.upperTickIdx,
+        farms: {
+          trackers: raw.farms.trackers.map((t: any) => ({
+            staged: t.staged,
+            lastSeenIndex: t.lastSeenIndex,
+          })),
+        },
+        shareTrackers: {
+          trackers: raw.shareTrackers.trackers.map((tracker: any) => ({
+            tickIdx: tracker.tickIdx,
+            rightTickIdx: tracker.rightTickIdx,
+            splitEpoch: tracker.splitEpoch,
+            lpShare: tracker.lpShare,
+            emissions: {
+              trackers: tracker.emissions.trackers.map((e: any) => ({
+                staged: e.staged,
+                lastSeenIndex: e.lastSeenIndex,
+              })),
+            },
+          })),
+        },
+      }
+
+      return deserializeLpPositionCLMM(v)
+    } catch (e) {
+      console.error(`Error fetching clmm lp position ${address.toBase58()}`)
+      console.error(e)
+      throw e
+    }
+  }
+
   async fetchYtPosition(address: web3.PublicKey): Promise<YtPosition> {
     const x: YtPositionRaw = await this.program.account.yieldTokenPosition.fetch(address)
     return deserializeYtPosition(x)
   }
 
+  /** Batch fetch multiple YT positions in a single RPC call */
+  async fetchYtPositions(addresses: web3.PublicKey[]): Promise<(YtPosition | null)[]> {
+    if (addresses.length === 0) return []
+    const results = await this.program.account.yieldTokenPosition.fetchMultiple(addresses)
+    return results.map((x) => (x ? deserializeYtPosition(x as YtPositionRaw) : null))
+  }
+
   async fetchJitoRestakingSyMeta(address: web3.PublicKey): Promise<JitoRestakingSyMetaAccount> {
     const x: JitoRestakingSyMetaAccountRaw = await this.jitoRestakingSyProgram.account.syMeta.fetch(address)
 
@@ -284,6 +390,256 @@ export class ExponentFetcher {
 
     return deserializeGenericSyMetaAccountRaw(x)
   }
+
+  async fetchAllMarketThree(): Promise<MarketThree[]> {
+    //TODO Replace with the following code when all damaged markets are removed onchain
+    // const marketsProgramAccounts: ProgramAccount<MarketThreeRaw>[] =
+    //   await this.exponentClmmProgram.account.marketThree.all()
+    // return marketsProgramAccounts.map(({ account }) => deserializeMarketThree(account))
+
+    const MARKET_THREE_DISCRIMINATOR = Buffer.from([242, 240, 26, 15, 148, 186, 185, 205])
+    const marketsProgramAccounts = await this.connection.getProgramAccounts(this.exponentClmmProgram.programId, {
+      filters: [
+        {
+          memcmp: {
+            offset: 0,
+            bytes: bs58.encode(MARKET_THREE_DISCRIMINATOR),
+          },
+        },
+      ],
+    })
+
+    return marketsProgramAccounts
+      .map(({ account, pubkey }) => {
+        try {
+          return this.exponentClmmProgram.coder.accounts.decode("marketThree", account.data)
+        } catch (error) {
+          return null
+        }
+      })
+      .filter((m) => !!m)
+  }
+
+  async fetchMarketThree(address: web3.PublicKey): Promise<MarketThree> {
+    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(e)
+      throw e
+    }
+  }
+
+  async fetchAllMarketThreeTicks(): Promise<Ticks[]> {
+    const TICKS_DISCRIMINATOR = Buffer.from([122, 104, 41, 141, 214, 36, 222, 37])
+
+    const ticksAccounts = await this.connection.getProgramAccounts(this.exponentClmmProgram.programId, {
+      filters: [
+        {
+          memcmp: {
+            offset: 0,
+            bytes: bs58.encode(TICKS_DISCRIMINATOR),
+          },
+        },
+      ],
+    })
+
+    return ticksAccounts.map(({ account }) => deserializeMarketThreeTicks(account.data))
+  }
+
+  async fetchMarketThreeTicks(address: web3.PublicKey): Promise<Ticks> {
+    try {
+      const m = (await this.connection.getAccountInfo(address)).data
+      return deserializeMarketThreeTicks(m)
+    } catch (e) {
+      console.error(`Error fetching market ${address.toBase58()}`)
+      console.error(e)
+      throw e
+    }
+  }
+}
+
+export function deserializeMarketThreeTicks(data: Buffer): Ticks {
+  let offset = 8
+  const MAX_TICK_NODES = 100
+  const PERSONAL_TICK_YIELD_TRACKER_SIZE = 3
+
+  const readPubkey = (): web3.PublicKey => {
+    const pk = new web3.PublicKey(data.slice(offset, offset + 32))
+    offset += 32
+    return pk
+  }
+
+  const readNumber = (): number => {
+    // Number is 32 bytes (4 x u64)
+    const nums = []
+    for (let i = 0; i < 4; i++) {
+      nums.push(new BN(data.slice(offset + i * 8, offset + (i + 1) * 8), undefined, "le"))
+    }
+    offset += 32
+    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
+
+  const ticksTreeBump = data.readUInt32LE(offset)
+  offset += 4
+
+  const ticksTreeFreeIdx = data.readUInt32LE(offset)
+  offset += 4
+
+  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 = []
+    for (let j = 0; j < PERSONAL_TICK_YIELD_TRACKER_SIZE; j++) {
+      farms.push({ lastSeenIndex: readNumber() })
+    }
+
+    // Parse EmissionYieldTrackers (3 trackers x 64 bytes each)
+    const emissions = []
+    for (let j = 0; j < PERSONAL_TICK_YIELD_TRACKER_SIZE; j++) {
+      const lastSeenIndex = readNumber()
+      const lastPositionIndex = readNumber()
+      emissions.push({ lastSeenIndex, lastPositionIndex })
+    }
+
+    // Parse last_split_epoch (u64)
+    const lastSplitEpoch = data.readBigUInt64LE(offset)
+    offset += 8
+
+    // Skip padding (u64)
+    offset += 8
+
+    if (apyBasePoints === 0) continue
+    ticks.push({
+      apyBasePoints,
+      liquidityNet,
+      feeGrowthOutsidePt,
+      feeGrowthOutsideSy,
+      liquidityGross,
+      impliedRate,
+      principalPt,
+      principalSy,
+      principalShareSupply,
+      farms,
+      emissions,
+      lastSplitEpoch,
+    })
+    // 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
+
+  return {
+    ticksTree: ticks,
+    market,
+    feeGrowthIndexGlobalPt,
+    feeGrowthIndexGlobalSy,
+    currentPrefixSum,
+    currentSpotPrice,
+    currentTick,
+  }
+}
+
+function deserializeMarketThree(m: MarketThreeRaw): MarketThree {
+  return {
+    addressLookupTable: m.addressLookupTable,
+    mintSy: m.mintSy,
+    mintPt: m.mintPt,
+    vault: m.vault,
+    tokenSyEscrow: m.tokenSyEscrow,
+    tokenPtEscrow: m.tokenPtEscrow,
+    tokenFeeTreasurySy: m.tokenFeeTreasurySy,
+    tokenFeeTreasuryPt: m.tokenFeeTreasuryPt,
+    selfAddress: m.selfAddress,
+    syProgram: m.syProgram,
+    statusFlags: m.statusFlags,
+    cpiSyAccounts: m.cpiSyAccounts,
+    isCurrentFlashSwap: m.isCurrentFlashSwap,
+    lpFarm: m.lpFarm,
+    mintYt: m.mintYt,
+    tokenYtEscrow: m.tokenYtEscrow,
+    emissions: {
+      trackers: m.emissions.trackers.map((t) => ({
+        tokenEscrow: t.tokenEscrow,
+        lpShareIndex: deserializeAnchorizedPNum(t.lpShareIndex),
+        lastSeenStaged: Number(t.lastSeenStaged),
+      })),
+    },
+    liquidityNetBalanceLimits: m.liquidityNetBalanceLimits,
+    admin: m.admin,
+    ticks: m.ticks,
+    configurationOptions: {
+      lnFeeRateRoot: m.configurationOptions.lnFeeRateRoot,
+      treasuryFeeBps: m.configurationOptions.treasuryFeeBps,
+      minLpTickAmount: BigInt(m.configurationOptions.minLpTickAmount.toString()),
+      epsilonClamp: m.configurationOptions.epsilonClamp,
+      maxLpSupply: BigInt(m.configurationOptions.maxLpSupply.toString()),
+      tickSpace: m.configurationOptions.tickSpace,
+    },
+    financials: {
+      expirationTs: BigInt(m.financials.expirationTs),
+      ptBalance: BigInt(m.financials.ptBalance.toString()),
+      syBalance: BigInt(m.financials.syBalance.toString()),
+      liquidityBalance: BigInt(m.financials.liquidityBalance.toString()),
+    },
+    cpiCoreAccounts: m.cpiCoreAccounts,
+    exponentCoreProgram: m.exponentCoreProgram,
+  }
 }
 
 function deserializeMarketTwo(m: MarketTwoRaw): MarketTwo {
@@ -324,6 +680,34 @@ function deserializeMarketTwo(m: MarketTwoRaw): MarketTwo {
   }
 }
 
+function deserializeLpPositionCLMM(x: LpPositionCLMMRaw): LpPositionCLMM {
+  return {
+    owner: x.owner,
+    market: x.market,
+    feeInsideLastPt: BigInt(x.feeInsideLastPt.toString()),
+    feeInsideLastSy: BigInt(x.feeInsideLastSy.toString()),
+    lpBalance: BigInt(x.lpBalance.toString()),
+    tokensOwedSy: BigInt(x.tokensOwedSy.toString()),
+    tokensOwedPt: BigInt(x.tokensOwedPt.toString()),
+    lowerTickIdx: x.lowerTickIdx,
+    upperTickIdx: x.upperTickIdx,
+    farms: x.farms.trackers.map((t) => ({
+      staged: BigInt(t.staged.toString()),
+      lastSeenIndex: parseFloat(PreciseNumber.fromRaw(t.lastSeenIndex[0]).valueString),
+    })),
+    shareTrackers: x.shareTrackers.trackers.map((tracker) => ({
+      tickIdx: tracker.tickIdx,
+      rightTickIdx: tracker.rightTickIdx,
+      splitEpoch: BigInt(tracker.splitEpoch.toString()),
+      lpShare: BigInt(tracker.lpShare.toString()),
+      emissions: tracker.emissions.trackers.map((e) => ({
+        staged: BigInt(e.staged.toString()),
+        lastSeenIndex: parseFloat(PreciseNumber.fromRaw(e.lastSeenIndex[0]).valueString),
+      })),
+    })),
+  }
+}
+
 function deserializeVault(x: VaultRaw): Vault {
   return {
     syProgram: x.syProgram,
@@ -355,6 +739,246 @@ function deserializeVault(x: VaultRaw): Vault {
   }
 }
 
+function deserializeOrderbook(data: Buffer): Orderbook {
+  let offset = 0
+
+  // 1) Skip Anchor discriminator
+  offset += DISCRIMINATOR_SIZE
+
+  const readPubkey = (): web3.PublicKey => {
+    const pk = new web3.PublicKey(data.slice(offset, offset + 32))
+    offset += 32
+    return pk
+  }
+
+  // ConfigurationOptions struct
+  const thresholdAmount = data.readBigUInt64LE(offset)
+  offset += 8
+  const lnMakerFeeRate = data.readDoubleLE(offset)
+  offset += 8
+  const lnTakerFeeRate = data.readDoubleLE(offset)
+  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
+
+  // Pubkeys
+  const vault = readPubkey()
+  const yieldPosition = readPubkey()
+  const addressLookupTable = readPubkey()
+  const exponentCoreProgram = readPubkey()
+  const syProgram = readPubkey()
+  const tokenEscrowSy = readPubkey()
+  const tokenEscrowYt = readPubkey()
+  const tokenEscrowPt = readPubkey()
+  const cpiAccountOrderbook = readPubkey()
+  const admin = readPubkey()
+
+  // Skip last_sy_exchange_rate (Number type = 32 bytes)
+  offset += 32
+
+  // OrderbookFinancials struct
+  // Skip last_seen_sy_index (Number type = 32 bytes)
+  offset += 32
+  const ytBalance = data.readBigUInt64LE(offset)
+  offset += 8
+  const syBalance = data.readBigUInt64LE(offset)
+  offset += 8
+  const ptBalance = data.readBigUInt64LE(offset)
+  offset += 8
+  const ytFeeBalance = data.readBigUInt64LE(offset)
+  offset += 8
+  const syFeeBalance = data.readBigUInt64LE(offset)
+  offset += 8
+  const ptFeeBalance = data.readBigUInt64LE(offset)
+  offset += 8
+  const stagedSyBalance = data.readBigUInt64LE(offset)
+  offset += 8
+  const expirationTs = data.readUInt32LE(offset)
+  offset += 4
+  // Skip financials _padding: [u8; 4]
+  offset += 4
+
+  const configurationOptions: ConfigurationOptions = {
+    priceDecimals,
+    thresholdAmount,
+    lnMakerFeeRate,
+    lnTakerFeeRate,
+  }
+  const financials: OrderbookFinancials = {
+    expirationTs,
+    syBalance: syBalance,
+    ytBalance: ytBalance,
+    ptBalance: ptBalance,
+    ytFeeBalance,
+    syFeeBalance,
+    ptFeeBalance,
+    stagedSy: stagedSyBalance,
+  }
+  // console.log("financials", financials)
+  // ─── 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 = 8
+  offset += padTo8
+
+  // NodeAllocator<T=RBNode<u32,PriceNode>, N=MAX_PRICE_NODES, R=3>
+  // header: size:u64, bump_index:u32, free_list_head:u32
+
+  const priceTreeSize = Number(data.readBigUInt64LE(offset))
+  offset += 8
+
+  const _priceTreeBump = data.readUInt32LE(offset)
+  offset += 4
+
+  const _priceTreeFreeIdx = data.readUInt32LE(offset)
+  offset += 4
+
+  // each RBNode entry = registers[3] + key:u32 + first_offer:u32
+  const prices: PriceTreeNode[] = []
+  for (let i = 0; i < MAX_PRICE_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 key = data.readUInt32LE(offset)
+    offset += 4
+
+    const firstOfferSellYt = data.readUInt32LE(offset)
+    offset += 4
+    const firstOfferBuyYt = data.readUInt32LE(offset)
+    offset += 4
+    const lastOfferSellYt = data.readUInt32LE(offset)
+    offset += 4
+    const lastOfferBuyYt = data.readUInt32LE(offset)
+    offset += 4
+    if (key === 0) continue
+    prices.push({ key, firstOfferSellYt, firstOfferBuyYt, lastOfferSellYt, lastOfferBuyYt, parent, left, right })
+  }
+
+  // ─── Parse Offers slab ────────────────────────────────────────────────────
+  // NodeAllocator<Offer, MAX_OFFERS, 4>
+  // header: size:u64, bump_index:u32, free_list_head:u32
+
+  const offersSize = Number(data.readBigUInt64LE(offset))
+  offset += 8
+  const _offersBump = data.readUInt32LE(offset)
+  offset += 4
+  const _offersFreeIdx = data.readUInt32LE(offset)
+  offset += 4
+
+  const offers: OfferNode[] = []
+  for (let i = 0; i < MAX_OFFERS; i++) {
+    const register = data.readUInt32LE(offset)
+    offset += 4
+    const nextOfferPointer = data.readUInt32LE(offset)
+    offset += 4
+    const userVaultPointer = data.readUInt32LE(offset)
+    offset += 4
+    const pricePointer = data.readUInt32LE(offset)
+    offset += 4
+    const amount = data.readBigUInt64LE(offset)
+    offset += 8
+    const expiryAt = data.readUInt32LE(offset)
+    offset += 4
+    const createdAt = data.readUInt32LE(offset)
+    offset += 4
+    const virtualOffer = data.readUInt8(offset) !== 0
+    offset += 1
+    const orderTypeFlag = data.readUInt8(offset)
+    offset += 1
+    const fillOrKill = data.readUInt8(offset) !== 0
+    offset += 1
+    offset += 5 // reserved padding
+    if (userVaultPointer === 0) continue
+    offers.push({
+      nextOfferPointer,
+      amount,
+      userVaultPointer,
+      expiryAt,
+      createdAt,
+      virtualOffer,
+      orderTypeFlag,
+      fillOrKill,
+      pricePointer,
+    })
+  }
+
+  // ─── Parse UserEscrow slab ────────────────────────────────────────────────
+  // NodeAllocator<UserEscrow, MAX_USER_ESCROWS, 2>
+  // header: size:u64, bump_index:u32, free_list_head:u32
+  const escSize = Number(data.readBigUInt64LE(offset))
+  offset += 8
+  const _escBump = data.readUInt32LE(offset)
+  offset += 4
+  const _escFreeIdx = data.readUInt32LE(offset)
+  offset += 4
+
+  // each Node = [ no registers ] + UserEscrow.value
+  const userEscrows: UserEscrowNode[] = []
+  for (let i = 0; i < MAX_USER_ESCROWS; i++) {
+    const register = data.readUInt32LE(offset)
+    offset += 4
+    const register2 = data.readUInt32LE(offset)
+    offset += 4
+    const user = new web3.PublicKey(data.slice(offset, offset + 32))
+    offset += 32
+    /*const yieldIndex = data.readBigUInt64LE(offset).toString();*/ offset += 32
+    const ptAmount = data.readBigUInt64LE(offset)
+    offset += 8
+    const syAmount = data.readBigUInt64LE(offset)
+    offset += 8
+    const ytAmount = data.readBigUInt64LE(offset)
+    offset += 8
+    const stakedYtAmount = data.readBigInt64LE(offset)
+    offset += 8
+    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 })
+  }
+
+  // ─── Finally, seed_id + signer_bump + reserved ─────────────────────────────
+  // seed_id: [u8; 4]
+  const seedId = [
+    data.readUInt8(offset),
+    data.readUInt8(offset + 1),
+    data.readUInt8(offset + 2),
+    data.readUInt8(offset + 3),
+  ]
+  offset += 4
+  // signer_bump: [u8; 1]
+  const signerBump = data.readUInt8(offset)
+  offset += 1
+  // _reserved: [u8; 3] - skip
+  offset += 3
+
+  return {
+    vault,
+    yieldPosition,
+    addressLookupTable,
+    exponentCoreProgram,
+    syProgram,
+    admin,
+    tokenEscrowSy,
+    tokenEscrowYt,
+    tokenEscrowPt,
+    cpiAccountOrderbook,
+    financials,
+    prices,
+    configurationOptions,
+    offers,
+    userEscrows,
+  }
+}
+
 function deserializeMarginfiSyMeta(x: MarginfiSyMetaRaw): MarginfiSyMeta {
   return {
     ...x,
@@ -386,7 +1010,7 @@ function deserializeSyEmissionRaw(x: {
   }
 }
 
-function deserializeLpPosition(x: LpPositionRaw): LpPosition {
+export function deserializeLpPosition(x: LpPositionRaw): LpPosition {
   return {
     owner: x.owner,
     market: x.market,
@@ -402,7 +1026,7 @@ function deserializeLpPosition(x: LpPositionRaw): LpPosition {
   }
 }
 
-function deserializeYtPosition(x: YtPositionRaw): YtPosition {
+export function deserializeYtPosition(x: YtPositionRaw): YtPosition {
   return {
     owner: x.owner,
     vault: x.vault,
@@ -419,16 +1043,30 @@ function deserializeYieldTokenTracker(x: YieldTokenTrackerRaw): YieldTokenTracke
   }
 }
 
-export async function fetchKaminoReserve(address: web3.PublicKey, connection: web3.Connection) {
+export interface KaminoReserveSummary {
+  lendingMarket: web3.PublicKey
+  baseMint: web3.PublicKey
+  assetShareValue: Decimal
+  scopePriceFeed?: web3.PublicKey
+}
+
+export async function fetchKaminoReserve(
+  address: web3.PublicKey,
+  connection: web3.Connection,
+): Promise<KaminoReserveSummary> {
   const reserve = await Reserve.fetch(connection, address)
   if (!reserve) {
     throw new Error("Reserve not found")
   }
 
+  const rawScopePriceFeed = reserve.config.tokenInfo.scopeConfiguration.priceFeed
+  const scopePriceFeed = rawScopePriceFeed.equals(web3.PublicKey.default) ? undefined : rawScopePriceFeed
+
   return {
     lendingMarket: reserve.lendingMarket,
     baseMint: reserve.liquidity.mintPubkey,
     assetShareValue: reserve.getCollateralExchangeRate(),
+    scopePriceFeed,
   }
 }
 
@@ -492,6 +1130,157 @@ export function deserializeEmission(emission: VaultEmissionJson): VaultEmission
   }
 }
 
+export interface MarketThree {
+  admin: web3.PublicKey
+  addressLookupTable: web3.PublicKey
+  mintPt: web3.PublicKey
+  mintSy: web3.PublicKey
+  mintYt: web3.PublicKey
+  vault: web3.PublicKey
+  tokenPtEscrow: web3.PublicKey
+  tokenSyEscrow: web3.PublicKey
+  tokenYtEscrow: web3.PublicKey
+  tokenFeeTreasurySy: web3.PublicKey
+  tokenFeeTreasuryPt: web3.PublicKey
+  syProgram: web3.PublicKey
+  exponentCoreProgram: web3.PublicKey
+  selfAddress: web3.PublicKey
+  ticks: web3.PublicKey
+  statusFlags: number
+  configurationOptions: MarketConfigurationOptions
+  financials: MarketThreeFinancials
+  cpiSyAccounts: CpiAccountIndexes
+  cpiCoreAccounts: MarketCpiCoreIndexes
+  isCurrentFlashSwap: boolean
+  lpFarm: LpFarm
+  emissions: {
+    trackers: {
+      tokenEscrow: web3.PublicKey
+      lpShareIndex: number
+      lastSeenStaged: number
+    }[]
+  }
+  liquidityNetBalanceLimits: LiquidityNetBalanceLimits
+}
+
+export interface Ticks {
+  /** Current tick (left boundary of the active interval) */
+  currentTick: number
+  /** Array of ticks (simplified from RBTree for TypeScript) */
+  ticksTree: Tick[]
+  /** Market address this ticks account belongs to */
+  market: web3.PublicKey
+  /** Fee growth index global for PT */
+  feeGrowthIndexGlobalPt: bigint
+  /** Fee growth index global for SY */
+  feeGrowthIndexGlobalSy: bigint
+  /** Current prefix sum - the active liquidity at the current tick */
+  currentPrefixSum: bigint
+  /** Current spot price (ln implied rate) */
+  currentSpotPrice: number
+}
+
+export interface Tick {
+  liquidityNet: bigint
+  /** Total liquidity referencing this tick as a boundary */
+  liquidityGross: bigint
+  /** Fee growth index outside this tick for PT */
+  feeGrowthOutsidePt: bigint
+  /** Fee growth index outside this tick for SY */
+  feeGrowthOutsideSy: bigint
+  /** Principal PT accrued in the interval starting at this tick */
+  impliedRate: number
+  principalPt: bigint
+  /** Principal SY accrued in the interval starting at this tick */
+  principalSy: bigint
+  apyBasePoints: number
+  principalShareSupply: bigint
+  /** Farm yield trackers (3 trackers) */
+  farms: { lastSeenIndex: number }[]
+  /** Emission yield trackers (3 trackers) */
+  emissions: { lastSeenIndex: number; lastPositionIndex: number }[]
+  /** Last split epoch for this tick */
+  lastSplitEpoch: bigint
+}
+
+export interface MarketThreeRaw {
+  admin: web3.PublicKey
+  addressLookupTable: web3.PublicKey
+  mintPt: web3.PublicKey
+  mintSy: web3.PublicKey
+  mintYt: web3.PublicKey
+  vault: web3.PublicKey
+  tokenPtEscrow: web3.PublicKey
+  tokenSyEscrow: web3.PublicKey
+  tokenYtEscrow: web3.PublicKey
+  tokenFeeTreasurySy: web3.PublicKey
+  tokenFeeTreasuryPt: web3.PublicKey
+  syProgram: web3.PublicKey
+  exponentCoreProgram: web3.PublicKey
+  selfAddress: web3.PublicKey
+  ticks: web3.PublicKey
+  statusFlags: number
+  configurationOptions: MarketConfigurationOptionsRaw
+  financials: MarketThreeFinancialsRaw
+  cpiSyAccounts: CpiAccountIndexes
+  cpiCoreAccounts: MarketCpiCoreIndexes
+  isCurrentFlashSwap: boolean
+  lpFarm: LpFarm
+  emissions: MarketEmissions
+  liquidityNetBalanceLimits: LiquidityNetBalanceLimits
+  seedId: number[]
+}
+
+export interface MarketConfigurationOptions {
+  /** ln of fee rate root */
+  lnFeeRateRoot: number
+  /** Treasury fee in basis points */
+  treasuryFeeBps: number
+  /** Minimum LP amount per tick */
+  minLpTickAmount: bigint
+  /** Epsilon clamp for numerical stability */
+  epsilonClamp: number
+  /** Maximum LP supply */
+  maxLpSupply: bigint
+  /** Tick space */
+  tickSpace: number
+  // priceDecimals: number ??
+}
+
+export interface MarketThreeFinancials {
+  expirationTs: bigint
+  ptBalance: bigint
+  syBalance: bigint
+  liquidityBalance: bigint
+}
+
+export interface MarketConfigurationOptionsRaw {
+  lnFeeRateRoot: number
+  treasuryFeeBps: number
+  minLpTickAmount: BN
+  epsilonClamp: number
+  maxLpSupply: BN
+  tickSpace: number
+}
+
+export interface OrderbookConfigurationOptionsRaw {
+  thresholdAmount: BN
+  lnMakerFeeRate: number
+  lnTakerFeeRate: number
+  priceDecimals: number
+}
+
+export interface MarketThreeFinancialsRaw {
+  /** Expiration timestamp */
+  expirationTs: number
+  /** PT balance in the market */
+  ptBalance: BN
+  /** SY balance in the market */
+  syBalance: BN
+  /** Total liquidity balance */
+  liquidityBalance: BN
+}
+
 export interface MarketTwo {
   ptBalance: bigint
   syBalance: bigint
@@ -557,6 +1346,42 @@ export interface Vault {
   maxPySupply: bigint
 }
 
+interface OrderbookFinancials {
+  expirationTs: number
+  ytBalance: bigint
+  syBalance: bigint
+  ptBalance: bigint
+  ytFeeBalance: bigint
+  syFeeBalance: bigint
+  ptFeeBalance: bigint
+  stagedSy: bigint
+}
+
+export interface ConfigurationOptions {
+  priceDecimals: number
+  thresholdAmount: bigint
+  lnMakerFeeRate: number
+  lnTakerFeeRate: number
+}
+
+export interface Orderbook {
+  vault: web3.PublicKey
+  yieldPosition: web3.PublicKey
+  addressLookupTable: web3.PublicKey
+  exponentCoreProgram: web3.PublicKey
+  syProgram: web3.PublicKey
+  tokenEscrowSy: web3.PublicKey
+  tokenEscrowYt: web3.PublicKey
+  tokenEscrowPt: web3.PublicKey
+  cpiAccountOrderbook: web3.PublicKey
+  admin: web3.PublicKey
+  configurationOptions: ConfigurationOptions
+  financials: OrderbookFinancials
+  prices: PriceTreeNode[]
+  offers: OfferNode[]
+  userEscrows: UserEscrowNode[]
+}
+
 export interface KaminoSyMeta {
   kaminoReserve: web3.PublicKey
   kaminoObligation: web3.PublicKey
@@ -604,7 +1429,7 @@ export interface YieldTokenTracker {
   lastSeenIndex: number
 }
 
-interface LpPositionRaw {
+export interface LpPositionRaw {
   owner: web3.PublicKey
   market: web3.PublicKey
   lpBalance: BN
@@ -612,6 +1437,48 @@ interface LpPositionRaw {
   farms: { trackers: { staged: BN; lastSeenIndex: AnchorizedPNum }[] }
 }
 
+interface LpPositionCLMMRaw {
+  owner: web3.PublicKey
+  market: web3.PublicKey
+  feeInsideLastPt: BN
+  feeInsideLastSy: BN
+  lpBalance: BN
+  tokensOwedSy: BN
+  tokensOwedPt: BN
+  lowerTickIdx: number
+  upperTickIdx: number
+  farms: { trackers: { staged: BN; lastSeenIndex: AnchorizedPNum }[] }
+  shareTrackers: {
+    trackers: {
+      tickIdx: number
+      rightTickIdx: number
+      splitEpoch: BN
+      lpShare: BN
+      emissions: { trackers: { staged: BN; lastSeenIndex: AnchorizedPNum }[] }
+    }[]
+  }
+}
+
+export interface LpPositionCLMM {
+  owner: web3.PublicKey
+  market: web3.PublicKey
+  feeInsideLastPt: bigint
+  feeInsideLastSy: bigint
+  lpBalance: bigint
+  tokensOwedSy: bigint
+  tokensOwedPt: bigint
+  lowerTickIdx: number
+  upperTickIdx: number
+  farms: { staged: bigint; lastSeenIndex: number }[]
+  shareTrackers: {
+    tickIdx: number
+    rightTickIdx: number
+    splitEpoch: bigint
+    lpShare: bigint
+    emissions: { staged: bigint; lastSeenIndex: number }[]
+  }[]
+}
+
 export interface LpFarm {
   lastSeenTimestamp: number
   farmEmissions: FarmEmissionRaw[]
@@ -636,7 +1503,7 @@ export interface MarketEmissions {
   trackers: MarketEmission[]
 }
 
-interface MarketEmission {
+export interface MarketEmission {
   tokenEscrow: web3.PublicKey
   lpShareIndex: AnchorizedPNum
   lastSeenStaged: BN
@@ -719,7 +1586,7 @@ interface KaminoSyMetaRaw {
   emissions: SyEmissionRaw[]
 }
 
-interface YtPositionRaw {
+export interface YtPositionRaw {
   owner: web3.PublicKey
   vault: web3.PublicKey
   ytBalance: BN
@@ -732,6 +1599,62 @@ interface YieldTokenTrackerRaw {
   lastSeenIndex: AnchorizedPNum
 }
 
+export interface OrderbookCpiAccountsRaw {
+  syCpiAccounts: CpiAccountIndexes
+  exponentCoreCpiAccounts: ExponentCoreCpiIndexes
+}
+
+interface OrderbookRaw {
+  vault: web3.PublicKey
+  yieldPosition: web3.PublicKey
+  addressLookupTable: web3.PublicKey
+  exponentCoreProgram: web3.PublicKey
+  cpiAccountOrderbook: web3.PublicKey
+  tokenEscrowSy: web3.PublicKey
+  tokenEscrowYt: web3.PublicKey
+  tokenEscrowPt: web3.PublicKey
+  nodeCount: number
+  financials: OrderbookFinancialsRaw
+  prices: PriceTreeNodeRaw[]
+  offers: OfferNodeRaw[]
+  userEscrows: UserEscrowNodeRaw[]
+}
+
+interface OrderbookFinancialsRaw {
+  expirationTs: number
+  ytBalance: BN
+  syBalance: BN
+  ptBalance: BN
+}
+
+export interface PriceTreeNodeRaw {
+  key: number
+  firstOffer: number
+  parent: number
+  left: number
+  right: number
+}
+
+export interface OfferNodeRaw {
+  register: number
+  amount: BN
+  userVaultPointer: number
+  expiryAt: number
+  createdAt: number
+  virtualOffer: boolean
+  orderTypeFlag: number
+  fillOrKill: boolean
+}
+
+export interface UserEscrowNodeRaw {
+  user: web3.PublicKey
+  yieldIndex: BN
+  ptAmount: BN
+  syAmount: BN
+  ytAmount: BN
+  staged: number
+}
+
 function deserializeAnchorizedPNum(x: AnchorizedPNum): number {
   return parseFloat(PreciseNumber.fromRaw(x[0]).valueString)
 }
@@ -745,30 +1668,7 @@ async function fetchJitoVaultData({
   vaultAddress: web3.PublicKey
 }) {
   const vaultAccountInfo = await connection.getAccountInfo(vaultAddress)
-  const d = vaultAccountInfo.data
-
-  // the vault has an 8 byte discriminator at the beginning
-  const discriminatorOffset = 8
-  const vrtMintOffset = 32 + discriminatorOffset
-  const vrtSupplyOffset = 96 + discriminatorOffset
-  const jitoVaultTotalDepositsOffset = 104 + discriminatorOffset
-  const mintBase = new web3.PublicKey(d.slice(vrtMintOffset, vrtMintOffset + 32))
-
-  // For Borsh, numbers are serialized in little-endian format
-  const jitoVaultTotalSharesBuffer = d.slice(vrtSupplyOffset, vrtSupplyOffset + 8)
-  const jitoVaultTotalShares = new BN(jitoVaultTotalSharesBuffer, "le")
-
-  const jitoVaultTotalDepositsBuffer = d.slice(jitoVaultTotalDepositsOffset, jitoVaultTotalDepositsOffset + 8)
-  const jitoVaultTotalDeposits = new BN(jitoVaultTotalDepositsBuffer, "le")
-
-  const jitoVaultTotalSharesD = new Decimal(jitoVaultTotalShares.toString())
-  const jitoVaultTotalDepositsD = new Decimal(jitoVaultTotalDeposits.toString())
-
-  const exchangeRate = jitoVaultTotalDepositsD.isZero()
-    ? "1.0"
-    : jitoVaultTotalDepositsD.div(jitoVaultTotalSharesD).toString()
-
-  return { exchangeRate: parseFloat(exchangeRate), mintBase }
+  return decodeJitoVaultData(vaultAccountInfo.data)
 }
 
 async function fetchJitoSolToSolExchangeRate({
@@ -810,23 +1710,16 @@ export async function fetchPerenaStablePoolData({
   connection: web3.Connection
   perenaStablePool: web3.PublicKey
 }) {
-  const [lpMint, _] = web3.PublicKey.findProgramAddressSync(
-    [perenaStablePool.toBuffer(), Buffer.from("liquidity")],
-    new web3.PublicKey("NUMERUNsFCP3kuNmWZuXtm1AaQCPj9uw6Guv2Ekoi5P"),
-  )
+  const lpMint = getPerenaLpMint(perenaStablePool)
 
   const [accountInfo, lpMintInfo] = await connection.getMultipleAccountsInfo([perenaStablePool, lpMint])
-  const lpMintDeserialized = MintLayout.decode(lpMintInfo.data)
-  const d = accountInfo.data
-
-  const discriminatorOffset = 8
-  const invTOffset = discriminatorOffset + 32 + 32 + 32 + 32 // 4 Pubkeys before invT
-  const invTBuffer = d.slice(invTOffset, invTOffset + 8)
-  const invT = Buffer.from(invTBuffer).readBigUInt64LE(0)
 
-  const exchangeRate = new Decimal(invT.toString()).div(new Decimal(lpMintDeserialized.supply.toString())).toString()
+  const { lpSupply, invT, exchangeRate } = getPerenaStablePoolData({
+    perenaStablePoolData: accountInfo.data,
+    lpMintData: lpMintInfo.data,
+  })
 
-  return { lpSupply: lpMintDeserialized.supply, invT, exchangeRate, lpMint }
+  return { lpSupply, invT, exchangeRate, lpMint }
 }
 
 /**
@@ -880,53 +1773,19 @@ export async function fetchJupiterPerpsIndex({
   lastAumUsd: BN
   currentIndex: AnchorizedPNum
   lastRealizedFeeUsdUpdateUnixTimestamp: number
-}): Promise<{
-  index: number
-  newState: {
-    lastAumUsd: BN
-    lastRealizedFeeUsd: BN
-    lastFeeUsdResetUnixTimestamp: number
-    lastRealizedFeeUsdUpdateUnixTimestamp: number
-  }
-}> {
-  // Decode pool account using helper that leverages Anchor 0.29.0
+}): Promise<ReturnType<typeof calculateJupiterPerpsIndex>> {
   const accountInfo = await connection.getAccountInfo(pool)
-  const account: any = decodeJupiterPerpsPoolAccount(accountInfo?.data as Buffer)
-  const SECONDS_PER_YEAR = 365 * 24 * 60 * 60
-
-  let newFeesBn: BN
 
-  if (lastRealizedFeeUsdUpdateUnixTimestamp === 0) {
-    newFeesBn = new BN(account.poolApr.realizedFeeUsd.toString())
-  } else if (Number(account.poolApr.lastUpdated) > lastFeeUsdResetUnixTimestamp) {
-    const timeBetweenResets = Number(account.poolApr.lastUpdated) - lastFeeUsdResetUnixTimestamp
-    const feeAprBps = new BN(account.poolApr.feeAprBps)
-    const estTotalFees =
-      lastAumUsd.gt(new BN(0)) && timeBetweenResets > 0
-        ? feeAprBps.mul(lastAumUsd).mul(new BN(timeBetweenResets)).div(new BN(SECONDS_PER_YEAR)).div(new BN(10_000))
-        : new BN(0)
-
-    const missingFees = estTotalFees.sub(lastRealizedFeeUsd)
-    const feesSinceReset = new BN(account.poolApr.realizedFeeUsd.toString())
-    newFeesBn = missingFees.add(feesSinceReset)
-  } else {
-    newFeesBn = new BN(account.poolApr.realizedFeeUsd.toString()).sub(lastRealizedFeeUsd)
-  }
-
-  const aumUsd = new BN(account.aumUsd.toString())
-  const indexIncrease = new Decimal(newFeesBn.toString()).div(new Decimal(aumUsd.toString())).toNumber()
-  const currentIndexNum = parseFloat(PreciseNumber.fromRaw(currentIndex[0]).valueString)
-  const nextIndex = currentIndexNum + indexIncrease
-
-  return {
-    index: nextIndex,
-    newState: {
-      lastAumUsd: aumUsd,
-      lastRealizedFeeUsd: new BN(account.poolApr.realizedFeeUsd.toString()),
-      lastFeeUsdResetUnixTimestamp: Number(account.poolApr.lastUpdated),
-      lastRealizedFeeUsdUpdateUnixTimestamp: Math.floor(Date.now() / 1000),
+  return calculateJupiterPerpsIndex(
+    { pool: accountInfo.data },
+    {
+      lastFeeUsdResetUnixTimestamp,
+      lastRealizedFeeUsd,
+      lastAumUsd,
+      currentIndex,
+      lastRealizedFeeUsdUpdateUnixTimestamp,
     },
-  }
+  )
 }
 
 export async function fetchPyth(connection: web3.Connection): Promise<string> {
@@ -975,13 +1834,11 @@ export async function fetchFragmetricIndex({
   connection: web3.Connection
   fragmetricFund: web3.PublicKey
 }) {
-  const account = await connection.getAccountInfo(fragmetricFund)
-  const coder = new BorshCoder(FragmetricIdl as Idl)
-  const data = coder.accounts.decode("FundAccount", account.data)
-  const index = Number(data.one_receipt_token_as_sol) / Number(10 ** data.receipt_token_decimals)
+  const fragmetricFundRaw = await connection.getAccountInfo(fragmetricFund)
 
-  const receiptTokenMint = new web3.PublicKey(data.receipt_token_mint)
-  const wrappedTokenMint = new web3.PublicKey(data.wrapped_token.mint)
+  const { index, receiptTokenMint, wrappedTokenMint } = calculateFragmetricIndex({
+    fragmetricFund: fragmetricFundRaw.data,
+  })
 
   return { index, receiptTokenMint, wrappedTokenMint }
 }
@@ -992,21 +1849,24 @@ export async function fetchJupiterLendIndex({
 }: {
   connection: web3.Connection
   jupiterLendAccount: web3.PublicKey
-}) {
+}): Promise<ReturnType<typeof calculateJupiterLendIndex> & { rateModel: web3.PublicKey }> {
   const account = await connection.getAccountInfo(jupiterLendAccount)
-  const coder = new BorshCoder(JupiterLendIdl as Idl)
-  const data = coder.accounts.decode("Lending", account.data)
-  const index = Number(data.token_exchange_price) / Number(10 ** 12)
-  const tokenReservesLiquidity = data.token_reserves_liquidity
-  const lendingSupplyPosition = data.supply_position_on_liquidity
-  const rewardsRateModel = data.rewards_rate_model
+
   const rateModel = jupiterLendAccount.equals(new web3.PublicKey("BeAqbxfrcXmzEYT2Ra62oW2MqkuFDHaCtps47Mzg6Zj3"))
     ? new web3.PublicKey("Acvyi9HBGmqh3Exe1N4PjBVyY8fokq2AdC6fSLqV6KSo")
     : new web3.PublicKey("6iHHKAK9Mqjn57CVmWe4szAPyTH8s8pniXSj6vWaKW5r")
 
-  console.log("token reserves liquidity in fetch jupiter lend index", tokenReservesLiquidity.toBase58())
+  const { index, baseTokenMint, tokenReservesLiquidity, lendingSupplyPosition, rewardsRateModel } =
+    calculateJupiterLendIndex({ jupiterLend: account.data })
 
-  return { index, baseTokenMint: data.mint, tokenReservesLiquidity, lendingSupplyPosition, rewardsRateModel, rateModel }
+  return {
+    rateModel,
+    index,
+    baseTokenMint,
+    tokenReservesLiquidity,
+    lendingSupplyPosition,
+    rewardsRateModel,
+  }
 }
 
 export async function fetchKaminoVaultIndex({
@@ -1053,18 +1913,10 @@ export async function fetchFragmetricSupportedTokenIndex({
   connection: web3.Connection
   fragmetricFund: web3.PublicKey
   index: number
-}) {
+}): Promise<ReturnType<typeof calculateFragmetricSupportedTokenIndex>> {
   const account = await connection.getAccountInfo(fragmetricFund)
-  const coder = new BorshCoder(FragmetricIdl as Idl)
-  const data = coder.accounts.decode("FundAccount", account.data)
-  const syIndex =
-    Number(10 ** data.supported_tokens[index].decimals) /
-    Number(data.supported_tokens[index].one_token_as_receipt_token)
-
-  const receiptTokenMint = new web3.PublicKey(data.receipt_token_mint)
-  const wrappedTokenMint = new web3.PublicKey(data.wrapped_token.mint)
 
-  return { index: syIndex, receiptTokenMint, wrappedTokenMint }
+  return calculateFragmetricSupportedTokenIndex({ fragmetricFund: account.data }, index)
 }
 
 interface AccountsInterface {
@@ -1090,14 +1942,14 @@ export async function fetchMeteoraIndex({
   try {
     const VIRTUAL_PRICE_PRECISION = new BN(100_000_000)
 
-    const pool = await decodePoolAccount(connection, accounts.pool)
+    const pool = await fetchPoolAccount(connection, accounts.pool)
 
     const poolMint = await getMint(connection, pool.lpMint)
     const poolLpSupply = new BN(poolMint.supply.toString())
     const poolLpDecimals = Number(poolMint.decimals.toString())
 
-    const vaultA = await decodeVaultAccount(connection, accounts.vaultA)
-    const vaultB = await decodeVaultAccount(connection, accounts.vaultB)
+    const vaultA = await fetchVaultAccount(connection, accounts.vaultA)
+    const vaultB = await fetchVaultAccount(connection, accounts.vaultB)
 
     const vaultLpMintA = await getMint(connection, vaultA.lpMint)
     const vaultLpMintB = await getMint(connection, vaultB.lpMint)
@@ -1155,8 +2007,6 @@ export async function fetchAdrenaIndex({
   index: number
 }> {
   try {
-    const zero = new BN(0)
-
     // Fetch all account data in a single RPC call
     const accountInfos = await connection.getMultipleAccountsInfo([
       accounts.pool,
@@ -1170,25 +2020,17 @@ export async function fetchAdrenaIndex({
       throw new Error("One or more Adrena accounts not found")
     }
 
-    // Decode accounts using adrena-idl package functions
-    const { poolAccount, custodyAccounts } = decodePoolAndCustodyAccounts(accountInfos)
-    // @ts-ignore
-    const currentTotalFees = calculateTotalFeesFromCustodies(custodyAccounts)
-
-    let yieldIncrement: number
-    let aumValue = poolAccount.aumUsd.low
-
-    if (aumValue.eq(zero)) {
-      yieldIncrement = 0
-    }
-
-    let feeDifference = currentTotalFees.gte(previousTotalFees) ? currentTotalFees.sub(previousTotalFees) : zero
-
-    yieldIncrement = feeDifference.toNumber() / aumValue.toNumber()
-
-    let currentIndexNumber = parseFloat(PreciseNumber.fromRaw(currentIndex[0]).valueString)
-
-    return { index: currentIndexNumber + yieldIncrement }
+    return calculateAdrenaIndex(
+      {
+        pool: accountInfos[0].data,
+        custody1: accountInfos[1].data,
+        custody2: accountInfos[2].data,
+        custody3: accountInfos[3].data,
+        custody4: accountInfos[4].data,
+      },
+      previousTotalFees,
+      currentIndex,
+    )
   } catch (error) {
     throw error
   }
@@ -1201,26 +2043,14 @@ export async function fetchSanctumIndex({
   connection: web3.Connection
   accounts: AccountsInterface
 }): Promise<number> {
-  try {
-    const poolState = await decodePoolStateAccount(connection, accounts.poolState)
-    const lpMint = await getMint(connection, accounts.lpMint)
-
-    const zeroBn = new BN(0)
-    const precision = new BN(10 ** lpMint.decimals)
-    const lpTokenSupplyBn = new BN(lpMint.supply.toString())
-    const poolTotalSolValueBn = new BN(poolState.totalSolValue.toString())
-
-    if (lpTokenSupplyBn.eq(zeroBn) || poolTotalSolValueBn.eq(zeroBn)) {
-      return 1
-    }
-
-    const exchangeRateBn = lpTokenSupplyBn.mul(precision).div(poolTotalSolValueBn)
-    const exchangeRate = new Decimal(exchangeRateBn.toString()).div(precision.toString()).toNumber()
+  const [poolStateAccountRaw, lpMintAccountRaw] = await Promise.all(
+    [accounts.poolState, accounts.lpMint].map((pk) => connection.getAccountInfo(pk)),
+  )
 
-    return 1 / exchangeRate // We return inverse exchange rate
-  } catch (error) {
-    throw error
-  }
+  return calculateSanctumIndex({
+    poolStateAccountData: poolStateAccountRaw.data,
+    lpMintAccountData: lpMintAccountRaw.data,
+  })
 }
 
 export async function fetchSolsticeRedemptionRate({
@@ -1231,60 +2061,85 @@ export async function fetchSolsticeRedemptionRate({
   connection: web3.Connection
   yieldPool: web3.PublicKey
   vestingSchedule: web3.PublicKey
-}): Promise<{
-  redemptionRate: number
-  totalAssets: string
-  sharesSupply: string
-  vestingAmount: string
-  totalVestedAssets: string
-}> {
-  try {
-    // Fetch both accounts in a single RPC call for efficiency
-    const accountInfos = await connection.getMultipleAccountsInfo([yieldPool, vestingSchedule])
+}): Promise<ReturnType<typeof calculateSolsticeRedemptionRate>> {
+  // Fetch both accounts in a single RPC call for efficiency
+  const accountInfos = await connection.getMultipleAccountsInfo([yieldPool, vestingSchedule])
 
-    if (!accountInfos[0] || !accountInfos[1]) {
-      throw new Error("One or more Solstice accounts not found")
-    }
+  if (!accountInfos[0] || !accountInfos[1]) {
+    throw new Error("One or more Solstice accounts not found")
+  }
 
-    // Decode accounts using solstice-idl package function
-    const { yieldPoolAccount, vestingScheduleAccount } = decodeYieldPoolAndVestingScheduleAccounts(accountInfos)
+  return calculateSolsticeRedemptionRate({ yieldPool: accountInfos[0].data, vestingSchedule: accountInfos[1].data })
+}
 
-    // Extract fields for calculation (convert BN to bigint)
-    const poolTotalAssets = BigInt(yieldPoolAccount.total_assets.toString())
-    const poolSharesSupply = BigInt(yieldPoolAccount.shares_supply.toString())
-    const vestingAmount = BigInt(vestingScheduleAccount.vesting_amount.toString())
+const REFLECT_ORACLE_LEN = 17
+const REFLECT_MAX_STALENESS_SLOTS = 150
 
-    // Calculate total vested assets (mimicking the Rust logic)
-    let totalVestedAssets: bigint
-    if (vestingAmount === 0n) {
-      totalVestedAssets = poolTotalAssets // If no vesting amount, all assets are considered vested
-    } else {
-      const vestingStart = BigInt(vestingScheduleAccount.start_time.toString())
-      const vestingEnd = BigInt(vestingScheduleAccount.end_time.toString())
-      const currentTime = BigInt(Math.floor(Date.now() / 1000)) // Current Unix timestamp
-
-      // Calculate unvested amount
-      let unvestedAmount: bigint
-      if (currentTime > vestingEnd) {
-        unvestedAmount = 0n // If current time passed the vesting end, no unvested amount
-      } else {
-        unvestedAmount = (vestingAmount * (vestingEnd - currentTime)) / (vestingEnd - vestingStart)
-      }
+export async function fetchReflectRedemptionRate({
+  connection,
+  oracle,
+}: {
+  connection: web3.Connection
+  oracle: web3.PublicKey
+}): Promise<number> {
+  const accountInfo = await connection.getAccountInfo(oracle)
 
-      totalVestedAssets = poolTotalAssets - unvestedAmount
-    }
+  if (!accountInfo) {
+    throw new Error("Reflect oracle account not found")
+  }
 
-    // Calculate redemption rate: (total_vested_assets + 1) / (pool_shares_supply + 1)
-    const redemptionRate = Number(totalVestedAssets + 1n) / Number(poolSharesSupply + 1n)
+  if (accountInfo.data.length !== REFLECT_ORACLE_LEN) {
+    throw new Error(`Reflect oracle account has invalid length: ${accountInfo.data.length}`)
+  }
 
-    return {
-      redemptionRate,
-      totalAssets: poolTotalAssets.toString(),
-      sharesSupply: poolSharesSupply.toString(),
-      vestingAmount: vestingAmount.toString(),
-      totalVestedAssets: totalVestedAssets.toString(),
-    }
-  } catch (error) {
-    throw error
+  const slot = Number(accountInfo.data.readBigUInt64LE(0))
+  const price = Number(accountInfo.data.readBigUInt64LE(8))
+  const precision = accountInfo.data.readUInt8(16)
+
+  const currentSlot = await connection.getSlot()
+  if (slot > currentSlot) {
+    throw new Error("Reflect oracle slot is ahead of the current slot")
+  }
+  const slotDelta = currentSlot - slot
+
+  if (slotDelta > REFLECT_MAX_STALENESS_SLOTS) {
+    throw new Error("Reflect oracle data is stale")
+  }
+
+  const scale = Math.pow(10, precision)
+
+  if (scale === 0) {
+    throw new Error("Invalid oracle precision")
   }
+
+  return price / scale
+}
+
+export async function fetchOreExchangeRate({
+  connection,
+  storeMint,
+  stakeAccount,
+  treasury,
+}: {
+  connection: web3.Connection
+  storeMint: web3.PublicKey
+  stakeAccount: web3.PublicKey
+  treasury: web3.PublicKey
+}): Promise<number> {
+  // Fetch all accounts in parallel for efficiency
+  const [storeMintInfo, stakeAccountInfo, treasuryAccountInfo] = await Promise.all([
+    connection.getAccountInfo(storeMint),
+    connection.getAccountInfo(stakeAccount),
+    connection.getAccountInfo(treasury),
+  ])
+
+  if (!storeMintInfo || !stakeAccountInfo || !treasuryAccountInfo) {
+    throw new Error("One or more ORE accounts not found")
+  }
+
+  return calculateOreExchangeRate({
+    stakeAccount: stakeAccountInfo.data,
+    treasuryAccount: treasuryAccountInfo.data,
+    storeMint: storeMintInfo.data,
+  })
 }