Skip to main content
Kimia is not a monolith. Every responsibility, matching engine, hedging, tokenization, AMM, stablecoin, is a separate Anchor program, and the programs talk to each other via CPI. This makes each piece usable in isolation.

​
Program map

kimia-perp

Matching engine, orderbook, funding, liquidation, spot pool.

delta-vault

Holds USDC, opens/maintains a SOL-PERP short, mints vault shares.

split-engine

Wraps vault shares into PT + YT with MasterChef-style yield accounting.

yield-amm

Yield-space AMM for PT ↔ underlying, with prices that decay into par at maturity.

intent-router

Session state machine that verifies a multi-step fixed-rate lock succeeded.

kusd-mint

Stablecoin with multi-reserve backing and staking-based yield distribution.

​
Layered view

 ┌────────────────────────────────────────────────────────┐
 │                     Frontend / UX                      │
 │  (Next.js, @solana/kit, Codama-generated TS clients)   │
 └────────────────────────────────────────────────────────┘
                          │
 ┌────────────────────────────────────────────────────────┐
 │                 Intent / Composition                   │
 │                   intent-router                        │
 │   (session state machine — verifies each TX succeeded) │
 └────────────────────────────────────────────────────────┘
                          │
 ┌──────────────┬─────────┴────────┬────────────────────┐
 │  split-engine│    yield-amm     │     kusd-mint      │
 │  PT + YT     │  x · y^t = k     │   multi-reserve    │
 └──────────────┴─────────┬────────┴────────────────────┘
                          │
 ┌────────────────────────┴───────────────────────────────┐
 │                    delta-vault                         │
 │   (holds USDC, opens SOL short, splits funding yield)  │
 └────────────────────────┬───────────────────────────────┘
                          │
 ┌────────────────────────┴───────────────────────────────┐
 │                     kimia-perp                         │
 │  (orderbook, matching, funding, liquidation, spot)     │
 └────────────────────────┬───────────────────────────────┘
                          │
 ┌────────────────────────┴───────────────────────────────┐
 │               Pyth Hermes Pull Oracles                 │
 └────────────────────────────────────────────────────────┘

​
CPI graph

Arrows mean “A invokes B via CPI” between Kimia’s own programs. External programs can CPI in the same way, but note that Kimia does not publish its program crates to crates.io — consumers add them as path or git dependencies in their own Cargo.toml with features = ["cpi"]. 
  ┌────────────────┐
  │  intent-router │◄────── user (multi-tx session)
  └───────┬────────┘
          │ no CPI — verifies by reading account state
          ▼
  ┌────────────────┐     ┌────────────────┐     ┌────────────────┐
  │  delta-vault   │     │  split-engine  │     │   yield-amm    │
  └───────┬────────┘     └────────┬───────┘     └────────┬───────┘
          │                       │                      │
          │ deposit_collateral    │ reads vault          │ uses kimia-math
          │ spot_swap             │ share price          │
          │ place_order (short)   │                      │
          │ settle_funding        │                      │
          ▼                       │                      │
  ┌────────────────┐               │                      │
  │   kimia-perp   │◄──────────────┘                      │
  └────────────────┘                                      │
                                                          │
                              ┌────────────────┐          │
                              │  vault shares  │◄─────────┘
                              └────────────────┘

​
The fixed-rate lock, three transactions

The canonical user flow uses all five programs to turn USDC into a guaranteed fixed rate:
1

TX1, Deposit into delta-vault

User calls delta-vault::deposit(amount, open_perp=true). The vault splits the deposit 50/50, swaps one half into wSOL via spot_swap, and opens a matching SOL-PERP short via place_order. The user receives vault shares.
2

TX2, Split into PT + YT

User calls split-engine::deposit(vault_shares). The engine escrows the vault shares and mints PT (1:1) and YT (1:1) to the user.
3

TX3, Swap YT for underlying on yield-amm

User calls yield-amm::swap(YT → underlying). YT trades at a discount, the difference between what you paid and what you got back is the prepaid yield.
4

record_step3, Verify achieved rate

The intent-router recomputes the achieved APY from the swap receipts and reverts if it’s below the user’s target_rate. This is what makes it a “fixed-rate intent” instead of a hopeful multi-step script.

​
Design principles

Matching ≠ hedging ≠ tokenizing. Each program’s account model is independently auditable, and integrations only need to grok the parts they use.
update_funding_rate, liquidate, update_rewards, and rebalance can be called by anyone. The protocol pays the liquidator and skims yield for the insurance fund, incentives align, no whitelist.
Open orders lock collateral at placement. You can’t over-leverage by spamming the orderbook, a position and a resting order compete for the same free collateral.
The shared kimia-math and perps-math crates always round down on the user’s side. No “$0.00000001 of free money” arbitrage.