Create Vault (via SDK)

Strategy Vaults can also be created through the Strategy Vault manager frontend, which simplifies setup by offering a guided interface for configuring vault metadata, policies, roles, and other core vault parameters.

This guide walks through the vault setup workflow, from loading a vault to configuring policies and executing strategy operations, as well as managing withdrawals.

Exponent SDK Installation

yarn add @exponent-labs/exponent-sdk

npm install @exponent-labs/exponent-sdk

pnpm add @exponent-labs/exponent-sdk

Strategy Vault Setup

import { ExponentVault } from "@exponent-labs/exponent-sdk";
import {
  Connection,
  PublicKey,
  Transaction,
  sendAndConfirmTransaction,
  Keypair,
} from "@solana/web3.js";
const connection = new Connection("https://api.mainnet-beta.solana.com");
const wallet = Keypair.fromSecretKey(/* your keypair */);
const vaultAddress = new PublicKey("...");

// Load the vault — fetches on-chain state and all token entries
const vault = await ExponentVault.load({ connection, address: vaultAddress });

Vault Creation

Strategy Vaults are created by the vault manager using ExponentVault.ixInitializeVault. This sets up the vault PDA, mints initial LP tokens, and creates the Squads smart account for policy-gated execution. See Initialize Vault for the full parameter reference.

Loading a Vault

import { ExponentVault } from "@exponent-labs/exponent-sdk";
import { Connection, PublicKey } from "@solana/web3.js";

const connection = new Connection("https://api.mainnet-beta.solana.com");
const vaultAddress = new PublicKey("...");

const vault = await ExponentVault.load({ connection, address: vaultAddress });

// Access vault state
const squadsVault = vault.state.squadsVault;     // Squads smart account PDA
const tokenEntries = vault.state.tokenEntries;    // Accepted deposit tokens
const aumInBase = vault.state.financials.aumInBase;

Configuring Policies

Before the vault can execute any strategy operations, the manager must add policies that authorize specific interactions. Each policy defines which programs, instructions, and accounts the vault is permitted to interact with. Policies are added using vault.ixWrapperAddPolicy. This instruction enforces that the vault has zero AUM — policies must be configured before any deposits are accepted.

Once the vault holds depositor funds (AUM > 0), policy changes must go through a governance proposal using PolicyAction. See Governance for the proposal flow.

import {
  ExponentVault,
  createKaminoPolicy,
  KAMINO_MARKETS,
  KAMINO_RESERVES,
  KaminoMarket,
} from "@exponent-labs/exponent-sdk";
import { Connection, PublicKey, Transaction, sendAndConfirmTransaction } from "@solana/web3.js";

const connection = new Connection("https://api.mainnet-beta.solana.com");
const vault = await ExponentVault.load({ connection, address: vaultAddress });

const policyConfig = createKaminoPolicy({
  allowedDepositMints: [KAMINO_RESERVES[KaminoMarket.MAIN]["USDC"].mint],
  actions: ["deposit", "withdraw"],
  allowedLendingMarkets: [KAMINO_MARKETS[KaminoMarket.MAIN]],
});

const ix = vault.ixWrapperAddPolicy({
  payer: managerWallet.publicKey,
  policyConfig,
  squadsProgram,
  nextPolicySeed,
  nextTransactionIndex,
});

const tx = new Transaction().add(ix);
await sendAndConfirmTransaction(connection, tx, [managerWallet]);

Available Policy Builders

The SDK provides policy builders for each supported integration:

Builder	Integration	Description
`createCorePolicy`	Exponent Core	Strip and merge base tokens into PT + YT
`createMarketTwoTradePtPolicy`, `createMarketTwoBuyYtPolicy`, `createMarketTwoSellYtPolicy`	Exponent AMM (Market Two)	Trade PT, buy YT, and sell YT on legacy AMM markets
`createOrderbookPolicy`	Exponent Orderbook	Post offers, market orders, remove offers, withdraw funds
`createClmmPolicy`	Exponent CLMM	Provide liquidity, trade PT/YT, claim farm emissions
`createKaminoPolicy`	Kamino Lending	Deposit, withdraw, borrow, and repay on Kamino reserves
`createJupiterEarnPolicy`	Jupiter Lend Earn	Deposit, mint, withdraw, redeem on Jupiter Earn jlToken vaults
`createJupiterBorrowPolicy`	Jupiter Lend Borrow	Init, deposit/withdraw collateral, borrow/repay debt, and paired operate ops
`createOrcaWhirlpoolPolicy`	Orca Whirlpool	Open positions, modify liquidity, collect fees/rewards, close positions, and swap
`createLoopscalePolicy`	Loopscale	Authorize lender-side strategy and borrower-side loan actions
`createTitanSwapPolicy`	Titan	Swap tokens through the Titan DEX aggregator

See Policy Builders for detailed parameters and examples for each builder.

Policies are enforced onchain. Any transaction that does not match an approved policy is rejected. Ensure the correct policies are in place before attempting strategy operations.

Executing Strategy Operations

Strategy operations use a two-step pattern:

