@exponent-labs/exponent-sdk 0.9.1 → 0.9.3

package/src/exponentVaults/events.ts

@@ -1,15 +0,0 @@
-import { PublicKey } from "@solana/web3.js"
-import { CodamaEventDecoder } from "../CodamaEventDecoder"
-import { EVENT_CODEC_REGISTRY } from "../client/vaults/eventRegistry"
-import type { EventName, EventMap } from "../client/vaults/eventRegistry"
-import { PROGRAM_ID } from "@exponent-labs/exponent-vaults-idl"
-
-export const VAULTS_PROGRAM_ID = new PublicKey(PROGRAM_ID)
-
-export const VAULTS_CODAMA_EVENT_DECODER = new CodamaEventDecoder(VAULTS_PROGRAM_ID, EVENT_CODEC_REGISTRY)
-
-// Backwards-compatible alias
-export const VAULTS_EVENT_DECODER = VAULTS_CODAMA_EVENT_DECODER
-
-export type VaultsEventNames = EventName
-export type VaultsEvent<Name extends VaultsEventNames> = EventMap[Name]

package/src/exponentVaults/fetcher.ts

@@ -1,257 +0,0 @@
-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,322 +0,0 @@
-export { ExponentVault } from "./vault"
-export { ExponentVaultsFetcher } from "./fetcher"
-export {
-  SYNTHETIC_USD_DECIMALS,
-  SYNTHETIC_USD_MINT,
-  SYNTHETIC_USD9_DECIMALS,
-  SYNTHETIC_USD9_MINT,
-  getSyntheticMintDecimals,
-} from "./vault"
-export { AumCalculator, PositionType } from "./aumCalculator"
-export type { AumResult } from "./aumCalculator"
-export { PROGRAM_ID as EXPONENT_VAULTS_PROGRAM_ID } from "@exponent-labs/exponent-vaults-idl"
-export {
-  createActivateProposalInstruction,
-  type ActivateProposalInstructionAccounts,
-  type ActivateProposalInstructionArgs,
-} from "../client/vaults/instructions/activateProposal"
-export {
-  createAppendProposalActionsInstruction,
-  type AppendProposalActionsInstructionAccounts,
-  type AppendProposalActionsInstructionArgs,
-} from "../client/vaults/instructions/appendProposalActions"
-export {
-  createInitProposalInstruction,
-  type InitProposalInstructionAccounts,
-  type InitProposalInstructionArgs,
-} from "../client/vaults/instructions/initProposal"
-export {
-  createCancelProposalInstruction,
-  type CancelProposalInstructionAccounts,
-} from "../client/vaults/instructions/cancelProposal"
-export { proposalAction, proposalActionCodec, proposalActionsCodec } from "../client/vaults/types/proposalAction"
-export type { ProposalAction } from "../client/vaults/types/proposalAction"
-export type {
-  // User action params
-  DepositLiquidityParams,
-  QueueWithdrawalParams,
-  ExecuteWithdrawalParams,
-  TokenAccountPair,
-  // Vault initialization & policy params
-  InitializeVaultParams,
-  AddPolicyParams,
-  RemovePolicyParams,
-  // Vault configuration types
-  VaultType,
-  VaultRoles,
-  ProposalVoteConfig,
-  // Policy types
-  PolicyConfig,
-  PolicyType,
-  PolicyExpiration,
-  InstructionConstraint,
-  AccountConstraint,
-  DataConstraint,
-  DataOperator,
-  DataValue,
-  SpendingLimit,
-  TimeConstraints,
-  QuantityConstraints,
-  Period,
-  AllowedSettingsChange,
-  TokenEntryInput,
-  UpdatePriceActionParam,
-} from "./vault"
-export * as vaultsEvents from "./events"
-
-// Policy builders
-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,
-  createAccountConstraint,
-  createAccountDataConstraint,
-  createDiscriminatorConstraint,
-  // Kamino-specific builders
-  createKaminoDepositPolicy,
-  createKaminoWithdrawPolicy,
-  createKaminoBorrowPolicy,
-  createKaminoRepayPolicy,
-  createKaminoFullAccessPolicy,
-  createKaminoPolicy,
-  createKaminoVaultPolicy,
-  createKaminoFarmPolicy,
-  // Orderbook policy builders
-  EXPONENT_ORDERBOOK_PROGRAM_ID,
-  MARGINFI_STANDARD_PROGRAM_ID,
-  KAMINO_STANDARD_PROGRAM_ID,
-  JITO_RESTAKING_STANDARD_PROGRAM_ID,
-  PERENA_STANDARD_PROGRAM_ID,
-  GENERIC_STANDARD_PROGRAM_ID,
-  ORDERBOOK_DISCRIMINATORS,
-  ORDERBOOK_ACCOUNT_INDICES,
-  createOrderbookInstructionConstraints,
-  createOrderbookPolicy,
-  STANDARD_PROGRAM_DISCRIMINATORS,
-  STANDARD_PROGRAM_ACCOUNT_INDICES,
-  createStandardProgramInstructionConstraints,
-  createStandardProgramPolicy,
-  // Core policy builders
-  EXPONENT_CORE_PROGRAM_ID,
-  EXPONENT_CORE_DISCRIMINATORS,
-  EXPONENT_VAULT_ACCOUNT_DATA_OFFSETS,
-  EXPONENT_CORE_INITIALIZE_YIELD_POSITION_ACCOUNT_INDICES,
-  EXPONENT_CORE_STRIP_ACCOUNT_INDICES,
-  EXPONENT_CORE_MERGE_ACCOUNT_INDICES,
-  EXPONENT_CORE_COLLECT_INTEREST_ACCOUNT_INDICES,
-  EXPONENT_CORE_DEPOSIT_YT_ACCOUNT_INDICES,
-  EXPONENT_CORE_WITHDRAW_YT_ACCOUNT_INDICES,
-  EXPONENT_CORE_WRAPPER_COLLECT_INTEREST_ACCOUNT_INDICES,
-  createCoreInstructionConstraints,
-  createCorePolicy,
-  // Titan policy builders
-  TITAN_PROGRAM_ID,
-  TITAN_DISCRIMINATORS,
-  TITAN_ACCOUNT_INDICES,
-  createTitanSwapPolicy,
-  // Loopscale policy builders
-  LOOPSCALE_PROGRAM_ID,
-  LOOPSCALE_DISCRIMINATORS,
-  LOOPSCALE_ACCOUNT_INDICES,
-  createLoopscalePolicy,
-  deriveLoopscaleStrategyAddress,
-  deriveLoopscaleLoanAddress,
-  // CLMM policy builders
-  EXPONENT_CLMM_PROGRAM_ID,
-  CLMM_DISCRIMINATORS,
-  CLMM_ACCOUNT_INDICES,
-  createClmmPolicy,
-} from "./policyBuilders"
-export type {
-  OrderbookPolicyAction,
-  CorePolicyAction,
-  KaminoPolicyAction,
-  KaminoVaultPolicyAction,
-  KaminoFarmPolicyAction,
-  StandardProgramPolicyAction,
-  AllowedSyMintProgram,
-  LoopscalePolicyAction,
-} from "./policyBuilders"
-
-// Vault interaction builders (Kamino + Orderbook + Core)
-export {
-  createVaultSyncTransaction,
-  createOrderbookSyncTransaction,
-  kaminoAction,
-  kaminoVaultAction,
-  kaminoFarmAction,
-  orderbookAction,
-  coreAction,
-  syAction,
-  titanAction,
-  clmmAction,
-  loopscaleAction,
-  VaultAction,
-  KaminoVaultAction,
-  KaminoFarmAction,
-  OrderbookAction,
-  OrderbookTradeDirection,
-  CoreAction,
-  SyAction,
-  TitanAction,
-  ClmmAction,
-  LoopscaleAction,
-} from "./vault-interaction"
-export type {
-  VaultInstruction,
-  MarketInstruction,
-  ReserveInstruction,
-  KaminoVaultInstruction,
-  KaminoVaultDepositInstruction,
-  KaminoVaultWithdrawInstruction,
-  KaminoFarmInstruction,
-  KaminoFarmInitializeUserInstruction,
-  KaminoFarmStakeInstruction,
-  KaminoFarmUnstakeInstruction,
-  KaminoFarmWithdrawUnstakedDepositsInstruction,
-  KaminoFarmHarvestRewardInstruction,
-  OrderbookInstruction,
-  OrderbookPostOfferInstruction,
-  OrderbookMarketOfferInstruction,
-  OrderbookRemoveOfferInstruction,
-  OrderbookWithdrawFundsInstruction,
-  OrderbookOfferOption,
-  CoreInstruction,
-  CoreStripInstruction,
-  CoreMergeInstruction,
-  SyInstruction,
-  SyMintInstruction,
-  SyRedeemInstruction,
-  TitanSwapInstruction,
-  LoopscaleInstruction,
-  ClmmInstruction,
-  ClmmDepositLiquidityInstruction,
-  ClmmAddLiquidityInstruction,
-  ClmmWithdrawLiquidityInstruction,
-  ClmmTradePtInstruction,
-  ClmmBuyPtInstruction,
-  ClmmSellPtInstruction,
-  ClmmBuyYtInstruction,
-  ClmmSellYtInstruction,
-  ClmmClaimFarmEmissionInstruction,
-  VaultSyncTransactionResult,
-} from "./vault-interaction"
-
-// Titan quote
-export { getTitanQuote } from "./titan-quote"
-export type { TitanQuoteResult } from "./titan-quote"
-
-// Loopscale Client
-export {
-  LoopscaleClient,
-  deserializeLoopscaleTransactionResponse,
-  deserializeLoopscaleTransactionBatchResponse,
-  extractCreatedStrategyAddress,
-  extractCreatedStrategyNonce,
-  getLoopscaleTransactionResponses,
-  identifyLoopscaleInstruction,
-} from "./loopscale"
-export type {
-  LoopscaleClientConfig,
-  LoopscaleTransactionSignature,
-  LoopscaleVersionedTransactionResponse,
-  LoopscaleVersionedTransactionBatchResponse,
-  LoopscaleExpectedLoanInfo,
-  LoopscaleTransactionsResponse,
-  LoopscaleLoanTransactionResponse,
-  LoopscaleCreateLoanResponse,
-  LoopscaleTransactionResponse,
-  LoopscaleInstructionName,
-  LoopscaleQuoteParams,
-  LoopscaleQuote,
-  LoopscaleMaxQuoteParams,
-  LoopscaleMaxQuote,
-  LoopscaleLoanInfoParams,
-  LoopscaleLoanInfoResponse,
-  LoopscaleGetStrategiesParams,
-  LoopscaleStrategyInfoResponse,
-  LoopscaleCreateStrategyParams,
-  LoopscaleDepositStrategyParams,
-  LoopscaleWithdrawStrategyParams,
-  LoopscaleCloseLoanParams,
-  LoopscaleCloseStrategyParams,
-  ExternalYieldSourceParams,
-  TxnExternalYieldSourceArgs,
-  StrategyDuration,
-  AddCollateralArgs,
-  RemoveCollateralArgs,
-  CollateralParamsUpdateArgs,
-  CollateralAllocationUpdateArgs,
-  StrategyCollateralUpdates,
-  EditStrategySettingsArgs,
-  LoopscaleUpdateStrategyParams,
-  LoopscaleCreateLoanParams,
-  LoopscaleBorrowPrincipalParams,
-  LoopscaleDepositCollateralParams,
-  LoopscaleRepayLoanSimpleParams,
-  LoopscaleWithdrawCollateralParams,
-} 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"
-
-// Policy matching & hook resolution
-export {
-  fetchProgramInteractionPolicies,
-  getPolicyPostHookNumExtraAccounts,
-  resolveConstraintIndices,
-  resolveHookAccounts,
-  resolvePolicyMatch,
-  resolvePolicyMatchForVault,
-} from "./policyMatcher"
-
-// Sync transaction utilities
-export {
-  wrapInstructionsInSyncTransaction,
-  buildSyncTransactionInstruction,
-  compileToSyncTransactionPayload,
-  SQUADS_PROGRAM_ID,
-} from "./syncTransaction"
-export type { SyncTransactionPayload } from "./syncTransaction"
-
-export {
-  SquadsVaultTxnResolver,
-  INTERACTION_TYPES,
-  ACTION_DISPLAY_NAMES,
-  DecompiledInstructionWithInner,
-  decompileInstructions,
-  getMessageAccountKeysFromVersionedTxn,
-  getTxnTokensBalancesChanges,
-  TokenBalanceChange,
-  DefiInteraction,
-  InteractionType,
-} from "./squadsVaultTxnResolver"
-
-// Vault Transaction Builder
-export { VaultTransactionBuilder } from "./vaultTransactionBuilder"
-export type {
-  VaultTransactionBuilderConfig,
-  VaultTransactionBuilderLoopscaleConfig,
-  LoopscaleStepOptions,
-  StepOptions,
-  TransactionSet,
-  VaultTransactionBuildResult,
-  SendOptions,
-  SendResult,
-} from "./vaultTransactionBuilder"