Get Order History (WebSocket)

ws.send() wss://api.synthetix.io/v1/ws/trade

{
  "id": "getorders-1",
  "method": "post",
  "params": {
    "action": "getOrderHistory",
    "subAccountId": "1867542890123456789",
    "status": ["filled", "cancelled"],
    "fromTime": 1704067200000,
    "toTime": 1704672000000,
    "limit": 50,
    "expiresAfter": 1704067500,
    "signature": {
      "v": 28,
      "r": "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
      "s": "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890"
    }
  }
}

const domain = {
  name: "Synthetix",
  version: "1",
  chainId: 1,
  verifyingContract: "0x0000000000000000000000000000000000000000"
};
 
const types = {
  SubAccountAction: [
    { name: "subAccountId", type: "uint256" },
    { name: "action", type: "string" },
    { name: "expiresAfter", type: "uint256" }
  ]
};
 
const message = {
  subAccountId: "1867542890123456789",
  action: "getOrderHistory",
  expiresAfter: 0
};
 
const signature = await signer._signTypedData(domain, types, message);

{
  "id": "getorders-1",
  "status": 200,
  "result": {
    "status": "success",
    "response": [
      {
        "orderId": "1958787130134106112",
        "symbol": "BTC-USDT",
        "side": "buy",
        "type": "LIMIT",
        "quantity": "10.0",
        "price": "45000.00",
        "status": "filled",
        "timeInForce": "GTC",
        "createdTime": 1755846234000,
        "filledQuantity": "10.0",
        "filledPrice": "45000.00",
        "triggeredByLiquidation": false,
        "reduceOnly": false,
        "postOnly": false
      },
      {
        "orderId": "1958787130134106113",
        "symbol": "ETH-USDT",
        "side": "sell",
        "type": "LIMIT",
        "quantity": "5.0",
        "price": "2800.00",
        "status": "partially filled",
        "timeInForce": "GTC",
        "createdTime": 1755846235000,
        "filledQuantity": "2.0",
        "filledPrice": "2800.00",
        "triggeredByLiquidation": false,
        "reduceOnly": false,
        "postOnly": true
      }
    ]
  }
}

{
  "id": "getorders-1",
  "status": 400,
  "result": null,
  "error": {
    "code": 400,
    "message": "Failed to get orders"
  }
}

class OrderQuery {
  constructor(ws) {
    this.ws = ws;
    this.pendingRequests = new Map();
  }
 
  async getOrderHistory(options = {}) {
    const {
      status = null,
      fromTime = null,
      toTime = null,
      limit = 50,
      subAccountId
    } = options;
 
    // Validate 7-day time range if both times provided
    if (fromTime && toTime) {
      const maxRange = 7 * 24 * 60 * 60 * 1000; // 7 days in milliseconds
      if (toTime - fromTime > maxRange) {
        throw new Error('Time range cannot exceed 7 days');
      }
    }
 
    // Build request (no signature needed for read-only queries)
    const request = {
      id: `getorders-${Date.now()}`,
      method: "post",
      params: {
        action: "getOrderHistory",
        subAccountId: subAccountId.toString()
      }
    };
 
    // Add optional filters
    if (status) request.params.status = status;
    if (fromTime) request.params.fromTime = fromTime;
    if (toTime) request.params.toTime = toTime;
    if (limit) request.params.limit = limit;
 
    // Send and wait for response
    return this.sendRequest(request);
  }
 
  sendRequest(request) {
    return new Promise((resolve, reject) => {
      this.pendingRequests.set(request.id, { resolve, reject });
      this.ws.send(JSON.stringify(request));
 
      // Handle timeout
      setTimeout(() => {
        if (this.pendingRequests.has(request.id)) {
          this.pendingRequests.delete(request.id);
          reject(new Error('Request timeout'));
        }
      }, 10000); // 10 second timeout
    });
  }
 
  handleResponse(response) {
    const pending = this.pendingRequests.get(response.id);
    if (pending) {
      this.pendingRequests.delete(response.id);
      if (response.error) {
        pending.reject(new Error(response.error.message));
      } else {
        pending.resolve(response.result.response);
      }
    }
  }
}
 
