@exponent-labs/exponent-sdk 0.9.0 → 0.9.2

package/src/exponentVaults/fetcher.ts

@@ -0,0 +1,257 @@
+import type {
+  ActionProposal,
+  ExponentPrices,
+  ExponentVault,
+  WithdrawalAccount,
+} from "@exponent-labs/exponent-vaults-fetcher"
+import {
+  ExponentVaultsFetcher as AnchorExponentVaultsFetcher,
+  IGNORED_VAULTS,
+} from "@exponent-labs/exponent-vaults-fetcher"
+import { PROGRAM_ID } from "@exponent-labs/exponent-vaults-idl"
+import { Connection, PublicKey, type GetProgramAccountsFilter } from "@solana/web3.js"
+
+import { deserializeActionProposalAccount } from "../client/vaults/accounts/actionProposal"
+import { deserializeExponentStrategyVaultAccount } from "../client/vaults/accounts/exponentStrategyVault"
+import { deserializeWithdrawalAccountAccount } from "../client/vaults/accounts/withdrawalAccount"
+
+const VAULT_DISCRIMINATOR_BYTES = "HYNPjgfkiFc"
+const ACTION_PROPOSAL_DISCRIMINATOR_BYTES = "RDHYHK5bgsA"
+const WITHDRAWAL_ACCOUNT_DISCRIMINATOR_BYTES = "Hg45oo8yvEZ"
+const TOKEN_ENTRIES_VEC_OFFSET = 104
+const MAX_TOKEN_ENTRIES = 64
+
+function isPublicKey(value: unknown): value is PublicKey {
+  return value instanceof PublicKey
+}
+
+function toAnchorVariantKey(kind: string): string {
+  return kind.charAt(0).toLowerCase() + kind.slice(1)
+}
+
+function transformGeneratedData(value: unknown): unknown {
+  if (isPublicKey(value) || value instanceof Uint8Array) {
+    return value
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(transformGeneratedData)
+  }
+
+  if (!value || typeof value !== "object") {
+    return value
+  }
+
+  const record = value as Record<string, unknown>
+  if (typeof record.__kind === "string") {
+    const variantKey = toAnchorVariantKey(record.__kind)
+    if (Array.isArray(record.fields)) {
+      return {
+        [variantKey]: record.fields.map(transformGeneratedData),
+      }
+    }
+
+    const transformedEntries = Object.entries(record)
+      .filter(([key]) => key !== "__kind")
+      .map(([key, nestedValue]) => [key, transformGeneratedData(nestedValue)] as const)
+
+    if (transformedEntries.length === 0) {
+      return variantKey
+    }
+
+    return {
+      [variantKey]: Object.fromEntries(transformedEntries),
+    }
+  }
+
+  return Object.fromEntries(
+    Object.entries(record).map(([key, nestedValue]) => [key, transformGeneratedData(nestedValue)]),
+  )
+}
+
+export function deserializeExponentStrategyVaultFetcherShape(data: Uint8Array): ExponentVault {
+  return transformGeneratedData(deserializeExponentStrategyVaultAccount(data)) as ExponentVault
+}
+
+export function deserializeActionProposalFetcherShape(data: Uint8Array): ActionProposal {
+  return transformGeneratedData(deserializeActionProposalAccount(data)) as ActionProposal
+}
+
+export function deserializeWithdrawalAccountFetcherShape(data: Uint8Array): WithdrawalAccount {
+  return transformGeneratedData(deserializeWithdrawalAccountAccount(data)) as WithdrawalAccount
+}
+
+export class ExponentVaultsFetcher {
+  public readonly programId: PublicKey
+  public readonly program
+  private readonly anchorFetcher: AnchorExponentVaultsFetcher
+  private readonly connection: Connection
+
+  constructor(connection: Connection, programId: PublicKey | string = PROGRAM_ID) {
+    this.connection = connection
+    this.anchorFetcher = new AnchorExponentVaultsFetcher(connection, programId)
+    this.programId = this.anchorFetcher.programId
+    this.program = this.anchorFetcher.program
+  }
+
+  async fetchVault(address: PublicKey): Promise<ExponentVault> {
+    return this.fetchVaultDeserialized(address)
+  }
+
+  async fetchWithdrawalAccount(address: PublicKey): Promise<WithdrawalAccount> {
+    return this.fetchWithdrawalAccountDeserialized(address)
+  }
+
+  async fetchActionProposal(address: PublicKey): Promise<ActionProposal> {
+    return this.fetchActionProposalDeserialized(address)
+  }
+
+  async fetchAllVaults(filters?: GetProgramAccountsFilter[]): Promise<Array<{ publicKey: PublicKey; account: ExponentVault }>> {
+    const rawAccounts = await this.connection.getProgramAccounts(this.programId, {
+      filters: [{ memcmp: { offset: 0, bytes: VAULT_DISCRIMINATOR_BYTES } }, ...(filters ?? [])],
+    })
+
+    const decoded: Array<{ publicKey: PublicKey; account: ExponentVault }> = []
+    for (const { pubkey, account } of rawAccounts) {
+      if (IGNORED_VAULTS.has(pubkey.toBase58())) continue
+      if (account.data.length < TOKEN_ENTRIES_VEC_OFFSET + 4) continue
+
+      const tokenEntriesLen = account.data.readUInt32LE(TOKEN_ENTRIES_VEC_OFFSET)
+      if (tokenEntriesLen > MAX_TOKEN_ENTRIES) continue
+
+      try {
+        decoded.push({
+          publicKey: pubkey,
+          account: deserializeExponentStrategyVaultFetcherShape(account.data),
+        })
+      } catch {
+        // Skip accounts that fail to deserialize.
+      }
+    }
+
+    return decoded
+  }
+
+  async fetchAllActionProposals(
+    filters?: GetProgramAccountsFilter[],
+  ): Promise<Array<{ publicKey: PublicKey; account: ActionProposal }>> {
+    const rawAccounts = await this.connection.getProgramAccounts(this.programId, {
+      filters: [{ memcmp: { offset: 0, bytes: ACTION_PROPOSAL_DISCRIMINATOR_BYTES } }, ...(filters ?? [])],
+    })
+
+    const decoded: Array<{ publicKey: PublicKey; account: ActionProposal }> = []
+    for (const { pubkey, account } of rawAccounts) {
+      try {
+        decoded.push({
+          publicKey: pubkey,
+          account: deserializeActionProposalFetcherShape(account.data),
+        })
+      } catch {
+        // Skip accounts that fail to deserialize.
+      }
+    }
+
+    return decoded
+  }
+
+  async fetchAllWithdrawalAccounts(
+    filters?: GetProgramAccountsFilter[],
+  ): Promise<Array<{ publicKey: PublicKey; account: WithdrawalAccount }>> {
+    const rawAccounts = await this.connection.getProgramAccounts(this.programId, {
+      filters: [{ memcmp: { offset: 0, bytes: WITHDRAWAL_ACCOUNT_DISCRIMINATOR_BYTES } }, ...(filters ?? [])],
+    })
+
+    const decoded: Array<{ publicKey: PublicKey; account: WithdrawalAccount }> = []
+    for (const { pubkey, account } of rawAccounts) {
+      try {
+        decoded.push({
+          publicKey: pubkey,
+          account: deserializeWithdrawalAccountFetcherShape(account.data),
+        })
+      } catch {
+        // Skip accounts that fail to deserialize.
+      }
+    }
+
+    return decoded
+  }
+
+  async fetchAllActionProposalsForVault(
+    vaultAddress: PublicKey,
+    filters?: GetProgramAccountsFilter[],
+  ): Promise<Array<{ publicKey: PublicKey; account: ActionProposal }>> {
+    return this.fetchAllActionProposals([
+      {
+        memcmp: {
+          offset: 8,
+          bytes: vaultAddress.toBase58(),
+        },
+      },
+      ...(filters ?? []),
+    ])
+  }
+
+  async fetchVaultDeserialized(address: 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 accountInfo = await this.connection.getAccountInfo(address)
+    if (!accountInfo) {
+      throw new Error(`ExponentStrategyVault account not found at address: ${address.toBase58()}`)
+    }
+
+    return deserializeExponentStrategyVaultFetcherShape(accountInfo.data)
+  }
+
+  async fetchActionProposalDeserialized(address: PublicKey): Promise<ActionProposal> {
+    const accountInfo = await this.connection.getAccountInfo(address)
+    if (!accountInfo) {
+      throw new Error(`ActionProposal account not found at address: ${address.toBase58()}`)
+    }
+
+    return deserializeActionProposalFetcherShape(accountInfo.data)
+  }
+
+  async fetchWithdrawalAccountDeserialized(address: PublicKey): Promise<WithdrawalAccount> {
+    const accountInfo = await this.connection.getAccountInfo(address)
+    if (!accountInfo) {
+      throw new Error(`WithdrawalAccount account not found at address: ${address.toBase58()}`)
+    }
+
+    return deserializeWithdrawalAccountFetcherShape(accountInfo.data)
+  }
+
+  async fetchAllVaultsDeserialized(
+    filters?: GetProgramAccountsFilter[],
+  ): Promise<Array<{ publicKey: PublicKey; account: ExponentVault }>> {
+    return this.fetchAllVaults(filters)
+  }
+
+  async fetchAllActionProposalsDeserialized(
+    filters?: GetProgramAccountsFilter[],
+  ): Promise<Array<{ publicKey: PublicKey; account: ActionProposal }>> {
+    return this.fetchAllActionProposals(filters)
+  }
+
+  async fetchAllActionProposalsForVaultDeserialized(
+    vaultAddress: PublicKey,
+    filters?: GetProgramAccountsFilter[],
+  ): Promise<Array<{ publicKey: PublicKey; account: ActionProposal }>> {
+    return this.fetchAllActionProposalsForVault(vaultAddress, filters)
+  }
+
+  async fetchAllWithdrawalAccountsDeserialized(
+    filters?: GetProgramAccountsFilter[],
+  ): Promise<Array<{ publicKey: PublicKey; account: WithdrawalAccount }>> {
+    return this.fetchAllWithdrawalAccounts(filters)
+  }
+
+  async fetchExponentPrices(): Promise<ExponentPrices> {
+    return this.anchorFetcher.fetchExponentPrices()
+  }
+
+  getRequiredPriceIds(vault: ExponentVault): Set<bigint> {
+    return this.anchorFetcher.getRequiredPriceIds(vault)
+  }
+}

