@exponent-labs/exponent-vaults-fetcher 0.9.25 → 0.9.26

package/src/fetcher.test.ts

@@ -2,9 +2,12 @@ import { web3 } from "@coral-xyz/anchor"
 import assert from "node:assert/strict"
 import test from "node:test"
 
+import { ExponentVaultsPDA } from "@exponent-labs/exponent-vaults-pda"
+
 import { ExponentVaultsFetcher } from "./fetcher"
 
 const EXPONENT_PRICES_DISCRIMINATOR = Buffer.from([188, 97, 196, 52, 192, 41, 211, 196])
+const PRICE_INTERFACE_ACCOUNTS_DISCRIMINATOR = Buffer.from([166, 196, 173, 204, 35, 6, 104, 230])
 const PROGRAM_ID = new web3.PublicKey(Uint8Array.from({ length: 32 }, (_, index) => index + 1))
 const PRICE_MINT = new web3.PublicKey(Uint8Array.from({ length: 32 }, (_, index) => index + 33))
 
@@ -21,36 +24,144 @@ const EXPONENT_PRICES_SIZE = PRICE_NODES_OFFSET + MAX_PRICES * PRICE_NODE_SIZE +
 const PRICE_DECIMALS = 6
 const UNDERLYING_DECIMALS = 9
 const SY_PRICE_ID = 0x0807060504030201n
+const ZERO_PUBKEY = new web3.PublicKey(new Uint8Array(PUBKEY_BYTES))
+
+type ScopeConfigFixture = {
+  maximumAgeSeconds: bigint
+  priceChain: readonly [number, number, number, number]
+}
+
+type AccountFixture = {
+  data: Buffer
+  owner?: web3.PublicKey
+}
+
+type ConnectionOptions = {
+  accounts?: ReadonlyMap<string, AccountFixture | null>
+  rpcError?: Error
+  shortResponse?: boolean
+}
 
