openbroker 1.9.6 → 1.12.0

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

@@ -30,6 +30,35 @@ class StaticFillWatcher implements FillWatcher {
   }
 }
 
+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 = {
@@ -81,28 +110,130 @@ test('scale rejects invalid levels and rolls back resting orders on partial ladd
   ]);
 });
 
-test('bracket waits for limit-entry fill and arms linked TP/SL for confirmed size', async () => {
-  const pairCalls: Array<{ size: number; tp: number; sl: number; isBuy: boolean }> = [];
-  const client: BracketClient = {
+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,
-    address: '0x0000000000000000000000000000000000000001',
     async getAllMids() {
       return { ETH: '1000' };
     },
-    async marketOrder() {
-      throw new Error('marketOrder should not be called');
+    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 tpslPair(_coin, isBuy, size, tp, sl) {
-      pairCalls.push({ size, tp, sl, isBuy });
+    async tpslOrders(_coin, isBuy, size, opts) {
+      pairCalls.push({ size, isBuy, opts: opts ?? {} });
       return okOrder([{ resting: { oid: 778 } }, { resting: { oid: 779 } }]);
     },
-    async getUserFills() {
-      return [];
-    },
-  };
+  });
 
   const fillWatcher = new StaticFillWatcher(new Map([
     [777, { size: 0.4, notional: 392, avgPrice: 980 }],
@@ -117,6 +248,7 @@ test('bracket waits for limit-entry fill and arms linked TP/SL for confirmed siz
     entryType: 'limit',
     entryPrice: 990,
     entryTimeoutSec: 5,
+    atomic: false,
     client,
     fillWatcher,
     output: () => {},
@@ -128,8 +260,85 @@ test('bracket waits for limit-entry fill and arms linked TP/SL for confirmed siz
   assert.equal(pairCalls.length, 1);
   assert.equal(pairCalls[0].size, 0.4);
   assert.equal(pairCalls[0].isBuy, false);
-  assert.equal(pairCalls[0].tp, 1029);
-  assert.equal(pairCalls[0].sl, 960.4);
+  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 () => {
@@ -189,6 +398,130 @@ test('chase requotes only the remaining size after a partial fill', async () =>
   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({