@exponent-labs/exponent-fetcher 0.9.11 → 0.9.12

package/src/exponentFetcher.ts

@@ -87,8 +87,6 @@ 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 }
@@ -350,6 +348,11 @@ export class ExponentFetcher {
             },
           })),
         },
+        crossingSplit: {
+          crossLeftIdx: raw.crossingSplit.crossLeftIdx,
+          crossRightIdx: raw.crossingSplit.crossRightIdx,
+          lpBalanceCrossing: raw.crossingSplit.lpBalanceCrossing,
+        },
       }
 
       return deserializeLpPositionCLMM(v)
@@ -477,7 +480,7 @@ export class ExponentFetcher {
  * 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
+ * - 1000 RBTree nodes, each: nodeHeader(16) + key(4) + padding(4) + Tick(416) = 440 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 {
@@ -577,13 +580,13 @@ export function deserializeMarketThreeTicks(data: Buffer): Ticks {
     const principalSy = readU64() // 8 bytes
     const principalShareSupply = readPreciseNumberAsBigint() // 32 bytes - kept as bigint for arithmetic
 
-    // FarmYieldTrackers: 2 x FarmYieldTracker(32 bytes) = 64 bytes
+    // FarmYieldTrackers: 3 x FarmYieldTracker(32 bytes) = 96 bytes
     const farms: { lastSeenIndex: number }[] = []
     for (let j = 0; j < PERSONAL_TICK_YIELD_TRACKER_SIZE; j++) {
       farms.push({ lastSeenIndex: readPreciseNumberAsFloat() })
     }
 
-    // EmissionYieldTrackers: 2 x EmissionYieldTracker(64 bytes) = 128 bytes
+    // EmissionYieldTrackers: 3 x EmissionYieldTracker(64 bytes) = 192 bytes
     const emissions: { lastSeenIndex: number; lastPositionIndex: number }[] = []
     for (let j = 0; j < PERSONAL_TICK_YIELD_TRACKER_SIZE; j++) {
       emissions.push({
@@ -632,76 +635,7 @@ export function deserializeMarketThreeTicks(data: Buffer): Ticks {
   }
 }
 
-/** 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,
@@ -714,7 +648,7 @@ export function deserializeMarketThree(m: MarketThreeRaw): MarketThree {
     selfAddress: m.selfAddress,
     syProgram: m.syProgram,
     statusFlags: m.statusFlags,
-    cpiSyAccounts,
+    cpiSyAccounts: m.cpiSyAccounts,
     isCurrentFlashSwap: m.isCurrentFlashSwap,
     lpFarm: m.lpFarm,
     mintYt: m.mintYt,
@@ -743,9 +677,8 @@ export function deserializeMarketThree(m: MarketThreeRaw): MarketThree {
       syBalance: BigInt(m.financials.syBalance.toString()),
       liquidityBalance: BigInt(m.financials.liquidityBalance.toString()),
     },
-    cpiCoreAccounts,
+    cpiCoreAccounts: m.cpiCoreAccounts,
     exponentCoreProgram: m.exponentCoreProgram,
-    seedId: m.seedId,
   }
 }
 
@@ -812,6 +745,12 @@ function deserializeLpPositionCLMM(x: LpPositionCLMMRaw): LpPositionCLMM {
         lastSeenIndex: parseFloat(PreciseNumber.fromRaw(e.lastSeenIndex[0]).valueString),
       })),
     })),
+    crossingSplit: {
+      crossLeftIdx: x.crossingSplit.crossLeftIdx,
+      crossRightIdx: x.crossingSplit.crossRightIdx,
+      lpBalanceCrossing: BigInt(x.crossingSplit.lpBalanceCrossing.toString()),
+      isActive: x.crossingSplit.crossLeftIdx !== 0xffffffff && x.crossingSplit.crossRightIdx !== 0xffffffff,
+    },
   }
 }
 
@@ -867,7 +806,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] + _reserved[1024] = 1135 bytes
+  // Skip ConfigurationOptions padding/reserve:
+  // _placeholder_one[15] + _placeholder_two[32] + _placeholder_three[32] + _placeholder_four[32] + _reserved[1024]
   offset += 1135
 
   // Pubkeys
@@ -882,14 +822,7 @@ function deserializeOrderbook(data: Buffer): Orderbook {
   const cpiAccountOrderbook = readPubkey()
   const admin = readPubkey()
 
-  // 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
-  })()
+  // Skip last_sy_exchange_rate (Number type = 32 bytes)
   offset += 32
 
   // OrderbookFinancials struct
@@ -1045,12 +978,7 @@ function deserializeOrderbook(data: Buffer): Orderbook {
     offset += 4
     const user = new web3.PublicKey(data.slice(offset, offset + 32))
     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 yieldIndex = data.readBigUInt64LE(offset).toString();*/ offset += 32
     const ptAmount = data.readBigUInt64LE(offset)
     offset += 8
     const syAmount = data.readBigUInt64LE(offset)
@@ -1063,7 +991,7 @@ function deserializeOrderbook(data: Buffer): Orderbook {
     offset += 8
     offset += 8 // reserved
     // if (user.toBase58() == "11111111111111111111111111111111") continue
-    userEscrows.push({ user, yieldIndex, ptAmount, syAmount, ytAmount, stakedYtAmount, staged })
+    userEscrows.push({ user, yieldIndex: 0, ptAmount, syAmount, ytAmount, stakedYtAmount, staged })
   }
 
   // ─── Finally, seed_id + signer_bump + reserved ─────────────────────────────
@@ -1092,14 +1020,13 @@ function deserializeOrderbook(data: Buffer): Orderbook {
     tokenEscrowYt,
     tokenEscrowPt,
     cpiAccountOrderbook,
-    lastSyExchangeRate: lastSyExchangeRateRaw,
     financials,
     prices,
     configurationOptions,
     offers,
     userEscrows,
-    offersBumpIndex,
     offersFreeListHead,
+    offersBumpIndex,
   }
 }
 
@@ -1285,7 +1212,6 @@ export interface MarketThree {
     }[]
   }
   liquidityNetBalanceLimits: LiquidityNetBalanceLimits
-  seedId: number[]
 }
 
 export interface Ticks {
@@ -1320,13 +1246,13 @@ export interface Tick {
   principalSy: bigint
   apyBasePoints: number
   principalShareSupply: bigint
-  /** Farm yield trackers (2 trackers) */
+  /** Farm yield trackers (3 trackers) */
   farms: { lastSeenIndex: number }[]
-  /** Emission yield trackers (2 trackers) */
+  /** Emission yield trackers (3 trackers) */
   emissions: { lastSeenIndex: number; lastPositionIndex: number }[]
   /** Last split epoch for this tick */
   lastSplitEpoch: bigint
-  /** Frozen liquidity that cannot be withdrawn */
+  /** Minimum liquidity retained on ticks used by wrapper-base liquidity */
   frozenLiquidity: bigint
 }
 
@@ -1502,16 +1428,12 @@ 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
 }
 
@@ -1590,6 +1512,11 @@ interface LpPositionCLMMRaw {
       emissions: { trackers: { staged: BN; lastSeenIndex: AnchorizedPNum }[] }
     }[]
   }
+  crossingSplit: {
+    crossLeftIdx: number
+    crossRightIdx: number
+    lpBalanceCrossing: BN
+  }
 }
 
 export interface LpPositionCLMM {
@@ -1610,6 +1537,12 @@ export interface LpPositionCLMM {
     lpShare: bigint
     emissions: { staged: bigint; lastSeenIndex: number }[]
   }[]
+  crossingSplit: {
+    crossLeftIdx: number
+    crossRightIdx: number
+    lpBalanceCrossing: bigint
+    isActive: boolean
+  }
 }
 
 export interface LpFarm {
@@ -1781,7 +1714,7 @@ export interface OfferNodeRaw {
 
 export interface UserEscrowNodeRaw {
   user: web3.PublicKey
-  yieldIndex: number
+  yieldIndex: BN
   ptAmount: BN
   syAmount: BN
   ytAmount: BN
@@ -2025,70 +1958,28 @@ export async function fetchKaminoVaultIndex({
 
   const data = coder.accounts.decode("VaultState", account.data)
 
-  const activeAllocations = data.vault_allocation_strategy
-    .filter((allocation) => allocation.reserve.toBase58() !== web3.PublicKey.default.toBase58())
-  const activeReserves = activeAllocations.map((allocation) => allocation.reserve)
+  const activeReserves = data.vault_allocation_strategy
+    .map((r) => r.reserve)
+    .filter((reserve) => reserve.toBase58() !== web3.PublicKey.default.toBase58())
 
-  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),
-  )
+  console.log("activeReserves", activeReserves)
+  const activeReservesData = await connection.getMultipleAccountsInfo(activeReserves)
 
   const reserves = activeReserves.map((r, i) => {
-    const reserveAccount = decodedReserves[i]
-    const allocation = activeAllocations[i]
-    const [lendingMarketAuthority] = web3.PublicKey.findProgramAddressSync(
-      [Buffer.from("lma"), reserveAccount.lendingMarket.toBuffer()],
-      new web3.PublicKey("KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD"),
-    )
-
+    console.log("r.data", activeReservesData[i].data)
     return {
       reserveAddress: r,
-      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,
+      reserve: Reserve.decode(activeReservesData[i].data).lendingMarket,
     }
   })
 
+  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,
-    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,
-  }
+  return { index: 1, tokenVault, tokenMint, baseVaultAuthority, sharesMint, reserves }
 }
 
 export async function fetchFragmetricSupportedTokenIndex({

package/src/utils/ore.ts

@@ -3,12 +3,12 @@ import { web3 } from "@coral-xyz/anchor"
 import { MintLayout } from "@solana/spl-token"
 import Decimal from "decimal.js"
 
-// Steel's Numeric type is a u128 with 12 decimal places of precision
-const NUMERIC_DECIMAL_PLACES = 12
+// Steel's Numeric type is an I80F48 fixed-point number.
+const NUMERIC_SCALE = new Decimal(2).pow(48)
 
 /**
  * Represents a Numeric value from the steel crate
- * Steel's Numeric is a u128 (16 bytes) with 1e12 scaling factor
+ * Steel's Numeric is a signed 128-bit I80F48 value.
  */
 export interface Numeric {
   rawValue: BN // The raw u128 value
@@ -23,7 +23,7 @@ function deserializeNumeric(data: Buffer, offset: number): Numeric {
   const low = new BN(data.slice(offset, offset + 8), "le")
   const high = new BN(data.slice(offset + 8, offset + 16), "le")
   const rawValue = low.add(high.shln(64))
-  const decimalValue = new Decimal(rawValue.toString()).div(new Decimal(10).pow(NUMERIC_DECIMAL_PLACES))
+  const decimalValue = new Decimal(rawValue.toString()).div(NUMERIC_SCALE)
   return { rawValue, decimalValue }
 }
 
@@ -32,19 +32,13 @@ function deserializeNumeric(data: Buffer, offset: number): Numeric {
  * Matches the Rust struct in solana/libraries/ore_cpi/src/state/stake.rs
  */
 export interface Stake {
-  /// The authority of this miner account.
+  /// The authority of this staker account.
   authority: web3.PublicKey
   /// The balance of this stake account.
   balance: BN
-  /// Buffer a (placeholder)
-  bufferA: BN
-  /// Buffer b (placeholder)
-  bufferB: BN
-  /// Buffer c (placeholder)
-  bufferC: BN
-  /// Buffer d (placeholder)
-  bufferD: BN
-  /// The lamport reserve to pay fees for auto-compounding bots.
+  /// The lamport fee to pay for auto-compounding bots.
+  compoundFee: BN
+  /// The lamport reserve to pay auto-compounding fees.
   compoundFeeReserve: BN
   /// The timestamp of last claim.
   lastClaimAt: BN
@@ -58,8 +52,6 @@ export interface Stake {
   rewards: BN
   /// The total amount of ORE this staker has earned over its lifetime.
   lifetimeRewards: BN
-  /// Buffer f (placeholder)
-  bufferF: BN
 }
 
 /**
@@ -67,41 +59,25 @@ export interface Stake {
  * Matches the Rust struct in solana/libraries/ore_cpi/src/state/treasury.rs
  */
 export interface Treasury {
-  /// The amount of SOL collected for buy-bury operations.
-  balance: BN
-  /// Buffer a (placeholder)
-  bufferA: BN
-  /// The amount of ORE in the motherlode rewards pool.
-  motherlode: BN
-  /// The cumulative ORE distributed to miners, divided by the total unclaimed ORE at the time of distribution.
-  minerRewardsFactor: Numeric
   /// The cumulative ORE distributed to stakers, divided by the total stake at the time of distribution.
-  stakeRewardsFactor: Numeric
-  /// Buffer b (placeholder)
-  bufferB: BN
-  /// The current total amount of refined ORE mining rewards.
-  totalRefined: BN
+  rewardsFactor: Numeric
   /// The current total amount of ORE staking deposits.
   totalStaked: BN
-  /// The current total amount of unclaimed ORE mining rewards.
-  totalUnclaimed: BN
 }
 
 /**
  * Deserialize Stake account from Buffer
  * Skips the 8-byte steel discriminator and deserializes the struct fields
  *
- * Account layout (152 bytes total):
+ * Account layout (120 bytes total):
  * - discriminator: 8 bytes
  * - authority: 32 bytes
  * - balance: 8 bytes
- * - buffer_a through buffer_d: 32 bytes (4 x u64)
- * - compound_fee_reserve: 8 bytes
+ * - compound_fee, compound_fee_reserve: 16 bytes (2 x u64)
  * - last_claim_at, last_deposit_at, last_withdraw_at: 24 bytes (3 x i64)
- * - rewards_factor: 16 bytes (u128 Numeric)
+ * - rewards_factor: 16 bytes (I80F48 Numeric)
  * - rewards: 8 bytes
  * - lifetime_rewards: 8 bytes
- * - buffer_f: 8 bytes
  */
 function deserializeStakeAccount(stakeData: Buffer): Stake {
   const DISCRIMINATOR_SIZE = 8
@@ -115,20 +91,8 @@ function deserializeStakeAccount(stakeData: Buffer): Stake {
   const balance = new BN(stakeData.slice(offset, offset + 8), "le")
   offset += 8
 
-  // buffer_a: u64 (8 bytes)
-  const bufferA = new BN(stakeData.slice(offset, offset + 8), "le")
-  offset += 8
-
-  // buffer_b: u64 (8 bytes)
-  const bufferB = new BN(stakeData.slice(offset, offset + 8), "le")
-  offset += 8
-
-  // buffer_c: u64 (8 bytes)
-  const bufferC = new BN(stakeData.slice(offset, offset + 8), "le")
-  offset += 8
-
-  // buffer_d: u64 (8 bytes)
-  const bufferD = new BN(stakeData.slice(offset, offset + 8), "le")
+  // compound_fee: u64 (8 bytes)
+  const compoundFee = new BN(stakeData.slice(offset, offset + 8), "le")
   offset += 8
 
   // compound_fee_reserve: u64 (8 bytes)
@@ -147,7 +111,7 @@ function deserializeStakeAccount(stakeData: Buffer): Stake {
   const lastWithdrawAt = new BN(stakeData.slice(offset, offset + 8), "le")
   offset += 8
 
-  // rewards_factor: Numeric (16 bytes = u128)
+  // rewards_factor: Numeric (16 bytes = I80F48)
   const rewardsFactor = deserializeNumeric(stakeData, offset)
   offset += 16
 
@@ -157,18 +121,11 @@ function deserializeStakeAccount(stakeData: Buffer): Stake {
 
   // lifetime_rewards: u64 (8 bytes)
   const lifetimeRewards = new BN(stakeData.slice(offset, offset + 8), "le")
-  offset += 8
-
-  // buffer_f: u64 (8 bytes)
-  const bufferF = new BN(stakeData.slice(offset, offset + 8), "le")
 
   return {
     authority,
     balance,
-    bufferA,
-    bufferB,
-    bufferC,
-    bufferD,
+    compoundFee,
     compoundFeeReserve,
     lastClaimAt,
     lastDepositAt,
@@ -176,7 +133,6 @@ function deserializeStakeAccount(stakeData: Buffer): Stake {
     rewardsFactor,
     rewards,
     lifetimeRewards,
-    bufferF,
   }
 }
 
@@ -184,67 +140,25 @@ function deserializeStakeAccount(stakeData: Buffer): Stake {
  * Deserialize Treasury account from Buffer
  * Skips the 8-byte steel discriminator and deserializes the struct fields
  *
- * Account layout (96 bytes total):
+ * Account layout (32 bytes total):
  * - discriminator: 8 bytes
- * - balance: 8 bytes
- * - buffer_a: 8 bytes
- * - motherlode: 8 bytes
- * - miner_rewards_factor: 16 bytes (u128 Numeric)
- * - stake_rewards_factor: 16 bytes (u128 Numeric)
- * - buffer_b: 8 bytes
- * - total_refined: 8 bytes
+ * - rewards_factor: 16 bytes (I80F48 Numeric)
  * - total_staked: 8 bytes
- * - total_unclaimed: 8 bytes
  */
 function deserializeTreasuryAccount(treasuryData: Buffer): Treasury {
   const DISCRIMINATOR_SIZE = 8
   let offset = DISCRIMINATOR_SIZE
 
-  // balance: u64 (8 bytes)
-  const balance = new BN(treasuryData.slice(offset, offset + 8), "le")
-  offset += 8
-
-  // buffer_a: u64 (8 bytes)
-  const bufferA = new BN(treasuryData.slice(offset, offset + 8), "le")
-  offset += 8
-
-  // motherlode: u64 (8 bytes)
-  const motherlode = new BN(treasuryData.slice(offset, offset + 8), "le")
-  offset += 8
-
-  // miner_rewards_factor: Numeric (16 bytes = u128)
-  const minerRewardsFactor = deserializeNumeric(treasuryData, offset)
-  offset += 16
-
-  // stake_rewards_factor: Numeric (16 bytes = u128)
-  const stakeRewardsFactor = deserializeNumeric(treasuryData, offset)
+  // rewards_factor: Numeric (16 bytes = I80F48)
+  const rewardsFactor = deserializeNumeric(treasuryData, offset)
   offset += 16
 
-  // buffer_b: u64 (8 bytes)
-  const bufferB = new BN(treasuryData.slice(offset, offset + 8), "le")
-  offset += 8
-
-  // total_refined: u64 (8 bytes)
-  const totalRefined = new BN(treasuryData.slice(offset, offset + 8), "le")
-  offset += 8
-
   // total_staked: u64 (8 bytes)
   const totalStaked = new BN(treasuryData.slice(offset, offset + 8), "le")
-  offset += 8
-
-  // total_unclaimed: u64 (8 bytes)
-  const totalUnclaimed = new BN(treasuryData.slice(offset, offset + 8), "le")
 
   return {
-    balance,
-    bufferA,
-    motherlode,
-    minerRewardsFactor,
-    stakeRewardsFactor,
-    bufferB,
-    totalRefined,
+    rewardsFactor,
     totalStaked,
-    totalUnclaimed,
   }
 }
 
@@ -254,8 +168,8 @@ function deserializeTreasuryAccount(treasuryData: Buffer): Treasury {
  *
  * Exchange rate formula: (stake.balance + total_rewards) / stORE_supply
  *
- * Where total_rewards is calculated using ORE protocol's Stake::calculate_accrued_rewards:
- * 1. accumulated_rewards = treasury.stake_rewards_factor - stake.rewards_factor
+ * Where total_rewards is calculated using ORE protocol's Stake::update_rewards:
+ * 1. accumulated_rewards = treasury.rewards_factor - stake.rewards_factor
  * 2. personal_rewards = accumulated_rewards * stake.balance
  * 3. total_rewards = stake.rewards + personal_rewards
  *
@@ -265,8 +179,7 @@ function deserializeTreasuryAccount(treasuryData: Buffer): Treasury {
  * the exchange rate. The stake.balance is only updated via ORE program
  * deposit/withdraw instructions.
  *
- * Note: Numeric values are stored as fixed-point numbers with 1e12 precision.
- * When multiplying two Numeric values, the result is divided by 1e12 to maintain scale.
+ * Note: Numeric values are stored as I80F48 fixed-point numbers.
  */
 export function calculateOreExchangeRate(accounts: {
   stakeAccount: Buffer
@@ -291,22 +204,19 @@ export function calculateOreExchangeRate(accounts: {
   // This prevents exchange rate manipulation via direct token transfers
   const stakeBalance = stake.balance.toNumber()
 
-  // Calculate accrued rewards using ORE protocol's calculate_accrued_rewards algorithm
-  // This mirrors the exact logic from Stake::calculate_accrued_rewards() in ore_cpi
-  const treasuryStakeRewardsFactorDecimal = treasury.stakeRewardsFactor.decimalValue
+  // Calculate accrued rewards using ORE protocol's update_rewards algorithm
+  // This mirrors the exact logic from Stake::update_rewards() in ore_cpi
+  const treasuryRewardsFactorDecimal = treasury.rewardsFactor.decimalValue
   const stakeRewardsFactorDecimal = stake.rewardsFactor.decimalValue
 
   let newlyAccruedRewards = 0
-  if (treasuryStakeRewardsFactorDecimal.gt(stakeRewardsFactorDecimal)) {
-    // accumulated_rewards = treasury.stake_rewards_factor - stake.rewards_factor
-    const accumulatedRewards = treasuryStakeRewardsFactorDecimal.minus(stakeRewardsFactorDecimal)
+  if (treasuryRewardsFactorDecimal.gt(stakeRewardsFactorDecimal)) {
+    // accumulated_rewards = treasury.rewards_factor - stake.rewards_factor
+    const accumulatedRewards = treasuryRewardsFactorDecimal.minus(stakeRewardsFactorDecimal)
 
     // personal_rewards = accumulated_rewards * stake.balance
-    // In Rust: accumulated_rewards (as Numeric) * Numeric::from_u64(stake.balance)
-    // The Numeric type uses 1e12 scaling internally. When multiplying two Numerics,
-    // the result is (a * b) / 1e12 to maintain scale. Then to_u64() divides by 1e12.
-    // Since decimalValue already gives us the decimal representation (divided by 1e12),
-    // we just multiply by balance and floor the result.
+    // Since decimalValue already gives us the decoded fixed-point value, we just
+    // multiply by balance and floor the result.
     const personalRewards = accumulatedRewards.mul(new Decimal(stakeBalance))
     newlyAccruedRewards = Math.floor(personalRewards.toNumber())
   }
@@ -318,5 +228,9 @@ export function calculateOreExchangeRate(accounts: {
   const totalBalanceWithRewards = stakeBalance + totalRewards
 
   // Calculate exchange rate: (stake.balance + accrued_rewards) / stORE_supply
+  if (totalBalanceWithRewards === 0) {
+    return 1
+  }
+
   return totalBalanceWithRewards / storeSupply
 }