@exponent-labs/exponent-sdk 0.9.1 → 0.9.3

package/src/exponentVaults/vault.ts

@@ -1,2667 +0,0 @@
-// 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,
-  OrderbookEntry,
-  PriceId,
-  TokenAccountEntry,
-  TokenEntry,
-} 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, uniqueRemainingAccounts } from "../utils"
-import { AumCalculator } from "./aumCalculator"
-import { deserializeExponentStrategyVaultFetcherShape, ExponentVaultsFetcher } from "./fetcher"
-import { getKaminoFarmScopePricesAddress, decodeKaminoFarmState } from "./kamino-farms"
-import { extractPriceIds } from "./pricePathResolver"
-import { SquadsVaultTxnResolver } from "./squadsVaultTxnResolver"
-import { getKaminoFarmsObligationFarm } from "./../../../kamino-lend-standard/src/constants"
-
-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
-const LOCAL_UPDATE_PRICE_DISCRIMINATOR = Buffer.from([7])
-const KAMINO_FARMS_PROGRAM_ID = new PublicKey("FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr")
-
-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
-}
-
-function unwrapTupleLikeValue(value: unknown): unknown {
-  if (Array.isArray(value)) {
-    return value[0]
-  }
-  if (value && typeof value === "object" && "0" in value) {
-    return (value as { 0?: unknown })[0]
-  }
-  return value ?? undefined
-}
-
-function addTrackedPriceIds(target: Set<number>, priceIdValue: unknown) {
-  for (const id of extractPriceIds(priceIdValue)) {
-    const numericId = Number(id)
-    if (numericId !== 0) {
-      target.add(numericId)
-    }
-  }
-}
-
-export function collectTrackedStrategyVaultPriceIds(state: {
-  tokenEntries: Array<{ priceId: unknown }>
-  strategyPositions: Array<Record<string, unknown>>
-}): Set<number> {
-  const allPriceIds = new Set<number>()
-
-  for (const entry of state.tokenEntries) {
-    addTrackedPriceIds(allPriceIds, entry.priceId)
-  }
-
-  for (const position of state.strategyPositions) {
-    if ("orderbook" in position) {
-      const orderbook = unwrapTupleLikeValue(position.orderbook) as { priceIdPt?: unknown } | undefined
-      if (orderbook?.priceIdPt) {
-        addTrackedPriceIds(allPriceIds, orderbook.priceIdPt)
-      }
-      continue
-    }
-
-    if ("tokenAccount" in position) {
-      const tokenAccount = unwrapTupleLikeValue(position.tokenAccount) as {
-        balances?: Array<{ priceId?: unknown }>
-      } | undefined
-      for (const balance of tokenAccount?.balances ?? []) {
-        if (balance.priceId) {
-          addTrackedPriceIds(allPriceIds, balance.priceId)
-        }
-      }
-      continue
-    }
-
-    if ("yieldPosition" in position) {
-      const yieldPosition = unwrapTupleLikeValue(position.yieldPosition) as { priceIdPt?: unknown } | undefined
-      if (yieldPosition?.priceIdPt) {
-        addTrackedPriceIds(allPriceIds, yieldPosition.priceIdPt)
-      }
-      continue
-    }
-
-    if ("clmmPosition" in position) {
-      const clmmPosition = unwrapTupleLikeValue(position.clmmPosition) as {
-        priceIdPt?: unknown
-        priceIdSy?: unknown
-      } | undefined
-      if (clmmPosition?.priceIdPt) {
-        addTrackedPriceIds(allPriceIds, clmmPosition.priceIdPt)
-      }
-      if (clmmPosition?.priceIdSy) {
-        addTrackedPriceIds(allPriceIds, clmmPosition.priceIdSy)
-      }
-      continue
-    }
-
-    if ("obligation" in position) {
-      const rawObligation = position.obligation as Record<string, unknown> | Array<unknown>
-      const inner = unwrapTupleLikeValue(rawObligation as unknown[] | { 0?: unknown })
-      const kaminoVariant =
-        inner && typeof inner === "object" && "kaminoObligation" in inner
-          ? (inner as { kaminoObligation?: unknown }).kaminoObligation
-          : inner
-      const kaminoEntry = unwrapTupleLikeValue(kaminoVariant) as {
-        quotePriceId?: unknown
-        reservePriceMappings?: Array<{ reservePriceId?: unknown }>
-      } | undefined
-      if (kaminoEntry?.quotePriceId) {
-        addTrackedPriceIds(allPriceIds, kaminoEntry.quotePriceId)
-      }
-      for (const mapping of kaminoEntry?.reservePriceMappings ?? []) {
-        if (mapping.reservePriceId) {
-          addTrackedPriceIds(allPriceIds, mapping.reservePriceId)
-        }
-      }
-    }
-  }
-
-  return allPriceIds
-}
-
-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 })
-}
-
-const isLocalRpcEndpoint = (rpcEndpoint: string): boolean => {
-  try {
-    const hostname = new URL(rpcEndpoint).hostname
-    return hostname === "127.0.0.1" || hostname === "localhost"
-  } catch {
-    return rpcEndpoint.includes("127.0.0.1") || rpcEndpoint.includes("localhost")
-  }
-}
-
-// ============================================================================
-// 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 UpdateStrategyVaultPricesOptions {
-  manager?: PublicKey
-  priceIds?: Iterable<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 interface WrapperAddKaminoObligationPositionParams {
-  manager: PublicKey
-  obligation: PublicKey
-  lendingProgramId: PublicKey
-  quotePriceId: exponentVaults.PriceId
-  reservePriceMappings: exponentVaults.ReservePriceMapping[]
-  reserveFarmMappings?: exponentVaults.ReserveFarmMapping[]
-  minPriceStatusFlags: number
-  remainingAccounts?: AccountMeta[]
-  exponentPrices?: PublicKey
-  systemProgram?: PublicKey
-}
-
-export interface WrapperUpsertKaminoObligationReservePriceMappingsParams {
-  manager: PublicKey
-  obligation: PublicKey
-  reservePriceMappings: exponentVaults.ReservePriceMapping[]
-  reserveFarmMappings?: exponentVaults.ReserveFarmMapping[]
-  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()
-  private kaminoFarmAuxAccountsMap: Map<string, AccountMeta[]> = new Map()
-  private kaminoObligationFarmUserStates: Set<string> = new Set()
-  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 Promise.all([
-      vault.populateClmmTicksCache(params.connection),
-      vault.populateKaminoFarmAuxAccountsCache(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.flatMap((vault) => [
-        vault.populateClmmTicksCache(params.connection),
-        vault.populateKaminoFarmAuxAccountsCache(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.kaminoFarmAuxAccountsMap = refreshed.kaminoFarmAuxAccountsMap
-    this.kaminoObligationFarmUserStates = refreshed.kaminoObligationFarmUserStates
-    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)
-      }
-    }
-  }
-
-  private async populateKaminoFarmAuxAccountsCache(connection: Connection): Promise<void> {
-    this.kaminoFarmAuxAccountsMap.clear()
-    this.kaminoObligationFarmUserStates.clear()
-
-    const farmStates: PublicKey[] = []
-    const delegatedFarmUsers: Array<{ obligation: PublicKey; farmState: PublicKey; userState: PublicKey }> = []
-    for (const pos of this.state.strategyPositions) {
-      if ("kaminoFarm" in pos && pos.kaminoFarm && typeof pos.kaminoFarm === "object") {
-        const entry = (pos as { kaminoFarm: { 0: { farmState: PublicKey } } }).kaminoFarm[0]
-        if (!farmStates.some((farmState) => farmState.equals(entry.farmState))) {
-          farmStates.push(entry.farmState)
-        }
-        continue
-      }
-
-      if (!("obligation" in pos) || !pos.obligation || typeof pos.obligation !== "object") {
-        continue
-      }
-
-      const rawObligation = pos["obligation"] as Record<string, unknown> | Array<unknown>
-      const inner = Array.isArray(rawObligation)
-        ? (rawObligation[0] as Record<string, unknown> | undefined)
-        : rawObligation && typeof rawObligation === "object" && "0" in rawObligation
-          ? (rawObligation[0] as Record<string, unknown> | undefined)
-          : (rawObligation 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
-                reserveFarmMappings?: Array<{ farmState: PublicKey }>
-              }
-            | undefined)
-        : kaminoVariant && typeof kaminoVariant === "object" && "0" in (kaminoVariant as Record<string, unknown>)
-          ? ((
-              kaminoVariant as {
-                0?: {
-                  obligation?: PublicKey
-                  reserveFarmMappings?: Array<{ farmState: PublicKey }>
-                }
-              }
-            )[0] ?? undefined)
-          : (kaminoVariant as
-              | {
-                  obligation?: PublicKey
-                  reserveFarmMappings?: Array<{ farmState: PublicKey }>
-                }
-              | undefined)
-      if (!(entry?.obligation instanceof PublicKey)) {
-        continue
-      }
-
-      for (const mapping of entry.reserveFarmMappings ?? []) {
-        if (!farmStates.some((farmState) => farmState.equals(mapping.farmState))) {
-          farmStates.push(mapping.farmState)
-        }
-        delegatedFarmUsers.push({
-          obligation: entry.obligation,
-          farmState: mapping.farmState,
-          userState: getKaminoFarmsObligationFarm(entry.obligation, mapping.farmState, KAMINO_FARMS_PROGRAM_ID),
-        })
-      }
-    }
-
-    if (farmStates.length === 0) {
-      return
-    }
-
-    const farmInfos = await connection.getMultipleAccountsInfo(farmStates)
-    for (const [index, farmInfo] of farmInfos.entries()) {
-      const farmState = farmStates[index]
-      if (!farmState || !farmInfo?.data) {
-        if (ExponentVault.debugAum && farmState) {
-          console.log("[VAULT_AUM] kaminoFarmAux: missing farm info", farmState.toBase58())
-        }
-        continue
-      }
-
-      const farm = decodeKaminoFarmState(Buffer.from(farmInfo.data))
-      const auxAccounts: AccountMeta[] = [{ pubkey: farm.globalConfig, isSigner: false, isWritable: false }]
-      const scopePrices = getKaminoFarmScopePricesAddress(farm)
-      if (scopePrices) {
-        auxAccounts.push({ pubkey: scopePrices, isSigner: false, isWritable: false })
-      }
-
-      this.kaminoFarmAuxAccountsMap.set(farmState.toBase58(), auxAccounts)
-      if (ExponentVault.debugAum) {
-        console.log(
-          "[VAULT_AUM] kaminoFarmAux:",
-          farmState.toBase58(),
-          auxAccounts.map((account) => account.pubkey.toBase58()).join(", "),
-        )
-      }
-    }
-
-    if (delegatedFarmUsers.length === 0) {
-      return
-    }
-
-    const uniqueUsers = Array.from(
-      new Map(
-        delegatedFarmUsers.map((entry) => [
-          `${entry.obligation.toBase58()}:${entry.farmState.toBase58()}`,
-          entry,
-        ]),
-      ).values(),
-    )
-    const userInfos = await connection.getMultipleAccountsInfo(uniqueUsers.map((entry) => entry.userState))
-    for (const [index, userInfo] of userInfos.entries()) {
-      if (!userInfo?.data) {
-        continue
-      }
-
-      const entry = uniqueUsers[index]
-      if (!entry) {
-        continue
-      }
-
-      this.kaminoObligationFarmUserStates.add(`${entry.obligation.toBase58()}:${entry.farmState.toBase58()}`)
-    }
-  }
-
-  /**
-   * 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 rawObligation = pos["obligation"] as Record<string, unknown> | Array<unknown>
-        const inner = Array.isArray(rawObligation)
-          ? (rawObligation[0] as Record<string, unknown> | undefined)
-          : rawObligation && typeof rawObligation === "object" && "0" in rawObligation
-            ? (rawObligation[0] as Record<string, unknown> | undefined)
-            : (rawObligation 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 }>
-                  reserveFarmMappings?: Array<{ farmState: PublicKey }>
-                }
-              | undefined)
-          : kaminoVariant && typeof kaminoVariant === "object" && "0" in (kaminoVariant as Record<string, unknown>)
-            ? ((
-                kaminoVariant as {
-                  0?: {
-                    obligation?: PublicKey
-                    reservePriceMappings?: Array<{ reserve: PublicKey }>
-                    reserveFarmMappings?: Array<{ farmState: PublicKey }>
-                  }
-                }
-              )[0] ?? undefined)
-            : (kaminoVariant as
-                | {
-                    obligation?: PublicKey
-                    reservePriceMappings?: Array<{ reserve: PublicKey }>
-                    reserveFarmMappings?: Array<{ farmState: 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,
-            })
-          }
-          for (const mapping of entry.reserveFarmMappings ?? []) {
-            metas.push({
-              pubkey: mapping.farmState,
-              isSigner: false,
-              isWritable: false,
-            })
-            const obligationFarmUserKey = `${entry.obligation.toBase58()}:${mapping.farmState.toBase58()}`
-            if (this.kaminoObligationFarmUserStates.has(obligationFarmUserKey)) {
-              metas.push({
-                pubkey: getKaminoFarmsObligationFarm(entry.obligation, mapping.farmState, KAMINO_FARMS_PROGRAM_ID),
-                isSigner: false,
-                isWritable: false,
-              })
-            }
-            metas.push(...(this.kaminoFarmAuxAccountsMap.get(mapping.farmState.toBase58()) ?? []))
-          }
-          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())
-            }
-            for (const mapping of entry.reserveFarmMappings ?? []) {
-              console.log("[VAULT_AUM] strategyPosition: Kamino delegated farm", mapping.farmState.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 ("kaminoFarm" in pos && pos.kaminoFarm && typeof pos.kaminoFarm === "object") {
-        const entry = (pos as { kaminoFarm: { 0: { farmState: PublicKey; userState: PublicKey } } }).kaminoFarm[0]
-        metas.push({
-          pubkey: entry.farmState,
-          isSigner: false,
-          isWritable: false,
-        })
-        metas.push({
-          pubkey: entry.userState,
-          isSigner: false,
-          isWritable: false,
-        })
-        const auxAccounts = this.kaminoFarmAuxAccountsMap.get(entry.farmState.toBase58()) ?? []
-        metas.push(...auxAccounts)
-        if (ExponentVault.debugAum) {
-          console.log(
-            "[VAULT_AUM] strategyPosition: KaminoFarm",
-            entry.farmState.toBase58(),
-            entry.userState.toBase58(),
-          )
-          console.log(
-            "[VAULT_AUM] strategyPosition: KaminoFarm aux",
-            auxAccounts.map((account) => account.pubkey.toBase58()).join(", ") || "(none)",
-          )
-        }
-      } 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()]
-  }
-
-  /**
-   * Returns the readonly account metas required to recalculate the vault's current tracked AUM.
-   * Extra metas can be appended for pending positions or newly introduced Kamino reserves.
-   */
-  getAumRemainingAccountMetas(extraRemainingAccounts: AccountMeta[] = []): AccountMeta[] {
-    return uniqueRemainingAccounts([...this.aumRemainingAccounts(), ...extraRemainingAccounts])
-  }
-
-  private ixManagePriceUpdates({
-    manager,
-    updates,
-  }: {
-    manager?: PublicKey
-    updates: Array<{
-      priceId: number
-      priceType: exponentVaults.PriceType
-      priceInterfaceAccounts?: PublicKey
-    }>
-  }): TransactionInstruction {
-    if (updates.length === 0) {
-      throw new Error("ixManagePriceUpdates requires at least one update")
-    }
-
-    const resolvedManager = manager ?? this.state.roles.manager[0]
-    if (!resolvedManager) {
-      throw new Error("Vault manager not found")
-    }
-
-    const [exponentPrices] = this.pda.exponentPrices()
-    const remainingAccounts: AccountMeta[] = []
-    const actions: exponentVaults.UpdatePriceAction[] = updates.map((update) => {
-      if (!update.priceInterfaceAccounts) {
-        throw new Error(`priceInterfaceAccounts required for priceId ${update.priceId}`)
-      }
-
-      remainingAccounts.push({ pubkey: update.priceInterfaceAccounts, isSigner: false, isWritable: false })
-
-      return {
-        __kind: "UpdatePrice",
-        priceId: BigInt(update.priceId),
-        priceType: update.priceType,
-      }
-    })
-
-    const ix = exponentVaults.createManagePricesInstruction(
-      { manager: resolvedManager, exponentPrices, systemProgram: SystemProgram.programId },
-      { actions },
-      this.programId,
-    )
-    ix.keys.push(...remainingAccounts)
-    return ix
-  }
-
-  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 }] },
-      this.programId,
-    )
-    ix.keys.push(...updateRemainingAccounts)
-    if (isLocalRpcEndpoint(this.connection.rpcEndpoint)) {
-      ix.data = Buffer.concat([LOCAL_UPDATE_PRICE_DISCRIMINATOR, ix.data.subarray(1)])
-    }
-    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 tokenProgramLp = useLegacyTokenAccounts ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID
-
-    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,
-        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
-  }
-
-  /**
-   * Convenience wrapper for adding a tracked Kamino obligation position.
-   */
-  ixWrapperAddKaminoObligationPosition({
-    manager,
-    obligation,
-    lendingProgramId,
-    quotePriceId,
-    reservePriceMappings,
-    reserveFarmMappings = [],
-    minPriceStatusFlags,
-    remainingAccounts = [],
-    exponentPrices = this.pda.exponentPrices()[0],
-    systemProgram = SystemProgram.programId,
-  }: WrapperAddKaminoObligationPositionParams): TransactionInstruction {
-    const obligationEntry: exponentVaults.KaminoObligationEntry = {
-      obligation,
-      lendingProgramId,
-      quotePriceId,
-      reservePriceMappings,
-      reserveFarmMappings,
-      minPriceStatusFlags,
-    }
-
-    return this.ixWrapperManagerUpdatePosition({
-      manager,
-      exponentPrices,
-      systemProgram,
-      remainingAccounts: this.getAumRemainingAccountMetas(remainingAccounts),
-      update: exponentVaults.positionUpdate("AddKaminoObligationEntry", [
-        obligationEntry,
-      ] as [exponentVaults.KaminoObligationEntry]),
-    })
-  }
-
-  /**
-   * Convenience wrapper for updating tracked reserve price mappings on a Kamino obligation.
-   */
-  ixWrapperUpsertKaminoObligationReservePriceMappings({
-    manager,
-    obligation,
-    reservePriceMappings,
-    reserveFarmMappings = [],
-    remainingAccounts = [],
-    exponentPrices = this.pda.exponentPrices()[0],
-    systemProgram = SystemProgram.programId,
-  }: WrapperUpsertKaminoObligationReservePriceMappingsParams): TransactionInstruction {
-    return this.ixWrapperManagerUpdatePosition({
-      manager,
-      exponentPrices,
-      systemProgram,
-      remainingAccounts: this.getAumRemainingAccountMetas(remainingAccounts),
-      update: exponentVaults.positionUpdate("UpsertKaminoObligationReservePriceMappings", {
-        obligation,
-        reservePriceMappings,
-        reserveFarmMappings,
-      }),
-    })
-  }
-
-  // ==========================================================================
-  // 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 vaultStateAfterSimulations = deserializeExponentStrategyVaultFetcherShape(
-        Buffer.from(postVaultAccountData, "base64"),
-      ) 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,
-    options: UpdateStrategyVaultPricesOptions = {},
-  ): Promise<TransactionInstruction[]> {
-    const trackedPriceIds =
-      options.priceIds ??
-      collectTrackedStrategyVaultPriceIds({
-        tokenEntries: this.state.tokenEntries,
-        strategyPositions: this.state.strategyPositions,
-      })
-
-    const priceIds = [...trackedPriceIds].sort((a, b) => a - b)
-    if (priceIds.length === 0) {
-      return []
-    }
-
-    return priceIds.map((priceId) => {
-      const priceEntry = pricesAccount.prices[priceId]
-
-      if (!priceEntry) {
-        throw new Error(`Price entry not found for priceId ${priceId}`)
-      }
-
-      return this.ixUpdatePrice({
-        priceId,
-        priceInterfaceAccounts: priceEntry.priceInterfaceAccounts,
-        remainingAccounts: priceEntry.interfaceAccounts,
-      })
-    })
-  }
-
-  // ==========================================================================
-  // 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}`)
-    }
-  }
-}