WebSocket API

import { MonacoSDK } from '@0xmonaco/core';
import { createWalletClient, custom } from 'viem';
import { seiTestnet } from 'viem/chains';

const [account] = await window.ethereum.request({
  method: 'eth_requestAccounts'
});

const walletClient = createWalletClient({
  account,
  chain: seiTestnet,
  transport: custom(window.ethereum)
});

const sdk = new MonacoSDK({
  walletClient,
  network: 'staging',
  seiRpcUrl: 'https://evm-rpc-testnet.sei-apis.com', // public testnet RPC — use a private provider in production
});

await sdk.ws.connect();
console.log('WebSocket connected');

import { MonacoSDK } from '@0xmonaco/core';

// Via the SDK config — forwarded to the internal WebSocket client
const sdk = new MonacoSDK({
  walletClient,
  network: 'staging',
  seiRpcUrl: 'https://evm-rpc-testnet.sei-apis.com',
  ws: {
    maxReconnectAttempts: 10,
    onStatusChange: (status) => console.log('ws status', status),
    onResync: ({ slowClient }) => {
      // Re-fetch REST snapshots and merge on (id, version), then recover
      // what stopped resting during the gap: sdk.profile.getUserTrades for fills,
      // absence-from-snapshot for cancels and expiries.
      if (slowClient) console.warn('fell behind (1013) — expect a gap');
    },
    onError: ({ code, message, channel }) => {
      // The subscription is live but this channel's baseline is missing —
      // refetch just that one.
      if (code === 'SNAPSHOT_UNAVAILABLE' && channel) void refetchSnapshot(channel);
      else console.error('ws error', code, message, channel);
    },
  },
});

import { createMonacoWebSocket } from '@0xmonaco/core';

const ws = createMonacoWebSocket(baseUrl, {
  maxReconnectAttempts: 10,
  onStatusChange: (status) => console.log('ws status', status),
  onResync: ({ slowClient }) => {
    if (slowClient) console.warn('fell behind (1013) — expect a gap');
  },
});

/** Connection status */
type WebSocketStatus = "connected" | "connecting" | "disconnected" | "reconnecting";

/** Orderbook price quotation mode */
type OrderbookQuotationMode = "BASE" | "QUOTE";
// BASE:  Prices in quote currency per base (e.g., USD per BTC for BTC/USD)
// QUOTE: Prices in base currency per quote (e.g., BTC per USD for BTC/USD)

/** Valid magnitude values for orderbook grouping */
const ALL_MAGNITUDES = [0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000, 10000];

// Authenticate first
await sdk.login('688a21440e304c06b935f743dae88278');

// Get trading pair ID
const pair = await sdk.market.getTradingPairBySymbol('BTC/USDC');

// Subscribe to order events
const unsubscribe = sdk.ws.orders(pair.id, 'SPOT', (event) => {
  console.log('Order event:', event.eventType);
  console.log('Order ID:', event.orderId);
});

// Later, to unsubscribe:
unsubscribe();

// Authenticate first
await sdk.login('688a21440e304c06b935f743dae88278');

// Subscribe to all order events for the authenticated user
const unsubscribe = sdk.ws.userOrders((event) => {
  console.log('Order event:', event.eventType);
  console.log('Order ID:', event.orderId);
  console.log('Trading pair:', event.data.tradingPair);
});

// Later, to unsubscribe:
unsubscribe();

import type {
  OrderRole,
  OrderSide,
  OrderStatus,
  OrderType,
  TimeInForce,
  TradingMode,
} from '@0xmonaco/types';

type OrderEventType = 
  | "OrderPlaced" 
  | "OrderMatched" 
  | "OrderPartiallyFilled" 
  | "OrderFilled" 
  | "OrderCancelled" 
  | "OrderPartiallyCancelled"
  | "OrderRejected" 
  | "OrderExpired";