// Usage Examples
 
// Get All Placed Orders
async function getAllPlacedOrders(query, subAccountId) {
  try {
    const result = await query.getOrderHistory({
      subAccountId,
      status: ["placed"]
    });
    console.log(`Found ${result.length} placed orders`);
    return result;
  } catch (error) {
    console.error('Failed to get placed orders:', error);
    throw error;
  }
}
 
// Get Order History with Time Range
async function getOrderHistoryWithTimeRange(query, subAccountId, fromTime, toTime) {
  try {
    const result = await query.getOrderHistory({
      subAccountId,
      fromTime,
      toTime,
      limit: 100
    });
    console.log(`Found ${result.length} historical orders`);
    return result;
  } catch (error) {
    console.error('Failed to get order history:', error);
    throw error;
  }
}
 
// Filter by Status
async function getOrderHistoryByStatus(query, subAccountId, status) {
  try {
    const result = await query.getOrderHistory({
      subAccountId,
      status,
      limit: 50
    });
    console.log(`Found ${result.length} ${status} orders`);
    return result;
  } catch (error) {
    console.error(`Failed to get orders with status ${status}:`, error);
    throw error;
  }
}
 
// Recent Orders
async function getRecentOrders(query, subAccountId, hoursBack = 24) {
  const fromTime = Date.now() - (hoursBack * 60 * 60 * 1000);
 
  try {
    const result = await query.getOrderHistory({
      subAccountId,
      fromTime,
      limit: 25
    });
    console.log(`Found ${result.length} recent orders`);
    return result;
  } catch (error) {
    console.error('Failed to get recent orders:', error);
    throw error;
  }
}

class OrderManager {
  constructor(ws, query, subAccountId) {
    this.ws = ws;
    this.query = query;
    this.subAccountId = subAccountId;
    this.orders = new Map();
  }
 
  async initialize() {
    // 1. Get initial state (placed orders only)
    const orders = await this.query.getOrderHistory({
      subAccountId: this.subAccountId,
      status: ["placed"]
    });
 
    orders.forEach(order => {
      this.orders.set(order.orderId, order);
    });
 
    // 2. Subscribe to real-time updates
    this.ws.send(JSON.stringify({
      id: "subscribe-orders",
      method: "subscribe",
      params: {
        type: "orders",
        subAccountId: this.subAccountId
      }
    }));
  }
 
  handleOrderUpdate(update) {
    // Handle subscription events
    const { eventType, orderId } = update.data;
 
    if (eventType === 'cancelled' || eventType === 'filled') {
      this.orders.delete(orderId);
    } else {
      this.orders.set(orderId, update.data);
    }
  }
 
  async reconcile() {
    // Periodic verification
    const orders = await this.query.getOrderHistory({
      subAccountId: this.subAccountId,
      status: ["placed"]
    });
 
    // Sync any discrepancies
    this.orders.clear();
    orders.forEach(order => {
      this.orders.set(order.orderId, order);
    });
  }
}

{
  "id": "getorders-open",
  "method": "post",
  "params": {
    "action": "getOrderHistory",
    "status": ["placed"],
    "subAccountId": "1867542890123456789"
  }
}

{
  "id": "getorders-history",
  "method": "post",
  "params": {
    "action": "getOrderHistory",
    "fromTime": 1704067200000,
    "toTime": 1704153600000,
    "limit": 100,
    "subAccountId": "1867542890123456789"
  }
}

// Get all non-open orders
{ status: ["filled", "cancelled", "rejected", "partially filled"] }
 
// Get only successful orders
{ status: ["filled", "partially filled"] }
 
// Get failed orders
{ status: ["cancelled", "rejected"] }
 
// Get orders in transition states
{ status: ["cancelling", "modifying"] }

// Orders from last 24 hours
{ fromTime: Date.now() - 86400000 }
 
// Orders in specific date range
{ fromTime: 1704067200000, toTime: 1704153600000 }
 
// Orders since specific time (no end)
{ fromTime: 1704067200000 }