package/src/exponentVaults/index.ts

@@ -1,4 +1,5 @@
 export { ExponentVault } from "./vault"
+export { ExponentVaultsFetcher } from "./fetcher"
 export {
   SYNTHETIC_USD_DECIMALS,
   SYNTHETIC_USD_MINT,
@@ -8,7 +9,6 @@ export {
 } from "./vault"
 export { AumCalculator, PositionType } from "./aumCalculator"
 export type { AumResult } from "./aumCalculator"
-export { ExponentVaultsFetcher } from "@exponent-labs/exponent-vaults-fetcher"
 export { PROGRAM_ID as EXPONENT_VAULTS_PROGRAM_ID } from "@exponent-labs/exponent-vaults-idl"
 export {
   createActivateProposalInstruction,
@@ -68,8 +68,14 @@ export * as vaultsEvents from "./events"
 export {
   // Constants
   KAMINO_LENDING_PROGRAM_ID,
+  KAMINO_VAULT_PROGRAM_ID,
+  KAMINO_FARMS_PROGRAM_ID,
   KAMINO_DISCRIMINATORS,
+  KAMINO_VAULT_DISCRIMINATORS,
+  KAMINO_FARM_DISCRIMINATORS,
   KAMINO_ACCOUNT_INDICES,
+  KAMINO_VAULT_ACCOUNT_INDICES,
+  KAMINO_FARM_ACCOUNT_INDICES,
   // Generic policy builders
   createProgramInteractionPolicy,
   createInstructionConstraint,
@@ -83,6 +89,8 @@ export {
   createKaminoRepayPolicy,
   createKaminoFullAccessPolicy,
   createKaminoPolicy,
+  createKaminoVaultPolicy,
+  createKaminoFarmPolicy,
   // Orderbook policy builders
   EXPONENT_ORDERBOOK_PROGRAM_ID,
   MARGINFI_STANDARD_PROGRAM_ID,
@@ -133,6 +141,8 @@ export type {
   OrderbookPolicyAction,
   CorePolicyAction,
   KaminoPolicyAction,
+  KaminoVaultPolicyAction,
+  KaminoFarmPolicyAction,
   StandardProgramPolicyAction,
   AllowedSyMintProgram,
   LoopscalePolicyAction,
@@ -141,8 +151,11 @@ export type {
 // Vault interaction builders (Kamino + Orderbook + Core)
 export {
   createVaultSyncTransaction,
+  createVaultSyncTransactions,
   createOrderbookSyncTransaction,
   kaminoAction,
+  kaminoVaultAction,
+  kaminoFarmAction,
   orderbookAction,
   coreAction,
   syAction,
@@ -150,6 +163,8 @@ export {
   clmmAction,
   loopscaleAction,
   VaultAction,
+  KaminoVaultAction,
+  KaminoFarmAction,
   OrderbookAction,
   OrderbookTradeDirection,
   CoreAction,
@@ -162,6 +177,15 @@ export type {
   VaultInstruction,
   MarketInstruction,
   ReserveInstruction,
+  KaminoVaultInstruction,
+  KaminoVaultDepositInstruction,
+  KaminoVaultWithdrawInstruction,
+  KaminoFarmInstruction,
+  KaminoFarmInitializeUserInstruction,
+  KaminoFarmStakeInstruction,
+  KaminoFarmUnstakeInstruction,
+  KaminoFarmWithdrawUnstakedDepositsInstruction,
+  KaminoFarmHarvestRewardInstruction,
   OrderbookInstruction,
   OrderbookPostOfferInstruction,
   OrderbookMarketOfferInstruction,
@@ -194,24 +218,38 @@ export { getTitanQuote } from "./titan-quote"
 export type { TitanQuoteResult } from "./titan-quote"
 
 // Loopscale Client
-export { LoopscaleClient } from "./loopscale-client"
+export {
+  LoopscaleClient,
+  deserializeLoopscaleTransactionResponse,
+  deserializeLoopscaleTransactionBatchResponse,
+  extractCreatedStrategyAddress,
+  extractCreatedStrategyNonce,
+  getLoopscaleTransactionResponses,
+  identifyLoopscaleInstruction,
+} from "./loopscale"
 export type {
   LoopscaleClientConfig,
-  LoopscaleTxResult,
-  LoopscaleStrategyBatch,
-  LoopscaleStrategyBatchesResult,
-  LoopscaleStrategyResult,
-  LoopscaleUpdateStrategyResult,
-  VaultExecutionContext,
-  BatchExecutionResult,
-  ExecutionResult,
-  ClassifiedInstructions,
-  LoopscaleGeneratedInstruction,
-  LoopscaleGeneratedInstructionBundle,
+  LoopscaleTransactionSignature,
+  LoopscaleVersionedTransactionResponse,
+  LoopscaleVersionedTransactionBatchResponse,
+  LoopscaleExpectedLoanInfo,
+  LoopscaleTransactionsResponse,
+  LoopscaleLoanTransactionResponse,
+  LoopscaleCreateLoanResponse,
+  LoopscaleTransactionResponse,
+  LoopscaleInstructionName,
   LoopscaleQuoteParams,
+  LoopscaleQuote,
+  LoopscaleMaxQuoteParams,
+  LoopscaleMaxQuote,
+  LoopscaleLoanInfoParams,
+  LoopscaleLoanInfoResponse,
+  LoopscaleGetStrategiesParams,
+  LoopscaleStrategyInfoResponse,
   LoopscaleCreateStrategyParams,
   LoopscaleDepositStrategyParams,
   LoopscaleWithdrawStrategyParams,
+  LoopscaleCloseLoanParams,
   LoopscaleCloseStrategyParams,
   ExternalYieldSourceParams,
   TxnExternalYieldSourceArgs,
@@ -223,33 +261,18 @@ export type {
   StrategyCollateralUpdates,
   EditStrategySettingsArgs,
   LoopscaleUpdateStrategyParams,
-  LoopscaleBorrowPrincipalParams,
-  LoopscaleRepayLoanParams,
-  LoopscaleCloseLoanParams,
-  LoopscaleQuote,
   LoopscaleCreateLoanParams,
-  LoopscaleApiBorrowPrincipalParams,
+  LoopscaleBorrowPrincipalParams,
   LoopscaleDepositCollateralParams,
+  LoopscaleRepayLoanSimpleParams,
   LoopscaleWithdrawCollateralParams,
-  LoopscaleRefinanceLoanParams,
-  LoopscaleCreateLoanResult,
-  LoopscaleMaxQuoteParams,
-  LoopscaleMaxQuote,
-  LoopscaleLoanInfoParams,
-  LoopscaleLoanInfoResponse,
-  LoopscaleGetStrategiesParams,
-  LoopscaleStrategyInfoResponse,
-  LoopscaleCollateralHoldersParams,
-  LoopscaleCollateralHolder,
-  LoopscaleHistoricalCollateralHoldersParams,
-  LoopscaleHistoricalCollateralHolder,
-  LoopscaleVaultDepositorsParams,
-  LoopscaleVaultDepositor,
-  LoopscaleVaultInfoParams,
-  LoopscaleVaultInfoResponse,
-  LoopscaleLoopInfoParams,
-  LoopscaleLoopVaultInfo,
-} from "./loopscale-client"
+} from "./loopscale"
+export type {
+  LoopscaleBuildTransactionsContext,
+  LoopscaleBuiltTransaction,
+  LoopscalePreparedTransaction,
+  LoopscaleVaultPreparationContext,
+} from "./loopscale"
 
 export { KaminoMarket, KAMINO_MARKETS, KAMINO_RESERVES, getKaminoReserves } from "./kamino-markets"
 export type { KaminoReserveInfo } from "./kamino-markets"
@@ -287,12 +310,14 @@ export {
 } from "./squadsVaultTxnResolver"
 
 // Vault Transaction Builder
-export { VaultTransactionBuilder, bundleForJito } from "./vaultTransactionBuilder"
+export { VaultTransactionBuilder } from "./vaultTransactionBuilder"
 export type {
   VaultTransactionBuilderConfig,
+  VaultTransactionBuilderLoopscaleConfig,
+  LoopscaleStepOptions,
   StepOptions,
   TransactionSet,
   VaultTransactionBuildResult,
-  JitoBundleSendOptions,
-  JitoBundleResult,
+  SendOptions,
+  SendResult,
 } from "./vaultTransactionBuilder"