interface OrderEvent {
  /** Order ID (UUID) */
  orderId: string;
  /** Event type */
  eventType: OrderEventType | (string & {});
  /** ISO 8601 timestamp (UTC) */
  timestamp: string;
  /** Event-specific data */
  data: OrderEventData;
}

interface OrderEventData {
  // === Common Fields (all events) ===
  version?: number;              // same-order revision; absent means unknown
  orderId: string;
  userId: string;
  applicationId?: string;
  tradingPairId?: string;
  tradingPair: string;           // Pair symbol e.g., "BTC/USDC" (wire `trading_pair`; NOT `symbol`)
  tradingMode: TradingMode | (string & {});
  orderType?: OrderType | (string & {});
  side?: OrderSide | (string & {});
  price?: string;
  quantity?: string;
  quantityRaw?: string;          // `quantity` in RAW (integer, base-unit) precision
  timeInForce?: TimeInForce | (string & {}) | null; // null on every event of a MARKET order, which has none, and on a maker fill
  status?: OrderStatus | (string & {});
  role?: OrderRole | (string & {});
  clientOrderId?: string;        // Client-assigned correlation handle echoed on every order event (wire `client_order_id`); a maker fill carries the resting order's own handle. Omitted when the order carried none
  postOnly?: boolean;            // `true` when the order was admitted post-only (wire `post_only`) — on OrderPlaced, fills in both roles (maker fills included), OrderPartiallyCancelled, the resting-order OrderCancelled and OrderExpired. Never carried by OrderRejected, nor by the OrderCancelled that reports an IOC/market order's remainder after a partial fill (a separate payload); post-only cannot reach either. Only ever `true`: a non-post-only order omits the key rather than sending `false`, matching the REST read model

  // === Execution Fields (fill events) ===
  tradeId?: string;              // Trade ID (maker orders only)
  executionPrice?: string;       // Execution price (maker orders only)
  filledQuantity?: string;       // Cumulative order fill so far (wire `filled_quantity`) — the same value on every `role`; also carried on OrderCancelled
  filledQuantityRaw?: string;    // `filledQuantity` in RAW precision (wire `filled_quantity_raw`)
  lastFillQuantity?: string;     // Incremental quantity filled by THIS event (wire `last_fill_quantity`); omitted when the event carries no fill
  lastFillQuantityRaw?: string;  // `lastFillQuantity` in RAW precision (wire `last_fill_quantity_raw`)
  remainingQuantity?: string;    // Remaining quantity after this fill
  remainingQuantityRaw?: string; // `remainingQuantity` in RAW precision
  fee?: string;                  // Total fee for the fills this event covers, in decimal quote units,
                                 // negative = rebate: monacoFee + builderFee (wire `fee`; NOT `makerFee`)
  feeRaw?: string;               // `fee` in RAW quote units, 10^quoteDecimals (wire `fee_raw`)
  monacoFee?: string;            // Monaco's component of `fee` (wire `monaco_fee`)
  monacoFeeRaw?: string;         // `monacoFee` in RAW quote units (wire `monaco_fee_raw`)
  builderFee?: string;           // The builder fee component of `fee`; "0" for a maker (wire `builder_fee`)
  builderFeeRaw?: string;        // `builderFee` in RAW quote units (wire `builder_fee_raw`)
  executedAt?: string;           // Trade execution timestamp — RFC3339 with `Z` (e.g. "2026-01-02T03:04:05Z")

  // === Aggregate Fields (taker orders) ===
  tradesCount?: number;          // Total number of trades (taker orders only)
  // NOTE: `totalFilled` is NOT on a fill payload. It appears only on
  // OrderCancelled (a legacy alias of `filledQuantity`) and OrderRejected.
  // On a fill, read `filledQuantity` (cumulative) and `lastFillQuantity` (this event).
  totalFilled?: string;          // OrderCancelled / OrderRejected only
  totalFilledRaw?: string;       // `totalFilled` in RAW precision (OrderCancelled / OrderRejected)
  averageFillPrice?: string;     // The order's weighted average fill price across every fill so far, as REST reports it (fill events in both roles, the full OrderCancelled payload, and an edited order's OrderPlaced)

