@exponent-labs/exponent-vaults-fetcher 0.9.0

package/src/constants.ts

@@ -0,0 +1,33 @@
+import { web3 } from "@coral-xyz/anchor"
+
+import { PROGRAM_ID } from "@exponent-labs/exponent-vaults-idl"
+
+const EXPONENT_PRICES_SEED = new TextEncoder().encode("exponent_prices")
+
+/** Seed used for withdrawal PDA derivation on-chain. */
+export const WITHDRAWAL_ACCOUNT_SEED = "withdrawal" as const
+
+/**
+ * Set of vault addresses to ignore during fetching.
+ * These accounts cannot be deserialized due to program updates and should be skipped.
+ */
+export const IGNORED_VAULTS = new Set([
+  "Fo7vvPsSqNAYy2S7CpQoVFP8Ygnr22xB3fJVhde9GjcB",
+  "7apbV7QJHFhh5Ueczg35n6StyNdqeMmDdRwKDNCSRm7i",
+  "GsT257ZWjLboYAbWE1qDX2irHSyvCviQatyu3g2DSqmb",
+  "3KUQ8H5v4pLthqCsdPZuMnwjHVJcdkiFeWZGdX3Mr7MX",
+  "79aYbxCzLNFiF3tibivW6kva8B5qcFUAPAGweDuAyfMY",
+  "99RpUEbUMe1chVgpJNV16iXaJqdfvm459siFX9SA75nq",
+  "E957xxdpgsCbmqHo9AyHkLRTvgppxgQbZ9V8QXpQegg5",
+  "F9Tv2qBbS1YnsR4hYyaq6ztPUcTpht1ZT5Gb22DFwyg1",
+  "FKif7QNqt6cSaFj9cGL8eCz9cuSncKvbVNHxzd92r2hY",
+  "GfT6RcToh5mmkJ5DpPSBsBSJzun2WyVcsWXzNCtEfVUa",
+  "HUXvqaGbjX8kZ65ZhMhJgzfrjEX5By2gA8x9Z9mEFfQH",
+  "Hyi6LoTzcHpaQueSz4qqFdWeBydihpkRR8CqFvLWspqH",
+])
+
+/** Singleton ExponentPrices account address */
+export const EXPONENT_PRICES_ADDRESS = web3.PublicKey.findProgramAddressSync(
+  [EXPONENT_PRICES_SEED],
+  new web3.PublicKey(PROGRAM_ID),
+)[0].toBase58()

package/src/fetcher.ts

