@exponent-labs/exponent-sdk 0.1.7 → 0.9.0

package/build/exponentVaults/policyBuilders.d.ts

@@ -0,0 +1,694 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { PublicKey } from "@solana/web3.js";
+import { AccountConstraint, DataConstraint, InstructionConstraint, PolicyConfig, SpendingLimit } from "./vault";
+export declare const KAMINO_LENDING_PROGRAM_ID: PublicKey;
+/**
+ * Common Kamino Lending instruction discriminators.
+ * These can be used for data constraints to match specific instructions.
+ */
+export declare const KAMINO_DISCRIMINATORS: {
+    initUserMetadata: Buffer;
+    depositReserveLiquidity: Buffer;
+    depositReserveLiquidityAndObligationCollateral: Buffer;
+    depositReserveLiquidityAndObligationCollateralV2: Buffer;
+    withdrawObligationCollateralAndRedeemReserveCollateral: Buffer;
+    withdrawObligationCollateralAndRedeemReserveCollateralV2: Buffer;
+    borrowObligationLiquidity: Buffer;
+    borrowObligationLiquidityV2: Buffer;
+    repayObligationLiquidity: Buffer;
+    repayObligationLiquidityV2: Buffer;
+    initObligation: Buffer;
+    initObligationFarmsForReserve: Buffer;
+    refreshReserve: Buffer;
+    refreshObligation: Buffer;
+};
+/**
+ * Creates a basic ProgramInteraction policy configuration.
+ */
+export declare 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;
+/**
+ * Creates an instruction constraint for a specific program.
+ */
+export declare function createInstructionConstraint(params: {
+    programId: PublicKey;
+    accountConstraints?: AccountConstraint[];
+    dataConstraints?: DataConstraint[];
+}): InstructionConstraint;
+/**
+ * Creates an account constraint for a specific account index.
+ */
+export declare function createAccountConstraint(accountIndex: number, allowedKeys: PublicKey[]): AccountConstraint;
+/**
+ * Creates an account-data constraint for a specific account index.
+ */
+export declare function createAccountDataConstraint(accountIndex: number, accountDataConstraints: DataConstraint[]): AccountConstraint;
+/**
+ * Creates a data constraint to match instruction discriminator (first 8 bytes).
+ */
+export declare function createDiscriminatorConstraint(discriminator: Buffer | number[]): DataConstraint;
+/**
+ * Account indices in Kamino Lending instructions
+ */
+export declare const KAMINO_ACCOUNT_INDICES: {
+    initObligation: {
+        owner: number;
+        feePayer: number;
+        obligation: number;
+        lendingMarket: number;
+        seed1Account: number;
+        seed2Account: number;
+        ownerUserMetadata: number;
+        rent: number;
+        systemProgram: number;
+    };
+    depositCollateral: {
+        owner: number;
+        obligation: number;
+        lendingMarket: number;
+        lendingMarketAuthority: number;
+        reserve: number;
+        reserveLiquidityMint: number;
+        reserveLiquiditySupply: number;
+        reserveCollateralMint: number;
+        reserveDestinationDepositCollateral: number;
+        obligationCollateralTokenAccount: number;
+        userSourceLiquidity: number;
+        placeholderUserDestinationCollateral: number;
+        collateralTokenProgram: number;
+        liquidityTokenProgram: number;
+        instructionSysvarAccount: number;
+    };
+    withdrawCollateral: {
+        owner: number;
+        obligation: number;
+        lendingMarket: number;
+        lendingMarketAuthority: number;
+        withdrawReserve: number;
+        reserveLiquidityMint: number;
+        reserveSourceCollateral: number;
+        reserveCollateralMint: number;
+        reserveLiquiditySupply: number;
+        userDestinationLiquidity: number;
+        placeholderUserDestinationCollateral: number;
+        obligationCollateralTokenAccount: number;
+        collateralTokenProgram: number;
+        liquidityTokenProgram: number;
+        instructionSysvarAccount: number;
+    };
+    borrow: {
+        owner: number;
+        obligation: number;
+        lendingMarket: number;
+        lendingMarketAuthority: number;
+        borrowReserve: number;
+        borrowReserveLiquidityMint: number;
+        reserveSourceLiquidity: number;
+        borrowReserveLiquidityFeeReceiver: number;
+        userDestinationLiquidity: number;
+        referrerTokenState: number;
+        liquidityTokenProgram: number;
+        instructionSysvarAccount: number;
+    };
+    repay: {
+        owner: number;
+        obligation: number;
+        lendingMarket: number;
+        repayReserve: number;
+        reserveLiquidityMint: number;
+        reserveDestinationLiquidity: number;
+        userSourceLiquidity: number;
+        liquidityTokenProgram: number;
+        instructionSysvarAccount: number;
+    };
+};
+/**
+ * Creates a policy that allows Kamino account initialization for specific lending markets.
+ */
+export declare 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;
+/**
+ * Creates a policy that allows depositing into specific Kamino reserves.
+ */
+export declare 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;
+/**
+ * Creates a policy that allows withdrawing from specific Kamino reserves.
+ */
+export declare 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;
+/**
+ * Creates a policy that allows borrowing from specific Kamino reserves.
+ */
+export declare 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;
+/**
+ * Creates a policy that allows repaying on specific Kamino reserves.
+ */
+export declare 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;
+/**
+ * Creates a combined Kamino policy that allows multiple actions on the same reserves.
+ */
+export declare 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;
+/** 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 declare 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;
+export declare const EXPONENT_CORE_PROGRAM_ID: PublicKey;
+/**
+ * Single-byte discriminators for Exponent Core wrapper instructions.
+ */
+export declare const EXPONENT_CORE_DISCRIMINATORS: {
+    initializeYieldPosition: Buffer;
+    collectInterest: Buffer;
+    depositYt: Buffer;
+    withdrawYt: Buffer;
+    wrapperCollectInterest: Buffer;
+    wrapperStrip: Buffer;
+    wrapperMerge: Buffer;
+};
+/**
+ * Account indices in Exponent Core initialize_yield_position instruction.
+ */
+export declare const EXPONENT_CORE_INITIALIZE_YIELD_POSITION_ACCOUNT_INDICES: {
+    owner: number;
+    vault: number;
+    yieldPosition: number;
+    systemProgram: number;
+    eventAuthority: number;
+    program: number;
+};
+/**
+ * Account indices in Exponent Core wrapper_strip instruction.
+ */
+export declare const EXPONENT_CORE_STRIP_ACCOUNT_INDICES: {
+    depositor: number;
+    tokenSyDepositor: number;
+    vault: number;
+    escrowSy: number;
+    tokenYtDepositor: number;
+    tokenPtDepositor: number;
+    mintYt: number;
+    mintPt: number;
+    authority: number;
+    vaultAddressLookupTable: number;
+    tokenProgram: number;
+    escrowYt: number;
+    userYieldPosition: number;
+    vaultRobotYieldPosition: number;
+    syProgram: number;
+    systemProgram: number;
+};
+/**
+ * Account indices in Exponent Core wrapper_merge instruction.
+ */
+export declare const EXPONENT_CORE_MERGE_ACCOUNT_INDICES: {
+    merger: number;
+    tokenSyMerger: number;
+    vault: number;
+    escrowSy: number;
+    tokenYtMerger: number;
+    tokenPtMerger: number;
+    mintYt: number;
+    mintPt: number;
+    authority: number;
+    vaultAddressLookupTable: number;
+    tokenProgram: number;
+    vaultRobotYieldPosition: number;
+    syProgram: number;
+    systemProgram: number;
+};
+export declare const EXPONENT_CORE_DEPOSIT_YT_ACCOUNT_INDICES: {
+    depositor: number;
+    vault: number;
+};
+export declare const EXPONENT_CORE_COLLECT_INTEREST_ACCOUNT_INDICES: {
+    owner: number;
+    vault: number;
+};
+export declare const EXPONENT_CORE_WITHDRAW_YT_ACCOUNT_INDICES: {
+    owner: number;
+    vault: number;
+};
+export declare const EXPONENT_CORE_WRAPPER_COLLECT_INTEREST_ACCOUNT_INDICES: {
+    claimer: number;
+    vault: number;
+};
+export declare const EXPONENT_VAULT_ACCOUNT_DATA_OFFSETS: {
+    readonly mintSy: 40n;
+};
+/** Core actions that can be included in a policy */
+export type CorePolicyAction = "initializeYieldPosition" | "collectInterest" | "depositYt" | "withdrawYt" | "wrapperCollectInterest" | "strip" | "merge";
+/**
+ * Creates instruction constraints for Exponent Core operations.
+ */
+export declare 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[];
+/**
+ * Creates a complete Exponent Core strip/merge policy configuration.
+ */
+export declare 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;
+export declare const EXPONENT_ORDERBOOK_PROGRAM_ID: PublicKey;
+export declare const MARGINFI_STANDARD_PROGRAM_ID: PublicKey;
+export declare const KAMINO_STANDARD_PROGRAM_ID: PublicKey;
+export declare const JITO_RESTAKING_STANDARD_PROGRAM_ID: PublicKey;
+export declare const PERENA_STANDARD_PROGRAM_ID: PublicKey;
+export declare const GENERIC_STANDARD_PROGRAM_ID: PublicKey;
+/**
+ * Single-byte discriminators for Exponent Orderbook wrapper instructions.
+ * The orderbook uses single-byte discriminators, not 8-byte Anchor discriminators.
+ */
+export declare const ORDERBOOK_DISCRIMINATORS: {
+    rawPostOffer: Buffer;
+    rawMarketOffer: Buffer;
+    wrapperPostOffer: Buffer;
+    wrapperMarketOffer: Buffer;
+    wrapperRemoveOffer: Buffer;
+    wrapperWithdrawFunds: Buffer;
+};
+/**
+ * Account indices in Exponent Orderbook wrapper instructions.
+ * Used for setting up account constraints.
+ */
+export declare const ORDERBOOK_ACCOUNT_INDICES: {
+    trader: number;
+    orderbook: number;
+    vault: number;
+};
+/** 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 declare 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[];
+export declare const STANDARD_PROGRAM_DISCRIMINATORS: {
+    mint: Buffer;
+    redeem: Buffer;
+};
+type StandardProgramAccountIndices = {
+    mint: {
+        mintSy: number;
+    };
+    redeem: {
+        mintSy: number;
+    };
+};
+export declare const STANDARD_PROGRAM_ACCOUNT_INDICES: Record<string, StandardProgramAccountIndices>;
+export type StandardProgramPolicyAction = "mintSy" | "redeemSy";
+export type AllowedSyMintProgram = {
+    syMint: PublicKey;
+    programId: PublicKey;
+};
+export declare function createStandardProgramInstructionConstraints(params: {
+    allowedSyMints: AllowedSyMintProgram[];
+    actions: StandardProgramPolicyAction[];
+}): InstructionConstraint[];
+export declare function createStandardProgramPolicy(params: {
+    allowedSyMints: AllowedSyMintProgram[];
+    actions: StandardProgramPolicyAction[];
+    spendingLimits?: SpendingLimit[];
+    threshold?: number;
+    timeLock?: number;
+}): PolicyConfig;
+/**
+ * Creates a complete Exponent Orderbook policy configuration.
+ *
+ * @example
+ * ```ts
+ * const policy = createOrderbookPolicy({
+ *   allowedSyMints: [BULKSOL_SY_MINT],
+ *   actions: ["postOffer", "marketOffer", "removeOffer", "withdrawFunds"],
+ * })
+ * ```
+ */
+export declare const TITAN_PROGRAM_ID: PublicKey;
+export declare const TITAN_DISCRIMINATORS: {
+    swapRouteV2: Buffer;
+};
+export declare const TITAN_ACCOUNT_INDICES: {
+    inputMint: number;
+    outputMint: number;
+};
+/**
+ * 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 declare function createTitanSwapPolicy(params?: {
+    /** Allowed input/output mints (optional) */
+    allowedMints?: PublicKey[];
+    /** Threshold (default 1) */
+    threshold?: number;
+    /** Time lock in seconds (default 0) */
+    timeLock?: number;
+}): PolicyConfig;
+/** Loopscale lending protocol program ID. */
+export declare const LOOPSCALE_PROGRAM_ID: PublicKey;
+/**
+ * Derive a Loopscale Strategy PDA.
+ * seeds = ["strategy", nonce] where nonce is a Pubkey (keypair generated at creation).
+ */
+export declare function deriveLoopscaleStrategyAddress(nonce: PublicKey): [PublicKey, number];
+/**
+ * Derive a Loopscale Loan PDA.
+ * seeds = [borrower, nonce] where nonce is a u64 (typically current timestamp).
+ */
+export declare function deriveLoopscaleLoanAddress(borrower: PublicKey, nonce: bigint): [PublicKey, number];
+/**
+ * 8-byte Anchor discriminators for Loopscale instructions (loans + strategies).
+ * Must match the on-chain constants in `interaction_validations/loopscale.rs`.
+ */
+export declare const LOOPSCALE_DISCRIMINATORS: {
+    createLoan: Buffer;
+    depositCollateral: Buffer;
+    borrowPrincipal: Buffer;
+    repayPrincipal: Buffer;
+    withdrawCollateral: Buffer;
+    closeLoan: Buffer;
+    createStrategy: Buffer;
+    depositStrategy: Buffer;
+    withdrawStrategy: Buffer;
+    closeStrategy: Buffer;
+    updateWeightMatrix: Buffer;
+    lockLoan: Buffer;
+    unlockLoan: Buffer;
+    updateStrategy: Buffer;
+    refinanceLedger: Buffer;
+};
+/**
+ * Account indices for Loopscale instructions (loans + strategies), matching
+ * the on-chain validation in `interaction_validations/loopscale.rs`.
+ */
+export declare const LOOPSCALE_ACCOUNT_INDICES: {
+    /** Loan account (BORROWER side) — index 3 for loan instructions, index 2 for update_weight_matrix */
+    loan: number;
+    updateWeightMatrixLoan: number;
+    /** Mint indices vary per instruction */
+    depositCollateralMint: number;
+    borrowPrincipalMint: number;
+    repayPrincipalMint: number;
+    withdrawCollateralMint: number;
+    strategy: number;
+    depositStrategyMint: number;
+    withdrawStrategyMint: number;
+    lockLoanLoan: number;
+    unlockLoanLoan: number;
+    refinanceLedgerLoan: number;
+};
+export type LoopscalePolicyAction = "createLoan" | "depositCollateral" | "borrowPrincipal" | "repayPrincipal" | "withdrawCollateral" | "closeLoan" | "updateWeightMatrix" | "lockLoan" | "unlockLoan" | "createStrategy" | "depositStrategy" | "withdrawStrategy" | "closeStrategy" | "updateStrategy" | "refinanceLedger";
+/**
+ * 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 declare 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;
+export declare 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;
+/** Exponent CLMM program ID. */
+export declare const EXPONENT_CLMM_PROGRAM_ID: PublicKey;
+/**
+ * Single-byte discriminators for CLMM instructions.
+ * These correspond to the instruction indices in the CLMM program.
+ */
+export declare const CLMM_DISCRIMINATORS: {
+    depositLiquidity: Buffer;
+    addLiquidity: Buffer;
+    withdrawLiquidity: Buffer;
+    tradePt: Buffer;
+    tradePtExactOut: Buffer;
+    buyYt: Buffer;
+    sellYt: Buffer;
+    claimFarmEmission: Buffer;
+};
+/**
+ * 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 declare const CLMM_ACCOUNT_INDICES: {
+    depositLiquidity: {
+        depositor: number;
+        market: number;
+        ticks: number;
+        lpPosition: number;
+        tokenPtSrc: number;
+        tokenSySrc: number;
+    };
+    addLiquidity: {
+        owner: number;
+        market: number;
+        ticks: number;
+        lpPosition: number;
+        tokenPtSrc: number;
+        tokenSySrc: number;
+    };
+    withdrawLiquidity: {
+        owner: number;
+        market: number;
+        lpPosition: number;
+        ticks: number;
+        tokenPtDst: number;
+        tokenSyDst: number;
+    };
+    tradePt: {
+        trader: number;
+        market: number;
+        ticks: number;
+        tokenSyTrader: number;
+        tokenPtTrader: number;
+    };
+    tradePtExactOut: {
+        trader: number;
+        market: number;
+        ticks: number;
+        tokenSyTrader: number;
+        tokenPtTrader: number;
+    };
+    buyYt: {
+        trader: number;
+        market: number;
+        ticks: number;
+        tokenSyTrader: number;
+        tokenYtTrader: number;
+        tokenPtTrader: number;
+    };
+    sellYt: {
+        trader: number;
+        market: number;
+        ticks: number;
+        tokenYtTrader: number;
+        tokenPtTrader: number;
+        tokenSyTrader: number;
+    };
+    claimFarmEmission: {
+        owner: number;
+        market: number;
+        ticks: number;
+        lpPosition: number;
+        tokenDst: number;
+        mint: number;
+        tokenFarm: number;
+        tokenProgram: number;
+    };
+};
+/**
+ * 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 declare 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;
+export {};