  // === Slippage Fields (taker only, null for maker) ===
  referencePrice?: string;       // Reference price for slippage calculation
  bestPrice?: string;            // Best price achieved
  worstPrice?: string;           // Worst price achieved
  actualSlippageBps?: number;    // Actual slippage in basis points
  maxSlippageBps?: number;       // Maximum allowed slippage

  // === Cancellation/Rejection Fields ===
  reason?: string;               // Reason for cancellation/rejection/expiration
  cancelledAt?: string;          // OrderCancelled — cancellation timestamp, RFC3339 with `Z` (wire `cancelled_at`)
  terminalReason?: string;       // OrderCancelled — stable machine-readable cause (wire `terminal_reason`), e.g. `SELF_TRADE_PREVENTION` or `PRICE_BAND`
  selfTradePreventionMode?: string; // The mode REQUESTED on the order (wire `self_trade_prevention_mode`) — on OrderPlaced, fills in both roles, OrderRejected, remainder cancels, the resting order's lifecycle frames and the orders snapshot. Absent when the order carried none; echoes the request, never the resolved wallet or platform default
  parentOrderId?: string;        // The TWAP parent of a child order, as getOrder returns it (wire `parent_order_id`) — on every frame of a TWAP child: OrderPlaced, taker fills and remainder cancels, maker fills, OrderCancelled, OrderPartiallyCancelled, OrderExpired and the orders snapshot. Absent for any other order
  positionId?: string;           // The margin position the order is bound to, as getOrder returns it (wire `position_id`). Bound at admission when the order's margin account (cross) or risk bucket (isolated) already holds an open position in the pair, so a resting close or reduce-only order carries it before it fills; otherwise the first fill binds it. On live OrderPlaced, taker fills and remainder cancels, maker fills (the maker's own binding), OrderCancelled, OrderPartiallyCancelled and OrderExpired; absent from those events while unbound and for spot. The orders snapshot always includes its nullable position_id key, using null while unbound and for spot
  marginAccountId?: string;      // The margin account the order trades on — the default one or a sub-account (wire `margin_account_id`) — on OrderPlaced, fills in both roles (a maker fill carries the maker's account), remainder cancels and OrderPartiallyCancelled. Absent for a spot order
  leverage?: string;             // OrderPlaced — margin orders placed with a leverage (wire `leverage`)
  reduceOnly?: boolean;          // OrderPlaced — every margin order, `false` included (wire `reduce_only`); absent for spot
  origin?: string;               // What placed the order (wire `origin`): "USER" | "LIQUIDATION" | "SYSTEM" | "ADL" | "COPY"; absent means not reported, never "USER"
  copyRelationshipId?: string;   // "COPY" orders only (wire `copy_relationship_id`) — the follow the copy trading engine placed it for, the same id as Follow.followId
  stpCounterpartyOrderId?: string; // OrderCancelled — self-trade-prevention counterparty (wire `stp_counterparty_order_id`); present ONLY alongside terminalReason `SELF_TRADE_PREVENTION`. Declared on OrderPartiallyCancelled too, but nothing emits it there today
}

const pair = await sdk.market.getTradingPairBySymbol('BTC/USDC');

