@exponent-labs/exponent-fetcher 0.9.11 → 0.9.13

package/src/exponentFetcher.ts

@@ -85,9 +85,7 @@ import { computeD, getAmountByShare } from "./utils/meteora"
 import { calculateOreExchangeRate } from "./utils/ore"
 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")
+import { calculateSolsticeGlamVaultExchangeRate, calculateSolsticeRedemptionRate } from "./utils/solstice"
 
 export function serializeAnchorizedPNumFromJson(pnum: AnchorizedPNum): AnchorizedPNumJson {
   const serializedArray = pnum[0].map((bn) => bn.toString())
@@ -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,7 +677,7 @@ 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 +746,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 +807,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 +823,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 +979,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 +992,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 +1021,13 @@ function deserializeOrderbook(data: Buffer): Orderbook {
     tokenEscrowYt,
     tokenEscrowPt,
     cpiAccountOrderbook,
-    lastSyExchangeRate: lastSyExchangeRateRaw,
     financials,
     prices,
     configurationOptions,
     offers,
     userEscrows,
-    offersBumpIndex,
     offersFreeListHead,
+    offersBumpIndex,
   }
 }
 
@@ -1109,6 +1037,7 @@ function deserializeMarginfiSyMeta(x: MarginfiSyMetaRaw): MarginfiSyMeta {
     maxSySupply: BigInt(x.maxSySupply.toString()),
     minMintSize: BigInt(x.minMintSize.toString()),
     minRedeemSize: BigInt(x.minRedeemSize.toString()),
+    lastSlotCached: BigInt(x.lastSlotCached.toString()),
   }
 }
 
@@ -1320,13 +1249,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 +1431,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 +1515,11 @@ interface LpPositionCLMMRaw {
       emissions: { trackers: { staged: BN; lastSeenIndex: AnchorizedPNum }[] }
     }[]
   }
+  crossingSplit: {
+    crossLeftIdx: number
+    crossRightIdx: number
+    lpBalanceCrossing: BN
+  }
 }
 
 export interface LpPositionCLMM {
@@ -1610,6 +1540,12 @@ export interface LpPositionCLMM {
     lpShare: bigint
     emissions: { staged: bigint; lastSeenIndex: number }[]
   }[]
+  crossingSplit: {
+    crossLeftIdx: number
+    crossRightIdx: number
+    lpBalanceCrossing: bigint
+    isActive: boolean
+  }
 }
 
 export interface LpFarm {
@@ -1717,6 +1653,8 @@ interface KaminoSyMetaRaw {
   /** Where the SY tokens get deposited */
   tokenSyEscrow: web3.PublicKey
   emissions: SyEmissionRaw[]
+  lastIndex: AnchorizedPNum
+  lastSlotCached: BN
 }
 
 export interface YtPositionRaw {
@@ -1781,14 +1719,14 @@ export interface OfferNodeRaw {
 
 export interface UserEscrowNodeRaw {
   user: web3.PublicKey
-  yieldIndex: number
+  yieldIndex: BN
   ptAmount: BN
   syAmount: BN
   ytAmount: BN
   staged: number
 }
 
-function deserializeAnchorizedPNum(x: AnchorizedPNum): number {
+export function deserializeAnchorizedPNum(x: AnchorizedPNum): number {
   return parseFloat(PreciseNumber.fromRaw(x[0]).valueString)
 }
 
@@ -2025,70 +1963,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({
@@ -2258,6 +2154,30 @@ export async function fetchSolsticeRedemptionRate({
   return calculateSolsticeRedemptionRate({ yieldPool: accountInfos[0].data, vestingSchedule: accountInfos[1].data })
 }
 
+export async function fetchSolsticeGlamVaultExchangeRate({
+  connection,
+  stakingVaultSlxAta,
+  slxMint,
+  stslxMint,
+}: {
+  connection: web3.Connection
+  stakingVaultSlxAta: web3.PublicKey
+  slxMint: web3.PublicKey
+  stslxMint: web3.PublicKey
+}): Promise<number> {
+  const accountInfos = await connection.getMultipleAccountsInfo([stakingVaultSlxAta, slxMint, stslxMint])
+
+  if (!accountInfos[0] || !accountInfos[1] || !accountInfos[2]) {
+    throw new Error("One or more Solstice GLAM vault accounts not found")
+  }
+
+  return calculateSolsticeGlamVaultExchangeRate({
+    stakingVaultSlxAta: accountInfos[0].data,
+    slxMint: accountInfos[1].data,
+    stslxMint: accountInfos[2].data,
+  })
+}
+
 const REFLECT_ORACLE_LEN = 17
 const REFLECT_MAX_STALENESS_SLOTS = 15000000