openbroker 1.9.5 → 1.10.0

package/scripts/operations/advanced-orders.test.ts

@@ -0,0 +1,542 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { runBracket, type BracketClient } from './bracket.js';
+import { runChase, type ChaseClient } from './chase.js';
+import { runScale, type ScaleClient } from './scale.js';
+import { UserFillWatcher, type FillSummary, type FillWatcher } from './execution.js';
+import type { CancelResponse, OpenOrder, OrderResponse } from '../core/types.js';
+
+const okOrder = (statuses: OrderResponse['response'] extends infer R
+  ? R extends { data: { statuses: infer S } } ? S : never
+  : never): OrderResponse => ({
+    status: 'ok',
+    response: { type: 'order', data: { statuses } },
+  });
+
+const okCancel = (): CancelResponse => ({
+  status: 'ok',
+  response: { type: 'cancel', data: { statuses: ['success'] } },
+});
+
+class StaticFillWatcher implements FillWatcher {
+  constructor(private readonly fills: Map<number, FillSummary>) {}
+  async start(): Promise<void> {}
+  async stop(): Promise<void> {}
+  getFilled(oid: number): FillSummary {
+    return this.fills.get(oid) ?? { size: 0, notional: 0 };
+  }
+  async waitForFill(oid: number): Promise<FillSummary> {
+    return this.getFilled(oid);
+  }
+}
+
+function bracketClientStub(overrides: Partial<BracketClient> = {}): BracketClient {
+  return {
+    verbose: false,
+    address: '0x0000000000000000000000000000000000000001',
+    async getAllMids() {
+      return { ETH: '1000' };
+    },
+    async marketOrder() {
+      throw new Error('marketOrder should not be called');
+    },
+    async limitOrder() {
+      throw new Error('limitOrder should not be called');
+    },
+    async tpslOrders() {
+      throw new Error('tpslOrders should not be called');
+    },
+    async bracketOrder() {
+      throw new Error('bracketOrder should not be called');
+    },
+    async cancel() {
+      throw new Error('cancel should not be called');
+    },
+    async getUserFills() {
+      return [];
+    },
+    ...overrides,
+  };
+}
+
+test('scale rejects invalid levels and rolls back resting orders on partial ladder placement', async () => {
+  const cancelled: Array<{ coin: string; oid: number }> = [];
+  const client: ScaleClient = {
+    verbose: false,
+    async getAllMids() {
+      return { ETH: '1000' };
+    },
+    async bulkOrder() {
+      return okOrder([
+        { resting: { oid: 101 } },
+        { error: 'insufficient margin' },
+        { resting: { oid: 103 } },
+      ]);
+    },
+    async bulkCancel(cancels) {
+      cancelled.push(...cancels);
+      return okCancel();
+    },
+  };
+
+  await assert.rejects(
+    () => runScale({
+      coin: 'ETH',
+      side: 'buy',
+      size: 1,
+      levels: 0,
+      rangePct: 2,
+      client,
+      output: () => {},
+    }),
+    /levels must be a positive integer/,
+  );
+
+  const result = await runScale({
+    coin: 'ETH',
+    side: 'buy',
+    size: 1,
+    levels: 3,
+    rangePct: 2,
+    client,
+    output: () => {},
+  });
+
+  assert.equal(result.status, 'partial');
+  assert.equal(result.rolledBack, true);
+  assert.deepEqual(cancelled, [
+    { coin: 'ETH', oid: 101 },
+    { coin: 'ETH', oid: 103 },
+  ]);
+});
+
+test('scale pre-checks the $10 exchange minimum on the thinnest level (waived for reduce-only)', async () => {
+  let placed = false;
+  const client: ScaleClient = {
+    verbose: false,
+    async getAllMids() {
+      return { ETH: '1000' };
+    },
+    async bulkOrder(orders) {
+      placed = true;
+      return okOrder(orders.map((_, i) => ({ resting: { oid: 200 + i } })));
+    },
+    async bulkCancel() {
+      return okCancel();
+    },
+  };
+
+  // Total ~$30 over 3 linear levels → thinnest level ~$5 < $10.
+  await assert.rejects(
+    () => runScale({
+      coin: 'ETH',
+      side: 'buy',
+      size: 0.03,
+      levels: 3,
+      rangePct: 2,
+      client,
+      output: () => {},
+    }),
+    /below the \$10 exchange minimum/,
+  );
+  assert.equal(placed, false);
+
+  // Same ladder reduce-only is allowed (exchange waives the minimum).
+  const result = await runScale({
+    coin: 'ETH',
+    side: 'buy',
+    size: 0.03,
+    levels: 3,
+    rangePct: 2,
+    reduceOnly: true,
+    client,
+    output: () => {},
+  });
+  assert.equal(result.status, 'complete');
+});
+
+test('bracket limit entry defaults to one atomic normalTpsl batch', async () => {
+  const calls: Array<{ coin: string; isBuy: boolean; size: number; entryPrice: number; opts: Record<string, unknown> }> = [];
+  const client = bracketClientStub({
+    async bracketOrder(coin, isBuy, size, entryPrice, opts) {
+      calls.push({ coin, isBuy, size, entryPrice, opts: opts ?? {} });
+      return okOrder([
+        { resting: { oid: 500 } },
+        'waitingForFill' as never,
+        'waitingForFill' as never,
+      ]);
+    },
+  });
+
+  const result = await runBracket({
+    coin: 'ETH',
+    side: 'buy',
+    size: 1,
+    tpPct: 5,
+    slPct: 2,
+    entryType: 'limit',
+    entryPrice: 990,
+    client,
+    output: () => {},
+  });
+
+  assert.equal(result.status, 'armed');
+  assert.equal(result.entryOid, 500);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].isBuy, true);
+  assert.equal(calls[0].entryPrice, 990);
+  assert.equal(calls[0].opts.takeProfitPrice, 990 * 1.05);
+  assert.equal(calls[0].opts.stopLossPrice, 990 * 0.98);
+  assert.equal(calls[0].opts.stopLossIsMarket, true);
+});
+
+test('bracket atomic batch rolls back resting orders when a leg is rejected', async () => {
+  const cancelled: number[] = [];
+  const client = bracketClientStub({
+    async bracketOrder() {
+      return okOrder([
+        { resting: { oid: 600 } },
+        'waitingForFill' as never,
+        { error: 'Invalid TP/SL price.' },
+      ]);
+    },
+    async cancel(_coin, oid) {
+      cancelled.push(oid);
+      return okCancel();
+    },
+  });
+
+  const result = await runBracket({
+    coin: 'ETH',
+    side: 'buy',
+    size: 1,
+    tpPct: 5,
+    slPct: 2,
+    entryType: 'limit',
+    entryPrice: 990,
+    client,
+    output: () => {},
+  });
+
+  assert.equal(result.status, 'entry_failed');
+  assert.match(result.reason ?? '', /Invalid TP\/SL price/);
+  assert.deepEqual(cancelled, [600]);
+});
+
+test('bracket with --no-atomic waits for limit-entry fill and arms positionTpsl for confirmed size', async () => {
+  const pairCalls: Array<{ size: number; isBuy: boolean; opts: Record<string, unknown> }> = [];
+  const client = bracketClientStub({
+    async limitOrder() {
+      return okOrder([{ resting: { oid: 777 } }]);
+    },
+    async tpslOrders(_coin, isBuy, size, opts) {
+      pairCalls.push({ size, isBuy, opts: opts ?? {} });
+      return okOrder([{ resting: { oid: 778 } }, { resting: { oid: 779 } }]);
+    },
+  });
+
+  const fillWatcher = new StaticFillWatcher(new Map([
+    [777, { size: 0.4, notional: 392, avgPrice: 980 }],
+  ]));
+
+  const result = await runBracket({
+    coin: 'ETH',
+    side: 'buy',
+    size: 1,
+    tpPct: 5,
+    slPct: 2,
+    entryType: 'limit',
+    entryPrice: 990,
+    entryTimeoutSec: 5,
+    atomic: false,
+    client,
+    fillWatcher,
+    output: () => {},
+  });
+
+  assert.equal(result.status, 'complete');
+  assert.equal(result.protectedSize, 0.4);
+  assert.equal(result.entryPrice, 980);
+  assert.equal(pairCalls.length, 1);
+  assert.equal(pairCalls[0].size, 0.4);
+  assert.equal(pairCalls[0].isBuy, false);
+  assert.equal(pairCalls[0].opts.grouping, 'positionTpsl');
+  assert.equal(pairCalls[0].opts.takeProfitPrice, 1029);
+  assert.equal(pairCalls[0].opts.stopLossPrice, 960.4);
+});
+
+test('bracket market entry supports a one-sided TP sized to the actual fill', async () => {
+  const calls: Array<{ isBuy: boolean; size: number; opts: Record<string, unknown> }> = [];
+  const client = bracketClientStub({
+    async marketOrder() {
+      return okOrder([{ filled: { totalSz: '0.8', avgPx: '1001', oid: 1 } }]);
+    },
+    async tpslOrders(_coin, isBuy, size, opts) {
+      calls.push({ isBuy, size, opts: opts ?? {} });
+      return okOrder([{ resting: { oid: 2 } }]);
+    },
+  });
+
+  const result = await runBracket({
+    coin: 'ETH',
+    side: 'buy',
+    size: 1,
+    tpPct: 5,
+    entryType: 'market',
+    client,
+    fillWatcher: new StaticFillWatcher(new Map()),
+    output: () => {},
+  });
+
+  assert.equal(result.status, 'complete');
+  assert.equal(result.protectedSize, 0.8);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].size, 0.8);
+  assert.equal(calls[0].isBuy, false);
+  assert.equal(calls[0].opts.grouping, 'positionTpsl');
+  assert.equal(calls[0].opts.takeProfitPrice, 1001 * 1.05);
+  assert.equal(calls[0].opts.stopLossPrice, undefined);
+});
+
+test('bracket validates targets before any order goes out', async () => {
+  // SL% ≥ 100 resolves to a negative price.
+  await assert.rejects(
+    () => runBracket({
+      coin: 'ETH',
+      side: 'buy',
+      size: 1,
+      tpPct: 5,
+      slPct: 150,
+      client: bracketClientStub(),
+      output: () => {},
+    }),
+    /SL must resolve to a positive price/,
+  );
+
+  // Absolute TP on the wrong side of the entry.
+  await assert.rejects(
+    () => runBracket({
+      coin: 'ETH',
+      side: 'buy',
+      size: 1,
+      tpPrice: 900,
+      entryType: 'limit',
+      entryPrice: 990,
+      client: bracketClientStub(),
+      output: () => {},
+    }),
+    /TP price must be above entry/,
+  );
+
+  // No target at all.
+  await assert.rejects(
+    () => runBracket({
+      coin: 'ETH',
+      side: 'buy',
+      size: 1,
+      client: bracketClientStub(),
+      output: () => {},
+    }),
+    /provide a TP target, an SL target, or both/,
+  );
+});
+
+test('chase requotes only the remaining size after a partial fill', async () => {
+  const limitSizes: number[] = [];
+  const cancelled: number[] = [];
+  const fills = new Map<number, FillSummary>();
+  let orderCount = 0;
+  let mid = 1000;
+
+  const client: ChaseClient = {
+    verbose: false,
+    address: '0x0000000000000000000000000000000000000001',
+    async getAllMids() {
+      mid += 2;
+      return { ETH: String(mid) };
+    },
+    async getOpenOrders(): Promise<OpenOrder[]> {
+      return [];
+    },
+    async getUserFills() {
+      return [];
+    },
+    async limitOrder(_coin, _isBuy, size) {
+      limitSizes.push(size);
+      orderCount += 1;
+      const oid = 900 + orderCount;
+      if (orderCount === 1) {
+        fills.set(oid, { size: 0.4, notional: 400, avgPrice: 1000 });
+      } else {
+        fills.set(oid, { size, notional: size * 1002, avgPrice: 1002 });
+      }
+      return okOrder([{ resting: { oid } }]);
+    },
+    async cancel(_coin, oid) {
+      cancelled.push(oid);
+      return okCancel();
+    },
+  };
+
+  const result = await runChase({
+    coin: 'ETH',
+    side: 'buy',
+    size: 1,
+    offsetBps: 5,
+    timeoutSec: 2,
+    intervalMs: 1,
+    maxChaseBps: 1_000,
+    client,
+    fillWatcher: new StaticFillWatcher(fills),
+    output: () => {},
+  });
+
+  assert.equal(result.status, 'filled');
+  assert.equal(limitSizes.length, 2);
+  assert.equal(limitSizes[0], 1);
+  assert(Math.abs(limitSizes[1] - 0.6) < 1e-9);
+  assert.deepEqual(cancelled, [901]);
+});
+
+test('chase reprices and continues after a post-only rejection', async () => {
+  const fills = new Map<number, FillSummary>();
+  let orderCount = 0;
+
+  const client: ChaseClient = {
+    verbose: false,
+    address: '0x0000000000000000000000000000000000000001',
+    async getAllMids() {
+      return { ETH: '1000' };
+    },
+    async getOpenOrders(): Promise<OpenOrder[]> {
+      return [];
+    },
+    async getUserFills() {
+      return [];
+    },
+    async limitOrder(_coin, _isBuy, size) {
+      orderCount += 1;
+      if (orderCount === 1) {
+        return okOrder([{ error: 'Post only order would have immediately matched, bbo was 999.9@1000.1' }]);
+      }
+      const oid = 900 + orderCount;
+      fills.set(oid, { size, notional: size * 1000, avgPrice: 1000 });
+      return okOrder([{ resting: { oid } }]);
+    },
+    async cancel() {
+      return okCancel();
+    },
+  };
+
+  const result = await runChase({
+    coin: 'ETH',
+    side: 'buy',
+    size: 1,
+    offsetBps: 5,
+    timeoutSec: 2,
+    intervalMs: 1,
+    maxChaseBps: 1_000,
+    client,
+    fillWatcher: new StaticFillWatcher(fills),
+    output: () => {},
+  });
+
+  assert.equal(result.status, 'filled');
+  assert.equal(orderCount, 2);
+});
+
+test('chase cancels the resting order even when the loop throws', async () => {
+  const cancelled: number[] = [];
+
+  const client: ChaseClient = {
+    verbose: false,
+    address: '0x0000000000000000000000000000000000000001',
+    async getAllMids() {
+      return { ETH: '1000' };
+    },
+    async getOpenOrders(): Promise<OpenOrder[]> {
+      throw new Error('open-orders lookup exploded');
+    },
+    async getUserFills() {
+      return [];
+    },
+    async limitOrder() {
+      return okOrder([{ resting: { oid: 950 } }]);
+    },
+    async cancel(_coin, oid) {
+      cancelled.push(oid);
+      return okCancel();
+    },
+  };
+
+  await assert.rejects(
+    () => runChase({
+      coin: 'ETH',
+      side: 'buy',
+      size: 1,
+      offsetBps: 5,
+      timeoutSec: 2,
+      intervalMs: 1,
+      maxChaseBps: 1_000,
+      client,
+      fillWatcher: new StaticFillWatcher(new Map()),
+      output: () => {},
+    }),
+    /open-orders lookup exploded/,
+  );
+
+  assert.deepEqual(cancelled, [950]);
+});
+
+test('chase rejects a start size below the $10 exchange minimum', async () => {
+  const client: ChaseClient = {
+    verbose: false,
+    address: '0x0000000000000000000000000000000000000001',
+    async getAllMids() {
+      return { ETH: '1000' };
+    },
+    async getOpenOrders(): Promise<OpenOrder[]> {
+      return [];
+    },
+    async getUserFills() {
+      return [];
+    },
+    async limitOrder() {
+      throw new Error('limitOrder should not be called');
+    },
+    async cancel() {
+      return okCancel();
+    },
+  };
+
+  await assert.rejects(
+    () => runChase({
+      coin: 'ETH',
+      side: 'buy',
+      size: 0.005,
+      client,
+      fillWatcher: new StaticFillWatcher(new Map()),
+      output: () => {},
+    }),
+    /below the \$10 exchange minimum/,
+  );
+});
+
+test('user fill watcher de-duplicates repeated REST fallback fills', async () => {
+  const fillTime = Date.now();
+  const watcher = new UserFillWatcher({
+    verbose: false,
+    address: '0x0000000000000000000000000000000000000001',
+    async getUserFills() {
+      return [
+        { coin: 'ETH', px: '1000', sz: '0.25', time: fillTime, oid: 123 },
+      ];
+    },
+  }, { ws: null, sinceMs: fillTime - 1000 });
+
+  await watcher.start();
+  await watcher.waitForFill(123, 1, 1, { coin: 'ETH', pollMs: 1 });
+  await watcher.waitForFill(123, 1, 1, { coin: 'ETH', pollMs: 1 });
+
+  assert.equal(watcher.getFilled(123).size, 0.25);
+});