Search across all documentation pages
DeFi integrations on Solana are patterns for composing liquidity, credit, stake receipts, prices, and derivatives through explicit account lists and cross-program invocations (CPIs). Once you map AMMs, Jupiter routing, lending, LSTs, oracles, perps, and Jito/MEV as one composability graph, product design becomes "which programs, which accounts, which failure modes," not a pile of unrelated SDKs.
DeFi Basics on Solana is the hands-on entry; AMMs (Raydium, Orca, Meteora), Lending & Borrowing, Liquid Staking (LSTs), Oracles, and Jito & MEV each zoom into one surface. This page sits underneath: how the DeFi stack fits together for builders.
Solana does not ship a single "DeFi VM." It ships a runtime that moves lamports and program-owned bytes under owner-writes rules, plus programs that interpret those bytes as pools, banks, stake receipts, and order books. Integration means speaking those programs' instruction layouts and account graphs correctly.
Every durable balance is still an SPL token account (or native / wrapped SOL). DeFi positions add more accounts: pool vaults, obligation PDAs, LST mints, margin accounts, oracle feeds. Clients and programs must declare them so Sealevel can lock them and CPIs can pass them down the stack.
Think of the builder map as layers from user intent to inclusion:
User intent (swap, lend, lever, hedge)
|
v
+--------------------------------------+
| Aggregators / routers (e.g. Jupiter) | optional off-chain route plan
+--------------------------------------+
| Venue programs: AMM / CLOB / perps / |
| lending / stake pools | on-chain state + CPI
+--------------------------------------+
| Oracles (Pyth, Switchboard, ...) | price and risk inputs
+--------------------------------------+
| Token Program + ATAs / vaults | custody of balances
+--------------------------------------+
| Inclusion: priority fees, Jito tips | land under contention
+--------------------------------------+AMMs (Raydium, Orca, Meteora, and peers) hold reserves or concentrated liquidity and price swaps by curve or tick math. Jupiter sits above many of them: quote off-chain and return a route so you do not maintain every pool graph. Lending (Kamino, MarginFi, and similar) maps collateral and debt to health and liquidations. LSTs (jitoSOL, mSOL, and peers; often Sanctum-style routing) wrap staked SOL into fungible claims for collateral and loops. Oracles publish price accounts you treat as time-bounded inputs. Perps and order books add positions, matching, and mark/funding rules. Jito and MEV paths decide whether multi-leg flow lands atomically and who captures sandwich or arb value.
The rule: your product owns the composition. Each leg is a validated CPI or client-built instruction list; atomicity is one transaction succeeds or none do until you deliberately multi-tx and accept partial state.
Before any swap or deposit, resolve mints, decimals, and ATAs for the user and intermediate hops. Missing ATAs are a common "works in tests, fails in wallet" bug. Wrap/unwrap SOL is first-class; treat wSOL as a mint with create/close, not free-floating lamports inside every pool.
Wallet (system-owned)
|
+--> ATA(mint_in) --transfer/CPI--> pool/user vaults
+--> ATA(mint_out) <--receive------- venue programDirect AMM work fits LP deposit/withdraw, custom routing, or on-chain CPI swaps without an aggregator. Validate program id, pool mints, and vault addresses before transfer CPI. See AMMs (Raydium, Orca, Meteora).
Constant-product intuition helps, but production liquidity is often concentrated or dynamic. Refresh pool state at build time and enforce slippage (min out / max in).
Swaps with Jupiter is the default product path: quote → swap tx → sign with @solana/kit. Duties remain: pin slippage bps, handle wrap SOL, simulate, re-quote on failure. Do not hard-code forever routes; liquidity migrates.
Use Jupiter for best price and low maintenance. Use direct AMM CPIs when your program must control path, custody, or fee skim inside one stack.
Money markets turn deposits into supply and allow borrows under a health factor: deposit collateral, optionally borrow, monitor health, and design for liquidators. Leverage loops are lending + AMM/Jupiter, not a separate chain feature. Plan for oracle dependency and utilization spikes. Details: Lending & Borrowing.
An LST is usually an SPL mint whose rate tracks staked SOL (minus provider fees). That unlocks collateral and faster market exit, plus contract, liquidity, and depeg risk. Surfaces: mint/redeem, LST swaps, collateral with oracle haircuts. See Liquid Staking (LSTs).
Any borrow, liquidation, or funding that depends on USD value must read a price feed, enforce max age, confidence, and correct feed id. Pyth and Switchboard still require fail-closed checks on stale or wrong accounts.
risk action --> load feed --> age/conf OK? --> convert units --> LTV or min-out
|
fail closed if stale or wrong feedDo not use last-trade pool spot alone as the risk oracle for undercollateralized credit. See Oracles.
CLOBs and perps optimize for price-time priority, limits, and leverage. Account graphs grow (market, orders, positions, vaults). Partial fills differ from AMM single-price swaps. Prefer them when limit UX or derivatives models beat curve swaps. See Perps & Order Books.
Multi-leg DeFi competes on inclusion and ordering. Priority fees bid via compute unit price. Jito bundles and tips are a parallel path through block engines.
Path A: single tx + CU price --> public leader schedule
Path B: bundle + tip --> block engine --> leaderBound slippage, consider bundles for toxic flow, and do not confuse tips with Compute Budget priority fees. See Jito & MEV.
Example: leveraged LST exposure.
The blueprint is complete when you can name program per leg, writable accounts, oracle gates, and how inclusion is bought.
Production DeFi fails less on algebra than on account graphs, versioning, and contention. Match depth to surface.
| Path | What you integrate | Strengths | Weaknesses | Best fit |
|---|---|---|---|---|
| Jupiter-only swaps | Quote/swap API + kit | Fast ship; multi-venue | Off-chain dependency | Wallets, rebalance |
| Direct AMM CPI | Pool accounts + ix | On-chain control; LP | Layout churn | Vaults, custom routers |
| Lending + oracle | Banks, obligations, feeds | Credit and leverage | Liquidation / pause risk | Money markets, loops |
| LST collateral stack | Pools + lending + oracles | Yield-bearing collateral | Depeg, provider risk | Treasury and loops |
| Perps / CLOB | Market + positions | Limits; derivatives | Latency and ops cost | Trading venues, hedges |
| MEV-aware landing | Tips, bundles, fees | Better atomic land rates | Extra infra | Liquidators, arbs, size |
CU and account limits cap hops per transaction. Split only with recovery: if leg 1 lands and leg 2 fails, UX must handle partial state.
Program upgrades change discriminators and remaining accounts. Pin IDL/SDK versions and fixture-test mainnet txs across upgrades.
Hot accounts serialize writers under load. Fees, tips, simulation, and fresh blockhashes are part of DeFi integration, not "infra only."
Security for integrators: verify external program ids, constrain client-supplied oracle/pool accounts, enforce slippage and health on-chain when you CPI, and document venue pause/upgrade authorities.
For design reviews: intent → instruction graph, custody per mint, oracle policy, slippage/health bounds, landing strategy, and which sibling article owns the deep dive.
Compose external programs through explicit accounts and CPIs (or client-built instruction lists), and treat oracles, slippage, health, and inclusion as first-class product requirements, not afterthoughts.
Use Jupiter for best-price user swaps and simple rebalances without maintaining pool graphs. Use direct AMM paths for LP management, tightly controlled on-chain CPI, or venue-specific features aggregators do not expose.
User token accounts (in/out), intermediate ATAs if multi-hop, pool or route accounts, Token Program, sometimes System Program for ATA create or SOL wrap, and compute budget accounts for fees.
They are separate programs. Leverage and vault strategies often CPI or sequence both: borrow from a money market, swap on an AMM or via Jupiter, then deposit again.
They turn staked SOL into a transferable SPL balance that markets accept as collateral or liquidity, enabling yield-bearing loops without native stake account UX on every hop.
Correct feed account, price age bound, confidence or status checks, and unit conversion (expo, decimals) before any risk-sensitive math.
CLOBs use order and position accounts with place/cancel/match semantics and often tighter latency requirements; AMMs usually price from pool state in a single swap-style instruction.
When atomic multi-transaction strategies, liquidations, or high-value order-sensitive flows need better inclusion and ordering than public mempool priority fees alone provide.
Many products build Jupiter transactions off-chain with kit. Pure on-chain aggregator CPI is specialized and version-sensitive; prefer known venue interfaces when you must CPI from a program.
Stale quotes, undersized CU, missing writable accounts, hot-account contention, and underpriced fees or tips - more often than pure math bugs.
Decide wrap policy up front. Many venues want wSOL ATAs: create, fund, use, and close temporary accounts so users are not left with dust or failed transfers.
The protocol ratio of haircut, oracle-priced collateral to debt; below threshold the position is liquidatable.
RPC and kit suffice for current balances and one-shot txs. History, PnL, liquidator scanners, and ops metrics need parsed indexed events.
Pin SDKs/IDLs, fixture-test real transactions, gate remaining-account changes behind client versions, and watch upgrade authorities you depend on.
Map mints and ATAs, name external program ids, define oracle and slippage/health policy, simulate full txs, set CU and fee/tip strategy, document partial-failure recovery, and own venue upgrade response.
Stack versions: This page was written for Agave 4.1.1, Solana CLI 3.0.10, Anchor 0.32.1, Rust 1.91.1, and @solana/kit 7.0.0.
Reviewed by Chris St. John·Last updated Jul 15, 2026