Build instruction descriptors using a protocol-specific action builder (kaminoAction, orderbookAction, coreAction, marketTwoAction, clmmAction, orcaWhirlpoolAction, titanAction). Each builder returns a lightweight descriptor — it does not execute anything on its own.
Wrap in a sync transaction by passing the descriptors to createVaultSyncTransaction, which resolves all required accounts, builds the Squads sync transaction, and returns the final instructions to send.

import {
  kaminoAction,
  createVaultSyncTransaction,
  KaminoMarket,
} from "@exponent-labs/exponent-sdk";
import { BN } from "@coral-xyz/anchor";

// Step 1: Build an instruction descriptor
const depositDescriptor = kaminoAction.deposit(KaminoMarket.MAIN, "USDC", new BN(100_000_000));

// Step 2: Wrap in a sync transaction
const { preInstructions, instruction, postInstructions } =
  await createVaultSyncTransaction({
    instructions: [depositDescriptor],
    owner: vaultPda,
    connection,
    policyPda,
    vaultPda,
    signer: wallet.publicKey,
    vaultAddress,
  });

// Step 3: Send
const tx = new Transaction().add(...preInstructions, instruction, ...postInstructions);
await sendAndConfirmTransaction(connection, tx, [wallet]);

Action Builders

Each integration has its own action builder namespace:

Action Builder	Integration	Example
`coreAction`	Exponent Core	`coreAction.strip({ vault, amountBase })`
`marketTwoAction`	Exponent AMM (Market Two)	`marketTwoAction.tradePt({ market, netTraderPt, syConstraint })`
`orderbookAction`	Exponent Orderbook	`orderbookAction.postOffer({ orderbook, direction, priceApy, amount, offerIdx })`
`clmmAction`	Exponent CLMM	`clmmAction.buyPt({ market, amountSy, outConstraint })`
`kaminoAction`	Kamino Lending	`kaminoAction.deposit(KaminoMarket.MAIN, "USDC", new BN(100_000_000))`
`jupiterEarnAction`	Jupiter Lend Earn	`jupiterEarnAction.deposit({ instruction })`
`jupiterBorrowAction`	Jupiter Lend Borrow	`jupiterBorrowAction.depositCollateral({ instruction, vaultId: 1 })`
`orcaWhirlpoolAction`	Orca Whirlpool	`orcaWhirlpoolAction.increaseLiquidityV2({ instruction })`
`managerAction`	Manager (vault-side)	`managerAction.fillWithdrawal({ withdrawalAccount, amount: { kind: "full" } })`
`titanAction`	Titan	`titanAction.swap({ instruction })`

For Titan swaps, the instruction descriptor wraps a pre-built TransactionInstruction obtained from TitanGatewayClient.quoteVaultSwapInstruction. See Titan Instructions for the full flow.

See the individual instruction pages for full usage and parameter details:

Policy Builders

Start here to define what your vault is allowed to do.

Core Instructions

Strip and merge tokens through Exponent Core.

Kamino Lend Instructions

Deposit, withdraw, borrow, and repay on Kamino Lend.

Kamino Vault Instructions

Deposit into and withdraw from direct Kamino Vault positions.

Order Book Instructions

Trade PT and YT on Exponent Orderbook, place limit orders.

Orca Whirlpool Instructions

Wrap Orca Whirlpool position and swap instructions for vault execution.

CLMM Instructions

Provide liquidity and trade on the Exponent CLMM.

Loopscale Instructions

Build raw Loopscale responses and turn them into executable vault transactions.

Titan Instructions

Swap tokens through the Titan DEX aggregator.

Managing Withdrawals

When depositors queue withdrawals, the vault manager fills them from available liquidity:

Queue — A depositor calls ixQueueWithdrawal to lock LP tokens and create a withdrawal request.
Fill — The vault manager calls fillWithdrawal to associate underlying tokens with the pending request. LP tokens are burned at this step.
Execute — The depositor calls ixExecuteWithdrawal to receive their underlying tokens.

See Moving Capital In/Out for the full depositor-facing flow.

Strategy Vault Basics

Vault Creation & Operations

Vault Strategy & Policies

Other Resources

Exponent SDK Installation

Strategy Vault Setup

Vault Creation

Loading a Vault

Configuring Policies

Available Policy Builders

Executing Strategy Operations

Action Builders

Policy Builders

Core Instructions

Kamino Lend Instructions

Kamino Vault Instructions

Order Book Instructions

Orca Whirlpool Instructions

CLMM Instructions

Loopscale Instructions

Titan Instructions

Managing Withdrawals

​Exponent SDK Installation

​Strategy Vault Setup

​Vault Creation

​Loading a Vault

​Configuring Policies

​Available Policy Builders

​Executing Strategy Operations

​Action Builders

Policy Builders

Core Instructions

Kamino Lend Instructions

Kamino Vault Instructions

Order Book Instructions

Orca Whirlpool Instructions

CLMM Instructions

Loopscale Instructions

Titan Instructions

​Managing Withdrawals

Exponent SDK Installation

Strategy Vault Setup

Vault Creation

Loading a Vault

Configuring Policies

Available Policy Builders

Executing Strategy Operations

Action Builders

Managing Withdrawals