@@ -0,0 +1,436 @@
+import { AnchorProvider, Program, Wallet, web3 } from "@coral-xyz/anchor"
+
+import { ExponentVaults, IDL, PROGRAM_ID } from "@exponent-labs/exponent-vaults-idl"
+import { ExponentVaultsPDA } from "@exponent-labs/exponent-vaults-pda"
+
+import { IGNORED_VAULTS } from "./constants"
+import { transformAnchorData } from "./typeUtils"
+import { ActionProposal, ExponentPrices, ExponentVault, WithdrawalAccount } from "./types"
+
+const EXPONENT_PRICES_META_DISCRIMINATOR = Buffer.from([188, 97, 196, 52, 192, 41, 211, 196])
+const MAX_PRICES = 32
+const MAX_PRICE_MANAGERS = 8
+const PRICE_NODE_REGISTERS = 4
+const PRICE_USAGE_AMOUNT_REGISTER = 1
+
+const PUBKEY_BYTES = 32
+const U32_BYTES = 4
+const U64_BYTES = 8
+const ZERO_PUBKEY = new web3.PublicKey(new Uint8Array(PUBKEY_BYTES))
+
+const EXPONENT_PRICE_SIZE = 224
+const PRICE_NODE_SIZE = EXPONENT_PRICE_SIZE
+const NODE_REGISTERS_SIZE = PRICE_NODE_REGISTERS * U32_BYTES
+const PRICE_NODE_WRAPPED_SIZE = NODE_REGISTERS_SIZE + PRICE_NODE_SIZE
+
+const EXPONENT_PRICES_MIN_SIZE =
+  8 + // discriminator
+  4 + // price_managers_len
+  4 + // padding
+  MAX_PRICE_MANAGERS * PUBKEY_BYTES + // price_managers
+  8 + // allocator.size
+  4 + // allocator.bump_index
+  4 + // allocator.free_list_head
+  MAX_PRICES * PRICE_NODE_WRAPPED_SIZE + // allocator nodes
+  128 // prices_options
+
+class MockWallet implements Wallet {
+  constructor(readonly payer: web3.Keypair) {
+    this.payer = payer
+  }
+  async signTransaction<T extends web3.Transaction | web3.VersionedTransaction>(tx: T): Promise<T> {
+    return tx
+  }
+  async signAllTransactions<T extends web3.Transaction | web3.VersionedTransaction>(txs: T[]): Promise<T[]> {
+    return txs
+  }
+  get publicKey(): web3.PublicKey {
+    return this.payer.publicKey
+  }
+}
+
+export class ExponentVaultsFetcher {
+  public readonly program: Program<ExponentVaults>
+  public readonly programId: web3.PublicKey
+
+  constructor(connection: web3.Connection, programId: web3.PublicKey | string = PROGRAM_ID) {
+    this.programId = new web3.PublicKey(programId)
+    const provider = new AnchorProvider(connection, new MockWallet(web3.Keypair.generate()))
+    const programIdl = {
+      ...(IDL as ExponentVaults),
+      address: this.programId.toBase58(),
+    } as ExponentVaults
+
+    this.program = new Program<ExponentVaults>(programIdl, provider)
+  }
+
+  fetchVault(address: web3.PublicKey) {
+    return this.program.account.exponentStrategyVault.fetch(address)
+  }
+
+  fetchWithdrawalAccount(address: web3.PublicKey) {
+    return this.program.account.withdrawalAccount.fetch(address)
+  }
+
+  fetchActionProposal(address: web3.PublicKey) {
+    return this.program.account.actionProposal.fetch(address)
+  }
+
+  async fetchAllVaults(filters?: web3.GetProgramAccountsFilter[]) {
+    const discriminator = this.program.account.exponentStrategyVault.coder.accounts.memcmp("exponentStrategyVault")
+    const baseFilters: web3.GetProgramAccountsFilter[] = discriminator
+      ? [{ memcmp: { offset: discriminator.offset, bytes: discriminator.bytes } }]
+      : []
+    const allFilters = filters ? [...baseFilters, ...filters] : baseFilters
+
+    const rawAccounts = await this.program.provider.connection.getProgramAccounts(this.programId, {
+      filters: allFilters,
+    })
+
+    const decoded: { publicKey: web3.PublicKey; account: any }[] = []
+    for (const { pubkey, account } of rawAccounts) {
+      if (IGNORED_VAULTS.has(pubkey.toBase58())) continue
+      // Guard against old/mismatched vault layouts: Borsh may read garbage vec lengths
+      // from misaligned data, causing uncatchable OOM via massive array allocation.
+      // The first vec (token_entries) is at byte offset 104 (8 discriminator + 3×32 pubkeys).
+      // If its u32 length is unreasonably large, the layout is wrong — skip to prevent OOM.
+      const TOKEN_ENTRIES_VEC_OFFSET = 104
+      if (account.data.length < TOKEN_ENTRIES_VEC_OFFSET + 4) continue
+      const tokenEntriesLen = account.data.readUInt32LE(TOKEN_ENTRIES_VEC_OFFSET)
+      if (tokenEntriesLen > 64) continue
+      try {
+        const data = this.program.account.exponentStrategyVault.coder.accounts.decode(
+          "exponentStrategyVault",
+          account.data,
+        )
+        decoded.push({ publicKey: pubkey, account: data })
+      } catch {
+        // skip accounts that fail to deserialize
+      }
+    }
+    return decoded
+  }
+
+  async fetchAllActionProposals(filters?: web3.GetProgramAccountsFilter[]) {
+    const discriminator = this.program.account.actionProposal.coder.accounts.memcmp("actionProposal")
+    const baseFilters: web3.GetProgramAccountsFilter[] = discriminator
+      ? [{ memcmp: { offset: discriminator.offset, bytes: discriminator.bytes } }]
+      : []
+    const allFilters = filters ? [...baseFilters, ...filters] : baseFilters
+
+    const rawAccounts = await this.program.provider.connection.getProgramAccounts(this.programId, {
+      filters: allFilters,
+    })
+
+    const decoded: { publicKey: web3.PublicKey; account: any }[] = []
+    for (const { pubkey, account } of rawAccounts) {
+      try {
+        const data = this.program.account.actionProposal.coder.accounts.decode("actionProposal", account.data)
+        decoded.push({ publicKey: pubkey, account: data })
+      } catch {
+        // skip accounts that fail to deserialize
+      }
+    }
+
+    return decoded
+  }
+
+  fetchAllWithdrawalAccounts(filters?: web3.GetProgramAccountsFilter[]) {
+    return this.program.account.withdrawalAccount.all(filters)
+  }
+
+  async fetchAllActionProposalsForVault(vaultAddress: web3.PublicKey, filters?: web3.GetProgramAccountsFilter[]) {
+    const vaultFilter: web3.GetProgramAccountsFilter = {
+      memcmp: {
+        offset: 8, // discriminator
+        bytes: vaultAddress.toBase58(),
+      },
+    }
+
+    return this.fetchAllActionProposals(filters ? [vaultFilter, ...filters] : [vaultFilter])
+  }
+
+  async fetchVaultDeserialized(address: web3.PublicKey): Promise<ExponentVault> {
+    if (IGNORED_VAULTS.has(address.toBase58())) {
+      throw new Error(`Vault ${address.toBase58()} is in the ignore list and cannot be fetched`)
+    }
+    const vault = await this.fetchVault(address)
+    return transformAnchorData(vault) as ExponentVault
+  }
+
+  async fetchActionProposalDeserialized(address: web3.PublicKey): Promise<ActionProposal> {
+    const proposal = await this.fetchActionProposal(address)
+    return transformAnchorData(proposal) as unknown as ActionProposal
+  }
+
+  async fetchWithdrawalAccountDeserialized(address: web3.PublicKey): Promise<WithdrawalAccount> {
+    const withdrawal = await this.fetchWithdrawalAccount(address)
+    return transformAnchorData(withdrawal)
+  }
+
+  async fetchAllVaultsDeserialized(filters?: web3.GetProgramAccountsFilter[]): Promise<
+    {
+      publicKey: web3.PublicKey
+      account: ExponentVault
+    }[]
+  > {
+    const accounts = await this.fetchAllVaults(filters)
+    return accounts.map(({ publicKey, account }) => ({
+      publicKey,
+      account: transformAnchorData(account) as ExponentVault,
+    }))
+  }
+
+  async fetchAllActionProposalsDeserialized(filters?: web3.GetProgramAccountsFilter[]): Promise<
+    {
+      publicKey: web3.PublicKey
+      account: ActionProposal
+    }[]
+  > {
+    const accounts = await this.fetchAllActionProposals(filters)
+    return accounts.map(({ publicKey, account }) => ({
+      publicKey,
+      account: transformAnchorData(account) as unknown as ActionProposal,
+    }))
+  }
+
+  async fetchAllActionProposalsForVaultDeserialized(
+    vaultAddress: web3.PublicKey,
+    filters?: web3.GetProgramAccountsFilter[],
+  ): Promise<
+    {
+      publicKey: web3.PublicKey
+      account: ActionProposal
+    }[]
+  > {
+    const accounts = await this.fetchAllActionProposalsForVault(vaultAddress, filters)
+    return accounts.map(({ publicKey, account }) => ({
+      publicKey,
+      account: transformAnchorData(account) as unknown as ActionProposal,
+    }))
+  }
+
+  async fetchAllWithdrawalAccountsDeserialized(filters?: web3.GetProgramAccountsFilter[]) {
+    const accounts = await this.fetchAllWithdrawalAccounts(filters)
+    return accounts.map(({ publicKey, account }) => ({
+      publicKey,
+      account: transformAnchorData(account),
+    }))
+  }
+
+  /**
+   * Fetch the singleton ExponentPrices account.
+   */
+  async fetchExponentPrices(): Promise<ExponentPrices> {
+    const address = new ExponentVaultsPDA(this.programId).exponentPrices()[0]
+    const accountInfo = await this.program.provider.connection.getAccountInfo(address)
+
+    if (!accountInfo) {
+      throw new Error(`ExponentPrices account not found: ${address.toBase58()}`)
+    }
+    if (!accountInfo.owner.equals(this.programId)) {
+      throw new Error(
+        `ExponentPrices owner mismatch: expected ${this.programId.toBase58()}, got ${accountInfo.owner.toBase58()}`,
+      )
+    }
+
+    const data = accountInfo.data
+    if (data.length < EXPONENT_PRICES_MIN_SIZE) {
+      throw new Error(
+        `ExponentPrices account too small: got ${data.length} bytes, expected at least ${EXPONENT_PRICES_MIN_SIZE}`,
+      )
+    }
+
+    const discriminator = data.subarray(0, 8)
+    if (!discriminator.equals(EXPONENT_PRICES_META_DISCRIMINATOR)) {
+      throw new Error("Invalid ExponentPrices discriminator")
+    }
+
+    let offset = 8
+
+    const readU32 = () => {
+      const value = data.readUInt32LE(offset)
+      offset += U32_BYTES
+      return value
+    }
+    const readU64 = () => {
+      const value = data.readBigUInt64LE(offset)
+      offset += U64_BYTES
+      return value
+    }
+
+    const managersLen = readU32()
+    offset += U32_BYTES // _padding0
+    if (managersLen > MAX_PRICE_MANAGERS) {
+      throw new Error(`Invalid ExponentPrices managers length: ${managersLen}`)
+    }
+    const managers: web3.PublicKey[] = []
+    for (let i = 0; i < managersLen; i++) {
+      const managerOffset = offset + i * PUBKEY_BYTES
+      managers.push(new web3.PublicKey(data.subarray(managerOffset, managerOffset + PUBKEY_BYTES)))
+    }
+    offset += MAX_PRICE_MANAGERS * PUBKEY_BYTES // price_managers
+
+    const allocatorSize = Number(readU64())
+    const bumpIndex = readU32()
+    const freeListHead = readU32()
+    if (allocatorSize > MAX_PRICES) {
+      throw new Error(`Invalid ExponentPrices allocator size: ${allocatorSize}`)
+    }
+    if (bumpIndex > MAX_PRICES + 1) {
+      throw new Error(`Invalid ExponentPrices bump index: ${bumpIndex}`)
+    }
+    if (freeListHead > MAX_PRICES + 1) {
+      throw new Error(`Invalid ExponentPrices free list head: ${freeListHead}`)
+    }
+
+    const nodesOffset = offset
+
+    const readNodeAt = (index: number) => {
+      if (index < 1 || index > MAX_PRICES) {
+        throw new Error(`Invalid ExponentPrices node index: ${index}`)
+      }
+      const nodeOffset = nodesOffset + (index - 1) * PRICE_NODE_WRAPPED_SIZE
+
+      const usageAmount = data.readUInt32LE(nodeOffset + PRICE_USAGE_AMOUNT_REGISTER * U32_BYTES)
+      const valueOffset = nodeOffset + NODE_REGISTERS_SIZE
+
+      const priceMintBytes = data.subarray(valueOffset, valueOffset + PUBKEY_BYTES)
+      const priceMint = new web3.PublicKey(priceMintBytes)
+      const active = priceMintBytes.some((b: number) => b !== 0)
+      const underlyingMint = new web3.PublicKey(
+        data.subarray(valueOffset + PUBKEY_BYTES, valueOffset + PUBKEY_BYTES * 2),
+      )
+
+      const priceOffset = valueOffset + PUBKEY_BYTES * 2
+      const n0 = data.readBigUInt64LE(priceOffset)
+      const n1 = data.readBigUInt64LE(priceOffset + 8)
+      const n2 = data.readBigUInt64LE(priceOffset + 16)
+      const n3 = data.readBigUInt64LE(priceOffset + 24)
+
+      const positionsAmount = data.readBigUInt64LE(valueOffset + 96)
+      const lastUpdatedAt = data.readBigUInt64LE(valueOffset + 104)
+      const lastUpdatedSlot = data.readBigUInt64LE(valueOffset + 112)
+      const priceType = data.readUInt8(valueOffset + 120)
+      const impliedApyBps = priceType === 3 ? data.readUInt32LE(valueOffset + 121) : null
+      const priceInterfaceAccounts = new web3.PublicKey(
+        data.subarray(valueOffset + 128, valueOffset + 128 + PUBKEY_BYTES),
+      )
+
+      return {
+        active,
+        usageAmount,
+        price: {
+          priceId: BigInt(index),
+          priceMint,
+          underlyingMint,
+          price: [[n0, n1, n2, n3]],
+          positionsAmount,
+          lastUpdatedAt,
+          lastUpdatedSlot,
+          priceType,
+          impliedApyBps,
+          impliedApy: impliedApyBps === null ? null : impliedApyBps / 1_000_000,
+          priceInterfaceAccounts,
+          interfaceAccounts: [],
+        },
+      }
+    }
+
+    const prices: ExponentPrices["prices"] = Array.from({ length: MAX_PRICES + 1 }, () => null)
+    let activePrices = 0
+    for (let nodeIndex = 1; nodeIndex <= MAX_PRICES; nodeIndex++) {
+      const parsed = readNodeAt(nodeIndex)
+      if (parsed.active) {
+        prices[nodeIndex] = parsed.price
+        activePrices += 1
+      }
+    }
+
+    if (activePrices !== allocatorSize) {
+      throw new Error(
+        `Corrupted ExponentPrices allocator: parsed ${activePrices} active entries, allocator has ${allocatorSize}`,
+      )
+    }
+
+    const activePriceEntries = prices.filter((entry) => entry !== null) as NonNullable<
+      ExponentPrices["prices"][number]
+    >[]
+    const uniqueInterfaceAccounts = [
+      ...new Map(
+        activePriceEntries.map((entry) => [entry.priceInterfaceAccounts.toBase58(), entry.priceInterfaceAccounts]),
+      ).values(),
+    ].filter((pubkey) => !pubkey.equals(ZERO_PUBKEY))
+
+    if (uniqueInterfaceAccounts.length > 0) {
+      const infos = await this.program.provider.connection.getMultipleAccountsInfo(uniqueInterfaceAccounts)
+      const decodedInterfaceAccounts = new Map<string, web3.PublicKey[]>()
+
+      for (let i = 0; i < uniqueInterfaceAccounts.length; i++) {
+        const key = uniqueInterfaceAccounts[i]
+        const info = infos[i]
+        if (!info) {
+          throw new Error(`PriceInterfaceAccounts account not found: ${key.toBase58()}`)
+        }
+        if (!info.owner.equals(this.programId)) {
+          throw new Error(
+            `PriceInterfaceAccounts owner mismatch: expected ${this.programId.toBase58()}, got ${info.owner.toBase58()}`,
+          )
+        }
+        decodedInterfaceAccounts.set(key.toBase58(), decodePriceInterfaceAccounts(info.data))
+      }
+
+      for (const entry of activePriceEntries) {
+        entry.interfaceAccounts = decodedInterfaceAccounts.get(entry.priceInterfaceAccounts.toBase58()) ?? []
+      }
+    }
+
+    return { managers, prices }
+  }
+
+  /**
+   * Get all unique price IDs required by a vault's token account positions.
+   * Returns a set of price IDs that should exist in an ExponentPrices account.
+   */
+  getRequiredPriceIds(vault: ExponentVault): Set<bigint> {
+    const priceIds = new Set<bigint>()
+
+    for (const position of vault.strategyPositions) {
+      if ("tokenAccount" in position) {
+        const entry = position.tokenAccount[0]
+        for (const balance of entry.balances) {
+          if ("simple" in balance.priceId) {
+            priceIds.add(balance.priceId.simple.priceId)
+          } else if ("multiply" in balance.priceId) {
+            for (const id of balance.priceId.multiply.priceIds) {
+              priceIds.add(id)
+            }
+          }
+        }
+      }
+    }
+
+    return priceIds
+  }
+}
+
+function decodePriceInterfaceAccounts(data: Buffer): web3.PublicKey[] {
+  if (data.length < 12) {
+    throw new Error(`PriceInterfaceAccounts account too small: ${data.length} bytes`)
+  }
+
+  const len = data.readUInt32LE(8)
+  const expectedSize = 8 + 4 + len * PUBKEY_BYTES
+  if (data.length < expectedSize) {
+    throw new Error(`PriceInterfaceAccounts account truncated: expected ${expectedSize} bytes, got ${data.length}`)
+  }
+
+  const interfaceAccounts: web3.PublicKey[] = []
+  let offset = 12
+  for (let i = 0; i < len; i++) {
+    interfaceAccounts.push(new web3.PublicKey(data.subarray(offset, offset + PUBKEY_BYTES)))
+    offset += PUBKEY_BYTES
+  }
+
+  return interfaceAccounts
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { ExponentVaultsFetcher } from "./fetcher"
+export * from "./types"
+export * from "./constants"
+export * from './typeUtils'

package/src/typeUtils.ts

@@ -0,0 +1,108 @@
+import { BN, web3 } from "@coral-xyz/anchor"
+
+// Extract enum discriminant keys
+type AnchorEnumKey<T> =
+  T extends Record<string, any>
+    ? {
+        [K in keyof T]: T[K] extends Record<string, never> ? K : never
+      }[keyof T]
+    : never
+
+// Check if type is an Anchor enum
+type IsAnchorEnum<T> =
+  T extends Record<string, any>
+    ? {
+        [K in keyof T]: T[K] extends Record<string, never> ? true : false
+      }[keyof T] extends true
+      ? true
+      : false
+    : false
+
+// Check if type is a PublicKey (has toBase58, equals, etc.)
+type IsPublicKey<T> = T extends { toBase58: any; equals: any; toBuffer: any } ? true : false
+
+// Main recursive transformation with PublicKey preservation
+type Transform<T> =
+  // Preserve PublicKey as-is
+  IsPublicKey<T> extends true
+    ? web3.PublicKey
+    : T extends BN
+      ? bigint
+      : T extends Array<infer U>
+        ? Array<Transform<U>>
+        : T extends Map<infer K, infer V>
+          ? Map<Transform<K>, Transform<V>>
+          : T extends Set<infer U>
+            ? Set<Transform<U>>
+            : T extends Uint8Array
+              ? Uint8Array
+              : T extends Date
+                ? Date
+                : T extends object
+                  ? IsAnchorEnum<T> extends true
+                    ? AnchorEnumKey<T>
+                    : {
+                        [K in keyof T]: Transform<T[K]>
+                      }
+                  : T
+
+// Export the main utility
+export type TransformedAnchorType<T> = Transform<T>
+
+// Helper function to convert at runtime
+export function transformAnchorData<T>(data: T): TransformedAnchorType<T> {
+  // Preserve PublicKey instances
+  if (data instanceof web3.PublicKey) {
+    return data as any
+  }
+
+  if (data instanceof BN) {
+    return BigInt(data.toString()) as any
+  }
+
+  if (data instanceof Date) {
+    return data as any
+  }
+
+  if (data instanceof Uint8Array) {
+    return data as any
+  }
+
+  if (Array.isArray(data)) {
+    return data.map(transformAnchorData) as any
+  }
+
+  if (data instanceof Map) {
+    const result = new Map()
+    data.forEach((value, key) => {
+      result.set(transformAnchorData(key), transformAnchorData(value))
+    })
+    return result as any
+  }
+
+  if (data instanceof Set) {
+    return new Set([...data].map(transformAnchorData)) as any
+  }
+
+  if (data && typeof data === "object") {
+    // Check if it's an Anchor enum
+    const keys = Object.keys(data)
+    if (keys.length === 1) {
+      const value = data[keys[0] as keyof typeof data]
+      if (value && typeof value === "object" && Object.keys(value).length === 0) {
+        return keys[0] as any
+      }
+    }
+
+    // Regular object - recursively transform
+    const result: any = {}
+    for (const key in data) {
+      if (Object.prototype.hasOwnProperty.call(data, key)) {
+        result[key] = transformAnchorData(data[key])
+      }
+    }
+    return result
+  }
+
+  return data as any
+}