Orders

Use this page when a trader account already exists and you want to build Solana instructions for trading. Your app still signs and sends the transaction with the correct authority, position authority, delegated wallet, or fee payer. For account indexes, cross vs isolated accounts, and trader-state subscriptions across all subaccounts, see Accounts. For mark-price joins, account health, and liquidation estimates, see Margin.

Instruction Builders

All order builders produce Phoenix instructions. They do not submit transactions by themselves.

Action	TypeScript builder	Rust builder	Phoenix instruction
Place limit order	`client.ixs.buildPlaceLimitOrder(...)`	`PhoenixTxBuilder::place_limit_order(...)`	`PlaceLimitOrder`
Cancel by order id	`client.ixs.buildCancelOrdersById(...)`	`PhoenixTxBuilder::build_cancel_orders(...)`	`CancelOrdersById`
Cancel all in a market	`client.ixs.buildCancelAll(...)`	`PhoenixTxBuilder::build_cancel_all_orders(...)`	`CancelAll`
Place market order	`client.ixs.buildPlaceMarketOrder(...)`	`PhoenixTxBuilder::place_market_order(...)`	`PlaceMarketOrder`
Place position stop loss	`client.ixs.buildPlaceStopLoss(...)`	`PhoenixTxBuilder::build_stop_loss_orders(...)`	`PlaceStopLoss`
Place conditional order	`client.ixs.buildPlacePositionConditionalOrder(...)`	`PhoenixTxBuilder::place_position_bracket_order(...)` or raw `ix` builders	`PlacePositionConditionalOrder`

Limit Order

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

await client.exchange.ready();

const orderPacket = await client.orderPackets.buildLimitOrderPacket({
  symbol: "SOL",
  side: Side.Bid,
  priceUsd: "150.50",
  baseUnits: "0.25",
});

const ix = await client.ixs.buildPlaceLimitOrder({
  authority: "AUTHORITY_PUBKEY",
  symbol: "SOL",
  orderPacket,
  traderPdaIndex: 0,
  traderSubaccountIndex: 0,
});

use phoenix_rise::{LimitOrderTicket, PhoenixTxBuilder, Side, TraderKey};

let trader = TraderKey::new(authority);
let builder = PhoenixTxBuilder::new(&metadata);

let ticket = LimitOrderTicket::builder()
    .authority(trader.authority())
    .trader_account(trader.pda())
    .symbol("SOL")
    .side(Side::Bid)
    .price(150.50)
    .num_base_lots(50_000)
    .build()?;

let ixs = builder.place_limit_order(ticket).await?;

References:

Cancel Limit Order

const ix = await client.ixs.buildCancelOrdersById({
  authority: "AUTHORITY_PUBKEY",
  symbol: "SOL",
  orders: [
    {
      price: 50_000n,
      orderSequenceNumber: "12345",
    },
  ],
  traderPdaIndex: 0,
  traderSubaccountIndex: 0,
});

use phoenix_rise::ix::types::CancelId;

let cancel_id = CancelId::new(50_000, 12_345);
let ixs = builder.build_cancel_orders(
    trader.authority(),
    trader.pda(),
    "SOL",
    vec![cancel_id],
)?;

Reference: Rust cancel-order example.

Cancel All

const ix = await client.ixs.buildCancelAll({
  authority: "AUTHORITY_PUBKEY",
  symbol: "SOL",
  traderPdaIndex: 0,
  traderSubaccountIndex: 0,
});

let ixs = builder.build_cancel_all_orders(
    trader.authority(),
    trader.pda(),
    "SOL",
)?;

Market Order

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

const orderPacket = await client.orderPackets.buildMarketOrderPacket({
  symbol: "SOL",
  side: Side.Bid,
  baseUnits: "0.25",
});

const ix = await client.ixs.buildPlaceMarketOrder({
  authority: "AUTHORITY_PUBKEY",
  symbol: "SOL",
  orderPacket,
  traderPdaIndex: 0,
  traderSubaccountIndex: 0,
});

use phoenix_rise::{MarketOrderTicket, Side};

let ticket = MarketOrderTicket::builder()
    .authority(trader.authority())
    .trader_account(trader.pda())
    .symbol("SOL")
    .side(Side::Bid)
    .num_base_lots(67)
    .build()?;

