@exponent-labs/exponent-fetcher 0.1.7 → 0.1.8

package/src/index.ts

@@ -1,3 +1,13 @@
 // TODO - rename to "sol"
 export * from "./exponentFetcher"
 export { fetchJupiterPerpsIndex } from "./exponentFetcher"
+export * from "./utils/meteora"
+export * from "./utils/sanctum"
+export * from "./utils/fragmetric"
+export * from "./utils/adrena"
+export * from "./utils/solstice"
+export * from "./utils/jupiter"
+export * from "./utils/kamino"
+export * from "./utils/perena"
+export * from "./utils/jito"
+export * from "./utils/ore"

package/src/utils/adrena.ts

@@ -0,0 +1,44 @@
+import BN from "bn.js"
+
+import { calculateTotalFeesFromCustodies, decodeCustodyAccount, decodePoolAccount } from "@exponent-labs/adrena-idl"
+import { AnchorizedPNum } from "@exponent-labs/exponent-types"
+import { PreciseNumber } from "@exponent-labs/precise-number"
+
+export function calculateAdrenaIndex(
+  accounts: {
+    pool: Buffer
+    custody1: Buffer
+    custody2: Buffer
+    custody3: Buffer
+    custody4: Buffer
+  },
+  previousTotalFees: BN,
+  currentIndex: AnchorizedPNum,
+) {
+  const ZERO_BN = new BN(0)
+
+  // Decode accounts using adrena-idl package functions
+  // @ts-ignore
+  const poolAccount = decodePoolAccount(accounts.pool)
+  const custodyAccounts = [accounts.custody1, accounts.custody2, accounts.custody3, accounts.custody4].map(
+    decodeCustodyAccount,
+  )
+
+  // @ts-ignore
+  const currentTotalFees = calculateTotalFeesFromCustodies(custodyAccounts)
+
+  let yieldIncrement: number
+  let aumValue = poolAccount.aumUsd.low
+
+  if (aumValue.eq(ZERO_BN)) {
+    yieldIncrement = 0
+  }
+
+  let feeDifference = currentTotalFees.gte(previousTotalFees) ? currentTotalFees.sub(previousTotalFees) : ZERO_BN
+
+  yieldIncrement = feeDifference.toNumber() / aumValue.toNumber()
+
+  let currentIndexNumber = parseFloat(PreciseNumber.fromRaw(currentIndex[0]).valueString)
+
+  return { index: currentIndexNumber + yieldIncrement }
+}

package/src/utils/fragmetric.ts

@@ -0,0 +1,34 @@
+import { web3 } from "@coral-xyz/anchor"
+
+import { decodeFundAccount as decodeFragmetricFundAccount } from "@exponent-labs/fragmetric-idl"
+
+export function calculateFragmetricIndex(accounts: { fragmetricFund: Buffer }) {
+  const fundAccount = decodeFragmetricFundAccount(accounts.fragmetricFund)
+  const index = Number(fundAccount.one_receipt_token_as_sol) / Number(10 ** fundAccount.receipt_token_decimals)
+
+  const receiptTokenMint = new web3.PublicKey(fundAccount.receipt_token_mint)
+  const wrappedTokenMint = new web3.PublicKey(fundAccount.wrapped_token.mint)
+
+  return { index, receiptTokenMint, wrappedTokenMint }
+}
+
+export const calculateFragmetricSupportedTokenIndex = (
+  accounts: {
+    fragmetricFund: Buffer
+  },
+  index = 0,
+): {
+  index: number
+  receiptTokenMint: web3.PublicKey
+  wrappedTokenMint: web3.PublicKey
+} => {
+  const fundAccount = decodeFragmetricFundAccount(accounts.fragmetricFund)
+  const syIndex =
+    Number(10 ** fundAccount.supported_tokens[index].decimals) /
+    Number(fundAccount.supported_tokens[index].one_token_as_receipt_token)
+
+  const receiptTokenMint = new web3.PublicKey(fundAccount.receipt_token_mint)
+  const wrappedTokenMint = new web3.PublicKey(fundAccount.wrapped_token.mint)
+
+  return { index: syIndex, receiptTokenMint, wrappedTokenMint }
+}

package/src/utils/jito.ts