const unsubscribe = sdk.ws.orders(pair.id, 'SPOT', (event) => {
  const { data } = event;
  
  switch (event.eventType) {
    case 'OrderPlaced':
      console.log(`Order placed: ${event.orderId}`);
      console.log(`Status: ${data.status}`);
      break;
    
    case 'OrderMatched':
      // Taker only - order matched, fills incoming
      console.log(`Order matched: ${event.orderId}`);
      console.log(`Trades: ${data.tradesCount}`);
      break;
    
    case 'OrderFilled':
      console.log(`Order filled: ${event.orderId}`);
      console.log(`Role: ${data.role}`);  // "taker" or "maker"
      if (data.role === 'taker') {
        console.log(`Average price: ${data.averageFillPrice}`);
        console.log(`Slippage: ${data.actualSlippageBps} bps`);
      } else {
        console.log(`Execution price: ${data.executionPrice}`);
        console.log(`Fee: ${data.fee}`);
      }
      break;
    
    case 'OrderPartiallyFilled':
      // Both roles report the CUMULATIVE fill as filledQuantity; this event's
      // own increment is lastFillQuantity.
      console.log(`Filled so far: ${data.filledQuantity}`);
      console.log(`This fill: ${data.lastFillQuantity}`);
      console.log(`Remaining: ${data.remainingQuantity}`);
      break;
    
    case 'OrderCancelled':
      console.log(`Order cancelled: ${data.reason}`);
      console.log(`Filled before cancel: ${data.filledQuantity}`);
      break;
    
    case 'OrderRejected':
      console.log(`Order rejected: ${data.reason}`);
      break;
    
    case 'OrderExpired':
      console.log(`Order expired: ${data.reason}`);
      console.log(`Filled before expiry: ${data.filledQuantity}`);
      break;
  }
});

const pair = await sdk.market.getTradingPairBySymbol('BTC/USDC');

// Magnitude controls price level grouping (e.g., 1 = $1 buckets, 0.01 = $0.01 buckets)
// Valid values: 0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000, 10000
const unsubscribe = sdk.ws.orderbook(
  pair.id,           // Trading pair ID
  'SPOT',            // Trading mode
  1,                 // Magnitude
  'BASE',            // Quotation mode: 'BASE' or 'QUOTE'
  (event) => {
    console.log('Best bid:', event.bestBid);
    console.log('Best ask:', event.bestAsk);
    console.log('Bids:', event.bids);
    console.log('Asks:', event.asks);
  }
);

// Later, to unsubscribe:
unsubscribe();

import type { OrderSide, TradingMode } from '@0xmonaco/types';

interface OrderbookLevel {
  /** Price level */
  price: string;
  /** Total quantity at this price level */
  quantity: string;
  /** Number of orders at this price level */
  orderCount: number;
}

interface PriceChange {
  /** Order side (BUY or SELL) */
  side: OrderSide | (string & {});
  /** Old price before the change */
  oldPrice?: string;
  /** New price after the change */
  newPrice?: string;
  /** Whether a price level was removed */
  levelRemoved: boolean;
  /** Whether a price level was added */
  levelAdded: boolean;
}

interface OrderbookEvent {
  /** Trading pair ID (UUID) */
  tradingPairId: string;
  /** Trading mode */
  tradingMode: TradingMode | (string & {});
  /** Bid orders (buy orders) - Full depth */
  bids: OrderbookLevel[];
  /** Ask orders (sell orders) - Full depth */
  asks: OrderbookLevel[];
  /** Best bid price */
  bestBid?: string;
  /** Best ask price */
  bestAsk?: string;
  /** Total bid volume */
  bidVolume?: string;
  /** Total ask volume */
  askVolume?: string;
  /** Price change information */
  priceChange?: PriceChange;
  /** Base token decimals */
  baseDecimals: number;
  /** Quote token decimals */
  quoteDecimals: number;
  /** Event timestamp (UTC) */
  timestamp: string;
  /** Sequence number for ordering */
  sequence: number;
}

const pair = await sdk.market.getTradingPairBySymbol('BTC/USDC');

const unsubscribe = sdk.ws.ohlcv(
  pair.id,    // Trading pair ID
  'SPOT',     // Trading mode
  '1m',       // Interval: '1m', '5m', '15m', '1h', '4h', '1d'
  (event) => {
    console.log('Candle:', event.candlestick);
    console.log('Open:', event.candlestick.o);
    console.log('High:', event.candlestick.h);
    console.log('Low:', event.candlestick.l);
    console.log('Close:', event.candlestick.c);
    console.log('Volume:', event.candlestick.v);
  }
);

// Later, to unsubscribe:
unsubscribe();

import type { Interval, TradingMode } from '@0xmonaco/types';

