openbroker 1.9.5 → 1.9.6

package/scripts/operations/chase.ts

@@ -3,7 +3,9 @@
 
 import { fileURLToPath } from 'url';
 import { getClient } from '../core/client.js';
+import type { OrderResponse, CancelResponse, OpenOrder } from '../core/types.js';
 import { formatUsd, parseArgs, sleep } from '../core/utils.js';
+import { UserFillWatcher, type FillWatcher } from './execution.js';
 
 function printUsage() {
   console.log(`
@@ -49,10 +51,22 @@ export interface ChaseOptions {
   reduceOnly?: boolean;
   dryRun?: boolean;
   verbose?: boolean;
+  client?: ChaseClient;
+  fillWatcher?: FillWatcher;
   /** Receives each output line. Defaults to console.log. */
   output?: (line: string) => void;
 }
 
+export interface ChaseClient {
+  verbose: boolean;
+  address: string;
+  getAllMids(): Promise<Record<string, string>>;
+  getOpenOrders(): Promise<OpenOrder[]>;
+  getUserFills(user?: string): Promise<Array<{ coin: string; px: string; sz: string; time: number; oid: number }>>;
+  limitOrder(coin: string, isBuy: boolean, size: number, price: number, tif?: 'Gtc' | 'Ioc' | 'Alo', reduceOnly?: boolean, leverage?: number): Promise<OrderResponse>;
+  cancel(coin: string, oid: number): Promise<CancelResponse>;
+}
+
 export interface ChaseResult {
   status: 'dry' | 'filled' | 'timeout' | 'max_chase_exceeded';
   iterations: number;
@@ -70,8 +84,12 @@ export async function runChase(opts: ChaseOptions): Promise<ChaseResult> {
   const isBuy = opts.side === 'buy';
 
   if (opts.size <= 0 || isNaN(opts.size)) throw new Error('size must be positive');
+  if (offsetBps < 0 || !Number.isFinite(offsetBps)) throw new Error('offsetBps must be non-negative');
+  if (timeoutSec <= 0 || !Number.isFinite(timeoutSec)) throw new Error('timeoutSec must be positive');
+  if (intervalMs <= 0 || !Number.isFinite(intervalMs)) throw new Error('intervalMs must be positive');
+  if (maxChaseBps <= 0 || !Number.isFinite(maxChaseBps)) throw new Error('maxChaseBps must be positive');
 
-  const client = getClient();
+  const client = opts.client ?? getClient();
   if (opts.verbose) client.verbose = true;
 
   out('Open Broker - Chase Order');
@@ -107,49 +125,34 @@ export async function runChase(opts: ChaseOptions): Promise<ChaseResult> {
   const startTime = Date.now();
   let currentOid: number | null = null;
   let lastPrice: number | null = null;
+  let remainingSize = opts.size;
   let iteration = 0;
   let filled = false;
   let exitReason: 'filled' | 'timeout' | 'max_chase_exceeded' = 'timeout';
-
-  while (Date.now() - startTime < timeoutSec * 1000) {
-    iteration++;
-
-    const currentMids = await client.getAllMids();
-    const currentMid = parseFloat(currentMids[opts.coin]);
-
-    if (isBuy && currentMid > maxChasePrice) {
-      out(`\n⚠️ Price ${formatUsd(currentMid)} exceeded max chase ${formatUsd(maxChasePrice)}`);
-      exitReason = 'max_chase_exceeded';
-      break;
-    }
-    if (!isBuy && currentMid < maxChasePrice) {
-      out(`\n⚠️ Price ${formatUsd(currentMid)} exceeded max chase ${formatUsd(maxChasePrice)}`);
-      exitReason = 'max_chase_exceeded';
-      break;
+  const accountedFills = new Map<number, number>();
+  const ownsFillWatcher = !opts.fillWatcher;
+  const fillWatcher = opts.fillWatcher ?? new UserFillWatcher(client, { sinceMs: startTime });
+
+  const applyFills = (oid: number): number => {
+    const totalFilled = fillWatcher.getFilled(oid).size;
+    const alreadyAccounted = accountedFills.get(oid) ?? 0;
+    const delta = Math.max(0, totalFilled - alreadyAccounted);
+    if (delta > 0) {
+      remainingSize = Math.max(0, remainingSize - delta);
+      accountedFills.set(oid, totalFilled);
     }
+    return delta;
+  };
 
-    const orderPrice = isBuy
-      ? currentMid * (1 - offsetBps / 10000)
-      : currentMid * (1 + offsetBps / 10000);
+  await fillWatcher.start();
 
-    const priceChanged = !lastPrice || Math.abs(orderPrice - lastPrice) / lastPrice > 0.0001;
+  try {
+    while (Date.now() - startTime < timeoutSec * 1000) {
+      iteration++;
 
-    if (priceChanged) {
       if (currentOid !== null) {
-        try {
-          await client.cancel(opts.coin, currentOid);
-        } catch {
-          // Order might have filled
-        }
-        currentOid = null;
-      }
-
-      const orders = await client.getOpenOrders();
-      const ourOrder = orders.find(o => o.coin === opts.coin && o.oid === currentOid);
-      if (!ourOrder && currentOid !== null) {
-        const state = await client.getUserState();
-        const pos = state.assetPositions.find(p => p.position.coin === opts.coin);
-        if (pos && Math.abs(parseFloat(pos.position.szi)) >= opts.size * 0.99) {
+        applyFills(currentOid);
+        if (remainingSize <= opts.size * 0.001) {
           filled = true;
           exitReason = 'filled';
           out(`\n✅ Order filled!`);
@@ -157,44 +160,112 @@ export async function runChase(opts: ChaseOptions): Promise<ChaseResult> {
         }
       }
 
-      out(`[${iteration}] Mid: ${formatUsd(currentMid)} → Order: ${formatUsd(orderPrice)}...`);
+      const currentMids = await client.getAllMids();
+      const currentMid = parseFloat(currentMids[opts.coin]);
+      if (!currentMid) throw new Error(`No market data for ${opts.coin}`);
 
-      const response = await client.limitOrder(opts.coin, isBuy, opts.size, orderPrice, 'Alo', opts.reduceOnly, opts.leverage);
+      if (isBuy && currentMid > maxChasePrice) {
+        out(`\n⚠️ Price ${formatUsd(currentMid)} exceeded max chase ${formatUsd(maxChasePrice)}`);
+        exitReason = 'max_chase_exceeded';
+        break;
+      }
+      if (!isBuy && currentMid < maxChasePrice) {
+        out(`\n⚠️ Price ${formatUsd(currentMid)} exceeded max chase ${formatUsd(maxChasePrice)}`);
+        exitReason = 'max_chase_exceeded';
+        break;
+      }
 
-      if (response.status === 'ok' && response.response && typeof response.response === 'object') {
-        const status = response.response.data.statuses[0];
-        if (status?.resting) {
-          currentOid = status.resting.oid;
-          lastPrice = orderPrice;
-          out(`OID: ${currentOid}`);
-        } else if (status?.filled) {
-          filled = true;
-          exitReason = 'filled';
-          out(`✅ Filled @ ${formatUsd(parseFloat(status.filled.avgPx))}`);
-          break;
-        } else if (status?.error) {
-          out(`❌ ${status.error}`);
+      const orderPrice = isBuy
+        ? currentMid * (1 - offsetBps / 10000)
+        : currentMid * (1 + offsetBps / 10000);
+
+      const priceChanged = !lastPrice || Math.abs(orderPrice - lastPrice) / lastPrice > 0.0001;
+
+      if (priceChanged) {
+        if (currentOid !== null) {
+          applyFills(currentOid);
+          if (remainingSize <= opts.size * 0.001) {
+            filled = true;
+            exitReason = 'filled';
+            out(`\n✅ Order filled!`);
+            break;
+          }
+          try {
+            await client.cancel(opts.coin, currentOid);
+          } catch {
+            // Order might have filled between the fill check and cancel.
+          }
+          applyFills(currentOid);
+          currentOid = null;
         }
-      } else {
-        out(`❌ Failed`);
-      }
-    } else {
-      if (currentOid !== null) {
-        const orders = await client.getOpenOrders();
-        const ourOrder = orders.find(o => o.oid === currentOid);
-        if (!ourOrder) {
+
+        if (remainingSize <= opts.size * 0.001) {
           filled = true;
           exitReason = 'filled';
           out(`\n✅ Order filled!`);
           break;
         }
+
+        out(`[${iteration}] Mid: ${formatUsd(currentMid)} → Order: ${formatUsd(orderPrice)} x ${remainingSize.toFixed(6)}...`);
+
+        const response = await client.limitOrder(opts.coin, isBuy, remainingSize, orderPrice, 'Alo', opts.reduceOnly, opts.leverage);
+
+        if (response.status === 'ok' && response.response && typeof response.response === 'object') {
+          const status = response.response.data.statuses[0];
+          if (status?.resting) {
+            currentOid = status.resting.oid;
+            lastPrice = orderPrice;
+            out(`OID: ${currentOid}`);
+          } else if (status?.filled) {
+            const totalSz = parseFloat(status.filled.totalSz);
+            remainingSize = Math.max(0, remainingSize - totalSz);
+            out(`✅ Filled ${totalSz} @ ${formatUsd(parseFloat(status.filled.avgPx))}`);
+            if (remainingSize <= opts.size * 0.001) {
+              filled = true;
+              exitReason = 'filled';
+              break;
+            }
+          } else if (status?.error) {
+            out(`❌ ${status.error}`);
+          }
+        } else {
+          out(`❌ Failed`);
+        }
+      } else {
+        if (currentOid !== null) {
+          await fillWatcher.waitForFill(currentOid, remainingSize, intervalMs, { coin: opts.coin, pollMs: intervalMs });
+          applyFills(currentOid);
+          if (remainingSize <= opts.size * 0.001) {
+            filled = true;
+            exitReason = 'filled';
+            out(`\n✅ Order filled!`);
+            break;
+          }
+
+          const orders = await client.getOpenOrders();
+          const ourOrder = orders.find(o => o.oid === currentOid);
+          if (!ourOrder) {
+            applyFills(currentOid);
+            if (remainingSize <= opts.size * 0.001) {
+              filled = true;
+              exitReason = 'filled';
+              out(`\n✅ Order filled!`);
+              break;
+            }
+            currentOid = null;
+            lastPrice = null;
+          }
+        }
       }
-    }
 
-    await sleep(intervalMs);
+      await sleep(intervalMs);
+    }
+  } finally {
+    if (ownsFillWatcher) await fillWatcher.stop();
   }
 
   if (currentOid !== null && !filled) {
+    applyFills(currentOid);
     out(`\nCancelling unfilled order...`);
     try {
       await client.cancel(opts.coin, currentOid);
@@ -202,6 +273,11 @@ export async function runChase(opts: ChaseOptions): Promise<ChaseResult> {
     } catch {
       out(`⚠️ Could not cancel (may have filled)`);
     }
+    applyFills(currentOid);
+    if (remainingSize <= opts.size * 0.001) {
+      filled = true;
+      exitReason = 'filled';
+    }
   }
 
   const elapsed = (Date.now() - startTime) / 1000;
@@ -213,6 +289,7 @@ export async function runChase(opts: ChaseOptions): Promise<ChaseResult> {
   out(`Iterations:   ${iteration}`);
   out(`Start Mid:    ${formatUsd(startMid)}`);
   out(`End Mid:      ${formatUsd(endMid)} (${priceMove >= 0 ? '+' : ''}${priceMove.toFixed(1)} bps)`);
+  out(`Filled Size:  ${(opts.size - remainingSize).toFixed(6)} / ${opts.size}`);
   out(`Result:       ${filled ? '✅ Filled' : '❌ Not filled'}`);
 
   return { status: exitReason, iterations: iteration, durationSec: elapsed, startMid, endMid };

package/scripts/operations/execution.ts

@@ -0,0 +1,138 @@
+import type { HyperliquidClient } from '../core/client.js';
+import { WebSocketManager, type WsEventMap } from '../core/ws.js';
+import { sleep } from '../core/utils.js';
+
+export interface FillSummary {
+  size: number;
+  notional: number;
+  avgPrice?: number;
+}
+
+export interface FillWatcher {
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  getFilled(oid: number): FillSummary;
+  waitForFill(
+    oid: number,
+    targetSize: number,
+    timeoutMs: number,
+    options?: { coin?: string; pollMs?: number }
+  ): Promise<FillSummary>;
+}
+
+type RestFill = { coin: string; px: string; sz: string; time: number; oid: number };
+
+type FillClient = Pick<HyperliquidClient, 'address' | 'verbose'> & {
+  getUserFills(user?: string): Promise<RestFill[]>;
+};
+
+export class UserFillWatcher implements FillWatcher {
+  private fills = new Map<number, FillSummary>();
+  private seenFills = new Set<string>();
+  private ws: WebSocketManager | null;
+  private ownsWs: boolean;
+  private started = false;
+  private readonly sinceMs: number;
+  private readonly user: `0x${string}`;
+  private readonly onFill = (fill: WsEventMap['userFill']) => {
+    this.recordFill({
+      oid: fill.oid,
+      coin: fill.coin,
+      px: fill.px,
+      sz: fill.sz,
+      time: fill.time,
+    });
+  };
+
+  constructor(
+    private readonly client: FillClient,
+    options: { ws?: WebSocketManager | null; sinceMs?: number; user?: string } = {},
+  ) {
+    this.ws = options.ws === undefined ? new WebSocketManager(client.verbose) : options.ws;
+    this.ownsWs = options.ws === undefined;
+    this.sinceMs = options.sinceMs ?? Date.now();
+    this.user = (options.user ?? client.address) as `0x${string}`;
+  }
+
+  async start(): Promise<void> {
+    if (this.started) return;
+    this.started = true;
+    if (!this.ws) return;
+    try {
+      await this.ws.connect();
+      this.ws.on('userFill', this.onFill);
+      await this.ws.subscribeUserFills(this.user);
+    } catch {
+      this.ws.off('userFill', this.onFill);
+      if (this.ownsWs) await this.ws.close().catch(() => {});
+      this.ws = null;
+    }
+  }
+
+  async stop(): Promise<void> {
+    if (!this.started) return;
+    this.started = false;
+    if (!this.ws) return;
+    this.ws.off('userFill', this.onFill);
+    if (this.ownsWs) await this.ws.close().catch(() => {});
+  }
+
+  getFilled(oid: number): FillSummary {
+    return this.fills.get(oid) ?? { size: 0, notional: 0 };
+  }
+
+  async waitForFill(
+    oid: number,
+    targetSize: number,
+    timeoutMs: number,
+    options: { coin?: string; pollMs?: number } = {},
+  ): Promise<FillSummary> {
+    const deadline = Date.now() + Math.max(0, timeoutMs);
+    const pollMs = Math.max(250, options.pollMs ?? 1000);
+
+    while (Date.now() <= deadline) {
+      await this.refreshRestFills(options.coin);
+      const filled = this.getFilled(oid);
+      if (filled.size >= targetSize * 0.999) return filled;
+      await sleep(Math.min(pollMs, Math.max(0, deadline - Date.now())));
+    }
+
+    await this.refreshRestFills(options.coin);
+    return this.getFilled(oid);
+  }
+
+  private async refreshRestFills(coin?: string): Promise<void> {
+    try {
+      const fills = await this.client.getUserFills(this.user);
+      for (const fill of fills) {
+        this.recordFill(fill, coin);
+      }
+    } catch {
+      // WebSocket is the primary path; REST polling is best-effort fallback.
+    }
+  }
+
+  private recordFill(
+    fill: { oid: number; coin: string; px: string; sz: string; time: number },
+    expectedCoin?: string,
+  ): void {
+    if (expectedCoin && fill.coin !== expectedCoin) return;
+    if (fill.time < this.sinceMs) return;
+    const key = `${fill.oid}:${fill.time}:${fill.px}:${fill.sz}`;
+    if (this.seenFills.has(key)) return;
+    const size = parseFloat(fill.sz);
+    const price = parseFloat(fill.px);
+    if (!Number.isFinite(size) || size <= 0 || !Number.isFinite(price) || price <= 0) return;
+    this.seenFills.add(key);
+
+    const prev = this.fills.get(fill.oid) ?? { size: 0, notional: 0 };
+    const next = {
+      size: prev.size + size,
+      notional: prev.notional + size * price,
+    };
+    this.fills.set(fill.oid, {
+      ...next,
+      avgPrice: next.notional / next.size,
+    });
+  }
+}