Modify Order (WebSocket)

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

{
  "id": "modify-1",
  "method": "post",
  "params": {
    "action": "modifyOrder",
    "orderId": "12345",
    "price": "45000.50",
    "quantity": "2.5",
    "subAccountId": "1",
    "nonce": 1703123456789,
    "expiresAfter": 1703123486789,
    "signature": {
      "v": 27,
      "r": "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
      "s": "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890"
    }
  }
}

{
  "id": "modify-1",
  "status": 200,
  "result": {
    "status": "ok",
    "response": {
      "orderId": "12345",
      "status": "modified",
      "price": "45000.50",
      "quantity": "2.5"
    },
    "request_id": "req-123456789",
    "timestamp": 1703123456789
  }
}

{
  "id": "modify-1",
  "status": 400,
  "result": null,
  "error": {
    "status": "error",
    "error": {
      "code": "VALIDATION_ERROR",
      "message": "Order not found or does not belong to this subaccount",
      "details": null
    },
    "request_id": "req-123456789",
    "timestamp": 1703123456789
  }
}

// TypeScript - WebSocket Order Modification
import { ethers } from 'ethers';
 
interface ModifyOrderParams {
  subAccountId: string;
  orderId: string;
  price?: string;
  quantity?: string;
}
 
interface WebSocketRequest {
  id: string;
  method: "post";
  params: {
    action: string;
    orderId: string;
    price?: string;
    quantity?: string;
    subAccountId: string;
    nonce: number;
    expiresAfter?: number;
    signature: {
      v: number;
      r: string;
      s: string;
    };
  };
}
 
class WebSocketOrderModifier {
  private ws: WebSocket;
  private signer: ethers.Signer;
  private requestId: number = 0;
  private pendingRequests: Map<string, {
    resolve: (value: any) => void;
    reject: (reason: any) => void;
  }> = new Map();
 
  constructor(ws: WebSocket, signer: ethers.Signer) {
    this.ws = ws;
    this.signer = signer;
  }
 
  async modifyOrder(params: ModifyOrderParams): Promise<any> {
    const { subAccountId, orderId, price, quantity } = params;
 
    if (!price && !quantity) {
      throw new Error('At least one of price or quantity must be provided');
    }
 
    // Generate nonce
    const nonce = Date.now();
    const expiresAfter = nonce + 30000; // 30 second expiry
 
    // Create modification signature
    const signature = await this.signModifyOrder(subAccountId, orderId, price, quantity, nonce, expiresAfter);
 
    // Build request with all parameters flattened into params
    const request: WebSocketRequest = {
      id: `modify-${++this.requestId}`,
      method: "post",
      params: {
        action: "modifyOrder",
        orderId: orderId,
        subAccountId: subAccountId,
        ...(price && { price }),
        ...(quantity && { quantity }),
        nonce,
        expiresAfter,
        signature
      }
    };
 
    // Send and wait for response
    return this.sendRequest(request);
  }
 
  private async signModifyOrder(
    subAccountId: string,
    orderId: string,
    price: string | undefined,
    quantity: string | undefined,
    nonce: number,
    expiresAfter: number
  ): Promise<{ v: number; r: string; s: string }> {
    const domain = {
      name: "Synthetix",
      version: "1",
      chainId: 1,
      verifyingContract: "0x0000000000000000000000000000000000000000"
    };
 
    const types = {
      ModifyOrderRequest: [
        { name: "subAccountId", type: "uint64" },
        { name: "orderId", type: "uint64" },
        { name: "price", type: "string" },
        { name: "quantity", type: "string" },
        { name: "nonce", type: "uint256" },
        { name: "expiresAfter", type: "uint256" }
      ]
    };
 
    const message = {
      subAccountId: subAccountId,
      orderId: orderId,
      price: price || "",
      quantity: quantity || "",
      nonce: nonce,
      expiresAfter: expiresAfter
    };
 
    // Using ethers v6 syntax
    const signature = await this.signer.signTypedData(domain, types, message);
    return ethers.Signature.from(signature);
  }
 
  private sendRequest(request: WebSocketRequest): Promise<any> {
    return new Promise((resolve, reject) => {
      this.pendingRequests.set(request.id, { resolve, reject });
      this.ws.send(JSON.stringify(request));
 
      setTimeout(() => {
        if (this.pendingRequests.has(request.id)) {
          this.pendingRequests.delete(request.id);
          reject(new Error('Request timeout'));
        }
      }, 15000);
    });
  }
}
 
// Usage Examples with proper typing
async function adjustOrderPriceOnly(
  modifier: WebSocketOrderModifier,
  subAccountId: string,
  orderId: string,
  newPrice: string
): Promise<any> {
  try {
    const result = await modifier.modifyOrder({
      subAccountId,
      orderId,
      price: newPrice
    });
    console.log('Order price adjusted:', result);
    return result;
  } catch (error) {
    console.error('Price adjustment failed:', error);
    throw error;
  }
}
 
async function adjustOrderQuantityOnly(
  modifier: WebSocketOrderModifier,
  subAccountId: string,
  orderId: string,
  newQuantity: string
): Promise<any> {
  try {
    const result = await modifier.modifyOrder({
      subAccountId,
      orderId,
      quantity: newQuantity
    });
    console.log('Order quantity adjusted:', result);
    return result;
  } catch (error) {
    console.error('Quantity adjustment failed:', error);
    throw error;
  }
}
 
async function adjustBothPriceAndQuantity(
  modifier: WebSocketOrderModifier,
  subAccountId: string,
  orderId: string,
  newPrice: string,
  newQuantity: string
): Promise<any> {
  try {
    const result = await modifier.modifyOrder({
      subAccountId,
      orderId,
      price: newPrice,
      quantity: newQuantity
    });
    console.log('Order price and quantity adjusted:', result);
    return result;
  } catch (error) {
    console.error('Order modification failed:', error);
    throw error;
  }
}