Rise SDK

Rise is the developer-facing SDK surface for Phoenix perpetual futures. Use it after you understand the protocol concepts in the Phoenix docs and want to build an app, service, bot, or on-chain integration that reads Phoenix state and sends Phoenix instructions. The SDK sources live in the public repo: github.com/Ellipsis-Labs/rise-public. The SDK currently ships as:

rise/ts - TypeScript SDK with HTTP route clients, a unified Phoenix client, exchange metadata caching, instruction builders, order-packet helpers, WebSocket adapters, trader-state stores, and margin helpers.
rise/rust - Rust workspace centered on the phoenix-rise crate, with typed HTTP and WebSocket clients, PhoenixMetadata, PhoenixTxBuilder, trader-state containers, margin math, and low-level instruction builders.

Install

TypeScript

npm add @ellipsis-labs/rise

bun add @ellipsis-labs/rise

pnpm add @ellipsis-labs/rise

Rust

cargo add phoenix-rise

cargo add phoenix-rise --no-default-features --features api

cargo add phoenix-rise --no-default-features --features cpi

Create A Client

import { createPhoenixClient } from "@ellipsis-labs/rise";

const client = createPhoenixClient({
  apiUrl: "https://perp-api.phoenix.trade",
  rpcUrl: "https://api.mainnet-beta.solana.com",
  ws: { connectMode: "eager" },
  exchangeMetadata: { stream: true },
});

use phoenix_rise::{PhoenixHttpClient, PhoenixMetadata};

let http = PhoenixHttpClient::new_from_env()?;
let exchange = http.get_exchange().await?.into();
let metadata = PhoenixMetadata::new(exchange);

For package setup and runnable examples, use the public SDK sources:

Which Client To Use

Task	TypeScript	Rust
HTTP snapshots, history, and transaction-builder routes	`client.api` or `PhoenixHttpClient`	`PhoenixHttpClient`
Exchange params, market metadata, PDA context, and order-packet sizing	`client.exchange` cache	`PhoenixMetadata`
Live market, orderbook, exchange, and trader streams	`client.streams`, `client.marketData()`, `client.orderbooks()`	`PhoenixWSClient` plus typed containers
Trader snapshots and deltas	`createTraderStateStore(client)`	`Trader::apply_update(...)`
Build Phoenix instructions	`client.ixs`	`PhoenixTxBuilder`
Margin and account-health calculations	`createMarginCalculator(...)` and trader-state `marginInputs()`	`TraderPortfolio::compute_margin(...)`

Prefer the exchange cache for market parameters. In TypeScript, wait for client.exchange.ready() and read markets with client.exchange.market(symbol) or client.exchange.marketMetadata(symbol). In Rust, build PhoenixMetadata from http.get_exchange() and update it with live market stats through metadata.apply_market_stats(&stats). Prefer trader-state primitives for snapshots and deltas. In TypeScript, createTraderStateStore(client) maintains local trader resources and exposes marginInputs(). In Rust, Trader::apply_update(&msg) applies traderState snapshots and deltas to the local container.

First Reads

const snapshot = await client.exchange.ready();
const sol = client.exchange.market("SOL");
const solMetadata = client.exchange.marketMetadata("SOL");
const trader = await client.api
  .traders()
  .getTraderStateSnapshot("AUTHORITY_PUBKEY", { traderPdaIndex: 0 });

console.log(snapshot.markets.length, sol?.assetId, solMetadata?.logoUri);
console.log(trader.snapshot.subaccounts);

use phoenix_rise::{PhoenixHttpClient, PhoenixMetadata};
use solana_pubkey::Pubkey;
use std::str::FromStr;

let http = PhoenixHttpClient::new_from_env()?;
let exchange = http.get_exchange().await?.into();
let metadata = PhoenixMetadata::new(exchange);
let authority = Pubkey::from_str("AUTHORITY_PUBKEY")?;

let sol = metadata.get_market("SOL");
let trader = http.traders().get_trader(&authority).await?;

println!("{:?} {}", sol.map(|m| &m.symbol), trader.len());

Runnable references:

Reading Order

Auth - optional for most public reads, required for referral onboarding and notifications.
Trader Onboarding - create or activate a trader account.
Accounts - understand authority, position authority, cross accounts, isolated accounts, and trader-state streams.
Collateral - move USDC into and out of Phoenix trader accounts.
Exchange Data - exchange cache, market metadata, L2 orderbooks, market stats, and market calendars.
WS/API Best Practices - when to stream, when to poll, and how to avoid rate-limit and drift issues.
Orders - build order instructions and manage stop losses and conditionals.
Margin - join market prices, compute account health, margin, and liquidation estimates.
On-Chain Programs and LiteSVM Testing - program integrations and local tests.

REST, WebSocket, and RPC

Use REST for startup snapshots, historical data, and server-built transaction workflows. Use WebSocket streams for current market state, exchange deltas, orderbooks, and trader state. Use Solana RPC for blockhashes, simulation, transaction submission, confirmation, and custom account reads. The usual production pattern is:

Fetch HTTP snapshots on startup.
Subscribe to WebSocket streams.
Apply exchange and trader deltas locally through SDK caches.
Build and sign instructions with the user’s wallet or signer service.
Confirm transactions through Solana RPC.
Reconcile from trader-state streams, falling back to fresh HTTP snapshots after reconnects or sequence gaps.

Start

Trading

On-Chain Programs

Install

TypeScript

Rust

Create A Client

Which Client To Use

First Reads

Reading Order

REST, WebSocket, and RPC

​Install

​TypeScript

​Rust

​Create A Client

​Which Client To Use

​First Reads

​Reading Order

​REST, WebSocket, and RPC

Install

TypeScript

Rust

Create A Client

Which Client To Use

First Reads

Reading Order

REST, WebSocket, and RPC