interface OHLCVEvent {
  tradingPairId: string;
  tradingMode: TradingMode | (string & {});
  interval: Interval | (string & {});
  priceType?: "trade" | "mark" | (string & {}); // concrete series; absent on legacy frames
  candlestick: {
    T: number;  // Period start timestamp (ms, UTC)
    t: number;  // Period end timestamp (ms, UTC)
    o: string;  // Open price
    h: string;  // High price
    l: string;  // Low price
    c: string;  // Close price
    v: string;  // Volume
    s: string;  // Symbol
    i: string;  // Interval
    n: number;  // Number of trades
  };
}

const pair = await sdk.market.getTradingPairBySymbol('BTC/USDC');

const unsubscribe = sdk.ws.trades(pair.id, (event) => {
  console.log('Trade ID:', event.data.tradeId);
  console.log('Price:', event.data.price);
  console.log('Quantity:', event.data.quantity);
  console.log('Maker side:', event.data.makerSide);
  console.log('Executed at:', event.data.executedAt);
});

// Later, to unsubscribe:
unsubscribe();

import type { OrderSide, TradingMode } from '@0xmonaco/types';

interface TradeEvent {
  eventType: 'trade';
  tradingPairId: string;
  tradingMode: TradingMode | (string & {});
  data: {
    tradeId: string;
    price: string;
    quantity: string;
    makerSide: OrderSide | (string & {});
    executedAt: string;  // ISO 8601 timestamp (UTC)
  };
}

// Authenticate first
await sdk.login('688a21440e304c06b935f743dae88278');

// Subscribe to your account's movements
const unsubscribe = sdk.ws.movements((event) => {
  console.log('Movement ID:', event.data.id);
  // Live types: deposit, withdrawal, funding (lowercase) and the order unlocks
  // OrderCancelled, OrderPartiallyCancelled, OrderExpired (entry type CREDIT).
  // Compare case-insensitively — the producers do not share one casing.
  console.log('Type:', event.data.transactionType);
  console.log('Entry:', event.data.entryType);
  console.log('Token:', event.data.tokenAddress);
  console.log('Amount:', event.data.amount);
  console.log('Balance:', event.data.balanceBefore, '→', event.data.balanceAfter);
  
  if (event.data.referenceId) {
    console.log('Reference:', event.data.referenceType, event.data.referenceId);
  }
});

// Later, to unsubscribe:
unsubscribe();

interface UserMovementEvent {
  eventType: 'movement';
  userId: string;  // Your user ID (UUID)
  data: {
    id: string;                    // Movement ID (UUID)
    entryType: string;             // free-form; live: "credit"/"debit" on deposits, withdrawals and funding, "CREDIT" on order unlocks. Compare case-insensitively
    transactionType: string;       // free-form; live: "deposit", "withdrawal", "funding", "OrderCancelled", "OrderPartiallyCancelled", "OrderExpired". History adds fill/fee types this channel never emits
    status?: string;               // Movement status: "completed", "pending", "failed" (wire `status`)
    token?: string;                // Token contract address (wire `token`; older payloads use the `token_address` alias)
    tokenAddress: string;          // Populated legacy alias of `token` (always set, for back-compat)
    assetId?: string;              // Asset registry ID, UUID (wire `asset_id`)
    symbol?: string;               // Token symbol (optional, e.g., "BTC", "USDC")
    decimals: number;              // Token decimals (e.g., 18 for ETH, 6 for USDC)
    amount: string;                // Movement amount (decimal string, human-readable)
    amountRaw?: string;            // Raw amount (smallest unit, e.g., wei)
    balanceBefore?: string;        // Balance before movement (decimal)
    balanceBeforeRaw?: string;     // Balance before (raw, smallest unit)
    balanceAfter?: string;         // Balance after movement (decimal)
    balanceAfterRaw?: string;      // Balance after (raw, smallest unit)
    lockedBefore?: string;         // Locked balance before (decimal)
    lockedBeforeRaw?: string;      // Locked balance before (raw)
    lockedAfter?: string;          // Locked balance after (decimal)
    lockedAfterRaw?: string;       // Locked balance after (raw)
    referenceId?: string;          // Related entity ID (e.g., order UUID)
    referenceType?: string;        // Reference type (e.g., "order", "deposit")
    description?: string;          // Human-readable description
    txHash?: string;               // On-chain transaction hash (if applicable)
    blockNumber?: number;          // Block number (if on-chain)
    createdAt?: string;            // ISO 8601 timestamp (UTC)
  };
}

