@exponent-labs/exponent-sdk 0.1.8 → 0.9.0

package/src/exponentVaults/vault.ts

@@ -0,0 +1,2256 @@
+// The following methods have breaking changes: ixDepositLiquidity, ixQueueWithdrawal, ixExecuteWithdrawal, ixManagerRefreshSyRate
+// Account names changed: tokenSySrc -> tokenSrc, tokenSyVault -> entryTokenVault
+// New required accounts: exponentPrices
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  NATIVE_MINT,
+  TOKEN_2022_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+  createAssociatedTokenAccountIdempotentInstruction,
+  createSyncNativeInstruction,
+  getAccount,
+  getAssociatedTokenAddressSync,
+  getMint,
+} from "@solana/spl-token"
+import {
+  AccountMeta,
+  Connection,
+  Keypair,
+  PublicKey,
+  SYSVAR_INSTRUCTIONS_PUBKEY,
+  SYSVAR_RENT_PUBKEY,
+  SystemProgram,
+  TransactionInstruction,
+  TransactionMessage,
+  VersionedTransaction,
+} from "@solana/web3.js"
+import bs58 from "bs58"
+
+import {
+  ClmmPositionEntry,
+  ExponentPrices,
+  ExponentVault as ExponentVaultAccountType,
+  ExponentVault as ExponentVaultType,
+  ExponentVaultsFetcher,
+  OrderbookEntry,
+  PriceId,
+  TokenAccountEntry,
+  TokenEntry,
+  transformAnchorData,
+} from "@exponent-labs/exponent-vaults-fetcher"
+import { PROGRAM_ID as EXPONENT_VAULTS_PROGRAM_ID } from "@exponent-labs/exponent-vaults-idl"
+import { ExponentVaultsPDA, SeedId, SquadsPDA } from "@exponent-labs/exponent-vaults-pda"
+
+import { fetchAllMaybeMarketThreeAccounts } from "../client/clmm/accounts/marketThree"
+import * as exponentVaults from "../client/vaults"
+import { Environment, LOCAL_ENV } from "../environment"
+import { emitEventAuthority } from "../utils"
+import { AumCalculator } from "./aumCalculator"
+import { SquadsVaultTxnResolver } from "./squadsVaultTxnResolver"
+
+type Numeric = bigint | number
+
+export const SYNTHETIC_USD_MINT = new PublicKey("USD1111111111111111111111111111111111111111")
+export const SYNTHETIC_USD_DECIMALS = 6
+export const SYNTHETIC_USD9_MINT = new PublicKey("USD1111111111111111111111111111111111111119")
+export const SYNTHETIC_USD9_DECIMALS = 9
+
+export const getSyntheticMintDecimals = (mint: PublicKey): number | null => {
+  if (mint.equals(SYNTHETIC_USD_MINT)) return SYNTHETIC_USD_DECIMALS
+  if (mint.equals(SYNTHETIC_USD9_MINT)) return SYNTHETIC_USD9_DECIMALS
+  return null
+}
+
+const getMintDecimals = async (connection: Connection, mint: PublicKey): Promise<number> => {
+  const syntheticDecimals = getSyntheticMintDecimals(mint)
+  if (syntheticDecimals !== null) {
+    return syntheticDecimals
+  }
+
+  const mintInfo = await getMint(connection, mint)
+  return mintInfo.decimals
+}
+
+const pushPriceMintAccount = (remainingAccounts: AccountMeta[], mint: PublicKey) => {
+  if (getSyntheticMintDecimals(mint) !== null) return
+  remainingAccounts.push({ pubkey: mint, isSigner: false, isWritable: false })
+}
+
+// ============================================================================
+// Policy Types (matching on-chain structures)
+// ============================================================================
+
+export type DataOperator =
+  | "Equals"
+  | "NotEquals"
+  | "GreaterThan"
+  | "GreaterThanOrEqualTo"
+  | "LessThan"
+  | "LessThanOrEqualTo"
+
+export type DataValue =
+  | { u8: number }
+  | { u16Le: number }
+  | { u32Le: number }
+  | { u64Le: bigint }
+  | { u128Le: bigint }
+  | { u8Slice: number[] }
+
+export interface DataConstraint {
+  dataOffset: bigint
+  dataValue: DataValue
+  operator: DataOperator
+}
+
+export interface AccountConstraint {
+  accountIndex: number
+  accountKeys?: PublicKey[]
+  accountDataConstraints?: DataConstraint[]
+  owner?: PublicKey | null
+}
+
+export interface InstructionConstraint {
+  programId: PublicKey
+  accountConstraints: AccountConstraint[]
+  dataConstraints: DataConstraint[]
+}
+
+export type Period = "OneTime" | "Hourly" | "Daily" | "Weekly" | "Monthly" | "Quarterly" | "Yearly"
+
+export interface TimeConstraints {
+  start: bigint
+  expiration: bigint | null
+  period: Period
+}
+
+export interface QuantityConstraints {
+  maxPerPeriod: bigint
+}
+
+export interface SpendingLimit {
+  mint: PublicKey
+  timeConstraints: TimeConstraints
+  quantityConstraints: QuantityConstraints
+}
+
+export type AllowedSettingsChange = "AddSigner" | "RemoveSigner" | "ChangeThreshold" | "ChangeTimeLock"
+
+export type PolicyType =
+  | {
+      programInteraction: {
+        accountIndex: number
+        instructionsConstraints: InstructionConstraint[]
+        spendingLimits: SpendingLimit[]
+      }
+    }
+  | {
+      internalFundTransfer: {
+        sourceAccountMask: number[]
+        destinationAccountMask: number[]
+        allowedMints: PublicKey[]
+      }
+    }
+  | {
+      settingsChange: {
+        allowedActions: AllowedSettingsChange[]
+      }
+    }
+  | {
+      spendingLimit: {
+        sourceAccountIndex: number
+        destinations: PublicKey[]
+        spendingLimit: SpendingLimit
+      }
+    }
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export type PolicyExpiration = { timestamp: bigint } | { settingsState: {} }
+
+export interface PolicyConfig {
+  policyType: PolicyType
+  threshold: number
+  timeLock: number
+  startTimestamp: bigint | null
+  expiration: PolicyExpiration | null
+}
+
+/** Interface type for adapter vaults */
+export type InterfaceType =
+  | { generic: Record<string, never> }
+  | { kamino: Record<string, never> }
+  | { marginfi: Record<string, never> }
+  | { jitoRestaking: Record<string, never> }
+  | { perena: Record<string, never> }
+
+export interface TokenEntryInput {
+  mint: PublicKey
+  priceId: PriceId
+  tokenSquadsAccount: PublicKey
+  tokenAccountVault: PublicKey
+  tokenEscrow: PublicKey
+  shareBp: number
+  currentLiquidity: bigint
+  mintFlag: number
+  interfaceType?: InterfaceType
+  /** Force deallocate policy IDs (optional, defaults to empty) */
+  forceDeallocatePolicyIds?: bigint[]
+}
+
+type TotalAumInfo = {
+  aum: bigint
+  aumHuman: number
+  lpRate: number
+  lpSupply: bigint
+  lpDecimals: number
+  underlyingDecimals: number
+}
+
+const VAULT_SEED = Buffer.from("vault")
+
+const toBigInt = (value: Numeric): bigint => {
+  if (typeof value === "bigint") return value
+  return BigInt(Math.ceil(value))
+}
+
+const toCodamaPriceId = (priceId: PriceId): exponentVaults.PriceId => {
+  if ("simple" in priceId) {
+    return {
+      __kind: "Simple",
+      priceId: toBigInt(priceId.simple.priceId),
+    }
+  }
+  if ("multiply" in priceId) {
+    return {
+      __kind: "Multiply",
+      priceIds: priceId.multiply.priceIds.map((id) => toBigInt(id)),
+    }
+  }
+  throw new Error("Unknown PriceId variant")
+}
+
+const defaultTokenAccount = (mint: PublicKey, owner: PublicKey, tokenProgram: PublicKey) =>
+  getAssociatedTokenAddressSync(mint, owner, true, tokenProgram)
+
+const PRICE_INTERFACE_ACCOUNTS_SEED = Buffer.from("price_interface_accounts")
+
+const randomPriceInterfaceAccountsSeed = (): Uint8Array =>
+  Uint8Array.from(Keypair.generate().publicKey.toBytes().slice(0, 8))
+
+const derivePriceInterfaceAccountsAddress = (
+  programId: PublicKey,
+  exponentPrices: PublicKey,
+  seed: Uint8Array,
+): [PublicKey, number] =>
+  PublicKey.findProgramAddressSync(
+    [PRICE_INTERFACE_ACCOUNTS_SEED, exponentPrices.toBuffer(), Buffer.from(seed)],
+    programId,
+  )
+
+const convertPriceType = (priceType: PriceTypeParam): exponentVaults.PriceType => {
+  if ("pyth" in priceType) return exponentVaults.PriceType.Pyth
+  if ("pythInverse" in priceType) return exponentVaults.PriceType.PythInverse
+  if ("splStakePool" in priceType) return exponentVaults.PriceType.SplStakePool
+  if ("one" in priceType) return exponentVaults.PriceType.One
+  if ("pt" in priceType) return exponentVaults.PriceType.Pt
+  if ("yt" in priceType) return exponentVaults.PriceType.Yt
+  if ("solstice" in priceType) return exponentVaults.PriceType.Solstice
+  if ("reflect" in priceType) return exponentVaults.PriceType.Reflect
+  if ("fragmetric" in priceType) return exponentVaults.PriceType.Fragmetric
+  if ("fragmetricSupportedAsset" in priceType) return exponentVaults.PriceType.FragmetricSupportedAsset
+  if ("jupiterLend" in priceType) return exponentVaults.PriceType.JupiterLend
+  if ("chainlink" in priceType) return exponentVaults.PriceType.Chainlink
+  if ("ore" in priceType) return exponentVaults.PriceType.Ore
+  if ("hyloLpToken" in priceType) return exponentVaults.PriceType.HyloLpToken
+  if ("meteora" in priceType) return exponentVaults.PriceType.Meteora
+  if ("kaminoVault" in priceType) return exponentVaults.PriceType.KaminoVault
+  throw new Error("Unknown PriceType variant")
+}
+
+const convertUpdatePriceAction = (
+  action: UpdatePriceActionParam,
+  programId: PublicKey,
+  exponentPrices: PublicKey,
+  remainingAccounts: AccountMeta[],
+): exponentVaults.UpdatePriceAction => {
+  if ("addPrice" in action) {
+    const seed = randomPriceInterfaceAccountsSeed()
+    const [priceInterfaceAccounts] = derivePriceInterfaceAccountsAddress(programId, exponentPrices, seed)
+    const interfaceAccounts = action.addPrice.interfaceAccounts ?? []
+    remainingAccounts.push({
+      pubkey: priceInterfaceAccounts,
+      isSigner: false,
+      isWritable: true,
+    })
+    pushPriceMintAccount(remainingAccounts, action.addPrice.priceMint)
+    pushPriceMintAccount(remainingAccounts, action.addPrice.underlyingMint)
+    return {
+      __kind: "AddPrice",
+      priceType: convertPriceType(action.addPrice.priceType),
+      priceMint: action.addPrice.priceMint,
+      underlyingMint: action.addPrice.underlyingMint,
+      interfaceAccounts,
+      priceInterfaceAccountsSeed: seed,
+    }
+  }
+  if ("removePrice" in action) {
+    if (!action.removePrice.priceInterfaceAccounts) {
+      throw new Error("removePrice requires priceInterfaceAccounts")
+    }
+    remainingAccounts.push({
+      pubkey: action.removePrice.priceInterfaceAccounts,
+      isSigner: false,
+      isWritable: true,
+    })
+    return {
+      __kind: "RemovePrice",
+      priceId: toBigInt(action.removePrice.priceId),
+    }
+  }
+  if ("updatePrice" in action) {
+    if (!action.updatePrice.priceInterfaceAccounts) {
+      throw new Error("updatePrice requires priceInterfaceAccounts")
+    }
+    remainingAccounts.push({
+      pubkey: action.updatePrice.priceInterfaceAccounts,
+      isSigner: false,
+      isWritable: false,
+    })
+    return {
+      __kind: "UpdatePrice",
+      priceId: toBigInt(action.updatePrice.priceId),
+      priceType: convertPriceType(action.updatePrice.priceType),
+    }
+  }
+  if ("addManager" in action) {
+    return {
+      __kind: "AddManager",
+      manager: action.addManager.manager,
+    }
+  }
+  if ("removeManager" in action) {
+    return {
+      __kind: "RemoveManager",
+      manager: action.removeManager.manager,
+    }
+  }
+  if ("addPtPrice" in action) {
+    const seed = randomPriceInterfaceAccountsSeed()
+    const [priceInterfaceAccounts] = derivePriceInterfaceAccountsAddress(programId, exponentPrices, seed)
+    const interfaceAccounts = action.addPtPrice.interfaceAccounts ?? []
+    remainingAccounts.push({
+      pubkey: priceInterfaceAccounts,
+      isSigner: false,
+      isWritable: true,
+    })
+    pushPriceMintAccount(remainingAccounts, action.addPtPrice.priceMint)
+    pushPriceMintAccount(remainingAccounts, action.addPtPrice.underlyingMint)
+    return {
+      __kind: "AddPtPrice",
+      priceMint: action.addPtPrice.priceMint,
+      underlyingMint: action.addPtPrice.underlyingMint,
+      interfaceAccounts,
+      priceInterfaceAccountsSeed: seed,
+      impliedApyBps: action.addPtPrice.impliedApyBps,
+    }
+  }
+  if ("addYtPrice" in action) {
+    const seed = randomPriceInterfaceAccountsSeed()
+    const [priceInterfaceAccounts] = derivePriceInterfaceAccountsAddress(programId, exponentPrices, seed)
+    const interfaceAccounts = action.addYtPrice.interfaceAccounts ?? []
+    remainingAccounts.push({
+      pubkey: priceInterfaceAccounts,
+      isSigner: false,
+      isWritable: true,
+    })
+    pushPriceMintAccount(remainingAccounts, action.addYtPrice.priceMint)
+    pushPriceMintAccount(remainingAccounts, action.addYtPrice.underlyingMint)
+    return {
+      __kind: "AddYtPrice",
+      priceMint: action.addYtPrice.priceMint,
+      underlyingMint: action.addYtPrice.underlyingMint,
+      interfaceAccounts,
+      priceInterfaceAccountsSeed: seed,
+      impliedApyBps: action.addYtPrice.impliedApyBps,
+    }
+  }
+  throw new Error("Unknown UpdatePriceAction variant")
+}
+
+export interface DepositLiquidityParams {
+  depositor: PublicKey
+  mint: PublicKey
+  tokenAmountIn: Numeric
+  minLpOut: Numeric
+  tokenSrc?: PublicKey
+  /** Defaults to the Squads-controlled token account defined by the vault entry. */
+  entryTokenVault?: PublicKey
+  tokenLpDst?: PublicKey
+  tokenProgram?: PublicKey
+  /** Additional remaining accounts (e.g., Kamino obligations) */
+  extraRemainingAccounts?: AccountMeta[]
+  /**
+   * When true, pass token_2022_program (TOKEN_2022_PROGRAM_ID) as the second token program account.
+   * Use for compatibility with older deployed programs that expect token_program + token_2022_program
+   * instead of token_program + token_program_lp. Required when running against Surfpool/mainnet fork.
+   */
+  useLegacyTokenAccounts?: boolean
+}
+
+export interface UpdatePriceParams {
+  priceInterfaceAccounts?: PublicKey
+  pythPriceFeedId?: PublicKey
+  remainingAccounts?: PublicKey[]
+  priceId: number
+}
+
+export interface QueueWithdrawalParams {
+  depositor: PublicKey
+  lpAmount: Numeric
+  tokenLpSrc?: PublicKey
+  tokenProgram?: PublicKey
+  systemProgram?: PublicKey
+  tokenLpEscrow?: PublicKey
+}
+
+export interface TokenAccountPair {
+  /** Source token account (vault's token escrow) */
+  tokenSrc: PublicKey
+  /** Destination token account (user's token account) */
+  tokenDst: PublicKey
+}
+
+export interface ExecuteWithdrawalParams {
+  owner: PublicKey
+  withdrawalAccount: PublicKey
+  /** Array of token account pairs matching the withdrawal fills */
+  tokenAccountPairs: TokenAccountPair[]
+  tokenProgram?: PublicKey
+  token2022Program?: PublicKey
+  tokenLpEscrow?: PublicKey
+  mintLp?: PublicKey
+}
+
+export interface ExecuteWithdrawalFromReservesParams {
+  owner: PublicKey
+  /** Index of the token entry to withdraw */
+  entryIdx: number
+  /** Amount of LP tokens to burn for withdrawal */
+  lpAmount: Numeric
+  /** Source token account (owned by squads_vault) */
+  tokenSrc: PublicKey
+  /** Source token account (owned by vault) */
+  tokenVaultSrc: PublicKey
+  /** Destination token account (owned by the user) */
+  tokenDst: PublicKey
+  squadsProgram: PublicKey
+  tokenLpSrc?: PublicKey
+  tokenProgram?: PublicKey
+  token2022Program?: PublicKey
+  tokenLpEscrow?: PublicKey
+  mintLp?: PublicKey
+}
+
+export interface FillWithdrawalFillParam {
+  /** Index of the token entry in vault.token_entries */
+  tokenEntryIdx: number
+  /** Percentage of remaining LP to fill in basis points (10000 = 100%) */
+  percentOfTotalLpBp: Numeric
+}
+
+export interface FillWithdrawalParams {
+  /** Withdrawal account to fill */
+  withdrawalAccount: PublicKey
+  /** Fill parameters: which token entries and what percentage */
+  fills: FillWithdrawalFillParam[]
+  /** Token account pairs per fill: [{ tokenSrc (squads), tokenDst (vault escrow), tokenProgram }] */
+  tokenAccountTriples: Array<{
+    tokenSrc: PublicKey
+    tokenDst: PublicKey
+    tokenProgram: PublicKey
+  }>
+  mintLp?: PublicKey
+  tokenLpEscrow?: PublicKey
+}
+
+export interface WrapperExecuteWithdrawalParams {
+  owner: PublicKey
+  withdrawalAccount: PublicKey
+  /** Array of token account pairs matching the withdrawal fills */
+  tokenAccountPairs: TokenAccountPair[]
+  /** Index of the token entry for reserves withdrawal */
+  entryIdx: number
+  /** Source token account for reserves withdrawal (owned by squads_vault) */
+  tokenSrc: PublicKey
+  /** Source token account for reserves withdrawal (owned by vault) */
+  tokenVaultSrc: PublicKey
+  /** Destination token account for reserves withdrawal (owned by user) */
+  tokenDst: PublicKey
+  squadsProgram: PublicKey
+  tokenProgram?: PublicKey
+  token2022Program?: PublicKey
+  tokenLpEscrow?: PublicKey
+  mintLp?: PublicKey
+}
+
+// ============================================================================
+// Vault Initialization & Policy Management Parameter Types
+// ============================================================================
+
+/** Vault type enum */
+export type VaultType = { orderbook: Record<string, never> } | { generic: Record<string, never> }
+
+/** Role membership lists for vault governance */
+export interface VaultRoles {
+  manager: PublicKey[]
+  curator: PublicKey[]
+  allocator: PublicKey[]
+  sentinel: PublicKey[]
+}
+
+/** Configuration for proposal voting system */
+export interface ProposalVoteConfig {
+  minVotingPeriodSeconds: number
+  maxVotingPeriodSeconds: number
+  defaultVotingPeriodSeconds: number
+  defaultTimelockSeconds: number
+  rejectionThresholdBps: bigint
+  nextProposalId: bigint
+  votingEnabled: boolean
+  liveProposalsCount: number
+  maxConcurrentLiveProposals: number
+  reserved: number[]
+}
+
+export interface InitializeVaultParams {
+  /** Payer of the transaction (will also be the initial manager) */
+  payer: PublicKey
+  /** Underlying mint used by vault-level price validation */
+  mint: PublicKey
+  /** Manager of the vault (can be different from payer) */
+  manager: PublicKey
+  /** 8-byte seed ID for the vault PDA */
+  seedId: SeedId
+  /** Fee treasury account */
+  feeTreasury: PublicKey
+  /** Fee treasury in basis points */
+  normalWithdrawalFeeBps: number
+  /** Annualized management fee in basis points (1e6 precision) */
+  managementFeeBps: bigint
+  /** Percentage of vault assets to keep as reserves in basis points (10000 = 100%) */
+  reservesShareBp: number
+  /** Additional fee charged on fast withdrawals in basis points */
+  fastWithdrawalCutBp?: number
+  /** Initial token entries for the vault */
+  tokenEntries: TokenEntryInput[]
+  /** Max LP token supply */
+  maxLpSupply: bigint
+  /** Initial LP amount to mint */
+  initialLpAmount: bigint
+  /** LP token decimals */
+  lpDecimals: number
+  /** Deprecated: ignored by the vaults program */
+  vaultType?: VaultType
+  /** Role membership lists */
+  roles: VaultRoles
+  /** Proposal voting configuration (optional) */
+  proposalVoteConfig?: ProposalVoteConfig
+  /** Address lookup table */
+  addressLookupTable: PublicKey
+  /** Squads program ID */
+  squadsProgram: PublicKey
+  /** Squads program config PDA (for creation fee) */
+  squadsProgramConfig: PublicKey
+  /** Squads treasury (receives creation fee) */
+  squadsTreasury: PublicKey
+  /** Squads settings account - derived as PDA("smart_account", "settings", index) */
+  squadsSettings: PublicKey
+  /** Squads vault account - derived as PDA("smart_account", settings_key, "smart_account", 0) */
+  squadsVault: PublicKey
+  /** Token program (defaults to Token) */
+  tokenProgram?: PublicKey
+}
+
+// ============================================================================
+// Price Management Types
+// ============================================================================
+
+/** Price type enum (matches on-chain PriceType) */
+export type PriceTypeParam =
+  | { pyth: Record<string, never> }
+  | { pythInverse: Record<string, never> }
+  | { splStakePool: Record<string, never> }
+  | { one: Record<string, never> }
+  | { pt: Record<string, never> }
+  | { yt: Record<string, never> }
+  | { solstice: Record<string, never> }
+  | { reflect: Record<string, never> }
+  | { fragmetric: Record<string, never> }
+  | { fragmetricSupportedAsset: Record<string, never> }
+  | { jupiterLend: Record<string, never> }
+  | { chainlink: Record<string, never> }
+  | { ore: Record<string, never> }
+  | { hyloLpToken: Record<string, never> }
+  | { meteora: Record<string, never> }
+  | { kaminoVault: Record<string, never> }
+
+/** Action for managing price entries in ExponentPrices account */
+export type UpdatePriceActionParam =
+  | {
+      addPrice: {
+        priceType: PriceTypeParam
+        priceMint: PublicKey
+        underlyingMint: PublicKey
+        interfaceAccounts?: PublicKey[]
+      }
+    }
+  | { removePrice: { priceId: bigint; priceInterfaceAccounts?: PublicKey } }
+  | { updatePrice: { priceId: bigint; priceType: PriceTypeParam; priceInterfaceAccounts?: PublicKey } }
+  | { addManager: { manager: PublicKey } }
+  | { removeManager: { manager: PublicKey } }
+  | {
+      addPtPrice: {
+        priceMint: PublicKey
+        underlyingMint: PublicKey
+        interfaceAccounts?: PublicKey[]
+        impliedApyBps: number
+      }
+    }
+  | {
+      addYtPrice: {
+        priceMint: PublicKey
+        underlyingMint: PublicKey
+        interfaceAccounts?: PublicKey[]
+        impliedApyBps: number
+      }
+    }
+
+export interface InitializePricesParams {
+  /** Manager of the vault (must sign, pays for account creation) */
+  manager: PublicKey
+  /** Optional override for the exponent_vaults program ID */
+  programId?: PublicKey
+}
+
+export interface ManagePricesParams {
+  /** Manager of the vault (must sign, pays for reallocation) */
+  manager: PublicKey
+  /** List of price actions to execute */
+  actions: UpdatePriceActionParam[]
+  /** Optional override for the exponent_vaults program ID */
+  programId?: PublicKey
+}
+
+export interface AddPolicyParams {
+  /** Payer for the transaction */
+  payer: PublicKey
+  /** Policy configuration to add */
+  policyConfig: PolicyConfig
+  /** Squads program ID */
+  squadsProgram: PublicKey
+  /** Next policy seed (get from settings.nextPolicySeed) */
+  nextPolicySeed: bigint
+  /** Next transaction index (get from settings.transactionIndex + 1) */
+  nextTransactionIndex: bigint
+}
+
+export interface RemovePolicyParams {
+  /** Payer for the transaction */
+  payer: PublicKey
+  /** Manager of the vault (must sign) */
+  manager: PublicKey
+  /** Policy seed to remove */
+  policySeed: bigint
+  /** Squads program ID */
+  squadsProgram: PublicKey
+  /** Next transaction index (get from settings.transactionIndex + 1) */
+  nextTransactionIndex: bigint
+}
+
+export interface UpdatePolicyParams {
+  payer: PublicKey
+  manager: PublicKey
+  policyConfig: PolicyConfig
+  policySeed: bigint
+  squadsProgram: PublicKey
+  nextTransactionIndex: bigint
+}
+
+export interface WrapperManageVaultSettingsParams {
+  manager: PublicKey
+  actions: exponentVaults.VaultSettingsAction[]
+  remainingAccounts?: AccountMeta[]
+  exponentPrices?: PublicKey
+  systemProgram?: PublicKey
+}
+
+export interface WrapperManagerUpdatePositionParams {
+  manager: PublicKey
+  update: exponentVaults.PositionUpdate
+  remainingAccounts?: AccountMeta[]
+  exponentPrices?: PublicKey
+  systemProgram?: PublicKey
+}
+
+export type WrapperAddPolicyParams = AddPolicyParams
+
+export type WrapperRemovePolicyParams = RemovePolicyParams
+
+export type WrapperUpdatePolicyParams = UpdatePolicyParams
+
+export interface CancelWithdrawalParams {
+  owner: PublicKey
+  withdrawalAccount: PublicKey
+  tokenLpDst?: PublicKey
+  tokenProgram?: PublicKey
+  tokenLpEscrow?: PublicKey
+}
+
+export interface CollectManagementFeeParams {
+  manager: PublicKey
+  mintLp?: PublicKey
+  feeTreasury?: PublicKey
+  tokenProgram?: PublicKey
+}
+
+export class ExponentVault {
+  public state: ExponentVaultAccountType
+  public readonly selfAddress: PublicKey
+  public readonly env: Environment
+  public connection: Connection
+  public readonly programId: PublicKey
+  public readonly fetcher: ExponentVaultsFetcher
+  public pda: ExponentVaultsPDA
+  public aumCalculator: AumCalculator
+  private clmmTicksMap: Map<string, PublicKey> = new Map()
+  static squadsVaultTxnResolver = new SquadsVaultTxnResolver()
+
+  constructor(params: {
+    state: ExponentVaultAccountType
+    address: PublicKey
+    env?: Environment
+    connection: Connection
+    programId?: PublicKey
+  }) {
+    this.state = params.state
+    this.selfAddress = params.address
+    this.env = params.env ?? LOCAL_ENV
+    this.connection = params.connection
+    this.programId = params.programId ?? this.env.exponentVaultsProgramId ?? new PublicKey(EXPONENT_VAULTS_PROGRAM_ID)
+    this.fetcher = new ExponentVaultsFetcher(this.connection, this.programId)
+    this.pda = new ExponentVaultsPDA(this.programId)
+    this.aumCalculator = new AumCalculator(this.state, this.connection, this.env)
+  }
+
+  static async load(params: { env?: Environment; connection: Connection; address: PublicKey }) {
+    const env = params.env ?? LOCAL_ENV
+    const fetcher = new ExponentVaultsFetcher(
+      params.connection,
+      env.exponentVaultsProgramId ?? EXPONENT_VAULTS_PROGRAM_ID,
+    )
+    const state = await fetcher.fetchVaultDeserialized(params.address)
+    const vault = new ExponentVault({
+      state,
+      address: params.address,
+      env,
+      connection: params.connection,
+      programId: fetcher.programId,
+    })
+    await vault.populateClmmTicksCache(params.connection)
+    return vault
+  }
+
+  static async loadAll(params: { env?: Environment; connection: Connection }): Promise<ExponentVault[]> {
+    const env = params.env ?? LOCAL_ENV
+    const fetcher = new ExponentVaultsFetcher(
+      params.connection,
+      env.exponentVaultsProgramId ?? EXPONENT_VAULTS_PROGRAM_ID,
+    )
+    const vaults = await fetcher.fetchAllVaultsDeserialized()
+    const results = vaults.map(
+      ({ publicKey, account }) =>
+        new ExponentVault({
+          state: account,
+          address: publicKey,
+          env,
+          connection: params.connection,
+          programId: fetcher.programId,
+        }),
+    )
+    await Promise.all(results.map((v) => v.populateClmmTicksCache(params.connection)))
+    return results
+  }
+
+  async reload(connection: Connection = this.connection) {
+    const refreshed = await ExponentVault.load({ env: this.env, connection, address: this.selfAddress })
+    this.state = refreshed.state
+    this.clmmTicksMap = refreshed.clmmTicksMap
+    this.connection = connection
+    this.aumCalculator = new AumCalculator(this.state, this.connection, this.env)
+    return refreshed
+  }
+
+  private async populateClmmTicksCache(connection: Connection): Promise<void> {
+    this.clmmTicksMap.clear()
+    const marketKeys: PublicKey[] = []
+    for (const pos of this.state.strategyPositions) {
+      if ("clmmPosition" in pos && pos.clmmPosition && typeof pos.clmmPosition === "object") {
+        const entry = (pos as { clmmPosition: { 0: ClmmPositionEntry } }).clmmPosition[0]
+        const key = entry.market.toBase58()
+        if (!this.clmmTicksMap.has(key) && !marketKeys.some((k) => k.equals(entry.market))) {
+          marketKeys.push(entry.market)
+        }
+      }
+    }
+    if (marketKeys.length === 0) return
+    const markets = await fetchAllMaybeMarketThreeAccounts(connection, marketKeys)
+    for (const market of markets) {
+      if (market) {
+        this.clmmTicksMap.set(market.address.toBase58(), market.data.ticks)
+      }
+    }
+  }
+
+  /**
+   * Derive the PDA for a vault using its 8-byte seed identifier.
+   */
+  static deriveVaultAddress(
+    seedId: Uint8Array | number[],
+    programId: PublicKey = new PublicKey(EXPONENT_VAULTS_PROGRAM_ID),
+  ) {
+    if (seedId.length !== 8) {
+      throw new Error(`seedId must contain 8 bytes, received ${seedId.length}`)
+    }
+    const seedBuffer = Buffer.from(seedId)
+    return PublicKey.findProgramAddressSync([VAULT_SEED, seedBuffer], programId)
+  }
+
+  get mintLp() {
+    return this.state.mintLp
+  }
+
+  get tokenLpEscrow() {
+    return this.state.tokenLpEscrow
+  }
+
+  get eventAuthority() {
+    return emitEventAuthority(this.programId)
+  }
+
+  private getTokenEntryOrThrow(mint: PublicKey): TokenEntry {
+    const entry = this.state.tokenEntries.find((e) => e.mint.equals(mint))
+    if (!entry) {
+      throw new Error(`Token entry not found for mint ${mint.toBase58()}`)
+    }
+    return entry
+  }
+
+  async fetchWithdrawalAccount(address: PublicKey) {
+    return this.fetcher.fetchWithdrawalAccountDeserialized(address)
+  }
+
+  async fetchAllActionProposals() {
+    const accounts = await this.connection.getProgramAccounts(this.programId, {
+      filters: [
+        { memcmp: { offset: 0, bytes: bs58.encode(Buffer.from([144, 192, 194, 210, 241, 173, 240, 41])) } },
+        { memcmp: { offset: 8, bytes: this.selfAddress.toBase58() } },
+      ],
+    })
+    return accounts.map(({ pubkey, account }) => ({
+      address: pubkey,
+      data: exponentVaults.deserializeActionProposalAccount(account.data),
+    }))
+  }
+
+  async fetchLpTokenSupply() {
+    const { supply } = await getMint(this.connection, this.state.mintLp)
+    return supply
+  }
+
+  /** Set DEBUG_VAULT_AUM=1 to log AUM remaining accounts (token entries + strategy positions) for debugging */
+  private static get debugAum(): boolean {
+    return typeof process !== "undefined" && process.env?.DEBUG_VAULT_AUM === "1"
+  }
+
+  private strategyPositionAccountMetas(): AccountMeta[] {
+    const metas: AccountMeta[] = []
+
+    for (const pos of this.state.strategyPositions) {
+      if ("orderbook" in pos && pos.orderbook && typeof pos.orderbook === "object") {
+        const entry: OrderbookEntry = pos["orderbook"][0]
+        metas.push({
+          pubkey: entry.orderbook,
+          isSigner: false,
+          isWritable: false,
+        })
+        if (ExponentVault.debugAum) {
+          console.log("[VAULT_AUM] strategyPosition: Orderbook", entry.orderbook.toBase58())
+        }
+      } else if ("tokenAccount" in pos && pos.tokenAccount && typeof pos.tokenAccount === "object") {
+        const entry: TokenAccountEntry = pos["tokenAccount"][0]
+        for (const balance of entry.balances) {
+          metas.push({
+            pubkey: balance.tokenAccount,
+            isSigner: false,
+            isWritable: false,
+          })
+          if (ExponentVault.debugAum) {
+            console.log("[VAULT_AUM] strategyPosition: TokenAccount balance", balance.tokenAccount.toBase58())
+          }
+        }
+      } else if ("obligation" in pos && pos.obligation && typeof pos.obligation === "object") {
+        const inner = pos["obligation"][0] as Record<string, unknown> | undefined
+        const kaminoVariant = inner && "kaminoObligation" in inner ? (inner.kaminoObligation as unknown) : inner
+        const entry = Array.isArray(kaminoVariant)
+          ? (kaminoVariant[0] as
+              | {
+                  obligation?: PublicKey
+                  reservePriceMappings?: Array<{ reserve: PublicKey }>
+                }
+              | undefined)
+          : kaminoVariant && typeof kaminoVariant === "object" && "0" in (kaminoVariant as Record<string, unknown>)
+            ? ((
+                kaminoVariant as {
+                  0?: {
+                    obligation?: PublicKey
+                    reservePriceMappings?: Array<{ reserve: PublicKey }>
+                  }
+                }
+              )[0] ?? undefined)
+            : (kaminoVariant as
+                | {
+                    obligation?: PublicKey
+                    reservePriceMappings?: Array<{ reserve: PublicKey }>
+                  }
+                | undefined)
+        if (entry?.obligation instanceof PublicKey) {
+          metas.push({
+            pubkey: entry.obligation,
+            isSigner: false,
+            isWritable: false,
+          })
+          for (const mapping of entry.reservePriceMappings ?? []) {
+            metas.push({
+              pubkey: mapping.reserve,
+              isSigner: false,
+              isWritable: false,
+            })
+          }
+          if (ExponentVault.debugAum) {
+            console.log("[VAULT_AUM] strategyPosition: Obligation", entry.obligation.toBase58())
+            for (const mapping of entry.reservePriceMappings ?? []) {
+              console.log("[VAULT_AUM] strategyPosition: Kamino reserve", mapping.reserve.toBase58())
+            }
+          }
+        }
+      } else if ("yieldPosition" in pos && pos.yieldPosition && typeof pos.yieldPosition === "object") {
+        const entry = pos["yieldPosition"][0] as { yieldPosition: PublicKey; vault: PublicKey }
+        metas.push({
+          pubkey: entry.yieldPosition,
+          isSigner: false,
+          isWritable: false,
+        })
+        metas.push({
+          pubkey: entry.vault,
+          isSigner: false,
+          isWritable: false,
+        })
+        if (ExponentVault.debugAum) {
+          console.log(
+            "[VAULT_AUM] strategyPosition: YieldPosition",
+            entry.yieldPosition.toBase58(),
+            entry.vault.toBase58(),
+            "(must exist and have exponent_core YieldTokenPosition discriminator)",
+          )
+        }
+      } else if ("clmmPosition" in pos && pos.clmmPosition && typeof pos.clmmPosition === "object") {
+        const entry = (pos as { clmmPosition: { 0: ClmmPositionEntry } }).clmmPosition[0]
+        metas.push({
+          pubkey: entry.lpPosition,
+          isSigner: false,
+          isWritable: false,
+        })
+        metas.push({
+          pubkey: entry.market,
+          isSigner: false,
+          isWritable: false,
+        })
+        const ticksKey = this.clmmTicksMap.get(entry.market.toBase58())
+        if (ticksKey) {
+          metas.push({
+            pubkey: ticksKey,
+            isSigner: false,
+            isWritable: false,
+          })
+        }
+        if (ExponentVault.debugAum) {
+          console.log(
+            "[VAULT_AUM] strategyPosition: ClmmPosition",
+            entry.lpPosition.toBase58(),
+            entry.market.toBase58(),
+            ticksKey ? ticksKey.toBase58() : "(ticks not cached)",
+          )
+        }
+      } else if ("loopscaleStrategy" in pos && pos.loopscaleStrategy && typeof pos.loopscaleStrategy === "object") {
+        const entry = (pos as any).loopscaleStrategy[0]
+        if (entry?.strategy instanceof PublicKey) {
+          metas.push({
+            pubkey: entry.strategy,
+            isSigner: false,
+            isWritable: false,
+          })
+          if (ExponentVault.debugAum) {
+            console.log("[VAULT_AUM] strategyPosition: LoopscaleStrategy", entry.strategy.toBase58())
+          }
+        }
+      } else if ("loopscaleLoan" in pos && pos.loopscaleLoan && typeof pos.loopscaleLoan === "object") {
+        const entry = (pos as any).loopscaleLoan[0]
+        if (entry?.loan instanceof PublicKey) {
+          metas.push({
+            pubkey: entry.loan,
+            isSigner: false,
+            isWritable: false,
+          })
+          if (ExponentVault.debugAum) {
+            console.log("[VAULT_AUM] strategyPosition: LoopscaleLoan", entry.loan.toBase58())
+          }
+        }
+      } else if (ExponentVault.debugAum) {
+        console.log("[VAULT_AUM] strategyPosition: UNMATCHED", JSON.stringify(Object.keys(pos)))
+      }
+    }
+
+    return metas
+  }
+
+  private tokenEntryAccountMetas(): AccountMeta[] {
+    const metas = this.state.tokenEntries.map((entry) => ({
+      pubkey: entry.tokenSquadsAccount,
+      isSigner: false,
+      isWritable: false,
+    }))
+    if (ExponentVault.debugAum) {
+      metas.forEach((m, i) => {
+        console.log(
+          `[VAULT_AUM] tokenEntry[${i}]:`,
+          m.pubkey.toBase58(),
+          "(vault ATA for mint, must be SPL token account)",
+        )
+      })
+    }
+    return metas
+  }
+
+  private aumRemainingAccounts(): AccountMeta[] {
+    return [...this.tokenEntryAccountMetas(), ...this.strategyPositionAccountMetas()]
+  }
+
+  ixUpdatePrice({
+    priceInterfaceAccounts,
+    pythPriceFeedId,
+    remainingAccounts = [],
+    priceId,
+  }: UpdatePriceParams): TransactionInstruction {
+    const [exponentPrices] = this.pda.exponentPrices()
+    if (!priceInterfaceAccounts) {
+      throw new Error("ixUpdatePrice requires priceInterfaceAccounts")
+    }
+    const updateRemainingAccounts = [
+      { pubkey: priceInterfaceAccounts, isSigner: false, isWritable: false },
+      ...remainingAccounts.map((pubkey) => ({ pubkey, isSigner: false, isWritable: false })),
+      ...(pythPriceFeedId ? [{ pubkey: pythPriceFeedId, isSigner: false, isWritable: false }] : []),
+    ]
+    const ix = exponentVaults.createUpdatePriceInstruction(
+      { exponentPrices },
+      { updates: [{ priceId: BigInt(priceId), interfaceAccountsIndex: 0 }] },
+    )
+    ix.keys.push(...updateRemainingAccounts)
+    return ix
+  }
+
+  async ixsDepositLiquidity({
+    depositor,
+    mint,
+    tokenAmountIn,
+    minLpOut,
+    tokenSrc,
+    entryTokenVault,
+    tokenLpDst,
+    tokenProgram = TOKEN_PROGRAM_ID,
+    extraRemainingAccounts = [],
+    useLegacyTokenAccounts = false,
+  }: DepositLiquidityParams): Promise<TransactionInstruction[]> {
+    const entry = this.getTokenEntryOrThrow(mint)
+    const source = tokenSrc ?? defaultTokenAccount(mint, depositor, tokenProgram)
+    const vault = entryTokenVault ?? entry.tokenSquadsAccount
+    const lpDst = tokenLpDst ?? defaultTokenAccount(this.state.mintLp, depositor, tokenProgram)
+    const exponentPrices = this.pda.exponentPrices()[0]
+
+    const preIxs: TransactionInstruction[] = []
+
+    // If depositing WSOL, wrap native SOL as needed
+    if (mint.equals(NATIVE_MINT)) {
+      const wsolAta = getAssociatedTokenAddressSync(NATIVE_MINT, depositor, false, tokenProgram)
+      // Create WSOL ATA (idempotent — no-op if already exists)
+      preIxs.push(
+        createAssociatedTokenAccountIdempotentInstruction(depositor, wsolAta, depositor, NATIVE_MINT, tokenProgram),
+      )
+
+      // Check existing WSOL balance
+      let existingWsolBalance = BigInt(0)
+      try {
+        const wsolAccount = await getAccount(this.connection, wsolAta, "confirmed", tokenProgram)
+        existingWsolBalance = wsolAccount.amount
+      } catch {
+        // Account doesn't exist yet — balance is 0
+      }
+
+      const totalNeeded = toBigInt(tokenAmountIn)
+      if (totalNeeded > existingWsolBalance) {
+        const wrapAmount = totalNeeded - existingWsolBalance
+        // Transfer native SOL to the WSOL ATA
+        preIxs.push(
+          SystemProgram.transfer({
+            fromPubkey: depositor,
+            toPubkey: wsolAta,
+            lamports: wrapAmount,
+          }),
+        )
+        // Sync the native balance so the token account reflects the deposited SOL
+        preIxs.push(createSyncNativeInstruction(wsolAta, tokenProgram))
+      }
+    }
+
+    const depositorLpAta = getAssociatedTokenAddressSync(this.state.mintLp, depositor)
+    const createLpAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      depositor,
+      depositorLpAta,
+      depositor,
+      this.state.mintLp,
+    )
+
+    const depositIx = exponentVaults.createDepositLiquidityInstruction(
+      {
+        depositor,
+        vault: this.selfAddress,
+        exponentPrices,
+        mint,
+        tokenSrc: source,
+        entryTokenVault: vault,
+        tokenLpDst: lpDst,
+        mintLp: this.state.mintLp,
+        tokenProgram,
+        tokenProgramLp: TOKEN_PROGRAM_ID,
+        eventAuthority: this.eventAuthority,
+        program: this.programId,
+      },
+      { tokenAmountIn: toBigInt(tokenAmountIn), minLpOut: toBigInt(minLpOut) },
+    )
+
+    const remainingAccounts = [...this.aumRemainingAccounts(), ...extraRemainingAccounts]
+    depositIx.keys.push(...remainingAccounts)
+
+    if (ExponentVault.debugAum) {
+      console.log("[VAULT_AUM] ixsDepositLiquidity: total remaining_accounts =", remainingAccounts.length)
+      remainingAccounts.forEach((acc, i) => {
+        console.log(`  [${i}] ${acc.pubkey.toBase58()} writable=${acc.isWritable} signer=${acc.isSigner}`)
+      })
+      console.log(
+        "[VAULT_AUM] DepositLiquidity expects: token_entry ATAs (for AUM) + strategy accounts (orderbook, yieldPosition). AccountDiscriminatorNotFound (0xbb9) = wrong account type at one of these.",
+      )
+    }
+
+    return [...preIxs, createLpAtaIx, depositIx]
+  }
+
+  ixQueueWithdrawal({
+    depositor,
+    lpAmount,
+    tokenLpSrc,
+    tokenProgram = TOKEN_PROGRAM_ID,
+    systemProgram = SystemProgram.programId,
+    tokenLpEscrow = this.state.tokenLpEscrow,
+  }: QueueWithdrawalParams): { ix: TransactionInstruction; withdrawalKeypair: Keypair } {
+    const withdrawalKeypair = Keypair.generate()
+    const lpSrc = tokenLpSrc ?? defaultTokenAccount(this.state.mintLp, depositor, tokenProgram)
+
+    const ix = exponentVaults.createQueueWithdrawalInstruction(
+      {
+        depositor,
+        vault: this.selfAddress,
+        withdrawalAccount: withdrawalKeypair.publicKey,
+        tokenLpSrc: lpSrc,
+        tokenLpEscrow,
+        tokenProgram,
+        systemProgram,
+      },
+      {
+        lpAmount: toBigInt(lpAmount),
+      },
+    )
+    ix.keys.push(...this.aumRemainingAccounts())
+    return { ix, withdrawalKeypair }
+  }
+
+  ixExecuteWithdrawal({
+    owner,
+    withdrawalAccount,
+    tokenAccountPairs,
+    tokenProgram = TOKEN_PROGRAM_ID,
+    token2022Program = TOKEN_2022_PROGRAM_ID,
+    tokenLpEscrow = this.state.tokenLpEscrow,
+    mintLp = this.state.mintLp,
+  }: ExecuteWithdrawalParams): TransactionInstruction {
+    // Flatten token account pairs into remaining accounts: [src1, dst1, src2, dst2, ...]
+    const tokenAccountMetas = tokenAccountPairs.flatMap((pair) => [
+      { pubkey: pair.tokenSrc, isWritable: true, isSigner: false },
+      { pubkey: pair.tokenDst, isWritable: true, isSigner: false },
+    ])
+
+    const tokenLpSrc = defaultTokenAccount(this.state.mintLp, owner, tokenProgram)
+
+    const ix = exponentVaults.createExecuteWithdrawalInstruction(
+      {
+        vault: this.selfAddress,
+        exponentPrices: this.pda.exponentPrices()[0],
+        owner,
+        withdrawalAccount,
+        tokenLpSrc,
+        tokenLpEscrow,
+        mintLp,
+        tokenProgram,
+        eventAuthority: this.eventAuthority,
+        program: this.programId,
+        token2022Program: token2022Program,
+      },
+      { tokenTransferAccountsUntil: tokenAccountPairs.length * 2 },
+    )
+    ix.keys.push(...tokenAccountMetas, ...this.aumRemainingAccounts())
+    return ix
+  }
+
+  ixExecuteWithdrawalFromReserves({
+    owner,
+    entryIdx,
+    lpAmount,
+    tokenSrc,
+    tokenVaultSrc,
+    tokenDst,
+    tokenLpSrc,
+    squadsProgram,
+    tokenProgram = TOKEN_PROGRAM_ID,
+    token2022Program = TOKEN_2022_PROGRAM_ID,
+    tokenLpEscrow = this.state.tokenLpEscrow,
+    mintLp = this.state.mintLp,
+  }: ExecuteWithdrawalFromReservesParams): TransactionInstruction {
+    const lpSrc = tokenLpSrc ?? defaultTokenAccount(this.state.mintLp, owner, tokenProgram)
+    const squadsPda = new SquadsPDA(squadsProgram)
+    const squadsSettings = this.state.squadsSettings
+    const [squadsPolicy] = squadsPda.policy({
+      settings: squadsSettings,
+      policySeed: 2n, // Policy seed 2 is the vault-authorized transfer policy created at init
+    })
+
+    const ix = exponentVaults.createExecuteWithdrawalFromReservesInstruction(
+      {
+        owner,
+        vault: this.selfAddress,
+        exponentPrices: this.pda.exponentPrices()[0],
+        tokenLpSrc: lpSrc,
+        tokenLpEscrow,
+        tokenVaultSrc,
+        mintLp,
+        tokenSrc,
+        tokenDst,
+        tokenProgram,
+        token2022Program,
+        squadsVault: this.state.squadsVault,
+        squadsPolicy: squadsPolicy,
+        squadsProgram: squadsProgram,
+      },
+      { entryIdx, lpAmount: toBigInt(lpAmount) },
+    )
+    ix.keys.push(...this.aumRemainingAccounts())
+    return ix
+  }
+
+  ixFillWithdrawal({
+    withdrawalAccount,
+    fills,
+    tokenAccountTriples,
+    mintLp = this.state.mintLp,
+    tokenLpEscrow = this.state.tokenLpEscrow,
+  }: FillWithdrawalParams): TransactionInstruction {
+    const ix = exponentVaults.createFillWithdrawalInstruction(
+      {
+        exponentVaultsProgram: this.programId,
+        squadsVault: this.state.squadsVault,
+        vault: this.selfAddress,
+        exponentPrices: this.pda.exponentPrices()[0],
+        withdrawalAccount,
+        mintLp,
+        tokenLpEscrow,
+        tokenProgramLp: TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId,
+      },
+      {
+        fills: fills.map((f) => ({
+          tokenEntryIdx: f.tokenEntryIdx,
+          percentOfTotalLpBp: toBigInt(f.percentOfTotalLpBp),
+        })),
+      },
+    )
+
+    // Remaining accounts layout: [aum_accounts..., token_src_0, token_dst_0, token_program_0, ...]
+    const tokenTransferMetas = tokenAccountTriples.flatMap((triple) => [
+      { pubkey: triple.tokenSrc, isWritable: true, isSigner: false },
+      { pubkey: triple.tokenDst, isWritable: true, isSigner: false },
+      { pubkey: triple.tokenProgram, isWritable: false, isSigner: false },
+    ])
+    ix.keys.push(...this.aumRemainingAccounts(), ...tokenTransferMetas)
+    return ix
+  }
+
+  ixWrapperExecuteWithdrawal({
+    owner,
+    withdrawalAccount,
+    tokenAccountPairs,
+    entryIdx,
+    tokenSrc,
+    tokenVaultSrc,
+    tokenDst,
+    squadsProgram,
+    tokenProgram = TOKEN_PROGRAM_ID,
+    token2022Program = TOKEN_2022_PROGRAM_ID,
+    tokenLpEscrow = this.state.tokenLpEscrow,
+    mintLp = this.state.mintLp,
+  }: WrapperExecuteWithdrawalParams): TransactionInstruction {
+    const tokenLpSrc = defaultTokenAccount(this.state.mintLp, owner, tokenProgram)
+    const squadsPda = new SquadsPDA(squadsProgram)
+    const [squadsPolicy] = squadsPda.policy({
+      settings: this.state.squadsSettings,
+      policySeed: 2n,
+    })
+
+    const tokenAccountMetas = tokenAccountPairs.flatMap((pair) => [
+      { pubkey: pair.tokenSrc, isWritable: true, isSigner: false },
+      { pubkey: pair.tokenDst, isWritable: true, isSigner: false },
+    ])
+
+    const ix = exponentVaults.createWrapperExecuteWithdrawalInstruction(
+      {
+        vault: this.selfAddress,
+        exponentPrices: this.pda.exponentPrices()[0],
+        owner,
+        withdrawalAccount,
+        tokenLpSrc,
+        tokenLpEscrow,
+        mintLp,
+        tokenProgram,
+        token2022Program,
+        systemProgram: SystemProgram.programId,
+        rent: SYSVAR_RENT_PUBKEY,
+        tokenSrc,
+        tokenVaultSrc,
+        tokenDst,
+        squadsVault: this.state.squadsVault,
+        squadsPolicy,
+        squadsProgram,
+        eventAuthority: this.eventAuthority,
+        program: this.programId,
+      },
+      { tokenTransferAccountsUntil: tokenAccountPairs.length * 2, entryIdx },
+    )
+    ix.keys.push(...tokenAccountMetas, ...this.aumRemainingAccounts())
+    return ix
+  }
+
+  ixCancelWithdrawal({
+    owner,
+    withdrawalAccount,
+    tokenLpDst,
+    tokenProgram = TOKEN_PROGRAM_ID,
+    tokenLpEscrow = this.state.tokenLpEscrow,
+  }: CancelWithdrawalParams) {
+    const lpDst = tokenLpDst ?? defaultTokenAccount(this.state.mintLp, owner, tokenProgram)
+
+    return exponentVaults.createCancelWithdrawalInstruction({
+      owner,
+      vault: this.selfAddress,
+      withdrawalAccount,
+      tokenLpEscrow,
+      tokenLpDst: lpDst,
+      tokenProgram,
+    })
+  }
+
+  // ixCollectManagementFee({
+  //   manager,
+  //   mintLp = this.state.mintLp,
+  //   feeTreasury = this.state.feeTreasury,
+  //   tokenProgram = TOKEN_PROGRAM_ID,
+  // }: CollectManagementFeeParams) {
+  //   return exponentVaults.createCollectManagementFeeInstruction({
+  //     manager,
+  //     vault: this.selfAddress,
+  //     mintLp,
+  //     feeTreasury,
+  //     tokenProgram,
+  //   })
+  // }
+
+  /**
+   * Create instruction to call wrapper_manage_vault_settings.
+   */
+  ixWrapperManageVaultSettings({
+    manager,
+    actions,
+    remainingAccounts = [],
+    exponentPrices = this.pda.exponentPrices()[0],
+    systemProgram = SystemProgram.programId,
+  }: WrapperManageVaultSettingsParams): TransactionInstruction {
+    const ix = exponentVaults.createWrapperManageVaultSettingsInstruction(
+      {
+        manager,
+        vault: this.selfAddress,
+        exponentPrices,
+        systemProgram,
+      },
+      { actions },
+    )
+    ix.keys.push(...remainingAccounts)
+    return ix
+  }
+
+  /**
+   * Create instruction to call wrapper_manager_update_position.
+   */
+  ixWrapperManagerUpdatePosition({
+    manager,
+    update,
+    remainingAccounts = [],
+    exponentPrices = this.pda.exponentPrices()[0],
+    systemProgram = SystemProgram.programId,
+  }: WrapperManagerUpdatePositionParams): TransactionInstruction {
+    const ix = exponentVaults.createWrapperManagerUpdatePositionInstruction(
+      {
+        manager,
+        vault: this.selfAddress,
+        exponentPrices,
+        systemProgram,
+      },
+      { update },
+    )
+    ix.keys.push(...remainingAccounts)
+    return ix
+  }
+
+  // ==========================================================================
+  // Policy Management Methods
+  // ==========================================================================
+
+  /**
+   * Create instruction to add a policy to this vault.
+   * Direct policy management requires an empty vault; live vaults must use proposals.
+   */
+  ixAddPolicy({ payer, policyConfig, squadsProgram, nextPolicySeed, nextTransactionIndex }: AddPolicyParams) {
+    const squadsSettings = this.state.squadsSettings
+    const squadsPda = new SquadsPDA(squadsProgram)
+
+    // Derive Squads PDAs
+    const [squadsSettingsTransaction] = squadsPda.transaction({
+      settings: squadsSettings,
+      transactionIndex: nextTransactionIndex,
+    })
+    const [squadsProposal] = squadsPda.proposal({
+      settings: squadsSettings,
+      transactionIndex: nextTransactionIndex,
+    })
+    const [squadsPolicy] = squadsPda.policy({
+      settings: squadsSettings,
+      policySeed: nextPolicySeed,
+    })
+
+    return exponentVaults.createAddPolicyInstruction(
+      {
+        payer,
+        vault: this.selfAddress,
+        squadsSettings,
+        squadsSettingsTransaction,
+        squadsProposal,
+        squadsPolicy,
+        squadsProgram,
+        systemProgram: SystemProgram.programId,
+      },
+      { policyConfig: this.toCodamaPolicyConfig(policyConfig) },
+    )
+  }
+
+  /**
+   * Create instruction to call wrapper_add_policy.
+   * Wrapper uses the same empty-vault guard as direct policy management.
+   */
+  ixWrapperAddPolicy({
+    payer,
+    policyConfig,
+    squadsProgram,
+    nextPolicySeed,
+    nextTransactionIndex,
+  }: WrapperAddPolicyParams) {
+    const squadsSettings = this.state.squadsSettings
+    const squadsPda = new SquadsPDA(squadsProgram)
+
+    const [squadsSettingsTransaction] = squadsPda.transaction({
+      settings: squadsSettings,
+      transactionIndex: nextTransactionIndex,
+    })
+    const [squadsProposal] = squadsPda.proposal({
+      settings: squadsSettings,
+      transactionIndex: nextTransactionIndex,
+    })
+    const [squadsPolicy] = squadsPda.policy({
+      settings: squadsSettings,
+      policySeed: nextPolicySeed,
+    })
+
+    return exponentVaults.createWrapperAddPolicyInstruction(
+      {
+        payer,
+        vault: this.selfAddress,
+        squadsSettings,
+        squadsSettingsTransaction,
+        squadsProposal,
+        squadsPolicy,
+        squadsProgram,
+        systemProgram: SystemProgram.programId,
+      },
+      { policyConfig: this.toCodamaPolicyConfig(policyConfig) },
+    )
+  }
+
+  /**
+   * Create instruction to remove a policy from this vault.
+   * Direct policy management requires an empty vault; live vaults must use proposals.
+   */
+  ixRemovePolicy({ payer, manager, policySeed, squadsProgram, nextTransactionIndex }: RemovePolicyParams) {
+    const squadsSettings = this.state.squadsSettings
+    const squadsPda = new SquadsPDA(squadsProgram)
+
+    // Derive Squads PDAs
+    const [squadsSettingsTransaction] = squadsPda.transaction({
+      settings: squadsSettings,
+      transactionIndex: nextTransactionIndex,
+    })
+    const [squadsProposal] = squadsPda.proposal({
+      settings: squadsSettings,
+      transactionIndex: nextTransactionIndex,
+    })
+    const [squadsPolicy] = squadsPda.policy({
+      settings: squadsSettings,
+      policySeed,
+    })
+
+    return exponentVaults.createRemovePolicyInstruction({
+      payer,
+      vault: this.selfAddress,
+      manager,
+      squadsSettings,
+      squadsSettingsTransaction,
+      squadsProposal,
+      squadsPolicy,
+      squadsProgram,
+      systemProgram: SystemProgram.programId,
+    })
+  }
+
+  /**
+   * Create instruction to call wrapper_remove_policy.
+   * Wrapper uses the same empty-vault guard as direct policy management.
+   */
+  ixWrapperRemovePolicy({
+    payer,
+    manager,
+    policySeed,
+    squadsProgram,
+    nextTransactionIndex,
+  }: WrapperRemovePolicyParams) {
+    const squadsSettings = this.state.squadsSettings
+    const squadsPda = new SquadsPDA(squadsProgram)
+
+    const [squadsSettingsTransaction] = squadsPda.transaction({
+      settings: squadsSettings,
+      transactionIndex: nextTransactionIndex,
+    })
+    const [squadsProposal] = squadsPda.proposal({
+      settings: squadsSettings,
+      transactionIndex: nextTransactionIndex,
+    })
+    const [squadsPolicy] = squadsPda.policy({
+      settings: squadsSettings,
+      policySeed,
+    })
+
+    return exponentVaults.createWrapperRemovePolicyInstruction({
+      payer,
+      vault: this.selfAddress,
+      manager,
+      squadsSettings,
+      squadsSettingsTransaction,
+      squadsProposal,
+      squadsPolicy,
+      squadsProgram,
+      systemProgram: SystemProgram.programId,
+    })
+  }
+
+  /**
+   * Create instruction to call wrapper_update_policy.
+   * Wrapper uses the same empty-vault guard as direct policy management.
+   */
+  ixWrapperUpdatePolicy({
+    payer,
+    manager,
+    policyConfig,
+    policySeed,
+    squadsProgram,
+    nextTransactionIndex,
+  }: WrapperUpdatePolicyParams) {
+    const squadsSettings = this.state.squadsSettings
+    const squadsPda = new SquadsPDA(squadsProgram)
+
+    const [squadsSettingsTransaction] = squadsPda.transaction({
+      settings: squadsSettings,
+      transactionIndex: nextTransactionIndex,
+    })
+    const [squadsProposal] = squadsPda.proposal({
+      settings: squadsSettings,
+      transactionIndex: nextTransactionIndex,
+    })
+    const [squadsPolicy] = squadsPda.policy({
+      settings: squadsSettings,
+      policySeed,
+    })
+
+    return exponentVaults.createWrapperUpdatePolicyInstruction(
+      {
+        payer,
+        vault: this.selfAddress,
+        manager,
+        squadsSettings,
+        squadsSettingsTransaction,
+        squadsProposal,
+        squadsPolicy,
+        squadsProgram,
+        systemProgram: SystemProgram.programId,
+      },
+      { policyConfig: this.toCodamaPolicyConfig(policyConfig) },
+    )
+  }
+
+  // ==========================================================================
+  // Price Management Methods
+  // ==========================================================================
+
+  /**
+   * Derive the ExponentPrices PDA for this vault.
+   */
+  deriveExponentPricesAddress(): [PublicKey, number] {
+    const vaultsPda = new ExponentVaultsPDA(this.programId)
+    return vaultsPda.exponentPrices()
+  }
+
+  // ==========================================================================
+  // Static Factory Methods
+  // ==========================================================================
+
+  /**
+   * Create instruction to initialize the global ExponentPrices account.
+   * The account is a singleton PDA derived from ["exponent_prices"].
+   */
+  static ixInitializePrices({ manager, programId: programIdOverride }: InitializePricesParams) {
+    const programId = programIdOverride ?? new PublicKey(EXPONENT_VAULTS_PROGRAM_ID)
+    const [exponentPrices] = new ExponentVaultsPDA(programId).exponentPrices()
+    return exponentVaults.createInitializePricesInstruction(
+      {
+        manager,
+        exponentPrices,
+        systemProgram: SystemProgram.programId,
+      },
+      programId,
+    )
+  }
+
+  /**
+   * Create instruction to manage price entries (add/remove/update) in the ExponentPrices account.
+   * Uses realloc to resize the account as prices are added or removed.
+   */
+  static ixManagePrices({ manager, actions, programId: programIdOverride }: ManagePricesParams) {
+    const programId = programIdOverride ?? new PublicKey(EXPONENT_VAULTS_PROGRAM_ID)
+    const [exponentPrices] = new ExponentVaultsPDA(programId).exponentPrices()
+    const remainingAccounts: AccountMeta[] = []
+    const codamaActions = actions.map((action) =>
+      convertUpdatePriceAction(action, programId, exponentPrices, remainingAccounts),
+    )
+    const ix = exponentVaults.createManagePricesInstruction(
+      { manager, exponentPrices, systemProgram: SystemProgram.programId },
+      { actions: codamaActions },
+      programId,
+    )
+    ix.keys.push(...remainingAccounts)
+    return ix
+  }
+
+  /**
+   * Create instruction to initialize a new vault.
+   * This is a static method since the vault doesn't exist yet.
+   */
+  static ixInitializeVault(params: InitializeVaultParams, env: Environment) {
+    const programId = env.exponentVaultsProgramId ?? new PublicKey(EXPONENT_VAULTS_PROGRAM_ID)
+    const vaultsPda = new ExponentVaultsPDA(programId)
+    const squadsPda = new SquadsPDA(params.squadsProgram)
+    const tokenProgram = params.tokenProgram ?? TOKEN_PROGRAM_ID
+
+    // Derive vault PDA
+    const [vault] = vaultsPda.vault({ seedId: params.seedId })
+    const [mintLp] = vaultsPda.mintLp({ vault })
+    const [tokenLpEscrow] = vaultsPda.tokenLpEscrow({ vault })
+
+    // Derive LP destination (ATA for payer)
+    const lpDst = getAssociatedTokenAddressSync(mintLp, params.payer, false, tokenProgram)
+
+    // Squads account is created via CPI during initialize_vault
+    // The on-chain program creates the Squads smart account first, so these start at 1
+    const nextTransactionIndex = BigInt(1)
+    const nextPolicySeed = BigInt(1)
+
+    const nextTransactionTransferIndex = BigInt(2)
+    const nextPolicyTransferSeed = BigInt(2)
+
+    // Derive Squads PDAs for the policy that gets created after the Squads account
+    // These all use squadsSettings (the Settings account) as the base key
+    const [squadsSettingsTransaction] = squadsPda.transaction({
+      settings: params.squadsSettings,
+      transactionIndex: nextTransactionIndex,
+    })
+    const [squadsProposal] = squadsPda.proposal({
+      settings: params.squadsSettings,
+      transactionIndex: nextTransactionIndex,
+    })
+    const [squadsPolicy] = squadsPda.policy({
+      settings: params.squadsSettings,
+      policySeed: nextPolicySeed,
+    })
+
+    // Derive Squads PDAs for the transfer accounts
+    const [squadsPolicyTransfer] = squadsPda.policy({
+      settings: params.squadsSettings,
+      policySeed: nextPolicyTransferSeed,
+    })
+    const [squadsSettingsTransactionTransfer] = squadsPda.transaction({
+      settings: params.squadsSettings,
+      transactionIndex: nextTransactionTransferIndex,
+    })
+    const [squadsProposalTransfer] = squadsPda.proposal({
+      settings: params.squadsSettings,
+      transactionIndex: nextTransactionTransferIndex,
+    })
+
+    // Convert token entries to Codama format
+    const codamaTokenEntries: exponentVaults.TokenEntry[] = params.tokenEntries.map((entry) => ({
+      mint: entry.mint,
+      priceId: toCodamaPriceId(entry.priceId),
+      tokenSquadsAccount: entry.tokenSquadsAccount,
+      tokenAccountVault: entry.tokenAccountVault,
+      forceDeallocatePolicyIds: (entry.forceDeallocatePolicyIds ?? []).map((id) => toBigInt(id)),
+    }))
+
+    // Convert seedId to Uint8Array
+    const seedIdArray = new Uint8Array(params.seedId)
+    if (seedIdArray.length !== 8) {
+      throw new Error(`seedId must contain 8 bytes, received ${seedIdArray.length}`)
+    }
+
+    // Convert roles
+    const codamaRoles: exponentVaults.VaultRoles = {
+      manager: params.roles.manager,
+      curator: params.roles.curator,
+      allocator: params.roles.allocator,
+      sentinel: params.roles.sentinel,
+    }
+
+    // Convert proposal vote config if provided
+    const codamaProposalVoteConfig: exponentVaults.ProposalVoteConfig | null = params.proposalVoteConfig
+      ? {
+          minVotingPeriodSeconds: params.proposalVoteConfig.minVotingPeriodSeconds,
+          maxVotingPeriodSeconds: params.proposalVoteConfig.maxVotingPeriodSeconds,
+          defaultVotingPeriodSeconds: params.proposalVoteConfig.defaultVotingPeriodSeconds,
+          defaultTimelockSeconds: params.proposalVoteConfig.defaultTimelockSeconds,
+          rejectionThresholdBps: toBigInt(params.proposalVoteConfig.rejectionThresholdBps),
+          nextProposalId: toBigInt(params.proposalVoteConfig.nextProposalId),
+          votingEnabled: params.proposalVoteConfig.votingEnabled,
+          liveProposalsCount: params.proposalVoteConfig.liveProposalsCount,
+          maxConcurrentLiveProposals: params.proposalVoteConfig.maxConcurrentLiveProposals,
+          reserved: new Uint8Array(params.proposalVoteConfig.reserved),
+        }
+      : null
+
+    const [exponentPrices] = new ExponentVaultsPDA(programId).exponentPrices()
+
+    return exponentVaults.createInitializeVaultInstruction(
+      {
+        payer: params.payer,
+        vault,
+        exponentPrices,
+        mint: params.mint,
+        mintLp,
+        tokenLpEscrow,
+        feeTreasury: params.feeTreasury,
+        lpDst,
+        tokenProgram,
+        systemProgram: SystemProgram.programId,
+        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+        addressLookupTable: params.addressLookupTable,
+        squadsProgram: params.squadsProgram,
+        squadsProgramConfig: params.squadsProgramConfig,
+        squadsTreasury: params.squadsTreasury,
+        squadsSettings: params.squadsSettings,
+        squadsVault: params.squadsVault,
+        squadsPolicy,
+        squadsSettingsTransaction,
+        squadsProposal,
+        squadsPolicyTransfer,
+        squadsSettingsTransactionTransfer,
+        squadsProposalTransfer,
+      },
+      {
+        manager: params.manager,
+        feeTreasuryLpBps: params.normalWithdrawalFeeBps,
+        managementFeeBps: toBigInt(params.managementFeeBps),
+        reservesShareBp: params.reservesShareBp,
+        fastWithdrawalCutBp: params.fastWithdrawalCutBp ?? 0,
+        tokenEntries: codamaTokenEntries,
+        maxLpSupply: toBigInt(params.maxLpSupply),
+        seedId: seedIdArray,
+        initialLpAmount: toBigInt(params.initialLpAmount),
+        lpDecimals: params.lpDecimals,
+        roles: codamaRoles,
+        proposalVoteConfig: codamaProposalVoteConfig,
+      },
+    )
+  }
+
+  async fetchTotalAumInfo(pricesAccount: ExponentPrices, jitoBundleRpc?: string): Promise<TotalAumInfo> {
+    const aum = await this.getTotalAumViaJitoBundle(pricesAccount, jitoBundleRpc)
+
+    const { supply: lpSupply, decimals: lpDecimals } = await getMint(this.connection, this.state.mintLp)
+    const underlyingDecimals = await getMintDecimals(this.connection, this.state.underlyingMint)
+
+    if (lpSupply === 0n) {
+      return {
+        aum,
+        aumHuman: 0,
+        lpRate: 0,
+        lpSupply,
+        lpDecimals,
+        underlyingDecimals,
+      }
+    }
+
+    const lpHuman = Number(lpSupply.toString()) / 10 ** lpDecimals
+    const aumHuman = Number(aum.toString()) / 10 ** underlyingDecimals
+    const lpRate = aumHuman / lpHuman
+
+    return {
+      aum,
+      aumHuman,
+      lpRate,
+      lpSupply,
+      lpDecimals,
+      underlyingDecimals,
+    }
+  }
+
+  /**
+   * LP token price: AUM / LP supply.
+   * Returns 0 when LP supply is zero.
+   */
+  async getLpPrice(): Promise<number> {
+    const aum = this.getTotalAum()
+    const lpSupply = await this.fetchLpTokenSupply()
+    const quoteDecimals = await getMintDecimals(this.connection, this.state.underlyingMint)
+
+    const lpSupplyNum = parseInt(lpSupply.toString())
+    if (lpSupplyNum === 0) return 0
+
+    const aumHuman = parseInt(aum.toString()) / 10 ** quoteDecimals
+    const lpMintInfo = await getMint(this.connection, this.state.mintLp)
+    return aumHuman / (lpSupplyNum / 10 ** lpMintInfo.decimals)
+  }
+
+  /**
+   * Total AUM: on-chain tracked base value + value held in strategy positions.
+   */
+  getTotalAum(): bigint {
+    return this.aumCalculator.getTotalAum()
+  }
+
+  /**
+   * Calculates total AUM by simulating a bundle that updates prices and deposits liquidity.
+   * Requires an RPC endpoint that supports the `simulateBundle` method (e.g., Jito, Helius).
+   */
+  async getTotalAumViaJitoBundle(pricesAccount: ExponentPrices, jitoBundleRpc?: string): Promise<bigint> {
+    try {
+      const rpcUrl = jitoBundleRpc ?? this.connection.rpcEndpoint
+
+      const depositor = this.state.roles.manager[0]
+      if (!depositor) {
+        throw new Error("Vault manager not found")
+      }
+
+      const depositMint = this.state.tokenEntries[0]?.mint
+      if (!depositMint) {
+        throw new Error("Deposit token not found")
+      }
+
+      const [updatePriceIxs, depositIxs] = await Promise.all([
+        this.ixsUpdateStrategyVaultPrices(pricesAccount),
+        this.ixsDepositLiquidity({
+          depositor,
+          mint: depositMint,
+          tokenAmountIn: 1,
+          minLpOut: 0,
+        }),
+      ])
+
+      // Use a dummy blockhash - Jito will replace it with replaceRecentBlockhash
+      const blockhash = "11111111111111111111111111111111"
+
+      const encodedTransactions: string[] = []
+
+      if (updatePriceIxs.length > 0) {
+        const priceMsg = new TransactionMessage({
+          payerKey: depositor,
+          recentBlockhash: blockhash,
+          instructions: updatePriceIxs,
+        }).compileToV0Message()
+        encodedTransactions.push(Buffer.from(new VersionedTransaction(priceMsg).serialize()).toString("base64"))
+      }
+
+      const depositMsg = new TransactionMessage({
+        payerKey: depositor,
+        recentBlockhash: blockhash,
+        instructions: depositIxs,
+      }).compileToV0Message()
+      encodedTransactions.push(Buffer.from(new VersionedTransaction(depositMsg).serialize()).toString("base64"))
+
+      const rpcResponse = await fetch(rpcUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: "1",
+          method: "simulateBundle",
+          params: [
+            { encodedTransactions },
+            {
+              preExecutionAccountsConfigs: [
+                null,
+                null,
+                // {
+                //   addresses: [this.state.selfAddress.toBase58()],
+                //   encoding: "base64",
+                // },
+              ],
+              postExecutionAccountsConfigs: [
+                null,
+                {
+                  addresses: [this.state.selfAddress.toBase58()],
+                  encoding: "base64",
+                },
+              ],
+              transactionEncoding: "base64",
+              skipSigVerify: true,
+              replaceRecentBlockhash: true,
+              simulationBank: { commitment: { commitment: "processed" } },
+            },
+          ],
+        }),
+        cache: "no-store",
+      })
+
+      type HeliusSimulationTransactionResult = {
+        err?: unknown
+        logs?: string[] | null
+        unitsConsumed?: number | null
+        preExecutionAccounts?: Array<{ data: [string, string] } | null> | null
+        postExecutionAccounts?: Array<{ data: [string, string] } | null> | null
+      }
+
+      type HeliusSimulationResponse = {
+        result?: {
+          value?: {
+            summary?: unknown
+            transactionResults?: HeliusSimulationTransactionResult[]
+          }
+        }
+        error?: unknown
+      }
+
+      const responseBody = (await rpcResponse.json().catch(() => null)) as HeliusSimulationResponse | null
+      const txnResults = responseBody?.result?.value?.transactionResults || []
+
+      if (!rpcResponse.ok || responseBody?.error) {
+        throw new Error("Jito bundle simulation failed")
+      }
+
+      const depositFailed = !!txnResults[1].err
+      if (depositFailed) {
+        throw new Error("Jito bundle simulation failed")
+      }
+
+      const postVaultAccountData = txnResults[1]?.postExecutionAccounts?.[0]?.data?.[0]
+
+      if (!postVaultAccountData) {
+        throw new Error("Jito bundle simulation failed")
+      }
+
+      const decoded = this.fetcher.program.account.exponentStrategyVault.coder.accounts.decode(
+        "exponentStrategyVault",
+        Buffer.from(postVaultAccountData, "base64"),
+      )
+      const vaultStateAfterSimulations = transformAnchorData(decoded) as ExponentVaultType
+      const aum =
+        vaultStateAfterSimulations.financials.aumInBase + vaultStateAfterSimulations.financials.aumInBaseInPositions
+
+      return aum
+    } catch {
+      console.warn("Unable to calculate AUM via simulation. Using AUM from vault.state")
+      return this.getTotalAum()
+    }
+  }
+
+  async ixsUpdateStrategyVaultPrices(pricesAccount: ExponentPrices): Promise<TransactionInstruction[]> {
+    type PriceIdValue = { simple: { priceId: bigint } } | { multiply: { priceIds: bigint[] } }
+
+    const extractPriceIds = (priceId: PriceIdValue): number[] => {
+      const ids = "simple" in priceId ? [Number(priceId.simple.priceId)] : priceId.multiply.priceIds.map(Number)
+      return ids.filter((id) => id !== 0) // skip passthrough (price_id 0)
+    }
+
+    const allPriceIds = new Set<number>()
+
+    for (const entry of this.state.tokenEntries) {
+      extractPriceIds(entry.priceId).forEach((id) => allPriceIds.add(id))
+    }
+
+    for (const position of this.state.strategyPositions) {
+      if ("orderbook" in position) {
+        const orderbook = position.orderbook[0]
+        extractPriceIds(orderbook.priceIdPt).forEach((id) => allPriceIds.add(id))
+        continue
+      }
+
+      if ("tokenAccount" in position) {
+        for (const balance of position.tokenAccount[0].balances) {
+          extractPriceIds(balance.priceId).forEach((id) => allPriceIds.add(id))
+        }
+        continue
+      }
+
+      if ("obligation" in position) {
+        const inner = position.obligation[0]
+        const kaminoEntry =
+          inner && typeof inner === "object" && "kaminoObligation" in inner ? inner.kaminoObligation?.[0] : inner?.[0]
+        if (kaminoEntry?.quotePriceId) {
+          extractPriceIds(kaminoEntry.quotePriceId).forEach((id: number) => allPriceIds.add(id))
+        }
+        for (const mapping of kaminoEntry?.reservePriceMappings ?? []) {
+          if (mapping.reservePriceId) {
+            extractPriceIds(mapping.reservePriceId).forEach((id: number) => allPriceIds.add(id))
+          }
+        }
+      }
+    }
+
+    return Promise.all(
+      [...allPriceIds].map((priceId) => {
+        const priceEntry = pricesAccount.prices[priceId]
+
+        if (!priceEntry) {
+          throw new Error(`Price entry not found for priceId ${priceId}`)
+        }
+
+        return this.ixUpdatePrice({
+          priceInterfaceAccounts: priceEntry.priceInterfaceAccounts,
+          remainingAccounts: priceEntry.interfaceAccounts,
+          priceId,
+        })
+      }),
+    )
+  }
+
+  // ==========================================================================
+  // Helper Methods — Codama type conversions
+  // ==========================================================================
+
+  /**
+   * Converts vault `PolicyConfig` (policyType shape from policy builders) to the Codama/client codec shape
+   * required by the proposal action codecs used by staged proposal creation.
+   */
+  public toCodamaPolicyConfig(config: PolicyConfig): exponentVaults.PolicyConfig {
+    return {
+      payload: this.toCodamaPolicyPayload(config.policyType),
+      threshold: config.threshold,
+      timeLock: config.timeLock,
+      startTimestamp: config.startTimestamp,
+      expiration: config.expiration ? this.toCodamaPolicyExpiration(config.expiration) : null,
+    }
+  }
+
+  private toCodamaPolicyPayload(policyType: PolicyType): exponentVaults.PolicyCreationPayload {
+    if ("programInteraction" in policyType) {
+      const pi = policyType.programInteraction
+      // Post-hook for interaction validation (matches initialize_vault.rs).
+      // num_extra_accounts: 7 (vault, exponent_prices, mint_lp, payer,
+      // system_program, instructions_sysvar, squads_policy).
+      // program_id is separate, so total = 8 accounts.
+      const validateInteractionPostHook = {
+        numExtraAccounts: 7,
+        accountConstraints: [],
+        instructionData: new Uint8Array([21]), // validate_interaction_hook discriminator
+        programId: this.programId,
+        passInnerInstructions: true,
+      }
+      const payload: exponentVaults.ProgramInteractionPolicyCreationPayload = {
+        accountIndex: pi.accountIndex,
+        instructionsConstraints: pi.instructionsConstraints.map((ic) => ({
+          programId: ic.programId,
+          accountConstraints: ic.accountConstraints.map((ac) => ({
+            accountIndex: ac.accountIndex,
+            accountConstraint:
+              ac.accountDataConstraints && ac.accountDataConstraints.length > 0
+                ? {
+                    __kind: "AccountData" as const,
+                    fields: [ac.accountDataConstraints.map((dc) => this.toCodamaDataConstraint(dc))],
+                  }
+                : { __kind: "Pubkey" as const, fields: [ac.accountKeys ?? []] },
+            owner: ac.owner ?? null,
+          })),
+          dataConstraints: ic.dataConstraints.map((dc) => this.toCodamaDataConstraint(dc)),
+        })),
+        preHook: null,
+        postHook: validateInteractionPostHook,
+        spendingLimits: pi.spendingLimits.map((sl) => ({
+          mint: sl.mint,
+          timeConstraints: {
+            start: sl.timeConstraints.start,
+            expiration: sl.timeConstraints.expiration,
+            period: this.toCodamaPeriod(sl.timeConstraints.period),
+          },
+          quantityConstraints: { maxPerPeriod: sl.quantityConstraints.maxPerPeriod },
+        })),
+      }
+      return { __kind: "ProgramInteraction", fields: [payload] }
+    }
+    if ("internalFundTransfer" in policyType) {
+      const ift = policyType.internalFundTransfer
+      const payload: exponentVaults.InternalFundTransferPolicyCreationPayload = {
+        sourceAccountIndices: new Uint8Array(ift.sourceAccountMask),
+        destinationAccountIndices: new Uint8Array(ift.destinationAccountMask),
+        allowedMints: ift.allowedMints,
+      }
+      return { __kind: "InternalFundTransfer", fields: [payload] }
+    }
+    if ("settingsChange" in policyType) {
+      const sc = policyType.settingsChange
+      const payload: exponentVaults.SettingsChangePolicyCreationPayload = {
+        actions: sc.allowedActions.map((a) => this.toCodamaAllowedSettingsChange(a)),
+      }
+      return { __kind: "SettingsChange", fields: [payload] }
+    }
+    if ("spendingLimit" in policyType) {
+      const spl = policyType.spendingLimit
+      const payload: exponentVaults.SpendingLimitPolicyCreationPayload = {
+        mint: spl.spendingLimit.mint,
+        sourceAccountIndex: spl.sourceAccountIndex,
+        timeConstraints: {
+          start: spl.spendingLimit.timeConstraints.start,
+          expiration: spl.spendingLimit.timeConstraints.expiration,
+          period: this.toCodamaPeriod(spl.spendingLimit.timeConstraints.period),
+          accumulateUnused: false,
+        },
+        quantityConstraints: {
+          maxPerPeriod: spl.spendingLimit.quantityConstraints.maxPerPeriod,
+          maxPerUse: 0n,
+          enforceExactQuantity: false,
+        },
+        usageState: null,
+        destinations: spl.destinations,
+      }
+      return { __kind: "SpendingLimit", fields: [payload] }
+    }
+    throw new Error("Unsupported policy type for Codama migration")
+  }
+
+  private toCodamaDataConstraint(constraint: DataConstraint): exponentVaults.DataConstraint {
+    return {
+      dataOffset: constraint.dataOffset,
+      dataValue: this.toCodamaDataValue(constraint.dataValue),
+      operator: this.toCodamaDataOperator(constraint.operator),
+    }
+  }
+
+  private toCodamaDataValue(value: DataValue): exponentVaults.DataValue {
+    if ("u8" in value) return { __kind: "U8", fields: [value.u8] }
+    if ("u16Le" in value) return { __kind: "U16Le", fields: [value.u16Le] }
+    if ("u32Le" in value) return { __kind: "U32Le", fields: [value.u32Le] }
+    if ("u64Le" in value) return { __kind: "U64Le", fields: [value.u64Le] }
+    if ("u128Le" in value) return { __kind: "U128Le", fields: [value.u128Le] }
+    if ("u8Slice" in value) return { __kind: "U8Slice", fields: [new Uint8Array(value.u8Slice)] }
+    throw new Error("Unknown data value type")
+  }
+
+  private toCodamaDataOperator(op: DataOperator): exponentVaults.DataOperator {
+    const map: Record<DataOperator, exponentVaults.DataOperator> = {
+      Equals: exponentVaults.DataOperator.Equals,
+      NotEquals: exponentVaults.DataOperator.NotEquals,
+      GreaterThan: exponentVaults.DataOperator.GreaterThan,
+      GreaterThanOrEqualTo: exponentVaults.DataOperator.GreaterThanOrEqualTo,
+      LessThan: exponentVaults.DataOperator.LessThan,
+      LessThanOrEqualTo: exponentVaults.DataOperator.LessThanOrEqualTo,
+    }
+    return map[op]
+  }
+
+  private toCodamaPeriod(period: Period): exponentVaults.PeriodV2 {
+    const map: Record<string, exponentVaults.PeriodV2> = {
+      OneTime: { __kind: "OneTime" },
+      Daily: { __kind: "Daily" },
+      Weekly: { __kind: "Weekly" },
+      Monthly: { __kind: "Monthly" },
+    }
+    const result = map[period]
+    if (!result) throw new Error(`Unsupported period: ${period}`)
+    return result
+  }
+
+  private toCodamaPolicyExpiration(expiration: PolicyExpiration): exponentVaults.PolicyExpirationArgs {
+    if ("timestamp" in expiration) return { __kind: "Timestamp", fields: [expiration.timestamp] }
+    if ("settingsState" in expiration) return { __kind: "SettingsState" }
+    throw new Error("Unknown expiration type")
+  }
+
+  private toCodamaAllowedSettingsChange(change: AllowedSettingsChange): exponentVaults.AllowedSettingsChange {
+    switch (change) {
+      case "AddSigner":
+        return { __kind: "AddSigner", newSigner: null, newSignerPermissions: null }
+      case "RemoveSigner":
+        return { __kind: "RemoveSigner", oldSigner: null }
+      case "ChangeThreshold":
+        return { __kind: "ChangeThreshold" }
+      case "ChangeTimeLock":
+        return { __kind: "ChangeTimeLock", newTimeLock: null }
+      default:
+        throw new Error(`Unsupported settings change: ${change}`)
+    }
+  }
+}