Hyperliquid SDK

You can perform actions on behalf of a vault or subaccount by providing a vaultAddress. Additionally, you can set an expiresAfter millisecond timestamp to ensure an action is rejected if not processed within a certain window. These fields are signed into the action hash.

Use hyperliquid.WithVaultAddress(vault) and hyperliquid.WithExpiresAfter(deadline) for one-line orders, or the corresponding methods on the OrderBuilder.

vault := "0xVault..."
deadline := time.Now().Add(30 * time.Second).UnixMilli()

// One-line order with vault and deadline
sdk.Buy("BTC", hyperliquid.WithSize(0.001), hyperliquid.WithPrice(65000),
    hyperliquid.WithVaultAddress(vault), hyperliquid.WithExpiresAfter(deadline))

// Using fluent builder
order := hyperliquid.Order().Buy("BTC").Size(0.001).Price(65000).GTC().
    VaultAddress(vault).ExpiresAfter(deadline)
sdk.PlaceOrder(order)

// Cancels and modifies for vaults
sdk.Cancel(oid, "BTC", hyperliquid.CancelWithVaultAddress(vault), hyperliquid.CancelWithExpiresAfter(deadline))
sdk.Modify(oid, "BTC", "buy", "61000", "0.001", hyperliquid.ModifyWithVaultAddress(vault))
sdk.ClosePosition("BTC", hyperliquid.CloseWithVaultAddress(vault))

// Trigger orders for vaults
sdk.StopLoss("BTC", 0.001, 60000, hyperliquid.TriggerWithVaultAddress(vault))

The L4 order book is a gRPC-only stream that provides every individual order including its unique order_id. This is critical for high-frequency trading (HFT) and market making because it allows you to track your exact queue position and perform order flow analysis (e.g., detecting icebergs).

Important Implementation Note: The server may send an unsolicited full snapshot at any time after you subscribe. When a snapshot is received, you MUST discard your local book state and replace it entirely with the snapshot data.

Data Structure:

{
    "coin": "BTC",
    "bids": [[price, size, order_id], ...],
    "asks": [[price, size, order_id], ...]
}

use hyperliquid_sdk::GRPCStream;

fn on_l4_book(data: serde_json::Value) {
    // L4 book data structure:
    // {
    //     "coin": "BTC",
    //     "bids": [[price, size, order_id], ...],
    //     "asks": [[price, size, order_id], ...]
    // }
    if let Some(bids) = data.get("bids").and_then(|b| b.as_array()) {
        for bid in bids.iter().take(3) {
            let px = bid.get(0).and_then(|v| v.as_f64()).unwrap_or(0.0);
            let sz = bid.get(1).and_then(|v| v.as_f64()).unwrap_or(0.0);
            let oid = bid.get(2).and_then(|v| v.as_i64()).unwrap_or(0);
            println!("Bid: ${:.2} x {} (order: {})", px, sz, oid);
        }
    }
}

let mut stream = GRPCStream::new(endpoint)?;
stream.l4_book("BTC", on_l4_book);
stream.run()?;

The L4 order book is a high-performance gRPC stream that provides visibility into every individual order including its order_id. This is critical for high-frequency trading (HFT) and market making because it allows you to track your exact queue position and detect order flow patterns like icebergs.

L4 Data Structure:

{
  "coin": "BTC",
  "bids": [[price, size, order_id], ...],
  "asks": [[price, size, order_id], ...]
}

Important: L4 Snapshot Contract When subscribing to L4 streams (l4Book, l4BookBytes, or l4BookUpdates), the server may send an unsolicited full snapshot at any time. Clients MUST discard local book state and replace it with any snapshot received mid-stream.

const sdk = new HyperliquidSDK(endpoint);

sdk.grpc.l4Book("BTC", (data) => {
  // L4 book data structure:
  // {
  //   "coin": "BTC",
  //   "bids": [[price, size, order_id], ...],
  //   "asks": [[price, size, order_id], ...]
  // }
  const bids = data.bids || [];
  for (const bid of bids.slice(0, 3)) {
    const [px, sz, oid] = bid;
    console.log(`Bid: $${Number(px).toLocaleString()} x ${sz} (order: ${oid})`);
  }
});

await sdk.grpc.start();

To trade on behalf of a vault or subaccount, you must provide the vault_address in the order or exchange options. This address is included in the signed action hash.

• Order level: Use .vault_address("0x...") on the Order builder.
• Options level: Use ExchangeOptions with a vault_address for methods like modify_with_options or close_position_with_options.
• Fast Cancels: Use CancelOptions { fast: true, ..Default::default() } with cancel_with_options to emit the "f": true flag for faster execution.

use hyperliquid_sdk::{CancelOptions, ExchangeOptions, Order};

// Trade on behalf of a vault
sdk.order(
    Order::buy("BTC")
        .size(0.001)
        .price(65000.0)
        .gtc()
        .vault_address("0x1719884eb866cb12b2287399b15f7db5e7d775ea")
).await?;

// Fast cancel
let fast = CancelOptions { fast: true, ..Default::default() };
sdk.cancel_with_options(oid, "BTC", &fast).await?;