sdk.ws.movements((event) => {
  if (event.data.transactionType === 'deposit') {
    console.log(`✅ Deposit confirmed: ${event.data.amount} tokens`);
    console.log(`New balance: ${event.data.balanceAfter}`);
    if (event.data.txHash) {
      console.log(`TX: ${event.data.txHash}`);
    }
  }
});

sdk.ws.movements((event) => {
  const type = event.data.transactionType.toLowerCase();
  if (type.startsWith('order') && event.data.referenceId) {
    console.log(`Unlocked by order ${event.data.referenceId}: ${event.data.amount}`);
    console.log(`Balance: ${event.data.balanceBefore} → ${event.data.balanceAfter}`);
  }
});

import { useUserMovements } from '@0xmonaco/react';

function MovementsFeed() {
  const { movements, loading, subscribed, error } = useUserMovements({ maxMovements: 50 });
  
  if (loading) return <div>Loading movements...</div>;
  if (error) return <div>Error: {error.message}</div>;
  
  return (
    <div>
      <p>Subscribed: {subscribed ? '✅' : '❌'}</p>
      {movements.map(movement => (
        <div key={movement.data.id}>
          {movement.data.transactionType}: {movement.data.amount}
        </div>
      ))}
    </div>
  );
}

// Authenticate first
await sdk.login('688a21440e304c06b935f743dae88278');

// Subscribe to balance updates
const unsubscribe = sdk.ws.balances((event) => {
  console.log('Balance updated:', event.data.reason);
  console.log('Token:', event.data.tokenSymbol);
  console.log('Available:', event.data.available);
  console.log('Locked:', event.data.locked);
  console.log('Total:', event.data.total);

  // Update UI with new balances
  if (event.data.reason === 'trade') {
    console.log('Balance changed from trade execution');
  } else if (event.data.reason === 'lock') {
    console.log('Balance locked for new order');
  }
});

// Later, to unsubscribe:
unsubscribe();

import type { BalanceUpdateReason } from '@0xmonaco/types';

interface UserBalanceEvent {
  eventType: "balance_update";
  userId: string;
  data: {
    tokenAddress: string;           // Token contract address
    tokenSymbol: string | null;     // Token symbol (e.g., "USDC"); populated on every reason, margin-collateral frames included — null only when the account has no bound collateral token, or the token is not a configured asset
    available: string;              // Available balance (normalized)
    availableRaw: string;           // Available balance (raw/wei)
    locked: string;                 // Locked in orders (normalized)
    lockedRaw: string;              // Locked in orders (raw/wei)
    total: string;                  // Total balance (normalized)
    totalRaw: string;               // Total balance (raw/wei)
    version?: number;               // Durable spot-row revision; absent on margin/legacy notifications
    reason: BalanceUpdateReason | (string & {});
    referenceId: string | null;     // Related entity ID (order, movement, etc.)
    updatedAt: string;              // ISO 8601 timestamp
  };
}

sdk.ws.balances((event) => {
  const { reason, tokenSymbol, available, locked } = event.data;

  switch (reason) {
    case 'deposit':
      console.log(`✅ Deposit confirmed: +${available} ${tokenSymbol}`);
      break;
    case 'withdrawal':
      console.log(`📤 Withdrawal processed: -${available} ${tokenSymbol}`);
      break;
    case 'lock':
      console.log(`🔒 Order placed: ${locked} ${tokenSymbol} locked`);
      break;
    case 'unlock':
      console.log(`🔓 Order cancelled: ${locked} ${tokenSymbol} released`);
      break;
    case 'trade':
      console.log(`💱 Trade executed: ${available} ${tokenSymbol} available`);
      break;
    case 'margin_transfer_in':
      console.log(`Collateral deposited to margin: ${tokenSymbol}`);
      break;
    case 'margin_transfer_out':
      console.log(`Collateral returned from margin: ${tokenSymbol}`);
      break;
  }
});

