@exponent-labs/exponent-fetcher 0.0.3

package/src/exponentFetcher.ts

@@ -0,0 +1,895 @@
+import { AnchorProvider, BN, Idl, Program, Wallet, web3 } from "@coral-xyz/anchor"
+import { ExponentCore, IDL, PROGRAM_ID } from "@exponent-labs/exponent-idl"
+import { PROGRAM_ID as KAMINO_STANDARD_PROGRAM_ID } from "@exponent-labs/kamino-sy-idl"
+import { KaminoLendStandard } from "@exponent-labs/kamino-sy-idl"
+import {
+  PROGRAM_ID as MARGINFI_SY_PROGRAM_ID,
+  MarginfiStandard,
+  IDL as MarginfiSyIdl,
+} from "@exponent-labs/marginfi-sy-idl"
+import { PROGRAM_ID as PERENA_STANDARD_PROGRAM_ID } from "@exponent-labs/perena-sy-idl"
+import { PROGRAM_ID as JITO_RESTAKING_SY_PROGRAM_ID } from "@exponent-labs/jito-restaking-sy-idl"
+import { IDL as KaminoSyIdl } from "@exponent-labs/kamino-lend-standard"
+import { PreciseNumber } from "@exponent-labs/precise-number"
+import { Reserve } from "@exponent-labs/kamino-reserve-deserializer"
+import { JitoRestakingStandard, IDL as JitoRestakingSyIdl } from "@exponent-labs/jito-restaking-sy-idl"
+import { IDL as PerenaSyIdl } from "@exponent-labs/perena-sy-idl"
+import { getStakePoolAccount } from "@solana/spl-stake-pool"
+import { IDL as FragmetricIdl } from "@exponent-labs/fragmetric-idl"
+import { decodePoolAccount, decodeVaultAccount } from "@exponent-labs/meteora-idl"
+import { getMint, getAccount } from "@solana/spl-token"
+import { BorshCoder } from "@coral-xyz/anchor"
+import {
+  AnchorizedPNum,
+  AnchorizedPNumJson,
+  MarginfiSyMeta,
+  MarginfiSyMetaRaw,
+  VaultEmission,
+  VaultEmissionJson,
+  CpiAccountIndexes,
+  JitoRestakingSyMetaAccountRaw,
+  JitoRestakingSyMetaAccount,
+  deserializeJitoRestakingSyMetaAccountRaw,
+  InterfaceType,
+  SyEmissionRaw,
+  GenericSyMetaAccount,
+  deserializeGenericSyMetaAccountRaw,
+  GenericSyMetaAccountRaw,
+  deserializePerenaSyMetaAccountRaw,
+  PerenaSyMetaAccountRaw,
+  PerenaSyMetaAccount,
+} from "@exponent-labs/exponent-types"
+import Decimal from "decimal.js"
+import { PerenaStandard } from "@exponent-labs/perena-sy-idl"
+import { MintLayout } from "@solana/spl-token"
+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 { computeD, getAmountByShare } from "./utils/meteora"
+
+export function serializeAnchorizedPNumFromJson(pnum: AnchorizedPNum): AnchorizedPNumJson {
+  const serializedArray = pnum[0].map((bn) => bn.toString())
+  return { 0: serializedArray }
+}
+
+export function deserializeAnchorizedPNumFromJson(serialized: AnchorizedPNumJson): AnchorizedPNum {
+  const bnArray = serialized[0].map((str) => new BN(str))
+  return { 0: bnArray }
+}
+
+export class MyWallet implements Wallet {
+  constructor(readonly payer: web3.Keypair) {
+    this.payer = payer
+  }
+
+  async signTransaction<T extends web3.Transaction | web3.VersionedTransaction>(tx: T): Promise<T> {
+    if (tx instanceof web3.Transaction) {
+      tx.partialSign(this.payer)
+    } else {
+      tx.sign([this.payer])
+    }
+    return tx
+  }
+
+  async signAllTransactions<T extends web3.Transaction | web3.VersionedTransaction>(txs: T[]): Promise<T[]> {
+    return txs.map((t) => {
+      if (t instanceof web3.Transaction) {
+        t.partialSign(this.payer)
+      } else if (t instanceof web3.VersionedTransaction) {
+        t.sign([this.payer])
+      }
+      return t
+    })
+  }
+
+  get publicKey(): web3.PublicKey {
+    return this.payer.publicKey
+  }
+}
+
+export class ExponentFetcher {
+  public program: Program<ExponentCore>
+  public marginfiSyProgram: Program<MarginfiStandard>
+  public kaminoSyProgram: Program<KaminoLendStandard>
+  public jitoRestakingSyProgram: Program<JitoRestakingStandard>
+  public perenaSyProgram: Program<PerenaStandard>
+  public genericStandardProgram: Program<GenericStandard>
+  public connection: web3.Connection
+  public coreProgramId: web3.PublicKey
+  public marginfiSyProgramId: web3.PublicKey
+  public kaminoSyProgramId: web3.PublicKey
+  public jitoRestakingSyProgramId: web3.PublicKey
+  public perenaSyProgramId: web3.PublicKey
+  public genericStandardProgramId: web3.PublicKey
+
+  constructor({
+    connection,
+    coreProgramId = new web3.PublicKey(PROGRAM_ID),
+    marginfiSyProgramId = new web3.PublicKey(MARGINFI_SY_PROGRAM_ID),
+    kaminoSyProgramId = new web3.PublicKey(KAMINO_STANDARD_PROGRAM_ID),
+    jitoRestakingSyProgramId = new web3.PublicKey(JITO_RESTAKING_SY_PROGRAM_ID),
+    perenaSyProgramId = new web3.PublicKey(PERENA_STANDARD_PROGRAM_ID),
+    genericStandardProgramId = new web3.PublicKey(GENERIC_STANDARD_PROGRAM_ID),
+  }: {
+    connection: web3.Connection
+    coreProgramId?: web3.PublicKey
+    marginfiSyProgramId?: web3.PublicKey
+    kaminoSyProgramId?: web3.PublicKey
+    jitoRestakingSyProgramId?: web3.PublicKey
+    perenaSyProgramId?: web3.PublicKey
+    genericStandardProgramId?: web3.PublicKey
+  }) {
+    this.connection = connection
+    this.coreProgramId = coreProgramId
+    this.marginfiSyProgramId = marginfiSyProgramId
+    this.kaminoSyProgramId = kaminoSyProgramId
+    this.jitoRestakingSyProgramId = jitoRestakingSyProgramId
+    this.perenaSyProgramId = perenaSyProgramId
+    this.genericStandardProgramId = genericStandardProgramId
+    // Note - keypair does not matter. this is purely read-only fetching
+    const mockWallet = new MyWallet(web3.Keypair.generate())
+    const provider = new AnchorProvider(connection, mockWallet)
+
+    this.program = new Program<ExponentCore>(IDL as ExponentCore, provider)
+    this.marginfiSyProgram = new Program<MarginfiStandard>(MarginfiSyIdl as MarginfiStandard, provider)
+    this.kaminoSyProgram = new Program<KaminoLendStandard>(KaminoSyIdl as KaminoLendStandard, provider)
+    this.jitoRestakingSyProgram = new Program<JitoRestakingStandard>(
+      JitoRestakingSyIdl as JitoRestakingStandard,
+      provider,
+    )
+    this.perenaSyProgram = new Program<PerenaStandard>(PerenaSyIdl as PerenaStandard, provider)
+    this.genericStandardProgram = new Program<GenericStandard>(GenericStandardIdl, provider)
+  }
+
+  async fetchVault(address: web3.PublicKey) {
+    try {
+      const v: VaultRaw = await this.program.account.vault.fetch(address)
+      return deserializeVault(v)
+    } catch (e) {
+      console.error(`Error fetching vault ${address.toBase58()}`)
+      console.error(e)
+      throw e
+    }
+  }
+
+  async fetchMarket(address: web3.PublicKey): Promise<MarketTwo> {
+    try {
+      const m: MarketTwoRaw = await this.program.account.marketTwo.fetch(address)
+      return deserializeMarketTwo(m)
+    } catch (e) {
+      console.error(`Error fetching market ${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)
+  }
+
+  async fetchMarginfiSyPosition(address: web3.PublicKey): Promise<SyPosition> {
+    const x = await this.marginfiSyProgram.account.position.fetch(address)
+    const emissions = x.rewardIndexes.map((r) => ({
+      mint: r.mint,
+      staged: BigInt(r.claimableRewardsAmount.toString()),
+      lastSeenIndex: parseFloat(PreciseNumber.fromRaw(r.lastSeenShareIndex[0]).valueString),
+    }))
+
+    return {
+      owner: x.owner,
+      balanceSy: BigInt(x.amount.toString()),
+      emissions,
+    }
+  }
+
+  async fetchKaminoSyPosition(address: web3.PublicKey): Promise<SyPosition> {
+    const x = await this.kaminoSyProgram.account.position.fetch(address)
+    const emissions = x.rewardIndexes.map((r) => ({
+      mint: r.mint,
+      staged: BigInt(r.claimableRewardsAmount.toString()),
+      lastSeenIndex: parseFloat(PreciseNumber.fromRaw(r.lastSeenShareIndex[0]).valueString),
+    }))
+
+    return {
+      owner: x.owner,
+      balanceSy: BigInt(x.amount.toString()),
+      emissions,
+    }
+  }
+
+  async fetchJitoRestakingSyPosition(address: web3.PublicKey): Promise<SyPosition> {
+    const x = await this.jitoRestakingSyProgram.account.position.fetch(address)
+    const emissions = x.rewardIndexes.map((r) => ({
+      mint: r.mint,
+      staged: BigInt(r.claimableRewardsAmount.toString()),
+      lastSeenIndex: parseFloat(PreciseNumber.fromRaw(r.lastSeenShareIndex[0]).valueString),
+    }))
+
+    return {
+      owner: x.owner,
+      balanceSy: BigInt(x.amount.toString()),
+      emissions,
+    }
+  }
+
+  async fetchPerenaSyPosition(address: web3.PublicKey): Promise<SyPosition> {
+    const x = await this.perenaSyProgram.account.position.fetch(address)
+    const emissions = x.rewardIndexes.map((r) => ({
+      mint: r.mint,
+      staged: BigInt(r.claimableRewardsAmount.toString()),
+      lastSeenIndex: parseFloat(PreciseNumber.fromRaw(r.lastSeenShareIndex[0]).valueString),
+    }))
+    return { owner: x.owner, balanceSy: BigInt(x.amount.toString()), emissions }
+  }
+
+  async fetchGenericSyPosition(address: web3.PublicKey): Promise<SyPosition> {
+    const x = await this.genericStandardProgram.account.position.fetch(address)
+    const emissions = x.rewardIndexes.map((r) => ({
+      mint: r.mint,
+      staged: BigInt(r.claimableRewardsAmount.toString()),
+      lastSeenIndex: parseFloat(PreciseNumber.fromRaw(r.lastSeenShareIndex[0]).valueString),
+    }))
+    return { owner: x.owner, balanceSy: BigInt(x.amount.toString()), emissions }
+  }
+
+  async fetchKaminoSyMeta(address: web3.PublicKey): Promise<KaminoSyMeta> {
+    const x: KaminoSyMetaRaw = await this.kaminoSyProgram.account.syMeta.fetch(address)
+    return {
+      ...x,
+      emissions: x.emissions.map(deserializeSyEmissionRaw),
+    }
+  }
+
+  async fetchLpPosition(address: web3.PublicKey): Promise<LpPosition> {
+    const x: LpPositionRaw = await this.program.account.lpPosition.fetch(address)
+    console.log("FARMs SHOULD BE HERE", x.farms)
+    return deserializeLpPosition(x)
+  }
+
+  async fetchYtPosition(address: web3.PublicKey): Promise<YtPosition> {
+    const x: YtPositionRaw = await this.program.account.yieldTokenPosition.fetch(address)
+    return deserializeYtPosition(x)
+  }
+
+  async fetchJitoRestakingSyMeta(address: web3.PublicKey): Promise<JitoRestakingSyMetaAccount> {
+    const x: JitoRestakingSyMetaAccountRaw = await this.jitoRestakingSyProgram.account.syMeta.fetch(address)
+
+    return deserializeJitoRestakingSyMetaAccountRaw(x)
+  }
+
+  async fetchPerenaSyMeta(address: web3.PublicKey): Promise<PerenaSyMetaAccount> {
+    const x: PerenaSyMetaAccountRaw = await this.perenaSyProgram.account.syMeta.fetch(address)
+    return deserializePerenaSyMetaAccountRaw(x)
+  }
+
+  async fetchGenericSyMeta(address: web3.PublicKey): Promise<GenericSyMetaAccount> {
+    const x: GenericSyMetaAccountRaw = await this.genericStandardProgram.account.syMeta.fetch(address)
+
+    return deserializeGenericSyMetaAccountRaw(x)
+  }
+}
+
+function deserializeMarketTwo(m: MarketTwoRaw): MarketTwo {
+  return {
+    ptBalance: BigInt(m.financials.ptBalance.toString()),
+    syBalance: BigInt(m.financials.syBalance.toString()),
+    lpEscrowAmount: BigInt(m.lpEscrowAmount.toString()),
+    maxLpSupply: BigInt(m.maxLpSupply.toString()),
+    rateScalarRoot: m.financials.rateScalarRoot,
+    lnFeeRateRoot: m.financials.lnFeeRateRoot,
+    lastLnImpliedRate: m.financials.lastLnImpliedRate,
+    expirationTs: m.financials.expirationTs.toNumber(),
+    addressLookupTable: m.addressLookupTable,
+    mintSy: m.mintSy,
+    mintPt: m.mintPt,
+    mintLp: m.mintLp,
+    vault: m.vault,
+    tokenLpEscrow: m.tokenLpEscrow,
+    tokenSyEscrow: m.tokenSyEscrow,
+    tokenPtEscrow: m.tokenPtEscrow,
+    tokenFeeTreasurySy: m.tokenFeeTreasurySy,
+    selfAddress: m.selfAddress,
+    syProgram: m.syProgram,
+    statusFlags: m.statusFlags,
+    cpiAccounts: m.cpiAccounts,
+    feeTreasurySyBps: m.feeTreasurySyBps,
+    isCurrentFlashSwap: m.isCurrentFlashSwap,
+    lpFarm: m.lpFarm,
+    emissions: {
+      trackers: m.emissions.trackers.map((t) => ({
+        tokenEscrow: t.tokenEscrow,
+        lpShareIndex: deserializeAnchorizedPNum(t.lpShareIndex),
+        lastSeenStaged: Number(t.lastSeenStaged),
+      })),
+    },
+    liquidityNetBalanceLimits: m.liquidityNetBalanceLimits,
+  }
+}
+
+function deserializeVault(x: VaultRaw): Vault {
+  return {
+    syProgram: x.syProgram,
+    mintSy: x.mintSy,
+    mintYt: x.mintYt,
+    mintPt: x.mintPt,
+    escrowSy: x.escrowSy,
+    escrowYt: x.escrowYt,
+    startTs: x.startTs,
+    duration: x.duration,
+    authority: x.authority,
+    lastSeenSyExchangeRate: deserializeAnchorizedPNum(x.lastSeenSyExchangeRate),
+    allTimeHighSyExchangeRate: deserializeAnchorizedPNum(x.allTimeHighSyExchangeRate),
+    finalSyExchangeRate: deserializeAnchorizedPNum(x.finalSyExchangeRate),
+    addressLookupTable: x.addressLookupTable,
+    ptSupply: BigInt(x.ptSupply.toString()),
+    syForPt: BigInt(x.syForPt.toString()),
+    yieldPosition: x.yieldPosition,
+    emissions: x.emissions,
+    cpiAccounts: x.cpiAccounts,
+    treasurySy: x.treasurySy,
+    totalSyInEscrow: BigInt(x.totalSyInEscrow.toString()),
+    interestBpsFee: x.interestBpsFee,
+    status: x.status,
+    treasurySyTokenAccount: x.treasurySyTokenAccount,
+    minOpSizeStrip: BigInt(x.minOpSizeStrip.toString()),
+    minOpSizeMerge: BigInt(x.minOpSizeMerge.toString()),
+    maxPySupply: BigInt(x.maxPySupply.toString()),
+  }
+}
+
+function deserializeMarginfiSyMeta(x: MarginfiSyMetaRaw): MarginfiSyMeta {
+  return {
+    ...x,
+    maxSySupply: BigInt(x.maxSySupply.toString()),
+    minMintSize: BigInt(x.minMintSize.toString()),
+    minRedeemSize: BigInt(x.minRedeemSize.toString()),
+  }
+}
+
+function deserializeSyEmissionRaw(x: {
+  mint: web3.PublicKey
+  index: AnchorizedPNum
+  lastSeenTotalAccruedEmissions: BN
+  totalClaimedEmissions: BN
+  tokenProgram: web3.PublicKey
+  escrowAccount: web3.PublicKey
+  treasuryEmission: BN
+  lastSeenIndex: AnchorizedPNum
+}): SyEmissionRaw {
+  return {
+    mint: x.mint,
+    index: x.index,
+    lastSeenTotalAccruedEmissions: new BN(x.lastSeenTotalAccruedEmissions.toString()),
+    totalClaimedEmissions: new BN(x.totalClaimedEmissions.toString()),
+    tokenProgram: x.tokenProgram,
+    escrowAccount: x.escrowAccount,
+    treasuryEmission: new BN(x.treasuryEmission.toString()),
+    lastSeenIndex: x.lastSeenIndex,
+  }
+}
+
+function deserializeLpPosition(x: LpPositionRaw): LpPosition {
+  return {
+    owner: x.owner,
+    market: x.market,
+    lpBalance: BigInt(x.lpBalance.toString()),
+    emissions: x.emissions.trackers.map((t) => ({
+      staged: BigInt(t.staged.toString()),
+      lastSeenIndex: parseFloat(PreciseNumber.fromRaw(t.lastSeenIndex[0]).valueString),
+    })),
+    farms: x.farms.trackers.map((t) => ({
+      staged: BigInt(t.staged.toString()),
+      lastSeenIndex: parseFloat(PreciseNumber.fromRaw(t.lastSeenIndex[0]).valueString),
+    })),
+  }
+}
+
+function deserializeYtPosition(x: YtPositionRaw): YtPosition {
+  return {
+    owner: x.owner,
+    vault: x.vault,
+    ytBalance: BigInt(x.ytBalance.toString()),
+    interest: deserializeYieldTokenTracker(x.interest),
+    emissions: x.emissions.map(deserializeYieldTokenTracker),
+  }
+}
+
+function deserializeYieldTokenTracker(x: YieldTokenTrackerRaw): YieldTokenTracker {
+  return {
+    staged: BigInt(x.staged.toString()),
+    lastSeenIndex: parseFloat(PreciseNumber.fromRaw(x.lastSeenIndex[0]).valueString),
+  }
+}
+
+export async function fetchKaminoReserve(address: web3.PublicKey, connection: web3.Connection) {
+  const reserve = await Reserve.fetch(connection, address)
+  if (!reserve) {
+    throw new Error("Reserve not found")
+  }
+
+  return {
+    lendingMarket: reserve.lendingMarket,
+    baseMint: reserve.liquidity.mintPubkey,
+    assetShareValue: reserve.getCollateralExchangeRate(),
+  }
+}
+
+export function serializeEmission(emission: VaultEmission): VaultEmissionJson {
+  return {
+    tokenAccount: emission.tokenAccount.toString(),
+    initialIndex: serializeAnchorizedPNumFromJson(emission.initialIndex),
+    lastSeenIndex: serializeAnchorizedPNumFromJson(emission.lastSeenIndex),
+    treasuryTokenAccount: emission.treasuryTokenAccount.toString(),
+    feeBps: emission.feeBps,
+    treasuryEmission: emission.treasuryEmission.toString(),
+  }
+}
+
+export function deserializeEmission(emission: VaultEmissionJson): VaultEmission {
+  return {
+    tokenAccount: new web3.PublicKey(emission.tokenAccount),
+    initialIndex: deserializeAnchorizedPNumFromJson(emission.initialIndex),
+    lastSeenIndex: deserializeAnchorizedPNumFromJson(emission.lastSeenIndex),
+    treasuryTokenAccount: new web3.PublicKey(emission.treasuryTokenAccount),
+    feeBps: emission.feeBps,
+    treasuryEmission: new BN(emission.treasuryEmission),
+  }
+}
+
+export interface MarketTwo {
+  ptBalance: bigint
+  syBalance: bigint
+  rateScalarRoot: number
+  lnFeeRateRoot: number
+  lastLnImpliedRate: number
+  expirationTs: number
+  addressLookupTable: web3.PublicKey
+  mintSy: web3.PublicKey
+  mintPt: web3.PublicKey
+  mintLp: web3.PublicKey
+  vault: web3.PublicKey
+  tokenPtEscrow: web3.PublicKey
+  tokenSyEscrow: web3.PublicKey
+  tokenLpEscrow: web3.PublicKey
+  tokenFeeTreasurySy: web3.PublicKey
+  syProgram: web3.PublicKey
+  selfAddress: web3.PublicKey
+  statusFlags: number
+  lpEscrowAmount: bigint
+  maxLpSupply: bigint
+  cpiAccounts: CpiAccountIndexes
+  feeTreasurySyBps: number
+  isCurrentFlashSwap: boolean
+  lpFarm: LpFarm
+  emissions: {
+    trackers: {
+      tokenEscrow: web3.PublicKey
+      lpShareIndex: number
+      lastSeenStaged: number
+    }[]
+  }
+  liquidityNetBalanceLimits: LiquidityNetBalanceLimits
+}
+
+export interface Vault {
+  syProgram: web3.PublicKey
+  mintSy: web3.PublicKey
+  mintYt: web3.PublicKey
+  mintPt: web3.PublicKey
+  escrowSy: web3.PublicKey
+  startTs: number
+  duration: number
+  authority: web3.PublicKey
+  lastSeenSyExchangeRate: number
+  allTimeHighSyExchangeRate: number
+  finalSyExchangeRate: number
+  addressLookupTable: web3.PublicKey
+  totalSyInEscrow: bigint
+  ptSupply: bigint
+  syForPt: bigint
+  yieldPosition: web3.PublicKey
+  escrowYt: web3.PublicKey
+  treasurySy: BN
+  treasurySyTokenAccount: web3.PublicKey
+  interestBpsFee: number
+  emissions: VaultEmission[]
+  status: number
+  minOpSizeStrip: bigint
+  minOpSizeMerge: bigint
+  cpiAccounts: CpiAccountIndexes
+  maxPySupply: bigint
+}
+
+export interface KaminoSyMeta {
+  kaminoReserve: web3.PublicKey
+  kaminoObligation: web3.PublicKey
+  kaminoFarm: web3.PublicKey
+  kaminoUserMetadata: web3.PublicKey
+  mintSy: web3.PublicKey
+  /** Where the SY tokens get deposited */
+  tokenSyEscrow: web3.PublicKey
+  minMintSize: BN
+  minRedeemSize: BN
+  emissions: SyEmissionRaw[]
+}
+
+export interface SyPosition {
+  balanceSy: bigint
+  owner: web3.PublicKey
+  emissions: {
+    /** Last seen index for SY-to-emission exchange rate */
+    lastSeenIndex: number
+    /** mint of emission token */
+    mint: web3.PublicKey
+    /** How many emissions are staged to claim */
+    staged: bigint
+  }[]
+}
+
+export interface LpPosition {
+  owner: web3.PublicKey
+  market: web3.PublicKey
+  lpBalance: bigint
+  emissions: { staged: bigint; lastSeenIndex: number }[]
+  farms: { staged: bigint; lastSeenIndex: number }[]
+}
+
+export interface YtPosition {
+  owner: web3.PublicKey
+  vault: web3.PublicKey
+  ytBalance: bigint
+  interest: YieldTokenTracker
+  emissions: YieldTokenTracker[]
+}
+
+export interface YieldTokenTracker {
+  staged: bigint
+  lastSeenIndex: number
+}
+
+interface LpPositionRaw {
+  owner: web3.PublicKey
+  market: web3.PublicKey
+  lpBalance: BN
+  emissions: { trackers: { staged: BN; lastSeenIndex: AnchorizedPNum }[] }
+  farms: { trackers: { staged: BN; lastSeenIndex: AnchorizedPNum }[] }
+}
+
+export interface LpFarm {
+  lastSeenTimestamp: number
+  farmEmissions: FarmEmissionRaw[]
+}
+
+interface FarmEmissionRaw {
+  mint: web3.PublicKey
+  tokenRate: BN
+  expiryTimestamp: number
+  index: AnchorizedPNum
+}
+
+export interface LiquidityNetBalanceLimits {
+  windowStartTimestamp: number
+  windowStartNetBalance: BN
+  maxNetBalanceChangeNegativePercentage: number
+  maxNetBalanceChangePositivePercentage: number
+  windowDurationSeconds: number
+}
+
+export interface MarketEmissions {
+  trackers: MarketEmission[]
+}
+
+interface MarketEmission {
+  tokenEscrow: web3.PublicKey
+  lpShareIndex: AnchorizedPNum
+  lastSeenStaged: BN
+}
+
+interface MarketTwoRaw {
+  financials: MarketFinancialsRaw
+  addressLookupTable: web3.PublicKey
+  vault: web3.PublicKey
+  mintSy: web3.PublicKey
+  mintLp: web3.PublicKey
+  mintPt: web3.PublicKey
+  tokenPtEscrow: web3.PublicKey
+  tokenSyEscrow: web3.PublicKey
+  tokenLpEscrow: web3.PublicKey
+  tokenFeeTreasurySy: web3.PublicKey
+  syProgram: web3.PublicKey
+  selfAddress: web3.PublicKey
+  statusFlags: number
+  lpEscrowAmount: BN
+  maxLpSupply: BN
+  cpiAccounts: CpiAccountIndexes
+  /** Fee rate taken off of trade fees (typically around 20%) */
+  feeTreasurySyBps: number
+  isCurrentFlashSwap: boolean
+  lpFarm: LpFarm
+  liquidityNetBalanceLimits: LiquidityNetBalanceLimits
+  emissions: MarketEmissions
+}
+
+interface MarketFinancialsRaw {
+  ptBalance: BN
+  syBalance: BN
+  rateScalarRoot: number
+  lnFeeRateRoot: number
+  lastLnImpliedRate: number
+  expirationTs: BN
+}
+
+interface VaultRaw {
+  syProgram: web3.PublicKey
+  mintSy: web3.PublicKey
+  mintYt: web3.PublicKey
+  mintPt: web3.PublicKey
+  escrowSy: web3.PublicKey
+  startTs: number
+  duration: number
+  authority: web3.PublicKey
+  lastSeenSyExchangeRate: AnchorizedPNum
+  allTimeHighSyExchangeRate: AnchorizedPNum
+  finalSyExchangeRate: AnchorizedPNum
+  addressLookupTable: web3.PublicKey
+  ptSupply: BN
+  syForPt: BN
+  escrowYt: web3.PublicKey
+  totalSyInEscrow: BN
+  yieldPosition: web3.PublicKey
+  treasurySy: BN
+  treasurySyTokenAccount: web3.PublicKey
+  interestBpsFee: number
+  emissions: VaultEmission[]
+  status: number
+  minOpSizeStrip: BN
+  minOpSizeMerge: BN
+  cpiAccounts: CpiAccountIndexes
+  maxPySupply: BN
+}
+
+interface KaminoSyMetaRaw {
+  kaminoReserve: web3.PublicKey
+  kaminoObligation: web3.PublicKey
+  kaminoFarm: web3.PublicKey
+  kaminoUserMetadata: web3.PublicKey
+  mintSy: web3.PublicKey
+  minMintSize: BN
+  minRedeemSize: BN
+  /** Where the SY tokens get deposited */
+  tokenSyEscrow: web3.PublicKey
+  emissions: SyEmissionRaw[]
+}
+
+interface YtPositionRaw {
+  owner: web3.PublicKey
+  vault: web3.PublicKey
+  ytBalance: BN
+  interest: YieldTokenTrackerRaw
+  emissions: YieldTokenTrackerRaw[]
+}
+
+interface YieldTokenTrackerRaw {
+  staged: BN
+  lastSeenIndex: AnchorizedPNum
+}
+
+function deserializeAnchorizedPNum(x: AnchorizedPNum): number {
+  return parseFloat(PreciseNumber.fromRaw(x[0]).valueString)
+}
+
+/** Fetch the exchange rate of a JitoRestaking vault's VRT to JitoSOL */
+async function fetchJitoVaultData({
+  connection,
+  vaultAddress,
+}: {
+  connection: web3.Connection
+  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 }
+}
+
+async function fetchJitoSolToSolExchangeRate({
+  connection,
+  interfaceType,
+  accounts,
+}: {
+  connection: web3.Connection
+  /** Interface type of the JitoRestaking interface program that Exponent manages */
+  interfaceType: InterfaceType
+  /** "remaining accounts" */
+  accounts: web3.PublicKey[]
+}) {
+  if (interfaceType.splStakePool) {
+    const stakePool = await getStakePoolAccount(connection, accounts[0])
+
+    return Number(stakePool.account.data.totalLamports) / Number(stakePool.account.data.poolTokenSupply)
+  }
+
+  throw new Error("Unsupported interface type")
+}
+
+export async function fetchPerenaStablePoolData({
+  connection,
+  perenaStablePool,
+}: {
+  connection: web3.Connection
+  perenaStablePool: web3.PublicKey
+}) {
+  const [lpMint, _] = web3.PublicKey.findProgramAddressSync(
+    [perenaStablePool.toBuffer(), Buffer.from("liquidity")],
+    new web3.PublicKey("NUMERUNsFCP3kuNmWZuXtm1AaQCPj9uw6Guv2Ekoi5P"),
+  )
+
+  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()
+
+  return { lpSupply: lpMintDeserialized.supply, invT, exchangeRate, lpMint }
+}
+
+/**
+ * Fetch the exchange rate of a JitoRestaking vault
+ * @param connection
+ * @param accounts "remaining accounts"
+ * @param vaultAddress "address of the Jito Restaking vault"
+ * @param interfaceType "interface type of the Jito Restaking interface program that Exponent manages"
+ * @returns
+ */
+export async function fetchJitoRestaking(
+  connection: web3.Connection,
+  accounts: web3.PublicKey[],
+  interfaceType: InterfaceType,
+  vaultAddress: web3.PublicKey,
+): Promise<{ mintBase: web3.PublicKey; exchangeRateUnderlying: number; exchangeRate: string }> {
+  const vaultDataP = fetchJitoVaultData({ connection, vaultAddress })
+
+  const solToSolExchangeRateP = fetchJitoSolToSolExchangeRate({ connection, interfaceType, accounts })
+
+  const [{ exchangeRate: e1, mintBase }, e2] = await Promise.all([vaultDataP, solToSolExchangeRateP])
+
+  // exchange rate of VRT to SOL is the product of the two exchange rates
+  const exr = e1 * e2
+
+  return {
+    mintBase,
+    exchangeRateUnderlying: e2,
+    exchangeRate: exr.toString(),
+  }
+}
+
+export async function fetchPyth(connection: web3.Connection): Promise<string> {
+  return ""
+}
+
+export async function fetchGenericSyMetaIndex({
+  connection,
+  genericSyMeta,
+}: {
+  connection: web3.Connection
+  genericSyMeta: web3.PublicKey
+}) {
+  const [accountInfo] = await connection.getMultipleAccountsInfo([genericSyMeta])
+  const d = accountInfo.data
+
+  // Calculate offset:
+  // 8 (discriminator) +
+  // 32 (mint_sy) +
+  // 32 (token_sy_escrow) +
+  // 8 (max_sy_supply) +
+  // 8 (min_mint_size) +
+  // 8 (min_redeem_size) +
+  // 1 (self_address_bump)
+  const indexOffset = 8 + 32 + 32 + 8 + 8 + 8 + 1
+  const indexBuffer = d.slice(indexOffset, indexOffset + 32)
+
+  // Split the 32 byte buffer into 4 u64 (8 bytes each)
+  const nums = []
+  for (let i = 0; i < 4; i++) {
+    const slice = indexBuffer.slice(i * 8, (i + 1) * 8)
+    nums.push(new BN(slice, undefined, "le")) // Added 'le' for little-endian
+  }
+
+  // Convert the buffer to AnchorizedPNum format with 4 BNs
+  const indexRaw = { 0: nums }
+  const index = parseFloat(PreciseNumber.fromRaw(indexRaw[0]).valueString)
+
+  return { index }
+}
+
+export async function fetchFragmetricIndex({
+  connection,
+  fragmetricFund,
+}: {
+  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 receiptTokenMint = new web3.PublicKey(data.receipt_token_mint)
+  const wrappedTokenMint = new web3.PublicKey(data.wrapped_token.mint)
+
+  return { index, receiptTokenMint, wrappedTokenMint }
+}
+
+export async function fetchMeteoraUsdcUsdtIndex({
+  connection,
+  accounts,
+  onChainTime,
+}: {
+  connection: web3.Connection
+  accounts: any
+  onChainTime: number
+}): Promise<number> {
+  try {
+    const VIRTUAL_PRICE_PRECISION = new BN(100_000_000)
+
+    const pool = await decodePoolAccount(connection, accounts.pool)
+
+    const poolLpSupply = new BN((await getMint(connection, pool.lpMint)).supply.toString())
+
+    const vaultA = await decodeVaultAccount(connection, accounts.vaultA)
+    const vaultB = await decodeVaultAccount(connection, accounts.vaultB)
+
+    const vaultALpSupply = (await getMint(connection, vaultA.lpMint)).supply
+    const vaultBLpSupply = (await getMint(connection, vaultB.lpMint)).supply
+
+    const poolVaultALpTokenAmount = (await getAccount(connection, pool.aVaultLp)).amount
+    const poolVaultBLpTokenAmount = (await getAccount(connection, pool.bVaultLp)).amount
+
+    const tokenAAmount = getAmountByShare(
+      new BN(poolVaultALpTokenAmount.toString()),
+      new BN(vaultALpSupply.toString()),
+      vaultA,
+      onChainTime,
+    )
+    const tokenBAmount = getAmountByShare(
+      new BN(poolVaultBLpTokenAmount.toString()),
+      new BN(vaultBLpSupply.toString()),
+      vaultB,
+      onChainTime,
+    )
+
+    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
+  } catch (error) {
+    throw error
+  }
+}