@@ -0,0 +1,30 @@
+import { BN, web3 } from "@coral-xyz/anchor"
+import Decimal from "decimal.js"
+
+export function decodeJitoVaultData(vaultAccountData: Buffer) {
+  // the vault has an 8 byte discriminator at the beginning
+  const DISCRIMINATOR_OFFSET = 8
+  const VRT_MINT_OFFSET = 32 + DISCRIMINATOR_OFFSET
+  const VRT_SUPPLY_OFFSET = 96 + DISCRIMINATOR_OFFSET
+  const JITO_VAULT_TOTAL_DEPOSITS_OFFSET = 104 + DISCRIMINATOR_OFFSET
+  const mintBase = new web3.PublicKey(vaultAccountData.subarray(VRT_MINT_OFFSET, VRT_MINT_OFFSET + 32))
+
+  // For Borsh, numbers are serialized in little-endian format
+  const jitoVaultTotalSharesBuffer = vaultAccountData.subarray(VRT_SUPPLY_OFFSET, VRT_SUPPLY_OFFSET + 8)
+  const jitoVaultTotalShares = new BN(jitoVaultTotalSharesBuffer, "le")
+
+  const jitoVaultTotalDepositsBuffer = vaultAccountData.subarray(
+    JITO_VAULT_TOTAL_DEPOSITS_OFFSET,
+    JITO_VAULT_TOTAL_DEPOSITS_OFFSET + 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 }
+}

package/src/utils/jupiter.ts

@@ -0,0 +1,98 @@
+import { web3 } from "@coral-xyz/anchor"
+import BN from "bn.js"
+import Decimal from "decimal.js"
+
+import { AnchorizedPNum } from "@exponent-labs/exponent-types"
+import { decodeJupiterLendAccount } from "@exponent-labs/jupiter-lend-idl"
+import { decodePoolAccount as decodeJupiterPerpsPoolAccount } from "@exponent-labs/jupiter-perps-idl"
+import { PreciseNumber } from "@exponent-labs/precise-number"
+
+export function calculateJupiterLendIndex(accounts: { jupiterLend: Buffer }): {
+  index: number
+  baseTokenMint: any
+  tokenReservesLiquidity: any
+  lendingSupplyPosition: any
+  rewardsRateModel: any
+} {
+  const accountData = decodeJupiterLendAccount(accounts.jupiterLend)
+
+  const index = Number(accountData.token_exchange_price) / Number(10 ** 12)
+  const tokenReservesLiquidity = accountData.token_reserves_liquidity
+  const lendingSupplyPosition = accountData.supply_position_on_liquidity
+  const rewardsRateModel = accountData.rewards_rate_model
+
+  return {
+    index,
+    baseTokenMint: accountData.mint,
+    tokenReservesLiquidity,
+    lendingSupplyPosition,
+    rewardsRateModel,
+  }
+}
+
+export function calculateJupiterPerpsIndex(
+  accounts: {
+    pool: Buffer
+  },
+  params: {
+    lastFeeUsdResetUnixTimestamp: number
+    lastRealizedFeeUsd: BN
+    lastAumUsd: BN
+    currentIndex: AnchorizedPNum
+    lastRealizedFeeUsdUpdateUnixTimestamp: number
+  },
+): {
+  index: number
+  newState: {
+    lastAumUsd: BN
+    lastRealizedFeeUsd: BN
+    lastFeeUsdResetUnixTimestamp: number
+    lastRealizedFeeUsdUpdateUnixTimestamp: number
+  }
+} {
+  const SECONDS_PER_YEAR = 365 * 24 * 60 * 60
+
+  const {
+    lastFeeUsdResetUnixTimestamp,
+    lastRealizedFeeUsd,
+    lastAumUsd,
+    currentIndex,
+    lastRealizedFeeUsdUpdateUnixTimestamp,
+  } = params
+
+  const account: any = decodeJupiterPerpsPoolAccount(accounts.pool)
+
+  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),
+    },
+  }
+}

package/src/utils/kamino.ts

@@ -0,0 +1,6 @@
+import { Reserve } from "@exponent-labs/kamino-reserve-deserializer"
+
+export function calculateKaminoIndex(accounts: { reserveAccountData: Buffer }) {
+  const reserve = Reserve.decode(accounts.reserveAccountData)
+  return reserve.getCollateralExchangeRate().toNumber()
+}