import { useUserBalances } from "@0xmonaco/react";

function BalancesDisplay() {
  const { balances, loading, subscribed, error, refresh } = useUserBalances();

  if (loading) return <div>Loading balances...</div>;
  if (error) return <div>Error: {error.message}</div>;

  return (
    <div>
      <div className="header">
        <h3>Your Balances</h3>
        {subscribed && <span className="live-indicator">● Live</span>}
        <button onClick={refresh}>Refresh</button>
      </div>

      {balances.map(balance => (
        <div key={balance.assetId} className="balance-item">
          <div className="token">{balance.symbol || 'Unknown'}</div>
          <div className="amounts">
            <div>Available: {balance.availableBalance}</div>
            <div>Locked: {balance.lockedBalance}</div>
            <div>Total: {balance.totalBalance}</div>
          </div>
        </div>
      ))}
    </div>
  );
}

// All conditional-order events for the authenticated user
const unsubscribe = sdk.ws.conditionalOrders((event) => {
  // event.eventType === "conditional_order_update"
  const { conditionalOrderId, state, reason, triggerPrice, triggeredOrderId } = event.data;
  console.log(`${conditionalOrderId} → ${state} (${reason})`);
});

// Optionally scope to one trading pair
const unsubscribePair = sdk.ws.conditionalOrders(
  (event) => { /* ... */ },
  tradingPairId,
);

// Cleanup
unsubscribe();

import type {
  ConditionalOrderConditionType,
  ConditionalOrderState,
  ConditionalOrderTriggerSource,
  OrderSide,
  OrderType,
  PositionSide,
  TimeInForce,
} from '@0xmonaco/types';

{
  eventType: "conditional_order_update";
  userId: string;
  data: {
    conditionalOrderId: string;
    version?: number;             // revision of this row, on every update; compare with >=
    tradingPairId: string;
    marginAccountId: string;
    positionId?: string;
    parentOrderId?: string;
    associationType?: "POSITION" | "PARENT_ORDER" | (string & {});
    linkedGroupId?: string;        // populated for OCO TP/SL pairs
    conditionType: ConditionalOrderConditionType | (string & {});
    triggerSource: ConditionalOrderTriggerSource | (string & {});
    triggerPrice: string;
    side: OrderSide | (string & {});
    positionSide: PositionSide | (string & {});
    orderType: OrderType | (string & {});
    limitPrice?: string;
    quantity?: string;
    slippageToleranceBps?: number;
    reduceOnly: boolean;
    timeInForce?: TimeInForce | (string & {});  // full enum, not just GTC/IOC — narrow before use
    state: ConditionalOrderState | (string & {});
    triggeredOrderId?: string;     // the close the trigger placed; set from the "triggered" update on
    triggeredAt?: string;
    activatedAt?: string;          // populated when parent-attached TP/SL becomes active
    cancelledAt?: string;
    expiresAt?: string;
    failureReason?: string;        // populated on FAILED and EXPIRED, and on a refused trailing stop
    trailBps?: number;             // TRAILING_STOP only: retracement behind the watermark, in bps
    activationPrice?: string;      // TRAILING_STOP only: level that starts tracking; absent when armed immediately
    watermarkPrice?: string;       // TRAILING_STOP only: best mark since arming; triggerPrice trails it
    trailArmedAt?: string;         // TRAILING_STOP only: when tracking began; absent while awaiting activationPrice
    reason: string;                // free-form on the wire; canonical values below
    createdAt?: string;            // same string REST returns; always sent by current servers, absent only from an older deployment
    updatedAt: string;
  }
}