let ixs = builder.place_market_order(ticket).await?;

Reference: Rust market-order example.

Stop Losses

Position stop losses use a per-trader, per-asset stop-loss account. If the account does not already exist, creating it can add an account-init instruction and incur rent.

import { Direction, Side, StopLossOrderKind } from "@ellipsis-labs/rise";

const ix = await client.ixs.buildPlaceStopLoss({
  authority: "AUTHORITY_PUBKEY",
  symbol: "SOL",
  triggerPrice: 140_000n,
  slippageBps: 100,
  tradeSide: Side.Ask,
  executionDirection: Direction.LessThan,
  orderKind: StopLossOrderKind.IOC,
  traderPdaIndex: 0,
  traderSubaccountIndex: 0,
});

use phoenix_rise::{BracketLeg, BracketLegOrders, Side};

let bracket = BracketLegOrders {
    stop_loss: Some(BracketLeg::new(140.0).with_slippage_bps(100)),
    take_profit: None,
};

let ixs = builder.build_stop_loss_orders(
    trader.authority(),
    trader.pda(),
    "SOL",
    Side::Bid,
    &bracket,
)?;

To cancel a position stop loss:

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

const ix = await client.ixs.buildCancelStopLoss({
  authority: "AUTHORITY_PUBKEY",
  symbol: "SOL",
  executionDirection: Direction.LessThan,
  traderPdaIndex: 0,
  traderSubaccountIndex: 0,
});

use phoenix_rise::Direction;

let ixs = builder.build_cancel_bracket_leg(
    trader.authority(),
    trader.pda(),
    "SOL",
    Direction::LessThan,
)?;

Reference: Rust cancel stop-loss example.

Conditional Orders

Conditional orders use a trader conditional-orders account. If the account does not already exist, your flow may need to create it first and pay rent. The newer bracket helpers can check and create the account when configured with an RPC client; raw builders require you to include CreateConditionalOrdersAccount yourself when needed.

import {
  Direction,
  Side,
  StopLossOrderKind,
  ticks,
} from "@ellipsis-labs/rise";

declare const conditionalOrdersAccountExists: boolean;

const ixs = [];

if (!conditionalOrdersAccountExists) {
  ixs.push(
    await client.ixs.buildCreateConditionalOrdersAccount({
      authority: "AUTHORITY_PUBKEY",
      traderPdaIndex: 0,
      traderSubaccountIndex: 0,
    })
  );
}

ixs.push(
  await client.ixs.buildPlacePositionConditionalOrder({
    authority: "AUTHORITY_PUBKEY",
    symbol: "SOL",
    lessTriggerOrder: {
      triggerDirection: Direction.LessThan,
      tradeSide: Side.Ask,
      orderKind: StopLossOrderKind.IOC,
      triggerPrice: ticks(140_000n),
      slippageBps: 100,
    },
    sizePercent: 100,
    traderPdaIndex: 0,
    traderSubaccountIndex: 0,
  })
);

use std::sync::Arc;
use phoenix_rise::{
    BracketLeg, BracketLegOrders, BracketLegTicket, Side,
};
use solana_rpc_client::nonblocking::rpc_client::RpcClient;

let rpc = Arc::new(RpcClient::new("https://api.mainnet-beta.solana.com".to_string()));
let bracket = BracketLegOrders {
    stop_loss: Some(BracketLeg::new(140.0).with_slippage_bps(100)),
    take_profit: Some(BracketLeg::new(180.0).with_limit_order()),
};

let ixs = builder
    .place_position_bracket_order(
        trader.authority(),
        trader.pda(),
        "SOL",
        Side::Bid,
        BracketLegTicket::new(rpc, bracket),
    )
    .await?;

For bulk cancellation, read the conditional-orders account, enumerate active trigger legs, and build one cancel instruction per active leg. The public examples show the full account-read and batching flow:

Start

Trading

On-Chain Programs

Instruction Builders

Limit Order

Cancel Limit Order

Cancel All

Market Order

Stop Losses

Conditional Orders

​Instruction Builders

​Limit Order

​Cancel Limit Order

​Cancel All

​Market Order

​Stop Losses

​Conditional Orders

Instruction Builders

Limit Order

Cancel Limit Order

Cancel All

Market Order

Stop Losses

Conditional Orders