package/src/utils/meteora.ts

@@ -1,6 +1,13 @@
-import { CurveType, VaultState } from "@exponent-labs/meteora-idl"
+import {
+  CurveType,
+  VaultState,
+  decodePool as decodeMeteoraPool,
+  decodeVault as decodeMeteoraVault,
+} from "@exponent-labs/meteora-idl"
+import Decimal from "decimal.js"
 import { BN } from "@coral-xyz/anchor"
 import sqrt from "bn-sqrt"
+import { AccountLayout, MintLayout } from "@solana/spl-token"
 
 /**
  * Calculates the unlocked (withdrawable) amount of tokens in a Meteora vault.
@@ -129,3 +136,68 @@ export function computeD(curve: CurveType, tokenAmountA: BN, tokenAmountB: BN):
   // Default case - should never reach here if CurveType is properly defined
   throw new Error("Invalid curve type")
 }
+
+export function calculateMeteoraIndex(accounts: {
+  pool: Buffer
+  lpMint: Buffer
+  vaultA: Buffer
+  vaultB: Buffer
+  vaultALpMint: Buffer
+  vaultBLpMint: Buffer
+  poolVaultALpAccount: Buffer
+  poolVaultBLpAccount: Buffer
+}) {
+  const VIRTUAL_PRICE_PRECISION = new BN(100_000_000)
+  const nowUnix = Math.floor(Date.now() / 1000)
+
+  const pool = decodeMeteoraPool(accounts.pool)
+
+  const poolMint = MintLayout.decode(accounts.lpMint.subarray(0, MintLayout.span))
+  const poolLpSupply = new BN(poolMint.supply.toString())
+  const poolLpDecimals = Number(poolMint.decimals.toString())
+
+  const vaultA = decodeMeteoraVault(accounts.vaultA)
+  const vaultB = decodeMeteoraVault(accounts.vaultB)
+
+  const vaultLpMintA = MintLayout.decode(accounts.vaultALpMint.subarray(0, MintLayout.span))
+  const vaultLpMintB = MintLayout.decode(accounts.vaultBLpMint.subarray(0, MintLayout.span))
+
+  const vaultALpSupply = vaultLpMintA.supply
+  const vaultBLpSupply = vaultLpMintB.supply
+
+  const decimalsA = vaultLpMintA.decimals
+  const decimalsB = vaultLpMintB.decimals
+
+  const poolVaultALpTokenAmount = AccountLayout.decode(
+    accounts.poolVaultALpAccount.subarray(0, AccountLayout.span),
+  ).amount
+  const poolVaultBLpTokenAmount = AccountLayout.decode(
+    accounts.poolVaultBLpAccount.subarray(0, AccountLayout.span),
+  ).amount
+
+  const tokenAAmount = getAmountByShare(
+    new BN(poolVaultALpTokenAmount.toString()),
+    new BN(vaultALpSupply.toString()),
+    vaultA,
+    nowUnix,
+  )
+  const tokenBAmount = getAmountByShare(
+    new BN(poolVaultBLpTokenAmount.toString()),
+    new BN(vaultBLpSupply.toString()),
+    vaultB,
+    nowUnix,
+  )
+
+  const d = computeD(pool.curveType, tokenAAmount, tokenBAmount)
+  const virtualPriceBigNum = poolLpSupply.isZero() ? new BN(0) : d.mul(VIRTUAL_PRICE_PRECISION).div(poolLpSupply)
+  const virtualPrice = new Decimal(virtualPriceBigNum.toString()).div(VIRTUAL_PRICE_PRECISION.toString()).toNumber()
+
+  return {
+    virtualPrice,
+    tokenAMint: pool.tokenAMint,
+    tokenBMint: pool.tokenBMint,
+    poolVaultALpTokenAmount: Number(poolVaultALpTokenAmount) / 10 ** decimalsA,
+    poolVaultBLpTokenAmount: Number(poolVaultBLpTokenAmount) / 10 ** decimalsB,
+    lpSupply: poolLpSupply.toNumber() / 10 ** poolLpDecimals,
+  }
+}

package/src/utils/ore.ts

@@ -0,0 +1,322 @@
+import { BN } from "@coral-xyz/anchor"
+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
+
+/**
+ * Represents a Numeric value from the steel crate
+ * Steel's Numeric is a u128 (16 bytes) with 1e12 scaling factor
+ */
+export interface Numeric {
+  rawValue: BN // The raw u128 value
+  decimalValue: Decimal // The scaled decimal representation
+}
+
+/**
+ * Deserialize a steel Numeric type from buffer
+ * Numeric is stored as u128 (16 bytes = 2 x u64, little-endian)
+ */
+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))
+  return { rawValue, decimalValue }
+}
+
+/**
+ * TypeScript representation of the Stake struct from ore_cpi
+ * Matches the Rust struct in solana/libraries/ore_cpi/src/state/stake.rs
+ */
+export interface Stake {
+  /// The authority of this miner 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.
+  compoundFeeReserve: BN
+  /// The timestamp of last claim.
+  lastClaimAt: BN
+  /// The timestamp the last time this staker deposited.
+  lastDepositAt: BN
+  /// The timestamp the last time this staker withdrew.
+  lastWithdrawAt: BN
+  /// The rewards factor last time rewards were updated on this stake account.
+  rewardsFactor: Numeric
+  /// The amount of ORE this staker can claim.
+  rewards: BN
+  /// The total amount of ORE this staker has earned over its lifetime.
+  lifetimeRewards: BN
+  /// Buffer f (placeholder)
+  bufferF: BN
+}
+
+/**
+ * TypeScript representation of the Treasury struct from ore_cpi
+ * 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
+  /// 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):
+ * - discriminator: 8 bytes
+ * - authority: 32 bytes
+ * - balance: 8 bytes
+ * - buffer_a through buffer_d: 32 bytes (4 x u64)
+ * - compound_fee_reserve: 8 bytes
+ * - last_claim_at, last_deposit_at, last_withdraw_at: 24 bytes (3 x i64)
+ * - rewards_factor: 16 bytes (u128 Numeric)
+ * - rewards: 8 bytes
+ * - lifetime_rewards: 8 bytes
+ * - buffer_f: 8 bytes
+ */
+function deserializeStakeAccount(stakeData: Buffer): Stake {
+  const DISCRIMINATOR_SIZE = 8
+  let offset = DISCRIMINATOR_SIZE
+
+  // authority: Pubkey (32 bytes)
+  const authority = new web3.PublicKey(stakeData.slice(offset, offset + 32))
+  offset += 32
+
+  // balance: u64 (8 bytes)
+  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")
+  offset += 8
+
+  // compound_fee_reserve: u64 (8 bytes)
+  const compoundFeeReserve = new BN(stakeData.slice(offset, offset + 8), "le")
+  offset += 8
+
+  // last_claim_at: i64 (8 bytes)
+  const lastClaimAt = new BN(stakeData.slice(offset, offset + 8), "le")
+  offset += 8
+
+  // last_deposit_at: i64 (8 bytes)
+  const lastDepositAt = new BN(stakeData.slice(offset, offset + 8), "le")
+  offset += 8
+
+  // last_withdraw_at: i64 (8 bytes)
+  const lastWithdrawAt = new BN(stakeData.slice(offset, offset + 8), "le")
+  offset += 8
+
+  // rewards_factor: Numeric (16 bytes = u128)
+  const rewardsFactor = deserializeNumeric(stakeData, offset)
+  offset += 16
+
+  // rewards: u64 (8 bytes)
+  const rewards = new BN(stakeData.slice(offset, offset + 8), "le")
+  offset += 8
+
+  // 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,
+    compoundFeeReserve,
+    lastClaimAt,
+    lastDepositAt,
+    lastWithdrawAt,
+    rewardsFactor,
+    rewards,
+    lifetimeRewards,
+    bufferF,
+  }
+}
+
+/**
+ * Deserialize Treasury account from Buffer
+ * Skips the 8-byte steel discriminator and deserializes the struct fields
+ *
+ * Account layout (96 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
+ * - 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)
+  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,
+    totalStaked,
+    totalUnclaimed,
+  }
+}
+
+/**
+ * Calculate ORE exchange rate from account data
+ * This mirrors the logic from the Rust implementation in generic_standard/src/utils.rs
+ *
+ * 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
+ * 2. personal_rewards = accumulated_rewards * stake.balance
+ * 3. total_rewards = stake.rewards + personal_rewards
+ *
+ * Security note: We use stake.balance as the canonical staked amount, NOT
+ * stake_tokens.amount from the token account. This prevents manipulation
+ * where an attacker transfers ORE directly into the stake ATA to inflate
+ * 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.
+ */
+export function calculateOreExchangeRate(accounts: {
+  stakeAccount: Buffer
+  treasuryAccount: Buffer
+  storeMint: Buffer
+}): number {
+  const { stakeAccount, treasuryAccount, storeMint } = accounts
+
+  // Decode mint account to get stORE supply
+  const storeMintAccount = MintLayout.decode(storeMint.subarray(0, MintLayout.span))
+  const storeSupply = Number(storeMintAccount.supply.toString())
+
+  if (storeSupply === 0) {
+    return 1
+  }
+
+  // Deserialize accounts into structured types
+  const stake = deserializeStakeAccount(stakeAccount)
+  const treasury = deserializeTreasuryAccount(treasuryAccount)
+
+  // Use stake.balance as the canonical staked amount (not token account balance)
+  // 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
+  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)
+
+    // 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.
+    const personalRewards = accumulatedRewards.mul(new Decimal(stakeBalance))
+    newlyAccruedRewards = Math.floor(personalRewards.toNumber())
+  }
+
+  // Total rewards = existing rewards + newly accrued rewards
+  const totalRewards = stake.rewards.toNumber() + newlyAccruedRewards
+
+  // Calculate total balance: stake.balance + total_rewards
+  const totalBalanceWithRewards = stakeBalance + totalRewards
+
+  // Calculate exchange rate: (stake.balance + accrued_rewards) / stORE_supply
+  return totalBalanceWithRewards / storeSupply
+}