-function createExponentPricesData(reservedByte: number): Buffer {
+function createPublicKey(seed: number): web3.PublicKey {
+  const bytes = new Uint8Array(PUBKEY_BYTES).fill(255)
+  new DataView(bytes.buffer).setUint32(0, seed, true)
+  return new web3.PublicKey(bytes)
+}
+
+function createExponentPricesData(priceInterfaceAccounts: readonly web3.PublicKey[], reservedByte = 0): Buffer {
   const data = Buffer.alloc(EXPONENT_PRICES_SIZE)
   EXPONENT_PRICES_DISCRIMINATOR.copy(data)
-  data.writeBigUInt64LE(1n, 8 + 8 + MAX_PRICE_MANAGERS * PUBKEY_BYTES)
-  PRICE_MINT.toBuffer().copy(data, FIRST_PRICE_VALUE_OFFSET)
-
-  data.writeUInt8(PRICE_DECIMALS, FIRST_PRICE_VALUE_OFFSET + 160)
-  data.writeUInt8(UNDERLYING_DECIMALS, FIRST_PRICE_VALUE_OFFSET + 161)
-  data.fill(reservedByte, FIRST_PRICE_VALUE_OFFSET + 162, FIRST_PRICE_VALUE_OFFSET + 168)
-  data.writeBigUInt64LE(SY_PRICE_ID, FIRST_PRICE_VALUE_OFFSET + 168)
-  data.fill(reservedByte, FIRST_PRICE_VALUE_OFFSET + 176, FIRST_PRICE_VALUE_OFFSET + EXPONENT_PRICE_SIZE)
+  data.writeBigUInt64LE(BigInt(priceInterfaceAccounts.length), 8 + 8 + MAX_PRICE_MANAGERS * PUBKEY_BYTES)
+
+  for (const [index, priceInterfaceAccount] of priceInterfaceAccounts.entries()) {
+    const valueOffset = FIRST_PRICE_VALUE_OFFSET + index * PRICE_NODE_SIZE
+    PRICE_MINT.toBuffer().copy(data, valueOffset)
+    priceInterfaceAccount.toBuffer().copy(data, valueOffset + 128)
+    data.writeUInt8(PRICE_DECIMALS, valueOffset + 160)
+    data.writeUInt8(UNDERLYING_DECIMALS, valueOffset + 161)
+    data.fill(reservedByte, valueOffset + 162, valueOffset + 168)
+    data.writeBigUInt64LE(SY_PRICE_ID, valueOffset + 168)
+    data.fill(reservedByte, valueOffset + 176, valueOffset + EXPONENT_PRICE_SIZE)
+  }
+
   return data
 }
 
-function createConnection(data: Buffer): web3.Connection {
-  return {
-    getAccountInfo: async () => ({
-      data,
-      executable: false,
-      lamports: 1,
-      owner: PROGRAM_ID,
-      rentEpoch: 0,
-    }),
+function createPriceInterfaceAccountsData(
+  interfaceAccounts: readonly web3.PublicKey[],
+  scopeConfig?: ScopeConfigFixture,
+): Buffer {
+  const data = Buffer.alloc(12 + interfaceAccounts.length * PUBKEY_BYTES + (scopeConfig ? 17 : 0))
+  PRICE_INTERFACE_ACCOUNTS_DISCRIMINATOR.copy(data)
+  data.writeUInt32LE(interfaceAccounts.length, 8)
+  interfaceAccounts.forEach((account, index) => account.toBuffer().copy(data, 12 + index * PUBKEY_BYTES))
+
+  if (scopeConfig) {
+    const stateOffset = 12 + interfaceAccounts.length * PUBKEY_BYTES
+    data.writeUInt8(2, stateOffset)
+    scopeConfig.priceChain.forEach((price, index) => data.writeUInt16LE(price, stateOffset + 1 + index * 2))
+    data.writeBigUInt64LE(scopeConfig.maximumAgeSeconds, stateOffset + 9)
+  }
+
+  return data
+}
+
+function createConnection(registryData: Buffer, options: ConnectionOptions = {}) {
+  const registryAddress = new ExponentVaultsPDA(PROGRAM_ID).exponentPrices()[0]
+  const singleAccountReads: web3.PublicKey[] = []
+  const multipleAccountReads: web3.PublicKey[][] = []
+  let activeMultipleAccountReads = 0
+  let maxConcurrentMultipleAccountReads = 0
+
+  const connection = {
+    async getAccountInfo(address: web3.PublicKey) {
+      singleAccountReads.push(address)
+      if (!address.equals(registryAddress)) {
+        throw new Error(`Unexpected getAccountInfo for PriceInterfaceAccounts: ${address.toBase58()}`)
+      }
+      return {
+        data: registryData,
+        executable: false,
+        lamports: 1,
+        owner: PROGRAM_ID,
+        rentEpoch: 0,
+      }
+    },
+    async getMultipleAccountsInfo(addresses: web3.PublicKey[]) {
+      multipleAccountReads.push(addresses)
+      activeMultipleAccountReads += 1
+      maxConcurrentMultipleAccountReads = Math.max(maxConcurrentMultipleAccountReads, activeMultipleAccountReads)
+      try {
+        await Promise.resolve()
+        if (options.rpcError) throw options.rpcError
+
+        const infos = addresses.map((address) => {
+          const fixture = options.accounts?.get(address.toBase58())
+          if (fixture === null || !fixture) return null
+          return {
+            data: fixture.data,
+            executable: false,
+            lamports: 1,
+            owner: fixture.owner ?? PROGRAM_ID,
+            rentEpoch: 0,
+          }
+        })
+        return options.shortResponse ? infos.slice(0, -1) : infos
+      } finally {
+        activeMultipleAccountReads -= 1
+      }
+    },
   } as unknown as web3.Connection
+
+  return {
+    connection,
+    multipleAccountReads,
+    get maxConcurrentMultipleAccountReads() {
+      return maxConcurrentMultipleAccountReads
+    },
+    registryAddress,
+    singleAccountReads,
+  }
+}
+
+function createAccountFixtures(keys: readonly web3.PublicKey[]): Map<string, AccountFixture> {
+  return new Map(
+    keys.map((key, index) => [
+      key.toBase58(),
+      {
+        data: createPriceInterfaceAccountsData([createPublicKey(128 + index)], {
+          maximumAgeSeconds: BigInt(index + 1),
+          priceChain: [index + 1, index + 2, index + 3, index + 4],
+        }),
+      },
+    ]),
+  )
 }
 
 test("decodes price metadata from exact wire offsets without consuming reserved bytes", async () => {
   for (const reservedByte of [0xa5, 0x5a]) {
-    const fetcher = new ExponentVaultsFetcher(createConnection(createExponentPricesData(reservedByte)), PROGRAM_ID)
+    const { connection } = createConnection(createExponentPricesData([ZERO_PUBKEY], reservedByte))
+    const fetcher = new ExponentVaultsFetcher(connection, PROGRAM_ID)
     const prices = await fetcher.fetchExponentPrices()
     const price = prices.prices[1]
 
@@ -60,3 +171,176 @@ test("decodes price metadata from exact wire offsets without consuming reserved
     assert.equal(price.syPriceId, SY_PRICE_ID)
   }
 })
+
+test("fetches unique price interface accounts sequentially in maximum 100-key batches", async () => {
+  const cases = [
+    { count: 0, expectedBatchSizes: [] },
+    { count: 1, expectedBatchSizes: [1] },
+    { count: 99, expectedBatchSizes: [99] },
+    { count: 100, expectedBatchSizes: [100] },
+    { count: 101, expectedBatchSizes: [100, 1] },
+    { count: 200, expectedBatchSizes: [100, 100] },
+    { count: 201, expectedBatchSizes: [100, 100, 1] },
+    { count: 1024, expectedBatchSizes: [100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 24] },
+  ]
+
+  for (const { count, expectedBatchSizes } of cases) {
+    const keys = Array.from({ length: count }, (_, index) => createPublicKey(index + 1))
+    const connectionState = createConnection(createExponentPricesData(keys), { accounts: createAccountFixtures(keys) })
+
+    const prices = await new ExponentVaultsFetcher(connectionState.connection, PROGRAM_ID).fetchExponentPrices()
+
+    assert.deepEqual(
+      connectionState.multipleAccountReads.map((batch) => batch.length),
+      expectedBatchSizes,
+      `count ${count}`,
+    )
+    assert.ok(
+      connectionState.multipleAccountReads.every((batch) => batch.length <= 100),
+      `count ${count}`,
+    )
+    assert.equal(connectionState.maxConcurrentMultipleAccountReads, count === 0 ? 0 : 1, `count ${count}`)
+    assert.deepEqual(
+      connectionState.singleAccountReads.map((address) => address.toBase58()),
+      [connectionState.registryAddress.toBase58()],
+      `count ${count}`,
+    )
+    assert.deepEqual(
+      connectionState.multipleAccountReads.flat().map((address) => address.toBase58()),
+      keys.map((key) => key.toBase58()),
+      `count ${count}`,
+    )
+    for (const [index, key] of keys.entries()) {
+      const price = prices.prices[index + 1]
+      assert.ok(price, `count ${count}, price ${index + 1}`)
+      assert.deepEqual(price.interfaceAccounts, [createPublicKey(128 + index)])
+      assert.deepEqual(price.scopeConfig, {
+        maximumAgeSeconds: BigInt(index + 1),
+        priceChain: [index + 1, index + 2, index + 3, index + 4],
+      })
+      assert.equal(price.priceInterfaceAccounts.toBase58(), key.toBase58())
+    }
+  }
+})
+
+test("deduplicates nonzero price interface accounts and hydrates every matching price", async () => {
+  const firstKey = createPublicKey(250)
+  const secondKey = createPublicKey(1)
+  const keys = [firstKey, ZERO_PUBKEY, firstKey, secondKey]
+  assert.notDeepEqual([firstKey.toBase58(), secondKey.toBase58()], [firstKey.toBase58(), secondKey.toBase58()].sort())
+  const { connection, multipleAccountReads, registryAddress, singleAccountReads } = createConnection(
+    createExponentPricesData(keys),
+    { accounts: createAccountFixtures([firstKey, secondKey]) },
+  )
+
+  const prices = await new ExponentVaultsFetcher(connection, PROGRAM_ID).fetchExponentPrices()
+
+  assert.deepEqual(
+    singleAccountReads.map((address) => address.toBase58()),
+    [registryAddress.toBase58()],
+  )
+  assert.deepEqual(
+    multipleAccountReads.map((batch) => batch.map((key) => key.toBase58())),
+    [[firstKey.toBase58(), secondKey.toBase58()]],
+  )
+  assert.deepEqual(prices.prices[1]?.interfaceAccounts, [createPublicKey(128)])
+  assert.deepEqual(prices.prices[2]?.interfaceAccounts, [])
+  assert.deepEqual(prices.prices[3]?.interfaceAccounts, [createPublicKey(128)])
+  assert.deepEqual(prices.prices[4]?.interfaceAccounts, [createPublicKey(129)])
+  assert.strictEqual(prices.prices[1]?.interfaceAccounts, prices.prices[3]?.interfaceAccounts)
+  assert.ok(prices.prices[1]?.scopeConfig)
+  assert.strictEqual(prices.prices[1]?.scopeConfig, prices.prices[3]?.scopeConfig)
+})
+
+test("preserves PriceInterfaceAccounts validation errors and malformed RPC response failures", async () => {
+  const key = createPublicKey(1)
+  const registryData = createExponentPricesData([key])
+
+  await assert.rejects(
+    () => new ExponentVaultsFetcher(createConnection(registryData).connection, PROGRAM_ID).fetchExponentPrices(),
+    new Error(`PriceInterfaceAccounts account not found: ${key.toBase58()}`),
+  )
+
+  await assert.rejects(
+    () =>
+      new ExponentVaultsFetcher(
+        createConnection(registryData, {
+          accounts: new Map([
+            [key.toBase58(), { data: createPriceInterfaceAccountsData([]), owner: createPublicKey(2) }],
+          ]),
+        }).connection,
+        PROGRAM_ID,
+      ).fetchExponentPrices(),
+    new Error(
+      `PriceInterfaceAccounts owner mismatch: expected ${PROGRAM_ID.toBase58()}, got ${createPublicKey(2).toBase58()}`,
+    ),
+  )
+
+  await assert.rejects(
+    () =>
+      new ExponentVaultsFetcher(
+        createConnection(registryData, { accounts: createAccountFixtures([key]), shortResponse: true }).connection,
+        PROGRAM_ID,
+      ).fetchExponentPrices(),
+    new Error("PriceInterfaceAccounts batch size mismatch: requested 1, got 0"),
+  )
+
+  const rpcError = new Error("RPC unavailable")
+  await assert.rejects(
+    () =>
+      new ExponentVaultsFetcher(
+        createConnection(registryData, { accounts: createAccountFixtures([key]), rpcError }).connection,
+        PROGRAM_ID,
+      ).fetchExponentPrices(),
+    rpcError,
+  )
+
+  await assert.rejects(
+    () =>
+      new ExponentVaultsFetcher(
+        createConnection(registryData, {
+          accounts: new Map([[key.toBase58(), { data: Buffer.alloc(1) }]]),
+        }).connection,
+        PROGRAM_ID,
+      ).fetchExponentPrices(),
+    new Error("PriceInterfaceAccounts account too small: 1 bytes"),
+  )
+})
+
+test("reports a missing account at its indexed position in the second batch", async () => {
+  const keys = Array.from({ length: 102 }, (_, index) => createPublicKey(index + 1))
+  const accounts = createAccountFixtures(keys)
+  const missingKey = keys[101]
+  accounts.set(missingKey.toBase58(), null)
+
+  await assert.rejects(
+    () =>
+      new ExponentVaultsFetcher(
+        createConnection(createExponentPricesData(keys), { accounts }).connection,
+        PROGRAM_ID,
+      ).fetchExponentPrices(),
+    new Error(`PriceInterfaceAccounts account not found: ${missingKey.toBase58()}`),
+  )
+})
+
+test("reports an owner mismatch at its indexed position in a later batch", async () => {
+  const keys = Array.from({ length: 202 }, (_, index) => createPublicKey(index + 1))
+  const accounts = createAccountFixtures(keys)
+  const mismatchedKey = keys[201]
+  const unexpectedOwner = createPublicKey(250)
+  accounts.set(mismatchedKey.toBase58(), {
+    data: createPriceInterfaceAccountsData([]),
+    owner: unexpectedOwner,
+  })
+
+  await assert.rejects(
+    () =>
+      new ExponentVaultsFetcher(
+        createConnection(createExponentPricesData(keys), { accounts }).connection,
+        PROGRAM_ID,
+      ).fetchExponentPrices(),
+    new Error(
+      `PriceInterfaceAccounts owner mismatch: expected ${PROGRAM_ID.toBase58()}, got ${unexpectedOwner.toBase58()}`,
+    ),
+  )
+})

package/src/fetcher.ts

@@ -4,14 +4,15 @@ import { ExponentVaults, IDL, PROGRAM_ID } from "@exponent-labs/exponent-vaults-
 import { ExponentVaultsPDA } from "@exponent-labs/exponent-vaults-pda"
 
 import { IGNORED_VAULTS } from "./constants"
-import { transformAnchorData } from "./typeUtils"
 import { decodePriceInterfaceAccounts } from "./priceInterfaceAccounts"
+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 = 1024
 const MAX_PRICE_MANAGERS = 8
 const MAX_AUTHORIZED_VAULT_CREATORS = 128
+const MAX_GET_MULTIPLE_ACCOUNTS_INFO_KEYS = 100
 const PRICE_NODE_REGISTERS = 4
 const PRICE_USAGE_AMOUNT_REGISTER = 1
 
@@ -261,9 +262,9 @@ export class ExponentVaultsFetcher {
     }))
   }
 
-  async fetchAllWithdrawalAccountsDeserialized(filters?: web3.GetProgramAccountsFilter[]): Promise<
-    DecodedAccount<WithdrawalAccount>[]
-  > {
+  async fetchAllWithdrawalAccountsDeserialized(
+    filters?: web3.GetProgramAccountsFilter[],
+  ): Promise<DecodedAccount<WithdrawalAccount>[]> {
     const accounts = await this.fetchAllWithdrawalAccounts(filters)
     return accounts.map(({ publicKey, account }) => ({
       publicKey,
@@ -432,20 +433,34 @@ export class ExponentVaultsFetcher {
     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 Promise.all(
-        uniqueInterfaceAccounts.map((pubkey) => this.program.provider.connection.getAccountInfo(pubkey)),
-      )
+    const priceEntriesByInterfaceAccount = new Map<
+      string,
+      { entries: NonNullable<ExponentPrices["prices"][number]>[]; key: web3.PublicKey }
+    >()
+    for (const entry of activePriceEntries) {
+      const key = entry.priceInterfaceAccounts
+      if (key.equals(ZERO_PUBKEY)) continue
+
+      const keyString = key.toBase58()
+      const group = priceEntriesByInterfaceAccount.get(keyString)
+      if (group) {
+        group.entries.push(entry)
+      } else {
+        priceEntriesByInterfaceAccount.set(keyString, { entries: [entry], key })
+      }
+    }
 
-      for (let i = 0; i < uniqueInterfaceAccounts.length; i++) {
-        const key = uniqueInterfaceAccounts[i]
-        const info = infos[i]
+    const priceInterfaceAccountGroups = [...priceEntriesByInterfaceAccount.values()]
+    for (let start = 0; start < priceInterfaceAccountGroups.length; start += MAX_GET_MULTIPLE_ACCOUNTS_INFO_KEYS) {
+      const groups = priceInterfaceAccountGroups.slice(start, start + MAX_GET_MULTIPLE_ACCOUNTS_INFO_KEYS)
+      const infos = await this.program.provider.connection.getMultipleAccountsInfo(groups.map((group) => group.key))
+      if (infos.length !== groups.length) {
+        throw new Error(`PriceInterfaceAccounts batch size mismatch: requested ${groups.length}, got ${infos.length}`)
+      }
+
+      for (let index = 0; index < groups.length; index++) {
+        const { entries, key } = groups[index]
+        const info = infos[index]
         if (!info) {
           throw new Error(`PriceInterfaceAccounts account not found: ${key.toBase58()}`)
         }
@@ -456,11 +471,9 @@ export class ExponentVaultsFetcher {
         }
 
         const decoded = decodePriceInterfaceAccounts(info.data)
-        for (const entry of activePriceEntries) {
-          if (entry.priceInterfaceAccounts.equals(key)) {
-            entry.interfaceAccounts = decoded.interfaceAccounts
-            entry.scopeConfig = decoded.scopeConfig
-          }
+        for (const entry of entries) {
+          entry.interfaceAccounts = decoded.interfaceAccounts
+          entry.scopeConfig = decoded.scopeConfig
         }
       }
     }