const status = sdk.ws.getStatus();
console.log('Status:', status); // "connected", "connecting", "disconnected", or "reconnecting"

if (sdk.ws.isConnected()) {
  console.log('WebSocket is connected');
}

sdk.ws.disconnect();
console.log('WebSocket disconnected');

import { MonacoSDK } from '@0xmonaco/core';
import { createWalletClient, custom } from 'viem';
import { seiTestnet } from 'viem/chains';

async function setupRealtimeData() {
  // 1. Setup SDK
  const [account] = await window.ethereum.request({ 
    method: 'eth_requestAccounts' 
  });

  const walletClient = createWalletClient({
    account,
    chain: seiTestnet,
    transport: custom(window.ethereum)
  });

  const sdk = new MonacoSDK({
    walletClient,
    network: 'staging',
    seiRpcUrl: 'https://evm-rpc-testnet.sei-apis.com',
  });

  // 2. Login for authenticated channels
  await sdk.login('688a21440e304c06b935f743dae88278');

  // 3. Get trading pair
  const pair = await sdk.market.getTradingPairBySymbol('BTC/USDC');

  // 4. Subscribe to multiple channels
  const unsubOrders = sdk.ws.orders(pair.id, 'SPOT', (event) => {
    console.log('Order:', event.eventType, event.orderId);
  });

  const unsubOrderbook = sdk.ws.orderbook(pair.id, 'SPOT', 1, 'BASE', (event) => {
    console.log('Orderbook:', event.bestBid, event.bestAsk);
  });

  const unsubTrades = sdk.ws.trades(pair.id, (event) => {
    console.log('Trade:', event.data.price, event.data.quantity);
  });

  const unsubMovements = sdk.ws.movements((event) => {
    console.log('Movement:', event.data.transactionType, event.data.amount);
  });

  // 5. Place an order to trigger events
  const order = await sdk.trading.placeLimitOrder(
    pair.id,
    'BUY',
    '0.001',
    '50000.00'
  );
  console.log('Order placed:', order.orderId);

  // 6. Cleanup when done
  // unsubOrders();
  // unsubOrderbook();
  // unsubTrades();
  // unsubMovements();
  // sdk.ws.disconnect();
}

setupRealtimeData().catch(console.error);

import { useEffect, useState } from 'react';
import { useMonacoSDK } from '@0xmonaco/react';
import type { OrderEvent } from '@0xmonaco/types';

function OrderFeed({ tradingPairId }: { tradingPairId: string }) {
  const { sdk } = useMonacoSDK();
  const [orders, setOrders] = useState<OrderEvent[]>([]);

  useEffect(() => {
    if (!sdk) return;

    const unsubscribe = sdk.ws.orders(tradingPairId, 'SPOT', (event) => {
      setOrders(prev => [event, ...prev].slice(0, 50));
    });

    return () => {
      unsubscribe();
    };
  }, [sdk, tradingPairId]);

  return (
    <ul>
      {orders.map((order, i) => (
        <li key={i}>{order.eventType}: {order.orderId}</li>
      ))}
    </ul>
  );
}

// Get the trading pair ID first
const pair = await sdk.market.getTradingPairBySymbol('BTC/USDC');

// Use the UUID for subscriptions
sdk.ws.orders(pair.id, 'SPOT', handler);
sdk.ws.trades(pair.id, handler);

// Store unsubscribe functions
const unsubscribe = sdk.ws.orders(pairId, 'SPOT', handler);

// Call them when done
unsubscribe();

// The SDK handles reconnection automatically; poll status if you need it:
setInterval(() => {
  const status = sdk.ws.getStatus();
  if (status !== 'connected') {
    console.warn(`WebSocket ${status}`);
  }
}, 5000);

// Orders channel requires authentication
await sdk.login('688a21440e304c06b935f743dae88278');

// Now you can subscribe to orders
const unsub = sdk.ws.orders(pairId, 'SPOT', handler);