package/src/utils/perena.ts

@@ -0,0 +1,28 @@
+import { web3 } from "@coral-xyz/anchor"
+import { MintLayout } from "@solana/spl-token"
+import Decimal from "decimal.js"
+
+export function getPerenaLpMint(perenaStablePool: web3.PublicKey) {
+  const PERENA_NUMERAIRE_PROGRAM = new web3.PublicKey("NUMERUNsFCP3kuNmWZuXtm1AaQCPj9uw6Guv2Ekoi5P")
+
+  const [lpMint, _] = web3.PublicKey.findProgramAddressSync(
+    [perenaStablePool.toBuffer(), Buffer.from("liquidity")],
+    PERENA_NUMERAIRE_PROGRAM,
+  )
+  return lpMint
+}
+
+export function getPerenaStablePoolData(accounts: { perenaStablePoolData: Buffer; lpMintData: Buffer }) {
+  const { perenaStablePoolData, lpMintData } = accounts
+
+  const lpMintDeserialized = MintLayout.decode(lpMintData)
+
+  const discriminatorOffset = 8
+  const invTOffset = discriminatorOffset + 32 + 32 + 32 + 32 // 4 Pubkeys before invT
+  const invTBuffer = perenaStablePoolData.slice(invTOffset, invTOffset + 8)
+  const invT = Buffer.from(invTBuffer).readBigUInt64LE(0)
+
+  const exchangeRate = new Decimal(invT.toString()).div(new Decimal(lpMintDeserialized.supply.toString())).toString()
+
+  return { lpSupply: lpMintDeserialized.supply, invT, exchangeRate }
+}

package/src/utils/sanctum.ts

@@ -0,0 +1,24 @@
+import { decodePoolState } from "@exponent-labs/sanctum-idl"
+import { MintLayout } from "@solana/spl-token"
+import Decimal from "decimal.js"
+import { BN } from "@coral-xyz/anchor"
+
+export function calculateSanctumIndex(accounts: { lpMintAccountData: Buffer; poolStateAccountData: Buffer }) {
+  const poolState = decodePoolState(accounts.poolStateAccountData)
+
+  const lpMint = MintLayout.decode(accounts.lpMintAccountData.subarray(0, MintLayout.span))
+
+  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()
+
+  return 1 / exchangeRate // We return inverse exchange rate
+}