@exponent-labs/exponent-sdk 0.1.8 → 0.9.0

package/src/exponentVaults/policyBuilders.ts

@@ -0,0 +1,1559 @@
+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")
+
+// ============================================================================
+// 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]),
+}
+
+// ============================================================================
+// 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,
+  })
+}
+
+// ============================================================================
+// 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,
+  })
+}