openbroker 1.0.89 → 1.1.1

package/scripts/operations/chase.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env npx tsx
 // Chase Order - Follow price with limit orders until filled
 
+import { fileURLToPath } from 'url';
 import { getClient } from '../core/client.js';
 import { formatUsd, parseArgs, sleep } from '../core/utils.js';
 
@@ -27,212 +28,234 @@ Options:
   --reduce      Reduce-only order
   --dry         Dry run - show chase parameters without executing
 
-Strategy:
-  - Places ALO (post-only) order at mid ± offset
-  - If not filled, cancels and replaces closer to mid
-  - Stops when filled or timeout/max-chase reached
-  - Uses ALO to ensure maker rebates
-
 Examples:
   # Chase buy 0.5 ETH with 5 bps offset, 5 min timeout
   npx tsx scripts/operations/chase.ts --coin ETH --side buy --size 0.5
 
   # Chase sell with tighter offset and longer timeout
   npx tsx scripts/operations/chase.ts --coin BTC --side sell --size 0.1 --offset 2 --timeout 600
-
-  # Quick aggressive chase (1 bps offset, 1 min timeout, 50 bps max chase)
-  npx tsx scripts/operations/chase.ts --coin SOL --side buy --size 10 --offset 1 --timeout 60 --max-chase 50
 `);
 }
 
-async function main() {
-  const args = parseArgs(process.argv.slice(2));
+export interface ChaseOptions {
+  coin: string;
+  side: 'buy' | 'sell';
+  size: number;
+  offsetBps?: number;
+  timeoutSec?: number;
+  intervalMs?: number;
+  maxChaseBps?: number;
+  leverage?: number;
+  reduceOnly?: boolean;
+  dryRun?: boolean;
+  verbose?: boolean;
+  /** Receives each output line. Defaults to console.log. */
+  output?: (line: string) => void;
+}
 
-  const coin = args.coin as string;
-  const side = args.side as string;
-  const size = parseFloat(args.size as string);
-  const offsetBps = args.offset ? parseInt(args.offset as string) : 5;
-  const timeoutSec = args.timeout ? parseInt(args.timeout as string) : 300;
-  const intervalMs = args.interval ? parseInt(args.interval as string) : 2000;
-  const maxChaseBps = args['max-chase'] ? parseInt(args['max-chase'] as string) : 100;
-  const leverage = args.leverage ? parseInt(args.leverage as string) : undefined;
-  const reduceOnly = args.reduce as boolean;
-  const dryRun = args.dry as boolean;
+export interface ChaseResult {
+  status: 'dry' | 'filled' | 'timeout' | 'max_chase_exceeded';
+  iterations: number;
+  durationSec: number;
+  startMid: number;
+  endMid: number;
+}
 
-  if (!coin || !side || isNaN(size)) {
-    printUsage();
-    process.exit(1);
-  }
+export async function runChase(opts: ChaseOptions): Promise<ChaseResult> {
+  const out = opts.output ?? ((line: string) => console.log(line));
+  const offsetBps = opts.offsetBps ?? 5;
+  const timeoutSec = opts.timeoutSec ?? 300;
+  const intervalMs = opts.intervalMs ?? 2000;
+  const maxChaseBps = opts.maxChaseBps ?? 100;
+  const isBuy = opts.side === 'buy';
 
-  if (side !== 'buy' && side !== 'sell') {
-    console.error('Error: --side must be "buy" or "sell"');
-    process.exit(1);
-  }
+  if (opts.size <= 0 || isNaN(opts.size)) throw new Error('size must be positive');
 
-  const isBuy = side === 'buy';
   const client = getClient();
-
-  if (args.verbose) {
-    client.verbose = true;
+  if (opts.verbose) client.verbose = true;
+
+  out('Open Broker - Chase Order');
+  out('=========================\n');
+
+  const mids = await client.getAllMids();
+  const startMid = parseFloat(mids[opts.coin]);
+  if (!startMid) throw new Error(`No market data for ${opts.coin}`);
+
+  const maxChasePrice = isBuy
+    ? startMid * (1 + maxChaseBps / 10000)
+    : startMid * (1 - maxChaseBps / 10000);
+
+  out('Chase Parameters');
+  out('----------------');
+  out(`Coin:          ${opts.coin}`);
+  out(`Side:          ${isBuy ? 'BUY' : 'SELL'}`);
+  out(`Size:          ${opts.size}`);
+  out(`Start Mid:     ${formatUsd(startMid)}`);
+  out(`Offset:        ${offsetBps} bps (${(offsetBps / 100).toFixed(2)}%)`);
+  out(`Max Chase:     ${maxChaseBps} bps to ${formatUsd(maxChasePrice)}`);
+  out(`Timeout:       ${timeoutSec}s`);
+  out(`Update Rate:   ${intervalMs}ms`);
+  out(`Order Type:    ALO (post-only)`);
+
+  if (opts.dryRun) {
+    out('\n🔍 Dry run - chase not started');
+    return { status: 'dry', iterations: 0, durationSec: 0, startMid, endMid: startMid };
   }
 
-  console.log('Open Broker - Chase Order');
-  console.log('=========================\n');
-
-  try {
-    const mids = await client.getAllMids();
-    const startMid = parseFloat(mids[coin]);
-    if (!startMid) {
-      console.error(`Error: No market data for ${coin}`);
-      process.exit(1);
-    }
+  out('\nChasing...\n');
 
-    const maxChasePrice = isBuy
-      ? startMid * (1 + maxChaseBps / 10000)
-      : startMid * (1 - maxChaseBps / 10000);
-
-    console.log('Chase Parameters');
-    console.log('----------------');
-    console.log(`Coin:          ${coin}`);
-    console.log(`Side:          ${isBuy ? 'BUY' : 'SELL'}`);
-    console.log(`Size:          ${size}`);
-    console.log(`Start Mid:     ${formatUsd(startMid)}`);
-    console.log(`Offset:        ${offsetBps} bps (${(offsetBps / 100).toFixed(2)}%)`);
-    console.log(`Max Chase:     ${maxChaseBps} bps to ${formatUsd(maxChasePrice)}`);
-    console.log(`Timeout:       ${timeoutSec}s`);
-    console.log(`Update Rate:   ${intervalMs}ms`);
-    console.log(`Order Type:    ALO (post-only)`);
-
-    if (dryRun) {
-      console.log('\n🔍 Dry run - chase not started');
-      return;
-    }
+  const startTime = Date.now();
+  let currentOid: number | null = null;
+  let lastPrice: number | null = null;
+  let iteration = 0;
+  let filled = false;
+  let exitReason: 'filled' | 'timeout' | 'max_chase_exceeded' = 'timeout';
 
-    console.log('\nChasing...\n');
+  while (Date.now() - startTime < timeoutSec * 1000) {
+    iteration++;
 
-    const startTime = Date.now();
-    let currentOid: number | null = null;
-    let lastPrice: number | null = null;
-    let iteration = 0;
-    let filled = false;
+    const currentMids = await client.getAllMids();
+    const currentMid = parseFloat(currentMids[opts.coin]);
 
-    while (Date.now() - startTime < timeoutSec * 1000) {
-      iteration++;
+    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;
+    }
 
-      // Get current mid
-      const currentMids = await client.getAllMids();
-      const currentMid = parseFloat(currentMids[coin]);
+    const orderPrice = isBuy
+      ? currentMid * (1 - offsetBps / 10000)
+      : currentMid * (1 + offsetBps / 10000);
 
-      // Check max chase limit
-      if (isBuy && currentMid > maxChasePrice) {
-        console.log(`\n⚠️ Price ${formatUsd(currentMid)} exceeded max chase ${formatUsd(maxChasePrice)}`);
-        break;
-      }
-      if (!isBuy && currentMid < maxChasePrice) {
-        console.log(`\n⚠️ Price ${formatUsd(currentMid)} exceeded max chase ${formatUsd(maxChasePrice)}`);
-        break;
-      }
+    const priceChanged = !lastPrice || Math.abs(orderPrice - lastPrice) / lastPrice > 0.0001;
 
-      // Calculate order price with offset
-      const orderPrice = isBuy
-        ? currentMid * (1 - offsetBps / 10000)
-        : currentMid * (1 + offsetBps / 10000);
-
-      // Check if price moved enough to update
-      const priceChanged = !lastPrice || Math.abs(orderPrice - lastPrice) / lastPrice > 0.0001;
-
-      if (priceChanged) {
-        // Cancel existing order if any
-        if (currentOid !== null) {
-          try {
-            await client.cancel(coin, currentOid);
-          } catch {
-            // Order might have filled
-          }
-          currentOid = null;
+    if (priceChanged) {
+      if (currentOid !== null) {
+        try {
+          await client.cancel(opts.coin, currentOid);
+        } catch {
+          // Order might have filled
         }
+        currentOid = null;
+      }
 
-        // Check if we got filled while cancelling
-        const orders = await client.getOpenOrders();
-        const ourOrder = orders.find(o => o.coin === coin && o.oid === currentOid);
-        if (!ourOrder && currentOid !== null) {
-          // Order gone - might have filled
-          // Check position to confirm
-          const state = await client.getUserState();
-          const pos = state.assetPositions.find(p => p.position.coin === coin);
-          if (pos && Math.abs(parseFloat(pos.position.szi)) >= size * 0.99) {
-            filled = true;
-            console.log(`\n✅ Order filled!`);
-            break;
-          }
+      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) {
+          filled = true;
+          exitReason = 'filled';
+          out(`\n✅ Order filled!`);
+          break;
         }
+      }
 
-        // Place new order
-        process.stdout.write(`[${iteration}] Mid: ${formatUsd(currentMid)} → Order: ${formatUsd(orderPrice)}... `);
-
-        const response = await client.limitOrder(coin, isBuy, size, orderPrice, 'Alo', reduceOnly, 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;
-            console.log(`OID: ${currentOid}`);
-          } else if (status?.filled) {
-            filled = true;
-            console.log(`✅ Filled @ ${formatUsd(parseFloat(status.filled.avgPx))}`);
-            break;
-          } else if (status?.error) {
-            console.log(`❌ ${status.error}`);
-            // If ALO rejected (would be taker), try again next iteration
-          }
-        } else {
-          console.log(`❌ Failed`);
+      out(`[${iteration}] Mid: ${formatUsd(currentMid)} → Order: ${formatUsd(orderPrice)}...`);
+
+      const response = await client.limitOrder(opts.coin, isBuy, opts.size, 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) {
+          filled = true;
+          exitReason = 'filled';
+          out(`✅ Filled @ ${formatUsd(parseFloat(status.filled.avgPx))}`);
+          break;
+        } else if (status?.error) {
+          out(`❌ ${status.error}`);
         }
       } else {
-        // Price stable, check if filled
-        if (currentOid !== null) {
-          const orders = await client.getOpenOrders();
-          const ourOrder = orders.find(o => o.oid === currentOid);
-          if (!ourOrder) {
-            filled = true;
-            console.log(`\n✅ Order filled!`);
-            break;
-          }
+        out(`❌ Failed`);
+      }
+    } else {
+      if (currentOid !== null) {
+        const orders = await client.getOpenOrders();
+        const ourOrder = orders.find(o => o.oid === currentOid);
+        if (!ourOrder) {
+          filled = true;
+          exitReason = 'filled';
+          out(`\n✅ Order filled!`);
+          break;
         }
-        process.stdout.write('.');
       }
-
-      await sleep(intervalMs);
     }
 
-    // Cleanup
-    if (currentOid !== null && !filled) {
-      console.log(`\nCancelling unfilled order...`);
-      try {
-        await client.cancel(coin, currentOid);
-        console.log(`✅ Cancelled`);
-      } catch {
-        console.log(`⚠️ Could not cancel (may have filled)`);
-      }
+    await sleep(intervalMs);
+  }
+
+  if (currentOid !== null && !filled) {
+    out(`\nCancelling unfilled order...`);
+    try {
+      await client.cancel(opts.coin, currentOid);
+      out(`✅ Cancelled`);
+    } catch {
+      out(`⚠️ Could not cancel (may have filled)`);
     }
+  }
+
+  const elapsed = (Date.now() - startTime) / 1000;
+  const endMid = parseFloat((await client.getAllMids())[opts.coin]);
+  const priceMove = ((endMid - startMid) / startMid) * 10000;
+
+  out('\n========== Chase Summary ==========');
+  out(`Duration:     ${elapsed.toFixed(1)}s`);
+  out(`Iterations:   ${iteration}`);
+  out(`Start Mid:    ${formatUsd(startMid)}`);
+  out(`End Mid:      ${formatUsd(endMid)} (${priceMove >= 0 ? '+' : ''}${priceMove.toFixed(1)} bps)`);
+  out(`Result:       ${filled ? '✅ Filled' : '❌ Not filled'}`);
+
+  return { status: exitReason, iterations: iteration, durationSec: elapsed, startMid, endMid };
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
 
-    // Summary
-    const elapsed = (Date.now() - startTime) / 1000;
-    const endMid = parseFloat((await client.getAllMids())[coin]);
-    const priceMove = ((endMid - startMid) / startMid) * 10000;
+  const coin = args.coin as string;
+  const side = args.side as string;
+  const size = parseFloat(args.size as string);
 
-    console.log('\n========== Chase Summary ==========');
-    console.log(`Duration:     ${elapsed.toFixed(1)}s`);
-    console.log(`Iterations:   ${iteration}`);
-    console.log(`Start Mid:    ${formatUsd(startMid)}`);
-    console.log(`End Mid:      ${formatUsd(endMid)} (${priceMove >= 0 ? '+' : ''}${priceMove.toFixed(1)} bps)`);
-    console.log(`Result:       ${filled ? '✅ Filled' : '❌ Not filled'}`);
+  if (!coin || !side || isNaN(size)) {
+    printUsage();
+    process.exit(1);
+  }
+  if (side !== 'buy' && side !== 'sell') {
+    console.error('Error: --side must be "buy" or "sell"');
+    process.exit(1);
+  }
 
+  try {
+    await runChase({
+      coin,
+      side: side as 'buy' | 'sell',
+      size,
+      offsetBps: args.offset ? parseInt(args.offset as string) : undefined,
+      timeoutSec: args.timeout ? parseInt(args.timeout as string) : undefined,
+      intervalMs: args.interval ? parseInt(args.interval as string) : undefined,
+      maxChaseBps: args['max-chase'] ? parseInt(args['max-chase'] as string) : undefined,
+      leverage: args.leverage ? parseInt(args.leverage as string) : undefined,
+      reduceOnly: args.reduce as boolean,
+      dryRun: args.dry as boolean,
+      verbose: args.verbose as boolean,
+    });
   } catch (error) {
-    console.error('Error:', error);
+    console.error('Error:', error instanceof Error ? error.message : error);
     process.exit(1);
   }
 }
 
-main();
+// Only run when invoked as a script — not when imported as a module
+// (e.g. by `openbroker-plugin` via the lib re-export of `runChase`).
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  main();
+}