Vault Depositors and LP Tokens
A Strategy Vault is a shared pool of capital managed by a manager. Depositors interact with Strategy Vaults by:
- Depositing a supported token → receive Vault LP tokens representing their share
- Queuing a withdrawal → lock LP tokens and request redemption
- Filling the withdrawal (manager) → LP tokens are burned and underlying tokens are allocated
- Executing the withdrawal → receive underlying tokens
Strategy Vault LP tokens are fungible SPL tokens. Their value appreciates as the vault earns yield and grows AUM.
Token Entries
Each Strategy Vault can have one or more token entries — a configuration object for each accepted deposit token. A token entry specifies:
mint — the token’s SPL mint addressinterfaceType — the protocol this token is deployed into (exponent, kamino, titan, etc.)priceId — how this token’s price is derived (simple oracle or multiply)tokenEscrow / tokenSquadsAccount — the onchain escrow accounts
Vault Policies
Policies are Squads-level constraints that govern what actions the vault’s smart account can take. Before any strategy interaction, a matching policy must exist onchain.
See Policy Builders for setup details.
Protocol Integrations
Exponent Strategy Vault Policies support several protocol interactions, all executed through the createVaultSyncTransaction builder:
Exponent Core
Exponent CLMM
Exponent Orderbook
Kamino Lend
Titan DEX
Strip base tokens into PT + YT and merge them back through the Exponent Core program.import { coreAction } from "@exponent-labs/exponent-sdk";
const strip = coreAction.strip({
vault: new PublicKey("..."),
amountBase: 1_000_000_000n,
});
Provide concentrated liquidity on the Exponent CLMM, trade PT and YT, and claim farm emissions. LP positions are created with a specified tick range (APY boundaries).import { clmmAction } from "@exponent-labs/exponent-sdk";
const depositLp = clmmAction.depositLiquidity({
market: new PublicKey("..."),
ptInIntent: 1_000_000_000n,
syInIntent: 1_000_000_000n,
lowerTickKey: 500,
upperTickKey: 1500,
});
Trade PT and YT on Exponent Orderbooks — posting limit orders, executing market orders, cancelling offers, and withdrawing settled funds. Orders are quoted in implied APY.import { orderbookAction, OrderbookTradeDirection } from "@exponent-labs/exponent-sdk";
const buyPt = orderbookAction.postOffer({
orderbook: new PublicKey("..."),
direction: OrderbookTradeDirection.BUY_PT,
priceApy: 0.10,
amount: 1_000_000_000n,
offerIdx: 0,
});
Kamino Lend is a lending protocol. The SDK supports deploying vault capital into Kamino reserves — including deposits, withdrawals, borrows, and repayments.Setup PrerequisitesBefore interacting with Kamino, two one-time setup instructions must run for the vault owner:
- Init User Metadata — creates a
UserMetadata PDA on Kamino Lending (global, one per wallet)
- Init Obligation — creates an
Obligation PDA tied to a specific lending market (one per market)
Both are idempotent: they check if the account already exists before issuing the instruction.Execution FlowEvery Kamino interaction requires three steps: build a descriptor, wrap it in a sync transaction, and send it.// 1. Build an instruction descriptor (does not execute anything on its own)
const depositInstruction = kaminoAction.deposit(KaminoMarket.MAIN, "USDC", new BN(100_000_000));
// 2. Wrap in a Squads sync transaction — resolves all accounts and refresh instructions
const { preInstructions, instruction, postInstructions } =
await createVaultSyncTransaction({
instructions: [depositInstruction],
owner: vaultPda,
connection,
policyPda,
vaultPda,
signer: wallet.publicKey,
vaultAddress,
});
// 3. Assemble and send — all three parts must be included in order
const tx = new Transaction().add(...preInstructions, instruction, ...postInstructions);
await sendAndConfirmTransaction(connection, tx, [wallet]);
import { KaminoMarket, KAMINO_MARKETS, KAMINO_RESERVES } from "@exponent-labs/exponent-sdk";
// Get the lending market public key
const lendingMarket = KAMINO_MARKETS[KaminoMarket.MAIN];
// Get a specific reserve — returns { pubkey, mint }
const solReserve = KAMINO_RESERVES[KaminoMarket.MAIN]["SOL"].pubkey;
MAIN, JLP, ALTCOINS, ETHENA, JITO, BITCOIN, JUPITER, EXPONENT_PT_SOL, and more. Swap tokens through Titan, a Solana DEX aggregator. Quotes are fetched from Titan’s WebSocket API and then wrapped in a sync transaction.import { getTitanQuote, titanAction } from "@exponent-labs/exponent-sdk";
const quoteResult = await getTitanQuote(connection, auth, {
inputMint: new PublicKey("..."),
outputMint: new PublicKey("..."),
amount: 1_000_000_000n,
userPublicKey: vaultPda,
});
const swap = titanAction.swap({ instruction: quoteResult.instruction });
Withdrawal Queue
Withdrawals from the vault are not instant. The process is as follow:
- Queue — depositor calls
ixQueueWithdrawal({ depositor, lpAmount }). LP tokens are moved to escrow and a withdrawal account is created. The method returns { ix, withdrawalKeypair } — save the keypair’s public key for later.
- Fill — the vault manager calls
fillWithdrawal to associate underlying tokens with the withdrawal request. LP tokens are burned at this step.
- Execute — depositor calls
ixExecuteWithdrawal({ owner, withdrawalAccount, tokenAccountPairs }) to receive their underlying tokens.
Save the withdrawalKeypair.publicKey returned from step 1 — you’ll need it to execute the withdrawal. If lost, you can recover it by querying withdrawal accounts via RPC.
AUM Calculation
The vault tracks total AUM as:
AUM = aum_in_base + aum_in_base_in_positions
aum_in_base — tokens currently sitting in vault escrows (not deployed)aum_in_base_in_positions — tokens deployed into strategy positions, valued in base units
Prices are read from the ExponentPrices global account, which aggregates oracle data.
