@exponent-labs/exponent-sdk 0.9.2 → 0.9.3

package/src/exponentVaults/policyBuilders.ts

@@ -1,1729 +0,0 @@
-import { PublicKey } from "@solana/web3.js"
-
-import { AccountConstraint, DataConstraint, InstructionConstraint, PolicyConfig, SpendingLimit } from "./vault"
-
-// ============================================================================
-// Known Program IDs
-// ============================================================================
-
-export const KAMINO_LENDING_PROGRAM_ID = new PublicKey("KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD")
-export const KAMINO_VAULT_PROGRAM_ID = new PublicKey("KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd")
-export const KAMINO_FARMS_PROGRAM_ID = new PublicKey("FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr")
-
-// ============================================================================
-// Instruction Discriminators (first 8 bytes of sha256("global:<method_name>"))
-// ============================================================================
-
-/**
- * Common Kamino Lending instruction discriminators.
- * These can be used for data constraints to match specific instructions.
- */
-export const KAMINO_DISCRIMINATORS = {
-  initUserMetadata: Buffer.from([117, 169, 176, 69, 197, 23, 15, 162]),
-  depositReserveLiquidity: Buffer.from([171, 234, 45, 51, 25, 117, 180, 182]),
-  depositReserveLiquidityAndObligationCollateral: Buffer.from([129, 199, 4, 2, 222, 39, 26, 46]),
-  depositReserveLiquidityAndObligationCollateralV2: Buffer.from([216, 224, 191, 27, 204, 151, 102, 175]),
-  withdrawObligationCollateralAndRedeemReserveCollateral: Buffer.from([75, 93, 93, 220, 34, 150, 218, 196]),
-  withdrawObligationCollateralAndRedeemReserveCollateralV2: Buffer.from([235, 52, 119, 152, 149, 197, 20, 7]),
-  borrowObligationLiquidity: Buffer.from([121, 127, 18, 204, 73, 245, 225, 65]),
-  borrowObligationLiquidityV2: Buffer.from([161, 128, 143, 245, 171, 199, 194, 6]),
-  repayObligationLiquidity: Buffer.from([145, 178, 13, 225, 76, 240, 147, 72]),
-  repayObligationLiquidityV2: Buffer.from([116, 174, 213, 76, 180, 53, 210, 144]),
-  initObligation: Buffer.from([251, 10, 231, 76, 27, 11, 159, 96]),
-  initObligationFarmsForReserve: Buffer.from([1, 152, 226, 239, 191, 47, 250, 194]),
-  refreshReserve: Buffer.from([2, 218, 138, 235, 79, 201, 25, 102]),
-  refreshObligation: Buffer.from([33, 132, 147, 228, 151, 192, 72, 89]),
-}
-
-export const KAMINO_VAULT_DISCRIMINATORS = {
-  deposit: Buffer.from([242, 35, 198, 137, 82, 225, 242, 182]),
-  withdraw: Buffer.from([183, 18, 70, 156, 148, 109, 161, 34]),
-}
-
-export const KAMINO_FARM_DISCRIMINATORS = {
-  initializeUser: Buffer.from([111, 17, 185, 250, 60, 122, 38, 254]),
-  stake: Buffer.from([206, 176, 202, 18, 200, 209, 179, 108]),
-  unstake: Buffer.from([90, 95, 107, 42, 205, 124, 50, 225]),
-  withdrawUnstakedDeposits: Buffer.from([36, 102, 187, 49, 220, 36, 132, 67]),
-  harvestReward: Buffer.from([68, 200, 228, 233, 184, 32, 226, 188]),
-}
-
-// ============================================================================
-// Policy Builder Functions
-// ============================================================================
-
-/**
- * Creates a basic ProgramInteraction policy configuration.
- */
-export function createProgramInteractionPolicy(params: {
-  /** Index of the vault account that will sign (typically 0) */
-  accountIndex?: number
-  /** Instruction constraints (which programs/instructions are allowed) */
-  instructionsConstraints: InstructionConstraint[]
-  /** Spending limits (optional) */
-  spendingLimits?: SpendingLimit[]
-  /** Threshold (number of signers required, typically 1) */
-  threshold?: number
-  /** Time lock in seconds (typically 0 for instant execution) */
-  timeLock?: number
-}): PolicyConfig {
-  return {
-    policyType: {
-      programInteraction: {
-        accountIndex: params.accountIndex ?? 0,
-        instructionsConstraints: params.instructionsConstraints,
-        spendingLimits: params.spendingLimits ?? [],
-      },
-    },
-    threshold: params.threshold ?? 1,
-    timeLock: params.timeLock ?? 0,
-    startTimestamp: null,
-    expiration: null,
-  }
-}
-
-/**
- * Creates an instruction constraint for a specific program.
- */
-export function createInstructionConstraint(params: {
-  programId: PublicKey
-  accountConstraints?: AccountConstraint[]
-  dataConstraints?: DataConstraint[]
-}): InstructionConstraint {
-  return {
-    programId: params.programId,
-    accountConstraints: params.accountConstraints ?? [],
-    dataConstraints: params.dataConstraints ?? [],
-  }
-}
-
-/**
- * Creates an account constraint for a specific account index.
- */
-export function createAccountConstraint(accountIndex: number, allowedKeys: PublicKey[]): AccountConstraint {
-  return {
-    accountIndex,
-    accountKeys: allowedKeys,
-  }
-}
-
-/**
- * Creates an account-data constraint for a specific account index.
- */
-export function createAccountDataConstraint(accountIndex: number, accountDataConstraints: DataConstraint[]): AccountConstraint {
-  return {
-    accountIndex,
-    accountDataConstraints,
-  }
-}
-
-/**
- * Creates a data constraint to match instruction discriminator (first 8 bytes).
- */
-export function createDiscriminatorConstraint(discriminator: Buffer | number[]): DataConstraint {
-  return {
-    dataOffset: 0n,
-    dataValue: { u8Slice: Array.from(discriminator) },
-    operator: "Equals",
-  }
-}
-
-// ============================================================================
-// Kamino Lending Policy Builders
-// ============================================================================
-
-/**
- * Account indices in Kamino Lending instructions
- */
-export const KAMINO_ACCOUNT_INDICES = {
-  initObligation: {
-    owner: 0,
-    feePayer: 1,
-    obligation: 2,
-    lendingMarket: 3,
-    seed1Account: 4,
-    seed2Account: 5,
-    ownerUserMetadata: 6,
-    rent: 7,
-    systemProgram: 8,
-  },
-  // depositReserveLiquidityAndObligationCollateral
-  depositCollateral: {
-    owner: 0,
-    obligation: 1,
-    lendingMarket: 2,
-    lendingMarketAuthority: 3,
-    reserve: 4,
-    reserveLiquidityMint: 5,
-    reserveLiquiditySupply: 6,
-    reserveCollateralMint: 7,
-    reserveDestinationDepositCollateral: 8,
-    obligationCollateralTokenAccount: 9,
-    userSourceLiquidity: 10,
-    placeholderUserDestinationCollateral: 11,
-    collateralTokenProgram: 12,
-    liquidityTokenProgram: 13,
-    instructionSysvarAccount: 14,
-  },
-  // withdrawObligationCollateralAndRedeemReserveCollateral
-  withdrawCollateral: {
-    owner: 0,
-    obligation: 1,
-    lendingMarket: 2,
-    lendingMarketAuthority: 3,
-    withdrawReserve: 4,
-    reserveLiquidityMint: 5,
-    reserveSourceCollateral: 6,
-    reserveCollateralMint: 7,
-    reserveLiquiditySupply: 8,
-    userDestinationLiquidity: 9,
-    placeholderUserDestinationCollateral: 10,
-    obligationCollateralTokenAccount: 11,
-    collateralTokenProgram: 12,
-    liquidityTokenProgram: 13,
-    instructionSysvarAccount: 14,
-  },
-  // borrowObligationLiquidity
-  borrow: {
-    owner: 0,
-    obligation: 1,
-    lendingMarket: 2,
-    lendingMarketAuthority: 3,
-    borrowReserve: 4,
-    borrowReserveLiquidityMint: 5,
-    reserveSourceLiquidity: 6,
-    borrowReserveLiquidityFeeReceiver: 7,
-    userDestinationLiquidity: 8,
-    referrerTokenState: 9,
-    liquidityTokenProgram: 10,
-    instructionSysvarAccount: 11,
-  },
-  // repayObligationLiquidity
-  repay: {
-    owner: 0,
-    obligation: 1,
-    lendingMarket: 2,
-    repayReserve: 3,
-    reserveLiquidityMint: 4,
-    reserveDestinationLiquidity: 5,
-    userSourceLiquidity: 6,
-    liquidityTokenProgram: 7,
-    instructionSysvarAccount: 8,
-  },
-}
-
-/**
- * Creates a policy that allows Kamino account initialization for specific lending markets.
- */
-export function createKaminoInitPolicy(params: {
-  /** Optional: allowed lending markets for init_obligation */
-  allowedLendingMarkets?: PublicKey[]
-  /** Threshold (default 1) */
-  threshold?: number
-  /** Time lock in seconds (default 0) */
-  timeLock?: number
-} = {}): PolicyConfig {
-  const initObligationAccountConstraints: AccountConstraint[] = []
-
-  if (params.allowedLendingMarkets && params.allowedLendingMarkets.length > 0) {
-    initObligationAccountConstraints.push(
-      createAccountConstraint(KAMINO_ACCOUNT_INDICES.initObligation.lendingMarket, params.allowedLendingMarkets),
-    )
-  }
-
-  return createProgramInteractionPolicy({
-    threshold: params.threshold,
-    timeLock: params.timeLock,
-    instructionsConstraints: [
-      createInstructionConstraint({
-        programId: KAMINO_LENDING_PROGRAM_ID,
-        dataConstraints: [createDiscriminatorConstraint(KAMINO_DISCRIMINATORS.initUserMetadata)],
-      }),
-      createInstructionConstraint({
-        programId: KAMINO_LENDING_PROGRAM_ID,
-        accountConstraints: initObligationAccountConstraints,
-        dataConstraints: [createDiscriminatorConstraint(KAMINO_DISCRIMINATORS.initObligation)],
-      }),
-    ],
-  })
-}
-
-/**
- * Creates a policy that allows depositing into specific Kamino reserves.
- */
-export function createKaminoDepositPolicy(params: {
-  /** Allowed reserve addresses for deposits */
-  allowedReserves: PublicKey[]
-  /** Optional: allowed lending markets (if not specified, any market is allowed) */
-  allowedLendingMarkets?: PublicKey[]
-  /** Optional: spending limits */
-  spendingLimits?: SpendingLimit[]
-  /** Threshold (default 1) */
-  threshold?: number
-  /** Time lock in seconds (default 0) */
-  timeLock?: number
-}): PolicyConfig {
-  const accountConstraints: AccountConstraint[] = []
-
-  // Constrain on reserve account (index 4 in depositReserveLiquidityAndObligationCollateral)
-  if (params.allowedReserves.length > 0) {
-    accountConstraints.push(
-      createAccountConstraint(KAMINO_ACCOUNT_INDICES.depositCollateral.reserve, params.allowedReserves),
-    )
-  }
-
-  // Optionally constrain on lending market
-  if (params.allowedLendingMarkets && params.allowedLendingMarkets.length > 0) {
-    accountConstraints.push(
-      createAccountConstraint(KAMINO_ACCOUNT_INDICES.depositCollateral.lendingMarket, params.allowedLendingMarkets),
-    )
-  }
-
-  const instructionConstraint = createInstructionConstraint({
-    programId: KAMINO_LENDING_PROGRAM_ID,
-    accountConstraints,
-    // Match the deposit instruction discriminator
-    dataConstraints: [
-      createDiscriminatorConstraint(KAMINO_DISCRIMINATORS.depositReserveLiquidityAndObligationCollateralV2),
-    ],
-  })
-
-  return createProgramInteractionPolicy({
-    instructionsConstraints: [instructionConstraint],
-    spendingLimits: params.spendingLimits,
-    threshold: params.threshold,
-    timeLock: params.timeLock,
-  })
-}
-
-/**
- * Creates a policy that allows withdrawing from specific Kamino reserves.
- */
-export function createKaminoWithdrawPolicy(params: {
-  /** Allowed reserve addresses for withdrawals */
-  allowedReserves: PublicKey[]
-  /** Optional: allowed lending markets */
-  allowedLendingMarkets?: PublicKey[]
-  /** Optional: spending limits */
-  spendingLimits?: SpendingLimit[]
-  /** Threshold (default 1) */
-  threshold?: number
-  /** Time lock in seconds (default 0) */
-  timeLock?: number
-}): PolicyConfig {
-  const accountConstraints: AccountConstraint[] = []
-
-  // Constrain on withdraw reserve account (index 4)
-  if (params.allowedReserves.length > 0) {
-    accountConstraints.push(
-      createAccountConstraint(KAMINO_ACCOUNT_INDICES.withdrawCollateral.withdrawReserve, params.allowedReserves),
-    )
-  }
-
-  // Optionally constrain on lending market
-  if (params.allowedLendingMarkets && params.allowedLendingMarkets.length > 0) {
-    accountConstraints.push(
-      createAccountConstraint(KAMINO_ACCOUNT_INDICES.withdrawCollateral.lendingMarket, params.allowedLendingMarkets),
-    )
-  }
-
-  const instructionConstraint = createInstructionConstraint({
-    programId: KAMINO_LENDING_PROGRAM_ID,
-    accountConstraints,
-    dataConstraints: [
-      createDiscriminatorConstraint(KAMINO_DISCRIMINATORS.withdrawObligationCollateralAndRedeemReserveCollateralV2),
-    ],
-  })
-
-  return createProgramInteractionPolicy({
-    instructionsConstraints: [instructionConstraint],
-    spendingLimits: params.spendingLimits,
-    threshold: params.threshold,
-    timeLock: params.timeLock,
-  })
-}
-
-/**
- * Creates a policy that allows borrowing from specific Kamino reserves.
- */
-export function createKaminoBorrowPolicy(params: {
-  /** Allowed reserve addresses for borrowing */
-  allowedReserves: PublicKey[]
-  /** Optional: allowed lending markets */
-  allowedLendingMarkets?: PublicKey[]
-  /** Optional: spending limits */
-  spendingLimits?: SpendingLimit[]
-  /** Threshold (default 1) */
-  threshold?: number
-  /** Time lock in seconds (default 0) */
-  timeLock?: number
-}): PolicyConfig {
-  const accountConstraints: AccountConstraint[] = []
-
-  // Constrain on borrow reserve account (index 4)
-  if (params.allowedReserves.length > 0) {
-    accountConstraints.push(
-      createAccountConstraint(KAMINO_ACCOUNT_INDICES.borrow.borrowReserve, params.allowedReserves),
-    )
-  }
-
-  // Optionally constrain on lending market
-  if (params.allowedLendingMarkets && params.allowedLendingMarkets.length > 0) {
-    accountConstraints.push(
-      createAccountConstraint(KAMINO_ACCOUNT_INDICES.borrow.lendingMarket, params.allowedLendingMarkets),
-    )
-  }
-
-  const instructionConstraint = createInstructionConstraint({
-    programId: KAMINO_LENDING_PROGRAM_ID,
-    accountConstraints,
-    dataConstraints: [createDiscriminatorConstraint(KAMINO_DISCRIMINATORS.borrowObligationLiquidityV2)],
-  })
-
-  return createProgramInteractionPolicy({
-    instructionsConstraints: [instructionConstraint],
-    spendingLimits: params.spendingLimits,
-    threshold: params.threshold,
-    timeLock: params.timeLock,
-  })
-}
-
-/**
- * Creates a policy that allows repaying on specific Kamino reserves.
- */
-export function createKaminoRepayPolicy(params: {
-  /** Allowed reserve addresses for repaying */
-  allowedReserves: PublicKey[]
-  /** Optional: allowed lending markets */
-  allowedLendingMarkets?: PublicKey[]
-  /** Optional: spending limits */
-  spendingLimits?: SpendingLimit[]
-  /** Threshold (default 1) */
-  threshold?: number
-  /** Time lock in seconds (default 0) */
-  timeLock?: number
-}): PolicyConfig {
-  const accountConstraints: AccountConstraint[] = []
-
-  // Constrain on repay reserve account (index 3)
-  if (params.allowedReserves.length > 0) {
-    accountConstraints.push(createAccountConstraint(KAMINO_ACCOUNT_INDICES.repay.repayReserve, params.allowedReserves))
-  }
-
-  // Optionally constrain on lending market
-  if (params.allowedLendingMarkets && params.allowedLendingMarkets.length > 0) {
-    accountConstraints.push(
-      createAccountConstraint(KAMINO_ACCOUNT_INDICES.repay.lendingMarket, params.allowedLendingMarkets),
-    )
-  }
-
-  const instructionConstraint = createInstructionConstraint({
-    programId: KAMINO_LENDING_PROGRAM_ID,
-    accountConstraints,
-    dataConstraints: [createDiscriminatorConstraint(KAMINO_DISCRIMINATORS.repayObligationLiquidityV2)],
-  })
-
-  return createProgramInteractionPolicy({
-    instructionsConstraints: [instructionConstraint],
-    spendingLimits: params.spendingLimits,
-    threshold: params.threshold,
-    timeLock: params.timeLock,
-  })
-}
-
-/**
- * Creates a combined Kamino policy that allows multiple actions on the same reserves.
- */
-export function createKaminoFullAccessPolicy(params: {
-  /** Allowed reserve addresses */
-  allowedReserves: PublicKey[]
-  /** Which actions to allow */
-  allowedActions: ("deposit" | "withdraw" | "borrow" | "repay")[]
-  /** Optional: allowed lending markets */
-  allowedLendingMarkets?: PublicKey[]
-  /** Optional: spending limits */
-  spendingLimits?: SpendingLimit[]
-  /** Threshold (default 1) */
-  threshold?: number
-  /** Time lock in seconds (default 0) */
-  timeLock?: number
-}): PolicyConfig {
-  const instructionsConstraints: InstructionConstraint[] = []
-
-  for (const action of params.allowedActions) {
-    const accountConstraints: AccountConstraint[] = []
-
-    switch (action) {
-      case "deposit":
-        if (params.allowedReserves.length > 0) {
-          accountConstraints.push(
-            createAccountConstraint(KAMINO_ACCOUNT_INDICES.depositCollateral.reserve, params.allowedReserves),
-          )
-        }
-        instructionsConstraints.push(
-          createInstructionConstraint({
-            programId: KAMINO_LENDING_PROGRAM_ID,
-            accountConstraints,
-            dataConstraints: [
-              createDiscriminatorConstraint(KAMINO_DISCRIMINATORS.depositReserveLiquidityAndObligationCollateralV2),
-            ],
-          }),
-        )
-        break
-      case "withdraw":
-        if (params.allowedReserves.length > 0) {
-          accountConstraints.push(
-            createAccountConstraint(KAMINO_ACCOUNT_INDICES.withdrawCollateral.withdrawReserve, params.allowedReserves),
-          )
-        }
-        instructionsConstraints.push(
-          createInstructionConstraint({
-            programId: KAMINO_LENDING_PROGRAM_ID,
-            accountConstraints,
-            dataConstraints: [
-              createDiscriminatorConstraint(
-                KAMINO_DISCRIMINATORS.withdrawObligationCollateralAndRedeemReserveCollateralV2,
-              ),
-            ],
-          }),
-        )
-        break
-      case "borrow":
-        if (params.allowedReserves.length > 0) {
-          accountConstraints.push(
-            createAccountConstraint(KAMINO_ACCOUNT_INDICES.borrow.borrowReserve, params.allowedReserves),
-          )
-        }
-        instructionsConstraints.push(
-          createInstructionConstraint({
-            programId: KAMINO_LENDING_PROGRAM_ID,
-            accountConstraints,
-            dataConstraints: [createDiscriminatorConstraint(KAMINO_DISCRIMINATORS.borrowObligationLiquidityV2)],
-          }),
-        )
-        break
-      case "repay":
-        if (params.allowedReserves.length > 0) {
-          accountConstraints.push(
-            createAccountConstraint(KAMINO_ACCOUNT_INDICES.repay.repayReserve, params.allowedReserves),
-          )
-        }
-        instructionsConstraints.push(
-          createInstructionConstraint({
-            programId: KAMINO_LENDING_PROGRAM_ID,
-            accountConstraints,
-            dataConstraints: [createDiscriminatorConstraint(KAMINO_DISCRIMINATORS.repayObligationLiquidityV2)],
-          }),
-        )
-        break
-    }
-  }
-
-  return createProgramInteractionPolicy({
-    instructionsConstraints,
-    spendingLimits: params.spendingLimits,
-    threshold: params.threshold,
-    timeLock: params.timeLock,
-  })
-}
-
-/** Kamino actions that can be included in a policy */
-export type KaminoPolicyAction = "deposit" | "withdraw" | "borrow" | "repay"
-
-/**
- * Creates a Kamino policy configuration (unified API, similar to createCorePolicy).
- * Both allowedReserves and allowedDepositMints are optional; omit both to allow any reserve/mint.
- */
-export function createKaminoPolicy(params: {
-  /** Allowed reserve addresses (optional) */
-  allowedReserves?: PublicKey[]
-  /** Allowed liquidity mints for deposits/withdrawals/borrows/repays (optional) */
-  allowedDepositMints?: PublicKey[]
-  /** Which actions to allow */
-  actions: KaminoPolicyAction[]
-  /** Optional: allowed lending markets */
-  allowedLendingMarkets?: PublicKey[]
-  /** Optional: spending limits */
-  spendingLimits?: SpendingLimit[]
-  /** Threshold (default 1) */
-  threshold?: number
-  /** Time lock in seconds (default 0) */
-  timeLock?: number
-}): PolicyConfig {
-  const instructionsConstraints: InstructionConstraint[] = []
-
-  for (const action of params.actions) {
-    const accountConstraints: AccountConstraint[] = []
-
-    switch (action) {
-      case "deposit":
-        if (params.allowedReserves && params.allowedReserves.length > 0) {
-          accountConstraints.push(
-            createAccountConstraint(KAMINO_ACCOUNT_INDICES.depositCollateral.reserve, params.allowedReserves),
-          )
-        }
-        if (params.allowedDepositMints && params.allowedDepositMints.length > 0) {
-          accountConstraints.push(
-            createAccountConstraint(
-              KAMINO_ACCOUNT_INDICES.depositCollateral.reserveLiquidityMint,
-              params.allowedDepositMints,
-            ),
-          )
-        }
-        if (params.allowedLendingMarkets && params.allowedLendingMarkets.length > 0) {
-          accountConstraints.push(
-            createAccountConstraint(KAMINO_ACCOUNT_INDICES.depositCollateral.lendingMarket, params.allowedLendingMarkets),
-          )
-        }
-        instructionsConstraints.push(
-          createInstructionConstraint({
-            programId: KAMINO_LENDING_PROGRAM_ID,
-            accountConstraints,
-            dataConstraints: [
-              createDiscriminatorConstraint(KAMINO_DISCRIMINATORS.depositReserveLiquidityAndObligationCollateralV2),
-            ],
-          }),
-        )
-        break
-      case "withdraw":
-        if (params.allowedReserves && params.allowedReserves.length > 0) {
-          accountConstraints.push(
-            createAccountConstraint(
-              KAMINO_ACCOUNT_INDICES.withdrawCollateral.withdrawReserve,
-              params.allowedReserves,
-            ),
-          )
-        }
-        if (params.allowedDepositMints && params.allowedDepositMints.length > 0) {
-          accountConstraints.push(
-            createAccountConstraint(
-              KAMINO_ACCOUNT_INDICES.withdrawCollateral.reserveLiquidityMint,
-              params.allowedDepositMints,
-            ),
-          )
-        }
-        if (params.allowedLendingMarkets && params.allowedLendingMarkets.length > 0) {
-          accountConstraints.push(
-            createAccountConstraint(
-              KAMINO_ACCOUNT_INDICES.withdrawCollateral.lendingMarket,
-              params.allowedLendingMarkets,
-            ),
-          )
-        }
-        instructionsConstraints.push(
-          createInstructionConstraint({
-            programId: KAMINO_LENDING_PROGRAM_ID,
-            accountConstraints,
-            dataConstraints: [
-              createDiscriminatorConstraint(
-                KAMINO_DISCRIMINATORS.withdrawObligationCollateralAndRedeemReserveCollateralV2,
-              ),
-            ],
-          }),
-        )
-        break
-      case "borrow":
-        if (params.allowedReserves && params.allowedReserves.length > 0) {
-          accountConstraints.push(
-            createAccountConstraint(KAMINO_ACCOUNT_INDICES.borrow.borrowReserve, params.allowedReserves),
-          )
-        }
-        if (params.allowedDepositMints && params.allowedDepositMints.length > 0) {
-          accountConstraints.push(
-            createAccountConstraint(
-              KAMINO_ACCOUNT_INDICES.borrow.borrowReserveLiquidityMint,
-              params.allowedDepositMints,
-            ),
-          )
-        }
-        if (params.allowedLendingMarkets && params.allowedLendingMarkets.length > 0) {
-          accountConstraints.push(
-            createAccountConstraint(KAMINO_ACCOUNT_INDICES.borrow.lendingMarket, params.allowedLendingMarkets),
-          )
-        }
-        instructionsConstraints.push(
-          createInstructionConstraint({
-            programId: KAMINO_LENDING_PROGRAM_ID,
-            accountConstraints,
-            dataConstraints: [createDiscriminatorConstraint(KAMINO_DISCRIMINATORS.borrowObligationLiquidityV2)],
-          }),
-        )
-        break
-      case "repay":
-        if (params.allowedReserves && params.allowedReserves.length > 0) {
-          accountConstraints.push(
-            createAccountConstraint(KAMINO_ACCOUNT_INDICES.repay.repayReserve, params.allowedReserves),
-          )
-        }
-        if (params.allowedDepositMints && params.allowedDepositMints.length > 0) {
-          accountConstraints.push(
-            createAccountConstraint(
-              KAMINO_ACCOUNT_INDICES.repay.reserveLiquidityMint,
-              params.allowedDepositMints,
-            ),
-          )
-        }
-        if (params.allowedLendingMarkets && params.allowedLendingMarkets.length > 0) {
-          accountConstraints.push(
-            createAccountConstraint(KAMINO_ACCOUNT_INDICES.repay.lendingMarket, params.allowedLendingMarkets),
-          )
-        }
-        instructionsConstraints.push(
-          createInstructionConstraint({
-            programId: KAMINO_LENDING_PROGRAM_ID,
-            accountConstraints,
-            dataConstraints: [createDiscriminatorConstraint(KAMINO_DISCRIMINATORS.repayObligationLiquidityV2)],
-          }),
-        )
-        break
-    }
-  }
-
-  return createProgramInteractionPolicy({
-    instructionsConstraints,
-    spendingLimits: params.spendingLimits,
-    threshold: params.threshold,
-    timeLock: params.timeLock,
-  })
-}
-
-export const KAMINO_VAULT_ACCOUNT_INDICES = {
-  deposit: {
-    vaultState: 1,
-    tokenMint: 3,
-  },
-  withdraw: {
-    vaultState: 1,
-    tokenMint: 6,
-    reserve: 15,
-  },
-}
-
-export type KaminoVaultPolicyAction = "deposit" | "withdraw"
-
-export function createKaminoVaultPolicy(params: {
-  allowedVaults?: PublicKey[]
-  allowedDepositMints?: PublicKey[]
-  actions: KaminoVaultPolicyAction[]
-  spendingLimits?: SpendingLimit[]
-  threshold?: number
-  timeLock?: number
-}): PolicyConfig {
-  const instructionsConstraints: InstructionConstraint[] = []
-
-  for (const action of params.actions) {
-    const accountConstraints: AccountConstraint[] = []
-    const accountIndices =
-      action === "deposit" ? KAMINO_VAULT_ACCOUNT_INDICES.deposit : KAMINO_VAULT_ACCOUNT_INDICES.withdraw
-
-    if (params.allowedVaults && params.allowedVaults.length > 0) {
-      accountConstraints.push(createAccountConstraint(accountIndices.vaultState, params.allowedVaults))
-    }
-    if (params.allowedDepositMints && params.allowedDepositMints.length > 0) {
-      accountConstraints.push(createAccountConstraint(accountIndices.tokenMint, params.allowedDepositMints))
-    }
-
-    instructionsConstraints.push(
-      createInstructionConstraint({
-        programId: KAMINO_VAULT_PROGRAM_ID,
-        accountConstraints,
-        dataConstraints: [
-          createDiscriminatorConstraint(
-            action === "deposit"
-              ? KAMINO_VAULT_DISCRIMINATORS.deposit
-              : KAMINO_VAULT_DISCRIMINATORS.withdraw,
-          ),
-        ],
-      }),
-    )
-  }
-
-  return createProgramInteractionPolicy({
-    instructionsConstraints,
-    spendingLimits: params.spendingLimits,
-    threshold: params.threshold,
-    timeLock: params.timeLock,
-  })
-}
-
-export const KAMINO_FARM_ACCOUNT_INDICES = {
-  initializeUser: {
-    farmState: 5,
-  },
-  stake: {
-    farmState: 2,
-    tokenMint: 5,
-  },
-  unstake: {
-    farmState: 2,
-  },
-  withdrawUnstakedDeposits: {
-    farmState: 2,
-  },
-  harvestReward: {
-    farmState: 2,
-    rewardMint: 4,
-  },
-}
-
-export type KaminoFarmPolicyAction =
-  | "initializeUser"
-  | "stake"
-  | "unstake"
-  | "withdrawUnstakedDeposits"
-  | "harvestReward"
-
-export function createKaminoFarmPolicy(params: {
-  allowedFarmStates?: PublicKey[]
-  allowedUnderlyingMints?: PublicKey[]
-  allowedRewardMints?: PublicKey[]
-  actions: KaminoFarmPolicyAction[]
-  spendingLimits?: SpendingLimit[]
-  threshold?: number
-  timeLock?: number
-}): PolicyConfig {
-  const instructionsConstraints: InstructionConstraint[] = []
-
-  for (const action of params.actions) {
-    const accountConstraints: AccountConstraint[] = []
-
-    const farmIndex =
-      action === "initializeUser"
-        ? KAMINO_FARM_ACCOUNT_INDICES.initializeUser.farmState
-        : action === "stake"
-          ? KAMINO_FARM_ACCOUNT_INDICES.stake.farmState
-          : action === "unstake"
-            ? KAMINO_FARM_ACCOUNT_INDICES.unstake.farmState
-            : action === "withdrawUnstakedDeposits"
-              ? KAMINO_FARM_ACCOUNT_INDICES.withdrawUnstakedDeposits.farmState
-              : KAMINO_FARM_ACCOUNT_INDICES.harvestReward.farmState
-
-    if (params.allowedFarmStates && params.allowedFarmStates.length > 0) {
-      accountConstraints.push(createAccountConstraint(farmIndex, params.allowedFarmStates))
-    }
-
-    if (action === "stake" && params.allowedUnderlyingMints && params.allowedUnderlyingMints.length > 0) {
-      accountConstraints.push(
-        createAccountConstraint(KAMINO_FARM_ACCOUNT_INDICES.stake.tokenMint, params.allowedUnderlyingMints),
-      )
-    }
-
-    if (action === "harvestReward" && params.allowedRewardMints && params.allowedRewardMints.length > 0) {
-      accountConstraints.push(
-        createAccountConstraint(KAMINO_FARM_ACCOUNT_INDICES.harvestReward.rewardMint, params.allowedRewardMints),
-      )
-    }
-
-    const discriminator =
-      action === "initializeUser"
-        ? KAMINO_FARM_DISCRIMINATORS.initializeUser
-        : action === "stake"
-          ? KAMINO_FARM_DISCRIMINATORS.stake
-          : action === "unstake"
-            ? KAMINO_FARM_DISCRIMINATORS.unstake
-            : action === "withdrawUnstakedDeposits"
-              ? KAMINO_FARM_DISCRIMINATORS.withdrawUnstakedDeposits
-              : KAMINO_FARM_DISCRIMINATORS.harvestReward
-
-    instructionsConstraints.push(
-      createInstructionConstraint({
-        programId: KAMINO_FARMS_PROGRAM_ID,
-        accountConstraints,
-        dataConstraints: [createDiscriminatorConstraint(discriminator)],
-      }),
-    )
-  }
-
-  return createProgramInteractionPolicy({
-    instructionsConstraints,
-    spendingLimits: params.spendingLimits,
-    threshold: params.threshold,
-    timeLock: params.timeLock,
-  })
-}
-
-// ============================================================================
-// Exponent Core Policy Builders (Strip/Merge)
-// ============================================================================
-
-export const EXPONENT_CORE_PROGRAM_ID = new PublicKey("ExponentnaRg3CQbW6dqQNZKXp7gtZ9DGMp1cwC4HAS7")
-
-/**
- * Single-byte discriminators for Exponent Core wrapper instructions.
- */
-export const EXPONENT_CORE_DISCRIMINATORS = {
-  initializeYieldPosition: Buffer.from([3]),
-  collectInterest: Buffer.from([6]),
-  depositYt: Buffer.from([7]),
-  withdrawYt: Buffer.from([8]),
-  wrapperCollectInterest: Buffer.from([33]),
-  wrapperStrip: Buffer.from([38]),
-  wrapperMerge: Buffer.from([39]),
-}
-
-/**
- * Account indices in Exponent Core initialize_yield_position instruction.
- */
-export const EXPONENT_CORE_INITIALIZE_YIELD_POSITION_ACCOUNT_INDICES = {
-  owner: 0,
-  vault: 1,
-  yieldPosition: 2,
-  systemProgram: 3,
-  eventAuthority: 4,
-  program: 5,
-}
-
-/**
- * Account indices in Exponent Core wrapper_strip instruction.
- */
-export const EXPONENT_CORE_STRIP_ACCOUNT_INDICES = {
-  depositor: 0,
-  tokenSyDepositor: 1,
-  vault: 2,
-  escrowSy: 3,
-  tokenYtDepositor: 4,
-  tokenPtDepositor: 5,
-  mintYt: 6,
-  mintPt: 7,
-  authority: 8,
-  vaultAddressLookupTable: 9,
-  tokenProgram: 10,
-  escrowYt: 11,
-  userYieldPosition: 12,
-  vaultRobotYieldPosition: 13,
-  syProgram: 14,
-  systemProgram: 15,
-}
-
-/**
- * Account indices in Exponent Core wrapper_merge instruction.
- */
-export const EXPONENT_CORE_MERGE_ACCOUNT_INDICES = {
-  merger: 0,
-  tokenSyMerger: 1,
-  vault: 2,
-  escrowSy: 3,
-  tokenYtMerger: 4,
-  tokenPtMerger: 5,
-  mintYt: 6,
-  mintPt: 7,
-  authority: 8,
-  vaultAddressLookupTable: 9,
-  tokenProgram: 10,
-  vaultRobotYieldPosition: 11,
-  syProgram: 12,
-  systemProgram: 13,
-}
-
-export const EXPONENT_CORE_DEPOSIT_YT_ACCOUNT_INDICES = {
-  depositor: 0,
-  vault: 1,
-}
-
-export const EXPONENT_CORE_COLLECT_INTEREST_ACCOUNT_INDICES = {
-  owner: 0,
-  vault: 2,
-}
-
-export const EXPONENT_CORE_WITHDRAW_YT_ACCOUNT_INDICES = {
-  owner: 0,
-  vault: 1,
-}
-
-export const EXPONENT_CORE_WRAPPER_COLLECT_INTEREST_ACCOUNT_INDICES = {
-  claimer: 0,
-  vault: 2,
-}
-
-export const EXPONENT_VAULT_ACCOUNT_DATA_OFFSETS = {
-  mintSy: 40n,
-} as const
-
-/** Core actions that can be included in a policy */
-export type CorePolicyAction =
-  | "initializeYieldPosition"
-  | "collectInterest"
-  | "depositYt"
-  | "withdrawYt"
-  | "wrapperCollectInterest"
-  | "strip"
-  | "merge"
-
-function createExponentVaultMintSyConstraint(accountIndex: number, allowedSyMint: PublicKey): AccountConstraint {
-  return createAccountDataConstraint(accountIndex, [
-    {
-      dataOffset: EXPONENT_VAULT_ACCOUNT_DATA_OFFSETS.mintSy,
-      dataValue: { u8Slice: Array.from(allowedSyMint.toBytes()) },
-      operator: "Equals",
-    },
-  ])
-}
-
-function resolveExponentAccountConstraintVariants(params: {
-  accountIndex: number
-  allowedVaults?: PublicKey[]
-  allowedSyMints?: PublicKey[]
-}): AccountConstraint[][] {
-  if (params.allowedVaults && params.allowedVaults.length > 0) {
-    return [[createAccountConstraint(params.accountIndex, params.allowedVaults)]]
-  }
-
-  if (params.allowedSyMints && params.allowedSyMints.length > 0) {
-    return params.allowedSyMints.map((allowedSyMint) => [
-      createExponentVaultMintSyConstraint(params.accountIndex, allowedSyMint),
-    ])
-  }
-
-  return [[]]
-}
-
-/**
- * Creates instruction constraints for Exponent Core operations.
- */
-export function createCoreInstructionConstraints(params: {
-  /** Allowed vault addresses (optional) */
-  allowedVaults?: PublicKey[]
-  /** Allowed SY mints - constrains the vault account's mintSy field directly */
-  allowedSyMints?: PublicKey[]
-  /** Deprecated: no longer required when constraining by SY mint */
-  vaultsForSyMints?: PublicKey[]
-  /** Which actions to allow */
-  actions: CorePolicyAction[]
-}): InstructionConstraint[] {
-  const instructionsConstraints: InstructionConstraint[] = []
-
-  for (const action of params.actions) {
-    const accountIndex =
-      action === "initializeYieldPosition"
-        ? EXPONENT_CORE_INITIALIZE_YIELD_POSITION_ACCOUNT_INDICES.vault
-        : action === "collectInterest"
-          ? EXPONENT_CORE_COLLECT_INTEREST_ACCOUNT_INDICES.vault
-        : action === "depositYt"
-          ? EXPONENT_CORE_DEPOSIT_YT_ACCOUNT_INDICES.vault
-          : action === "withdrawYt"
-            ? EXPONENT_CORE_WITHDRAW_YT_ACCOUNT_INDICES.vault
-            : action === "wrapperCollectInterest"
-              ? EXPONENT_CORE_WRAPPER_COLLECT_INTEREST_ACCOUNT_INDICES.vault
-        : action === "strip"
-          ? EXPONENT_CORE_STRIP_ACCOUNT_INDICES.vault
-          : EXPONENT_CORE_MERGE_ACCOUNT_INDICES.vault
-    const accountConstraintVariants = resolveExponentAccountConstraintVariants({
-      accountIndex,
-      allowedVaults: params.allowedVaults,
-      allowedSyMints: params.allowedSyMints,
-    })
-    const discriminator =
-      action === "initializeYieldPosition"
-        ? EXPONENT_CORE_DISCRIMINATORS.initializeYieldPosition
-        : action === "collectInterest"
-          ? EXPONENT_CORE_DISCRIMINATORS.collectInterest
-        : action === "depositYt"
-          ? EXPONENT_CORE_DISCRIMINATORS.depositYt
-        : action === "withdrawYt"
-            ? EXPONENT_CORE_DISCRIMINATORS.withdrawYt
-            : action === "wrapperCollectInterest"
-              ? EXPONENT_CORE_DISCRIMINATORS.wrapperCollectInterest
-        : action === "strip"
-          ? EXPONENT_CORE_DISCRIMINATORS.wrapperStrip
-          : EXPONENT_CORE_DISCRIMINATORS.wrapperMerge
-
-    switch (action) {
-      case "initializeYieldPosition":
-      case "collectInterest":
-      case "depositYt":
-      case "withdrawYt":
-      case "wrapperCollectInterest":
-        accountConstraintVariants.forEach((accountConstraints) => {
-          instructionsConstraints.push(
-            createInstructionConstraint({
-              programId: EXPONENT_CORE_PROGRAM_ID,
-              accountConstraints,
-              dataConstraints: [createDiscriminatorConstraint(discriminator)],
-            }),
-          )
-        })
-        break
-      case "strip":
-        accountConstraintVariants.forEach((accountConstraints) => {
-          instructionsConstraints.push(
-            createInstructionConstraint({
-              programId: EXPONENT_CORE_PROGRAM_ID,
-              accountConstraints,
-              dataConstraints: [createDiscriminatorConstraint(discriminator)],
-            }),
-          )
-        })
-        break
-      case "merge":
-        accountConstraintVariants.forEach((accountConstraints) => {
-          instructionsConstraints.push(
-            createInstructionConstraint({
-              programId: EXPONENT_CORE_PROGRAM_ID,
-              accountConstraints,
-              dataConstraints: [createDiscriminatorConstraint(discriminator)],
-            }),
-          )
-        })
-        break
-    }
-  }
-
-  return instructionsConstraints
-}
-
-/**
- * Creates a complete Exponent Core strip/merge policy configuration.
- */
-export function createCorePolicy(params: {
-  /** Allowed vault addresses (optional) */
-  allowedVaults?: PublicKey[]
-  /** Allowed SY mints - constrains the vault account's mintSy field directly */
-  allowedSyMints?: PublicKey[]
-  /** Deprecated: no longer required when constraining by SY mint */
-  vaultsForSyMints?: PublicKey[]
-  /** Which actions to allow */
-  actions: CorePolicyAction[]
-  /** Spending limits (optional) */
-  spendingLimits?: SpendingLimit[]
-  /** Threshold (default 1) */
-  threshold?: number
-  /** Time lock in seconds (default 0) */
-  timeLock?: number
-}): PolicyConfig {
-  const instructionsConstraints = createCoreInstructionConstraints({
-    allowedVaults: params.allowedVaults,
-    allowedSyMints: params.allowedSyMints,
-    vaultsForSyMints: params.vaultsForSyMints,
-    actions: params.actions,
-  })
-
-  return createProgramInteractionPolicy({
-    instructionsConstraints,
-    spendingLimits: params.spendingLimits,
-    threshold: params.threshold,
-    timeLock: params.timeLock,
-  })
-}
-
-// ============================================================================
-// Exponent Orderbook Policy Builders
-// ============================================================================
-
-export const EXPONENT_ORDERBOOK_PROGRAM_ID = new PublicKey("XPBookgQTN2p8Yw1C2La35XkPMmZTCEYH77AdReVvK1")
-export const MARGINFI_STANDARD_PROGRAM_ID = new PublicKey("XPMfipyhcbq3DBvgvxkbZY7GekwmGNJLMD3wdiCkBc7")
-export const KAMINO_STANDARD_PROGRAM_ID = new PublicKey("XPK1ndTK1xrgRg99ifvdPP1exrx8D1mRXTuxBkkroCx")
-export const JITO_RESTAKING_STANDARD_PROGRAM_ID = new PublicKey("XPJitopeUEhMZVF72CvswnwrS2U2akQvk5s26aEfWv2")
-export const PERENA_STANDARD_PROGRAM_ID = new PublicKey("XPerenaJPyvnjseLCn7rgzxFEum6zX1k89C13SPTyGZ")
-export const GENERIC_STANDARD_PROGRAM_ID = new PublicKey("XP1BRLn8eCYSygrd8er5P4GKdzqKbC3DLoSsS5UYVZy")
-
-/**
- * Single-byte discriminators for Exponent Orderbook wrapper instructions.
- * The orderbook uses single-byte discriminators, not 8-byte Anchor discriminators.
- */
-export const ORDERBOOK_DISCRIMINATORS = {
-  rawPostOffer: Buffer.from([1]),
-  rawMarketOffer: Buffer.from([3]),
-  wrapperPostOffer: Buffer.from([7]),
-  wrapperMarketOffer: Buffer.from([8]),
-  wrapperRemoveOffer: Buffer.from([9]),
-  wrapperWithdrawFunds: Buffer.from([11]),
-}
-
-/**
- * Account indices in Exponent Orderbook wrapper instructions.
- * Used for setting up account constraints.
- */
-export const ORDERBOOK_ACCOUNT_INDICES = {
-  // Common to all wrapper instructions
-  trader: 0,
-  orderbook: 1,
-  vault: 2,
-}
-
-/** Orderbook actions that can be included in a policy */
-export type OrderbookPolicyAction =
-  | "rawPostOffer"
-  | "rawMarketOffer"
-  | "postOffer"
-  | "marketOffer"
-  | "removeOffer"
-  | "withdrawFunds"
-
-/**
- * Creates instruction constraints for Exponent Orderbook operations.
- *
- * When SY mints are provided, the vault account (account index 2) is constrained
- * by reading its mintSy field from account data instead of hardcoding vault PDAs.
- *
- * @example
- * ```ts
- * const constraints = createOrderbookInstructionConstraints({
- *   allowedSyMints: [BULKSOL_SY_MINT],
- *   actions: ["postOffer", "marketOffer", "removeOffer", "withdrawFunds"],
- * })
- * ```
- */
-export function createOrderbookInstructionConstraints(params: {
-  /** SY mints that are allowed via the vault account's mintSy field */
-  allowedSyMints: PublicKey[]
-  /** Which orderbook actions to allow */
-  actions: OrderbookPolicyAction[]
-}): InstructionConstraint[] {
-  const instructionsConstraints: InstructionConstraint[] = []
-  const accountConstraintVariants = resolveExponentAccountConstraintVariants({
-    accountIndex: ORDERBOOK_ACCOUNT_INDICES.vault,
-    allowedSyMints: params.allowedSyMints,
-  })
-
-  for (const action of params.actions) {
-    switch (action) {
-      case "rawPostOffer":
-        accountConstraintVariants.forEach((accountConstraints) => {
-          instructionsConstraints.push(
-            createInstructionConstraint({
-              programId: EXPONENT_ORDERBOOK_PROGRAM_ID,
-              accountConstraints,
-              dataConstraints: [createDiscriminatorConstraint(ORDERBOOK_DISCRIMINATORS.rawPostOffer)],
-            }),
-          )
-        })
-        break
-      case "rawMarketOffer":
-        accountConstraintVariants.forEach((accountConstraints) => {
-          instructionsConstraints.push(
-            createInstructionConstraint({
-              programId: EXPONENT_ORDERBOOK_PROGRAM_ID,
-              accountConstraints,
-              dataConstraints: [createDiscriminatorConstraint(ORDERBOOK_DISCRIMINATORS.rawMarketOffer)],
-            }),
-          )
-        })
-        break
-      case "postOffer":
-        accountConstraintVariants.forEach((accountConstraints) => {
-          instructionsConstraints.push(
-            createInstructionConstraint({
-              programId: EXPONENT_ORDERBOOK_PROGRAM_ID,
-              accountConstraints,
-              dataConstraints: [createDiscriminatorConstraint(ORDERBOOK_DISCRIMINATORS.wrapperPostOffer)],
-            }),
-          )
-        })
-        break
-      case "marketOffer":
-        accountConstraintVariants.forEach((accountConstraints) => {
-          instructionsConstraints.push(
-            createInstructionConstraint({
-              programId: EXPONENT_ORDERBOOK_PROGRAM_ID,
-              accountConstraints,
-              dataConstraints: [createDiscriminatorConstraint(ORDERBOOK_DISCRIMINATORS.wrapperMarketOffer)],
-            }),
-          )
-        })
-        break
-      case "removeOffer":
-        accountConstraintVariants.forEach((accountConstraints) => {
-          instructionsConstraints.push(
-            createInstructionConstraint({
-              programId: EXPONENT_ORDERBOOK_PROGRAM_ID,
-              accountConstraints,
-              dataConstraints: [createDiscriminatorConstraint(ORDERBOOK_DISCRIMINATORS.wrapperRemoveOffer)],
-            }),
-          )
-        })
-        break
-      case "withdrawFunds":
-        accountConstraintVariants.forEach((accountConstraints) => {
-          instructionsConstraints.push(
-            createInstructionConstraint({
-              programId: EXPONENT_ORDERBOOK_PROGRAM_ID,
-              accountConstraints,
-              dataConstraints: [createDiscriminatorConstraint(ORDERBOOK_DISCRIMINATORS.wrapperWithdrawFunds)],
-            }),
-          )
-        })
-        break
-    }
-  }
-
-  return instructionsConstraints
-}
-
-export const STANDARD_PROGRAM_DISCRIMINATORS = {
-  mint: Buffer.from([1]),
-  redeem: Buffer.from([2]),
-}
-
-type StandardProgramAccountIndices = {
-  mint: {
-    mintSy: number
-  }
-  redeem: {
-    mintSy: number
-  }
-}
-
-export const STANDARD_PROGRAM_ACCOUNT_INDICES: Record<string, StandardProgramAccountIndices> = {
-  [MARGINFI_STANDARD_PROGRAM_ID.toBase58()]: {
-    mint: { mintSy: 2 },
-    redeem: { mintSy: 5 },
-  },
-  [KAMINO_STANDARD_PROGRAM_ID.toBase58()]: {
-    mint: { mintSy: 6 },
-    redeem: { mintSy: 4 },
-  },
-  [JITO_RESTAKING_STANDARD_PROGRAM_ID.toBase58()]: {
-    mint: { mintSy: 2 },
-    redeem: { mintSy: 6 },
-  },
-  [PERENA_STANDARD_PROGRAM_ID.toBase58()]: {
-    mint: { mintSy: 2 },
-    redeem: { mintSy: 6 },
-  },
-  [GENERIC_STANDARD_PROGRAM_ID.toBase58()]: {
-    mint: { mintSy: 2 },
-    redeem: { mintSy: 5 },
-  },
-}
-
-export type StandardProgramPolicyAction = "mintSy" | "redeemSy"
-
-export type AllowedSyMintProgram = {
-  syMint: PublicKey
-  programId: PublicKey
-}
-
-export function createStandardProgramInstructionConstraints(params: {
-  allowedSyMints: AllowedSyMintProgram[]
-  actions: StandardProgramPolicyAction[]
-}): InstructionConstraint[] {
-  const instructionsConstraints: InstructionConstraint[] = []
-
-  for (const action of params.actions) {
-    for (const allowedMint of params.allowedSyMints) {
-      const indices = STANDARD_PROGRAM_ACCOUNT_INDICES[allowedMint.programId.toBase58()]
-      if (!indices) {
-        continue
-      }
-
-      const mintAccountIndex = action === "mintSy" ? indices.mint.mintSy : indices.redeem.mintSy
-      const discriminator =
-        action === "mintSy" ? STANDARD_PROGRAM_DISCRIMINATORS.mint : STANDARD_PROGRAM_DISCRIMINATORS.redeem
-
-      instructionsConstraints.push(
-        createInstructionConstraint({
-          programId: allowedMint.programId,
-          accountConstraints: [createAccountConstraint(mintAccountIndex, [allowedMint.syMint])],
-          dataConstraints: [createDiscriminatorConstraint(discriminator)],
-        }),
-      )
-    }
-  }
-
-  return instructionsConstraints
-}
-
-export function createStandardProgramPolicy(params: {
-  allowedSyMints: AllowedSyMintProgram[]
-  actions: StandardProgramPolicyAction[]
-  spendingLimits?: SpendingLimit[]
-  threshold?: number
-  timeLock?: number
-}): PolicyConfig {
-  return createProgramInteractionPolicy({
-    instructionsConstraints: createStandardProgramInstructionConstraints({
-      allowedSyMints: params.allowedSyMints,
-      actions: params.actions,
-    }),
-    spendingLimits: params.spendingLimits,
-    threshold: params.threshold,
-    timeLock: params.timeLock,
-  })
-}
-
-/**
- * Creates a complete Exponent Orderbook policy configuration.
- *
- * @example
- * ```ts
- * const policy = createOrderbookPolicy({
- *   allowedSyMints: [BULKSOL_SY_MINT],
- *   actions: ["postOffer", "marketOffer", "removeOffer", "withdrawFunds"],
- * })
- * ```
- */
-// ============================================================================
-// Titan Swap Policy Builders
-// ============================================================================
-
-export const TITAN_PROGRAM_ID = new PublicKey("T1TANpTeScyeqVzzgNViGDNrkQ6qHz9KrSBS4aNXvGT")
-
-export const TITAN_DISCRIMINATORS = {
-  swapRouteV2: Buffer.from([249, 91, 84, 33, 69, 22, 0, 135]),
-}
-
-export const TITAN_ACCOUNT_INDICES = {
-  inputMint: 2,
-  outputMint: 4,
-}
-
-/**
- * Creates a policy that allows Titan SwapRouteV2 swaps.
- * Optional mint constraints can be applied to both the input and output mint.
- * The on-chain post-hook validator separately checks that input/output token
- * accounts are vault-owned tracked accounts.
- */
-export function createTitanSwapPolicy(params?: {
-  /** Allowed input/output mints (optional) */
-  allowedMints?: PublicKey[]
-  /** Threshold (default 1) */
-  threshold?: number
-  /** Time lock in seconds (default 0) */
-  timeLock?: number
-}): PolicyConfig {
-  const accountConstraints: AccountConstraint[] = []
-
-  if (params?.allowedMints && params.allowedMints.length > 0) {
-    accountConstraints.push(
-      createAccountConstraint(TITAN_ACCOUNT_INDICES.inputMint, params.allowedMints),
-      createAccountConstraint(TITAN_ACCOUNT_INDICES.outputMint, params.allowedMints),
-    )
-  }
-
-  const instructionConstraint = createInstructionConstraint({
-    programId: TITAN_PROGRAM_ID,
-    accountConstraints,
-    dataConstraints: [createDiscriminatorConstraint(TITAN_DISCRIMINATORS.swapRouteV2)],
-  })
-
-  return createProgramInteractionPolicy({
-    instructionsConstraints: [instructionConstraint],
-    threshold: params?.threshold,
-    timeLock: params?.timeLock,
-  })
-}
-
-// ============================================================================
-// Loopscale Policy Builders
-// ============================================================================
-
-/** Loopscale lending protocol program ID. */
-export const LOOPSCALE_PROGRAM_ID = new PublicKey("1oopBoJG58DgkUVKkEzKgyG9dvRmpgeEm1AVjoHkF78")
-
-/**
- * Derive a Loopscale Strategy PDA.
- * seeds = ["strategy", nonce] where nonce is a Pubkey (keypair generated at creation).
- */
-export function deriveLoopscaleStrategyAddress(nonce: PublicKey): [PublicKey, number] {
-  return PublicKey.findProgramAddressSync(
-    [Buffer.from("strategy"), nonce.toBytes()],
-    LOOPSCALE_PROGRAM_ID,
-  )
-}
-
-/**
- * Derive a Loopscale Loan PDA.
- * seeds = [borrower, nonce] where nonce is a u64 (typically current timestamp).
- */
-export function deriveLoopscaleLoanAddress(borrower: PublicKey, nonce: bigint): [PublicKey, number] {
-  const nonceBuf = Buffer.alloc(8)
-  nonceBuf.writeBigUInt64LE(nonce)
-  return PublicKey.findProgramAddressSync(
-    [borrower.toBytes(), nonceBuf],
-    LOOPSCALE_PROGRAM_ID,
-  )
-}
-
-/**
- * 8-byte Anchor discriminators for Loopscale instructions (loans + strategies).
- * Must match the on-chain constants in `interaction_validations/loopscale.rs`.
- */
-export const LOOPSCALE_DISCRIMINATORS = {
-  createLoan: Buffer.from([166, 131, 118, 219, 138, 218, 206, 140]),
-  depositCollateral: Buffer.from([156, 131, 142, 116, 146, 247, 162, 120]),
-  borrowPrincipal: Buffer.from([106, 10, 38, 204, 139, 188, 124, 50]),
-  repayPrincipal: Buffer.from([229, 67, 83, 65, 77, 84, 80, 141]),
-  withdrawCollateral: Buffer.from([115, 135, 168, 106, 139, 214, 138, 150]),
-  closeLoan: Buffer.from([96, 114, 111, 204, 149, 228, 235, 124]),
-  createStrategy: Buffer.from([152, 160, 107, 148, 245, 190, 127, 224]),
-  depositStrategy: Buffer.from([246, 82, 57, 226, 131, 222, 253, 249]),
-  withdrawStrategy: Buffer.from([31, 45, 162, 5, 193, 217, 134, 188]),
-  closeStrategy: Buffer.from([56, 247, 170, 246, 89, 221, 134, 200]),
-  updateWeightMatrix: Buffer.from([252, 166, 37, 207, 154, 83, 187, 128]),
-  lockLoan: Buffer.from([28, 101, 52, 240, 146, 230, 95, 22]),
-  unlockLoan: Buffer.from([121, 226, 178, 98, 215, 209, 240, 38]),
-  updateStrategy: Buffer.from([16, 76, 138, 179, 171, 112, 196, 21]),
-  refinanceLedger: Buffer.from([103, 41, 134, 43, 140, 152, 253, 74]),
-}
-
-/**
- * Account indices for Loopscale instructions (loans + strategies), matching
- * the on-chain validation in `interaction_validations/loopscale.rs`.
- */
-export const LOOPSCALE_ACCOUNT_INDICES = {
-  /** Loan account (BORROWER side) — index 3 for loan instructions, index 2 for update_weight_matrix */
-  loan: 3,
-  updateWeightMatrixLoan: 2,
-  /** Mint indices vary per instruction */
-  depositCollateralMint: 6,
-  borrowPrincipalMint: 6,
-  repayPrincipalMint: 6,
-  withdrawCollateralMint: 7,
-  strategy: 3,
-  depositStrategyMint: 4,
-  withdrawStrategyMint: 4,
-  lockLoanLoan: 3,
-  unlockLoanLoan: 1,
-  refinanceLedgerLoan: 2,
-}
-
-export type LoopscalePolicyAction =
-  | "createLoan"
-  | "depositCollateral"
-  | "borrowPrincipal"
-  | "repayPrincipal"
-  | "withdrawCollateral"
-  | "closeLoan"
-  | "updateWeightMatrix"
-  | "lockLoan"
-  | "unlockLoan"
-  | "createStrategy"
-  | "depositStrategy"
-  | "withdrawStrategy"
-  | "closeStrategy"
-  | "updateStrategy"
-  | "refinanceLedger"
-
-const LOOPSCALE_ACTION_DISCRIMINATOR_MAP: Record<LoopscalePolicyAction, Buffer> = {
-  createLoan: LOOPSCALE_DISCRIMINATORS.createLoan,
-  depositCollateral: LOOPSCALE_DISCRIMINATORS.depositCollateral,
-  borrowPrincipal: LOOPSCALE_DISCRIMINATORS.borrowPrincipal,
-  repayPrincipal: LOOPSCALE_DISCRIMINATORS.repayPrincipal,
-  withdrawCollateral: LOOPSCALE_DISCRIMINATORS.withdrawCollateral,
-  closeLoan: LOOPSCALE_DISCRIMINATORS.closeLoan,
-  updateWeightMatrix: LOOPSCALE_DISCRIMINATORS.updateWeightMatrix,
-  lockLoan: LOOPSCALE_DISCRIMINATORS.lockLoan,
-  unlockLoan: LOOPSCALE_DISCRIMINATORS.unlockLoan,
-  createStrategy: LOOPSCALE_DISCRIMINATORS.createStrategy,
-  depositStrategy: LOOPSCALE_DISCRIMINATORS.depositStrategy,
-  withdrawStrategy: LOOPSCALE_DISCRIMINATORS.withdrawStrategy,
-  closeStrategy: LOOPSCALE_DISCRIMINATORS.closeStrategy,
-  updateStrategy: LOOPSCALE_DISCRIMINATORS.updateStrategy,
-  refinanceLedger: LOOPSCALE_DISCRIMINATORS.refinanceLedger,
-}
-
-/** Mint account index for actions that have one, or undefined for create/close. */
-const LOOPSCALE_ACTION_MINT_INDEX: Partial<Record<LoopscalePolicyAction, number>> = {
-  depositCollateral: LOOPSCALE_ACCOUNT_INDICES.depositCollateralMint,
-  borrowPrincipal: LOOPSCALE_ACCOUNT_INDICES.borrowPrincipalMint,
-  repayPrincipal: LOOPSCALE_ACCOUNT_INDICES.repayPrincipalMint,
-  withdrawCollateral: LOOPSCALE_ACCOUNT_INDICES.withdrawCollateralMint,
-  depositStrategy: LOOPSCALE_ACCOUNT_INDICES.depositStrategyMint,
-  withdrawStrategy: LOOPSCALE_ACCOUNT_INDICES.withdrawStrategyMint,
-}
-
-/**
- * Creates a policy that allows Loopscale interactions (loans and/or strategies).
- *
- * Loans (BORROWER side): create/close loan, deposit/withdraw collateral, borrow/repay principal.
- * Strategies (LENDER side): create/close strategy, deposit/withdraw into strategy.
- *
- * Optional mint constraints can restrict which collateral/principal mints are
- * allowed. The on-chain post-hook validator separately checks that positions are
- * tracked and that mints have matching token entries on the vault.
- *
- * @param params.actions - Which Loopscale actions to allow (default: all 15 — 10 loan + 5 strategy).
- * @param params.allowedMints - Optional list of allowed mints for deposit/borrow/repay/withdraw
- * @param params.threshold - Number of signers required (default 1)
- * @param params.timeLock - Time lock in seconds (default 0)
- *
- * @example
- * ```ts
- * // Allow all Loopscale loan actions (borrower side)
- * const policy = createLoopscalePolicy()
- *
- * // Allow only strategy actions (lender side)
- * const policy = createLoopscalePolicy({
- *   actions: ["createStrategy", "depositStrategy", "withdrawStrategy", "closeStrategy"],
- * })
- * ```
- */
-export function createLoopscalePolicy(params?: {
-  /** Which Loopscale actions to allow (default: all 15) */
-  actions?: LoopscalePolicyAction[]
-  /** Allowed mints for deposit/borrow/repay/withdraw (optional) */
-  allowedMints?: PublicKey[]
-  /** Threshold (default 1) */
-  threshold?: number
-  /** Time lock in seconds (default 0) */
-  timeLock?: number
-}): PolicyConfig {
-  const actions: LoopscalePolicyAction[] = params?.actions ?? [
-    // Loan actions (BORROWER side)
-    "createLoan",
-    "depositCollateral",
-    "borrowPrincipal",
-    "repayPrincipal",
-    "withdrawCollateral",
-    "closeLoan",
-    "updateWeightMatrix",
-    "lockLoan",
-    "unlockLoan",
-    // Strategy actions (LENDER side)
-    "createStrategy",
-    "depositStrategy",
-    "withdrawStrategy",
-    "closeStrategy",
-    "updateStrategy",
-    "refinanceLedger",
-  ]
-
-  const instructionsConstraints: InstructionConstraint[] = actions.map((action) => {
-    const accountConstraints: AccountConstraint[] = []
-
-    // Add mint constraints for actions that have a mint account
-    const mintIndex = LOOPSCALE_ACTION_MINT_INDEX[action]
-    if (mintIndex !== undefined && params?.allowedMints && params.allowedMints.length > 0) {
-      accountConstraints.push(createAccountConstraint(mintIndex, params.allowedMints))
-    }
-
-    return createInstructionConstraint({
-      programId: LOOPSCALE_PROGRAM_ID,
-      accountConstraints,
-      dataConstraints: [createDiscriminatorConstraint(LOOPSCALE_ACTION_DISCRIMINATOR_MAP[action])],
-    })
-  })
-
-  return createProgramInteractionPolicy({
-    instructionsConstraints,
-    threshold: params?.threshold,
-    timeLock: params?.timeLock,
-  })
-}
-
-export function createOrderbookPolicy(params: {
-  /** SY mints that are allowed */
-  allowedSyMints: PublicKey[]
-  /** Which orderbook actions to allow */
-  actions: OrderbookPolicyAction[]
-  /** Spending limits (optional) */
-  spendingLimits?: SpendingLimit[]
-  /** Threshold (number of signers required, typically 1) */
-  threshold?: number
-  /** Time lock in seconds (typically 0 for instant execution) */
-  timeLock?: number
-}): PolicyConfig {
-  const instructionsConstraints = createOrderbookInstructionConstraints({
-    allowedSyMints: params.allowedSyMints,
-    actions: params.actions,
-  })
-
-  return createProgramInteractionPolicy({
-    instructionsConstraints,
-    spendingLimits: params.spendingLimits,
-    threshold: params.threshold,
-    timeLock: params.timeLock,
-  })
-}
-
-// ============================================================================
-// CLMM Policy Builders
-// ============================================================================
-
-/** Exponent CLMM program ID. */
-export const EXPONENT_CLMM_PROGRAM_ID = new PublicKey("XPC1MM4dYACDfykNuXYZ5una2DsMDWL24CrYubCvarC")
-
-/**
- * Single-byte discriminators for CLMM instructions.
- * These correspond to the instruction indices in the CLMM program.
- */
-export const CLMM_DISCRIMINATORS = {
-  depositLiquidity: Buffer.from([4]),
-  addLiquidity: Buffer.from([25]),
-  withdrawLiquidity: Buffer.from([5]),
-  tradePt: Buffer.from([3]),
-  tradePtExactOut: Buffer.from([24]),
-  buyYt: Buffer.from([12]),
-  sellYt: Buffer.from([13]),
-  claimFarmEmission: Buffer.from([6]),
-}
-
-/**
- * Account indices for CLMM instructions (matching the on-chain validation in
- * `interaction_validations/clmm.rs`). Useful for building fine-grained
- * account constraints in policies.
- */
-export const CLMM_ACCOUNT_INDICES = {
-  depositLiquidity: { depositor: 0, market: 1, ticks: 2, lpPosition: 3, tokenPtSrc: 4, tokenSySrc: 5 },
-  addLiquidity: { owner: 0, market: 1, ticks: 2, lpPosition: 3, tokenPtSrc: 4, tokenSySrc: 5 },
-  withdrawLiquidity: { owner: 0, market: 1, lpPosition: 2, ticks: 3, tokenPtDst: 4, tokenSyDst: 5 },
-  tradePt: { trader: 0, market: 1, ticks: 2, tokenSyTrader: 3, tokenPtTrader: 4 },
-  tradePtExactOut: { trader: 0, market: 1, ticks: 2, tokenSyTrader: 3, tokenPtTrader: 4 },
-  buyYt: { trader: 0, market: 1, ticks: 2, tokenSyTrader: 3, tokenYtTrader: 4, tokenPtTrader: 5 },
-  sellYt: { trader: 0, market: 1, ticks: 2, tokenYtTrader: 3, tokenPtTrader: 4, tokenSyTrader: 5 },
-  claimFarmEmission: { owner: 0, market: 1, ticks: 2, lpPosition: 3, tokenDst: 4, mint: 5, tokenFarm: 6, tokenProgram: 7 },
-}
-
-/**
- * Creates a policy that allows all Exponent CLMM interactions: deposit/add/withdraw
- * liquidity, PT/SY swaps, YT trades, and farm emission claims.
- *
- * Optional market constraints can be applied to restrict which CLMM markets
- * the policy applies to. The on-chain post-hook validator separately checks
- * that token accounts are vault-owned tracked accounts.
- *
- * @param params.allowedMarkets - Optional list of allowed CLMM market addresses
- * @param params.threshold - Number of signers required (default 1)
- * @param params.timeLock - Time lock in seconds (default 0)
- *
- * @example
- * ```ts
- * // Allow all CLMM actions on any market
- * const policy = createClmmPolicy()
- *
- * // Allow CLMM actions only on specific markets
- * const policy = createClmmPolicy({
- *   allowedMarkets: [BULKSOL_CLMM_MARKET, ONYC_CLMM_MARKET],
- * })
- * ```
- */
-export function createClmmPolicy(params?: {
-  /** Allowed CLMM market addresses (optional — if omitted, all markets are allowed) */
-  allowedMarkets?: PublicKey[]
-  /** Threshold (default 1) */
-  threshold?: number
-  /** Time lock in seconds (default 0) */
-  timeLock?: number
-}): PolicyConfig {
-  const allDiscriminators = [
-    CLMM_DISCRIMINATORS.depositLiquidity,
-    CLMM_DISCRIMINATORS.addLiquidity,
-    CLMM_DISCRIMINATORS.withdrawLiquidity,
-    CLMM_DISCRIMINATORS.tradePt,
-    CLMM_DISCRIMINATORS.tradePtExactOut,
-    CLMM_DISCRIMINATORS.buyYt,
-    CLMM_DISCRIMINATORS.sellYt,
-    CLMM_DISCRIMINATORS.claimFarmEmission,
-  ]
-
-  const instructionsConstraints: InstructionConstraint[] = allDiscriminators.map((disc) => {
-    const accountConstraints: AccountConstraint[] = []
-
-    // Market account is at index 1 for all CLMM instructions
-    if (params?.allowedMarkets && params.allowedMarkets.length > 0) {
-      accountConstraints.push(createAccountConstraint(1, params.allowedMarkets))
-    }
-
-    return createInstructionConstraint({
-      programId: EXPONENT_CLMM_PROGRAM_ID,
-      accountConstraints,
-      dataConstraints: [createDiscriminatorConstraint(disc)],
-    })
-  })
-
-  return createProgramInteractionPolicy({
-    instructionsConstraints,
-    threshold: params?.threshold,
-    timeLock: params?.timeLock,
-  })
-}