openbroker 1.9.6 → 1.10.0

package/scripts/operations/bracket.ts

@@ -3,8 +3,8 @@
 
 import { fileURLToPath } from 'url';
 import { getClient } from '../core/client.js';
-import type { OrderResponse } from '../core/types.js';
-import { formatUsd, parseArgs, sleep } from '../core/utils.js';
+import type { CancelResponse, OrderResponse } from '../core/types.js';
+import { formatUsd, parseArgs, parseOrderStatus, sleep } from '../core/utils.js';
 import { UserFillWatcher, type FillWatcher } from './execution.js';
 
 function printUsage() {
@@ -26,12 +26,24 @@ Options:
   --price       Entry price (required if --entry limit)
   --tp          Take profit distance in % from entry
   --sl          Stop loss distance in % from entry
+  --tp-price    Take profit at an absolute price (instead of --tp)
+  --sl-price    Stop loss at an absolute price (instead of --sl)
   --slippage    Slippage for market entry in bps (default: 50)
-  --entry-timeout Seconds to wait for limit entry fill before returning (default: 300)
-  --sl-slippage Stop-loss trigger limit slippage in bps (default: 100)
+  --entry-timeout Seconds to wait for limit entry fill before returning
+                (default: 300; only used with --no-atomic)
+  --sl-slippage Stop-loss fill cap past the trigger in bps (default: 100)
+  --sl-limit    Place the SL as a stop-limit instead of a market trigger.
+                Warning: a gap move past the limit band can skip the stop
+                entirely and leave the position unprotected.
+  --no-atomic   For limit entries: place the entry alone and arm TP/SL only
+                after a confirmed fill, instead of the default atomic batch
+                where the exchange arms TP/SL on fill server-side.
   --leverage    Set leverage (e.g., 10 for 10x). Cross for main perps, isolated for HIP-3
   --dry         Dry run - show bracket plan without executing
 
+At least one of --tp/--tp-price/--sl/--sl-price is required; one-sided
+brackets (TP-only or SL-only) are supported.
+
 Take Profit / Stop Loss:
   For LONG (buy): TP is above entry, SL is below entry
   For SHORT (sell): TP is below entry, SL is above entry
@@ -40,9 +52,12 @@ Examples:
   # Long ETH with 3% take profit and 1.5% stop loss
   npx tsx scripts/operations/bracket.ts --coin ETH --side buy --size 0.5 --tp 3 --sl 1.5
 
-  # Short BTC with limit entry at $100k, 5% TP, 2% SL
+  # Short BTC with limit entry at $100k, 5% TP, 2% SL (armed atomically on fill)
   npx tsx scripts/operations/bracket.ts --coin BTC --side sell --size 0.1 --entry limit --price 100000 --tp 5 --sl 2
 
+  # Long with absolute targets, SL only
+  npx tsx scripts/operations/bracket.ts --coin SOL --side buy --size 10 --sl-price 120
+
   # Preview bracket setup
   npx tsx scripts/operations/bracket.ts --coin SOL --side buy --size 10 --tp 5 --sl 2 --dry
 `);
@@ -52,13 +67,27 @@ export interface BracketOptions {
   coin: string;
   side: 'buy' | 'sell';
   size: number;
-  tpPct: number;
-  slPct: number;
+  /** Take profit distance in % from entry. Optional if tpPrice/sl* given. */
+  tpPct?: number;
+  /** Stop loss distance in % from entry. Optional if slPrice/tp* given. */
+  slPct?: number;
+  /** Absolute take profit price (takes precedence over tpPct). */
+  tpPrice?: number;
+  /** Absolute stop loss trigger price (takes precedence over slPct). */
+  slPrice?: number;
   entryType?: 'market' | 'limit';
   entryPrice?: number;
   slippage?: number;
   entryTimeoutSec?: number;
   slSlippageBps?: number;
+  /** SL fires as a market trigger (default true); false = stop-limit. */
+  slMarket?: boolean;
+  /**
+   * Limit entries only: submit entry + TP/SL as one atomic normalTpsl batch
+   * (default true) — the exchange arms the exits when the entry fills, so the
+   * bracket survives this process exiting. false = legacy fill-watch path.
+   */
+  atomic?: boolean;
   leverage?: number;
   dryRun?: boolean;
   verbose?: boolean;
@@ -73,13 +102,29 @@ export interface BracketClient {
   getAllMids(): Promise<Record<string, string>>;
   marketOrder(coin: string, isBuy: boolean, size: number, slippageBps?: number, leverage?: number): Promise<OrderResponse>;
   limitOrder(coin: string, isBuy: boolean, size: number, price: number, tif?: 'Gtc' | 'Ioc' | 'Alo', reduceOnly?: boolean, leverage?: number): Promise<OrderResponse>;
-  tpslPair(coin: string, isBuy: boolean, size: number, takeProfitPrice: number, stopLossPrice: number, stopLossSlippageBps?: number, leverage?: number): Promise<OrderResponse>;
+  tpslOrders(coin: string, isBuy: boolean, size: number, opts?: {
+    takeProfitPrice?: number;
+    stopLossPrice?: number;
+    stopLossSlippageBps?: number;
+    stopLossIsMarket?: boolean;
+    grouping?: 'positionTpsl' | 'normalTpsl';
+    leverage?: number;
+  }): Promise<OrderResponse>;
+  bracketOrder(coin: string, isBuy: boolean, size: number, entryPrice: number, opts?: {
+    entryTif?: 'Gtc' | 'Alo';
+    takeProfitPrice?: number;
+    stopLossPrice?: number;
+    stopLossSlippageBps?: number;
+    stopLossIsMarket?: boolean;
+    leverage?: number;
+  }): Promise<OrderResponse>;
+  cancel(coin: string, oid: number): Promise<CancelResponse>;
   address: string;
   getUserFills(user?: string): Promise<Array<{ coin: string; px: string; sz: string; time: number; oid: number }>>;
 }
 
 export interface BracketResult {
-  status: 'dry' | 'limit_resting' | 'complete' | 'entry_failed' | 'partial';
+  status: 'dry' | 'armed' | 'limit_resting' | 'complete' | 'entry_failed' | 'partial';
   entryPrice?: number;
   tpPrice?: number;
   slPrice?: number;
@@ -90,17 +135,55 @@ export interface BracketResult {
   reason?: string;
 }
 
+interface ResolvedTargets {
+  tpPrice: number | null;
+  slPrice: number | null;
+}
+
 export async function runBracket(opts: BracketOptions): Promise<BracketResult> {
   const out = opts.output ?? ((line: string) => console.log(line));
   const entryType = opts.entryType ?? 'market';
+  const slMarket = opts.slMarket !== false;
+  const atomic = opts.atomic !== false;
   const isLong = opts.side === 'buy';
 
+  const hasTp = (opts.tpPct ?? 0) > 0 || (opts.tpPrice ?? 0) > 0;
+  const hasSl = (opts.slPct ?? 0) > 0 || (opts.slPrice ?? 0) > 0;
+
   if (opts.size <= 0 || isNaN(opts.size)) throw new Error('size must be positive');
-  if (opts.tpPct <= 0 || opts.slPct <= 0) throw new Error('tp and sl must be positive percentages');
+  if (!hasTp && !hasSl) throw new Error('provide a TP target, an SL target, or both (tpPct/tpPrice/slPct/slPrice)');
   if (entryType === 'limit' && opts.entryPrice === undefined) {
     throw new Error('entryPrice is required for limit entry');
   }
 
+  // Resolve percent targets off the reference entry and validate every provided leg.
+  const resolveTargets = (entryPrice: number): ResolvedTargets => {
+    const tpPrice = !hasTp
+      ? null
+      : (opts.tpPrice ?? 0) > 0
+        ? opts.tpPrice!
+        : isLong
+          ? entryPrice * (1 + opts.tpPct! / 100)
+          : entryPrice * (1 - opts.tpPct! / 100);
+    const slPrice = !hasSl
+      ? null
+      : (opts.slPrice ?? 0) > 0
+        ? opts.slPrice!
+        : isLong
+          ? entryPrice * (1 - opts.slPct! / 100)
+          : entryPrice * (1 + opts.slPct! / 100);
+    if (tpPrice !== null && tpPrice <= 0) throw new Error('TP must resolve to a positive price (keep TP% under 100 on shorts)');
+    if (slPrice !== null && slPrice <= 0) throw new Error('SL must resolve to a positive price (keep SL% under 100)');
+    if (isLong) {
+      if (tpPrice !== null && tpPrice <= entryPrice) throw new Error('for a long, TP price must be above entry');
+      if (slPrice !== null && slPrice >= entryPrice) throw new Error('for a long, SL price must be below entry');
+    } else {
+      if (tpPrice !== null && tpPrice >= entryPrice) throw new Error('for a short, TP price must be below entry');
+      if (slPrice !== null && slPrice <= entryPrice) throw new Error('for a short, SL price must be above entry');
+    }
+    return { tpPrice, slPrice };
+  };
+
   const client = opts.client ?? getClient();
   if (opts.verbose) client.verbose = true;
 
@@ -113,14 +196,13 @@ export async function runBracket(opts: BracketOptions): Promise<BracketResult> {
 
   const entry = entryType === 'limit' ? opts.entryPrice! : midPrice;
 
-  let tpPrice = isLong
-    ? entry * (1 + opts.tpPct / 100)
-    : entry * (1 - opts.tpPct / 100);
-  let slPrice = isLong
-    ? entry * (1 - opts.slPct / 100)
-    : entry * (1 + opts.slPct / 100);
+  // Validate targets against the pre-trade reference BEFORE the entry goes out,
+  // so a bad TP/SL never leaves an unprotected position behind.
+  let targets = resolveTargets(entry);
 
-  const riskReward = opts.tpPct / opts.slPct;
+  const legsLabel = hasTp && hasSl ? 'TP/SL' : hasTp ? 'TP' : 'SL';
+  const tpDistPct = targets.tpPrice !== null ? Math.abs(targets.tpPrice - entry) / entry * 100 : null;
+  const slDistPct = targets.slPrice !== null ? Math.abs(targets.slPrice - entry) / entry * 100 : null;
   const notional = entry * opts.size;
 
   out('Bracket Plan');
@@ -128,29 +210,111 @@ export async function runBracket(opts: BracketOptions): Promise<BracketResult> {
   out(`Coin:           ${opts.coin}`);
   out(`Position:       ${isLong ? 'LONG' : 'SHORT'}`);
   out(`Size:           ${opts.size}`);
-  out(`Entry Type:     ${entryType.toUpperCase()}`);
+  out(`Entry Type:     ${entryType.toUpperCase()}${entryType === 'limit' ? (atomic ? ' (atomic TP/SL)' : ' (fill-watch TP/SL)') : ''}`);
   out(`Current Mid:    ${formatUsd(midPrice)}`);
   out(`Entry Price:    ${formatUsd(entry)}${entryType === 'market' ? ' (approx)' : ''}`);
-  out(`Take Profit:    ${formatUsd(tpPrice)} (+${opts.tpPct}%)`);
-  out(`Stop Loss:      ${formatUsd(slPrice)} (-${opts.slPct}%)`);
-  out(`Risk/Reward:    1:${riskReward.toFixed(2)}`);
+  if (targets.tpPrice !== null) out(`Take Profit:    ${formatUsd(targets.tpPrice)} (${tpDistPct!.toFixed(2)}% from entry)`);
+  if (targets.slPrice !== null) out(`Stop Loss:      ${formatUsd(targets.slPrice)} (${slDistPct!.toFixed(2)}% from entry, ${slMarket ? 'market trigger' : 'stop-limit'})`);
+  if (tpDistPct !== null && slDistPct !== null && slDistPct > 0) {
+    out(`Risk/Reward:    1:${(tpDistPct / slDistPct).toFixed(2)}`);
+  }
   out(`Est. Notional:  ${formatUsd(notional)}`);
 
-  const potentialProfit = notional * (opts.tpPct / 100);
-  const potentialLoss = notional * (opts.slPct / 100);
   out('\nRisk Analysis');
   out('-------------');
-  out(`Potential Profit: ${formatUsd(potentialProfit)}`);
-  out(`Potential Loss:   ${formatUsd(potentialLoss)}`);
+  if (targets.tpPrice !== null) out(`Potential Profit: ${formatUsd(Math.abs(targets.tpPrice - entry) * opts.size)}`);
+  if (targets.slPrice !== null) out(`Potential Loss:   ${formatUsd(Math.abs(entry - targets.slPrice) * opts.size)}`);
 
   if (opts.dryRun) {
     out('\n🔍 Dry run - bracket not executed');
-    return { status: 'dry', entryPrice: entry, tpPrice, slPrice };
+    return { status: 'dry', entryPrice: entry, tpPrice: targets.tpPrice ?? undefined, slPrice: targets.slPrice ?? undefined };
   }
 
   out('\nExecuting bracket...\n');
 
-  // Step 1: Entry
+  // ── Atomic path: limit entry + TP/SL in one normalTpsl batch ──────────
+  // The exchange arms the exits when the entry fills (children come back as
+  // "waitingForFill"), so the bracket survives this process exiting.
+  if (entryType === 'limit' && atomic) {
+    out(`Step 1: Limit entry + ${legsLabel} (atomic normalTpsl batch)`);
+    const response = await client.bracketOrder(opts.coin, isLong, opts.size, entry, {
+      takeProfitPrice: targets.tpPrice ?? undefined,
+      stopLossPrice: targets.slPrice ?? undefined,
+      stopLossSlippageBps: opts.slSlippageBps,
+      stopLossIsMarket: slMarket,
+      leverage: opts.leverage,
+    });
+
+    if (response.status !== 'ok' || !response.response || typeof response.response !== 'object') {
+      const reason = typeof response.response === 'string' ? response.response : 'Unknown error';
+      out(`  ❌ Bracket failed: ${reason}`);
+      return { status: 'entry_failed', reason };
+    }
+
+    const statuses = response.response.data.statuses.map(parseOrderStatus);
+    const entryStatus = statuses[0];
+    const childStatuses = statuses.slice(1);
+    const failed = statuses.find((s) => s.kind === 'error' || s.kind === 'unknown');
+    if (failed) {
+      // Roll back anything that landed so no half-armed bracket is left behind.
+      const restingOids = statuses.flatMap((s) => (s.kind === 'resting' ? [s.oid] : []));
+      for (const oid of restingOids) {
+        try { await client.cancel(opts.coin, oid); } catch { /* may have filled */ }
+      }
+      const reason = failed.kind === 'error' ? failed.error : `Unexpected order status: ${JSON.stringify(failed)}`;
+      out(`  ❌ Bracket rejected: ${reason}`);
+      if (restingOids.length) out(`  Cancelled ${restingOids.length} resting order(s).`);
+      return { status: 'entry_failed', reason };
+    }
+
+    let entryOid: number | null = null;
+    let filledEntry: { size: number; avgPx: number } | null = null;
+    if (entryStatus.kind === 'resting') {
+      entryOid = entryStatus.oid;
+      out(`  ✅ Entry resting @ ${formatUsd(entry)} (OID: ${entryOid})`);
+    } else if (entryStatus.kind === 'filled') {
+      entryOid = entryStatus.oid;
+      filledEntry = { size: entryStatus.totalSz, avgPx: entryStatus.avgPx };
+      out(`  ✅ Entry filled immediately: ${entryStatus.totalSz} @ ${formatUsd(entryStatus.avgPx)}`);
+    }
+
+    let tpOid: number | null = null;
+    let slOid: number | null = null;
+    let childIdx = 0;
+    for (const label of [targets.tpPrice !== null ? 'TP' : null, targets.slPrice !== null ? 'SL' : null]) {
+      if (!label) continue;
+      const child = childStatuses[childIdx++];
+      if (!child) continue;
+      if (child.kind === 'waiting') {
+        out(`  ✅ ${label} armed — activates when the entry fills (${child.state})`);
+      } else if (child.kind === 'resting') {
+        if (label === 'TP') tpOid = child.oid; else slOid = child.oid;
+        out(`  ✅ ${label} trigger live (OID: ${child.oid})`);
+      }
+    }
+
+    out('\n========== Bracket Summary ==========');
+    out(`Position:    ${isLong ? 'LONG' : 'SHORT'} ${opts.size} ${opts.coin}`);
+    out(`Entry:       ${formatUsd(filledEntry?.avgPx ?? entry)}${filledEntry ? '' : ' (resting)'}`);
+    if (targets.tpPrice !== null) out(`Take Profit: ${formatUsd(targets.tpPrice)}`);
+    if (targets.slPrice !== null) out(`Stop Loss:   ${formatUsd(targets.slPrice)} (${slMarket ? 'market trigger' : 'stop-limit'})`);
+    out(filledEntry
+      ? `\n✅ Bracket complete! ${legsLabel} triggers are live.`
+      : `\n✅ Bracket armed! ${legsLabel} activates server-side when the entry fills.`);
+
+    return {
+      status: filledEntry ? 'complete' : 'armed',
+      entryPrice: filledEntry?.avgPx ?? entry,
+      tpPrice: targets.tpPrice ?? undefined,
+      slPrice: targets.slPrice ?? undefined,
+      tpOid,
+      slOid,
+      entryOid,
+      protectedSize: filledEntry?.size ?? opts.size,
+    };
+  }
+
+  // ── Fill-first path: market entry, or limit entry with --no-atomic ────
   out('Step 1: Entry order');
   let actualEntry = entry;
   let entryOid: number | null = null;
@@ -237,72 +401,80 @@ export async function runBracket(opts: BracketOptions): Promise<BracketResult> {
     return { status: 'entry_failed', reason: 'No confirmed fill size' };
   }
 
-  // Recalculate TP/SL based on actual entry
-  if (isLong) {
-    tpPrice = actualEntry * (1 + opts.tpPct / 100);
-    slPrice = actualEntry * (1 - opts.slPct / 100);
-  } else {
-    tpPrice = actualEntry * (1 - opts.tpPct / 100);
-    slPrice = actualEntry * (1 + opts.slPct / 100);
+  // Re-resolve off the actual fill price; if the fill drifted past a fixed
+  // target, report it instead of leaving a half-armed bracket silently.
+  try {
+    targets = resolveTargets(actualEntry);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    out(`\n❌ Entry filled @ ${formatUsd(actualEntry)}, but ${legsLabel} could not be armed: ${reason}`);
+    out('⚠️ Position is OPEN and UNPROTECTED - set TP/SL manually (openbroker set-tpsl).');
+    return { status: 'partial', entryPrice: actualEntry, protectedSize: 0, reason };
   }
 
   await sleep(500);
 
-  // Step 2: Paired TP/SL trigger orders
-  out('\nStep 2: Paired TP/SL trigger orders');
+  // Step 2: TP/SL triggers tied to the now-open position (positionTpsl) —
+  // OCO between themselves and cancelled by the venue if the position closes.
+  out(`\nStep 2: Position ${legsLabel} trigger orders`);
   const exitSide = !isLong;
-  const pairResponse = await client.tpslPair(
-    opts.coin,
-    exitSide,
-    filledSize,
-    tpPrice,
-    slPrice,
-    opts.slSlippageBps,
-    opts.leverage,
-  );
+  const pairResponse = await client.tpslOrders(opts.coin, exitSide, filledSize, {
+    takeProfitPrice: targets.tpPrice ?? undefined,
+    stopLossPrice: targets.slPrice ?? undefined,
+    stopLossSlippageBps: opts.slSlippageBps,
+    stopLossIsMarket: slMarket,
+    grouping: 'positionTpsl',
+    leverage: opts.leverage,
+  });
 
   let tpOid: number | null = null;
   let slOid: number | null = null;
+  let exitErrors = 0;
   if (pairResponse.status === 'ok' && pairResponse.response && typeof pairResponse.response === 'object') {
-    const [tpStatus, slStatus] = pairResponse.response.data.statuses;
-    if (tpStatus?.resting) {
-      tpOid = tpStatus.resting.oid;
-      out(`  ✅ TP trigger placed @ ${formatUsd(tpPrice)} (OID: ${tpOid})`);
-    } else if (tpStatus?.error) {
-      out(`  ❌ TP failed: ${tpStatus.error}`);
-    } else {
-      out(`  ⚠️ TP status: ${JSON.stringify(tpStatus)}`);
-    }
-
-    if (slStatus?.resting) {
-      slOid = slStatus.resting.oid;
-      out(`  ✅ SL trigger placed @ ${formatUsd(slPrice)} (OID: ${slOid})`);
-    } else if (slStatus?.error) {
-      out(`  ❌ SL failed: ${slStatus.error}`);
-    } else {
-      out(`  ⚠️ SL status: ${JSON.stringify(slStatus)}`);
+    const statuses = pairResponse.response.data.statuses.map(parseOrderStatus);
+    let idx = 0;
+    for (const leg of [targets.tpPrice !== null ? 'TP' : null, targets.slPrice !== null ? 'SL' : null]) {
+      if (!leg) continue;
+      const status = statuses[idx++];
+      const price = leg === 'TP' ? targets.tpPrice! : targets.slPrice!;
+      if (status?.kind === 'resting') {
+        if (leg === 'TP') tpOid = status.oid; else slOid = status.oid;
+        out(`  ✅ ${leg} trigger placed @ ${formatUsd(price)} (OID: ${status.oid})`);
+      } else if (status?.kind === 'waiting') {
+        out(`  ✅ ${leg} trigger armed @ ${formatUsd(price)} (${status.state})`);
+      } else if (status?.kind === 'error') {
+        exitErrors++;
+        out(`  ❌ ${leg} failed: ${status.error}`);
+      } else {
+        exitErrors++;
+        out(`  ⚠️ ${leg} status: ${JSON.stringify(status)}`);
+      }
     }
   } else {
+    exitErrors++;
     const reason = typeof pairResponse.response === 'string' ? pairResponse.response : 'Unknown error';
-    out(`  ❌ TP/SL pair failed: ${reason}`);
+    out(`  ❌ ${legsLabel} orders failed: ${reason}`);
   }
 
   out('\n========== Bracket Summary ==========');
   out(`Position:    ${isLong ? 'LONG' : 'SHORT'} ${filledSize} ${opts.coin}`);
   out(`Entry:       ${formatUsd(actualEntry)}`);
-  out(`Take Profit: ${formatUsd(tpPrice)} (+${opts.tpPct}%) - Trigger order`);
-  out(`Stop Loss:   ${formatUsd(slPrice)} (-${opts.slPct}%) - Trigger order`);
-  if (tpOid && slOid) {
-    out(`\n✅ Bracket complete! TP and SL are linked trigger orders.`);
+  if (targets.tpPrice !== null) out(`Take Profit: ${formatUsd(targets.tpPrice)} - Trigger order`);
+  if (targets.slPrice !== null) out(`Stop Loss:   ${formatUsd(targets.slPrice)} (${slMarket ? 'market trigger' : 'stop-limit'}) - Trigger order`);
+  if (exitErrors === 0) {
+    out(`\n✅ Bracket complete! ${legsLabel} triggers track the position (positionTpsl).`);
+  } else {
+    out('\n⚠️ Position is open but not fully protected - set the missing trigger manually.');
   }
 
   return {
-    status: tpOid && slOid ? 'complete' : 'partial',
+    status: exitErrors === 0 ? 'complete' : 'partial',
     entryPrice: actualEntry,
-    tpPrice,
-    slPrice,
+    tpPrice: targets.tpPrice ?? undefined,
+    slPrice: targets.slPrice ?? undefined,
     tpOid,
     slOid,
+    entryOid,
     protectedSize: filledSize,
   };
 }
@@ -315,15 +487,18 @@ async function main() {
   const size = parseFloat(args.size as string);
   const entryType = (args.entry as string || 'market') as 'market' | 'limit';
   const entryPrice = args.price ? parseFloat(args.price as string) : undefined;
-  const tpPct = parseFloat(args.tp as string);
-  const slPct = parseFloat(args.sl as string);
+  const tpPct = args.tp ? parseFloat(args.tp as string) : undefined;
+  const slPct = args.sl ? parseFloat(args.sl as string) : undefined;
+  const tpPrice = args['tp-price'] ? parseFloat(args['tp-price'] as string) : undefined;
+  const slPrice = args['sl-price'] ? parseFloat(args['sl-price'] as string) : undefined;
   const slippage = args.slippage ? parseInt(args.slippage as string) : undefined;
   const entryTimeoutSec = args['entry-timeout'] ? parseInt(args['entry-timeout'] as string) : undefined;
   const slSlippageBps = args['sl-slippage'] ? parseInt(args['sl-slippage'] as string) : undefined;
   const leverage = args.leverage ? parseInt(args.leverage as string) : undefined;
   const dryRun = args.dry as boolean;
 
-  if (!coin || !side || isNaN(size) || isNaN(tpPct) || isNaN(slPct)) {
+  const hasTarget = [tpPct, slPct, tpPrice, slPrice].some((v) => v !== undefined && !isNaN(v));
+  if (!coin || !side || isNaN(size) || !hasTarget) {
     printUsage();
     process.exit(1);
   }
@@ -339,11 +514,15 @@ async function main() {
       size,
       tpPct,
       slPct,
+      tpPrice,
+      slPrice,
       entryType,
       entryPrice,
       slippage,
       entryTimeoutSec,
       slSlippageBps,
+      slMarket: !(args['sl-limit'] as boolean),
+      atomic: !(args['no-atomic'] as boolean),
       leverage,
       dryRun,
       verbose: args.verbose as boolean,

package/scripts/operations/chase.ts

@@ -4,7 +4,7 @@
 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 { MIN_ORDER_NOTIONAL_USD, formatUsd, parseArgs, sleep } from '../core/utils.js';
 import { UserFillWatcher, type FillWatcher } from './execution.js';
 
 function printUsage() {
@@ -68,7 +68,7 @@ export interface ChaseClient {
 }
 
 export interface ChaseResult {
-  status: 'dry' | 'filled' | 'timeout' | 'max_chase_exceeded';
+  status: 'dry' | 'filled' | 'timeout' | 'max_chase_exceeded' | 'min_notional';
   iterations: number;
   durationSec: number;
   startMid: number;
@@ -99,6 +99,10 @@ export async function runChase(opts: ChaseOptions): Promise<ChaseResult> {
   const startMid = parseFloat(mids[opts.coin]);
   if (!startMid) throw new Error(`No market data for ${opts.coin}`);
 
+  const startBelowMinimum = !opts.reduceOnly && opts.size * startMid < MIN_ORDER_NOTIONAL_USD;
+  const minNotionalMsg = `Chase size (~$${(opts.size * startMid).toFixed(2)}) is below the $${MIN_ORDER_NOTIONAL_USD} exchange minimum`;
+  if (startBelowMinimum && !opts.dryRun) throw new Error(minNotionalMsg);
+
   const maxChasePrice = isBuy
     ? startMid * (1 + maxChaseBps / 10000)
     : startMid * (1 - maxChaseBps / 10000);
@@ -116,6 +120,7 @@ export async function runChase(opts: ChaseOptions): Promise<ChaseResult> {
   out(`Order Type:    ALO (post-only)`);
 
   if (opts.dryRun) {
+    if (startBelowMinimum) out(`\n⚠️ ${minNotionalMsg}`);
     out('\n🔍 Dry run - chase not started');
     return { status: 'dry', iterations: 0, durationSec: 0, startMid, endMid: startMid };
   }
@@ -128,7 +133,7 @@ export async function runChase(opts: ChaseOptions): Promise<ChaseResult> {
   let remainingSize = opts.size;
   let iteration = 0;
   let filled = false;
-  let exitReason: 'filled' | 'timeout' | 'max_chase_exceeded' = 'timeout';
+  let exitReason: 'filled' | 'timeout' | 'max_chase_exceeded' | 'min_notional' = 'timeout';
   const accountedFills = new Map<number, number>();
   const ownsFillWatcher = !opts.fillWatcher;
   const fillWatcher = opts.fillWatcher ?? new UserFillWatcher(client, { sinceMs: startTime });
@@ -160,9 +165,20 @@ export async function runChase(opts: ChaseOptions): Promise<ChaseResult> {
         }
       }
 
-      const currentMids = await client.getAllMids();
-      const currentMid = parseFloat(currentMids[opts.coin]);
-      if (!currentMid) throw new Error(`No market data for ${opts.coin}`);
+      // A transient /info failure mid-chase must not kill the execution (and
+      // strand the resting order) — wait a tick and retry instead.
+      let currentMid = NaN;
+      try {
+        const currentMids = await client.getAllMids();
+        currentMid = parseFloat(currentMids[opts.coin]);
+      } catch {
+        /* transient failure — retry next tick */
+      }
+      if (!Number.isFinite(currentMid) || currentMid <= 0) {
+        out(`[${iteration}] ⏳ No live price — retrying...`);
+        await sleep(intervalMs);
+        continue;
+      }
 
       if (isBuy && currentMid > maxChasePrice) {
         out(`\n⚠️ Price ${formatUsd(currentMid)} exceeded max chase ${formatUsd(maxChasePrice)}`);
@@ -206,6 +222,14 @@ export async function runChase(opts: ChaseOptions): Promise<ChaseResult> {
           break;
         }
 
+        // The dust remainder of a partial fill can drop below the exchange
+        // minimum — placing it would just error out on every tick.
+        if (!opts.reduceOnly && remainingSize * currentMid < MIN_ORDER_NOTIONAL_USD) {
+          out(`\n⚠️ Remaining size (~$${(remainingSize * currentMid).toFixed(2)}) fell below the $${MIN_ORDER_NOTIONAL_USD} exchange minimum`);
+          exitReason = 'min_notional';
+          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);
@@ -226,10 +250,18 @@ export async function runChase(opts: ChaseOptions): Promise<ChaseResult> {
               break;
             }
           } else if (status?.error) {
-            out(`❌ ${status.error}`);
+            if (/post.?only|immediately match/i.test(status.error)) {
+              // Stale mid crossed the book — the fast-market condition chase
+              // exists for. Reprice on the next tick instead of dying.
+              out(`↩️ Quote would cross the book — repricing`);
+              lastPrice = null;
+            } else {
+              throw new Error(status.error);
+            }
           }
         } else {
-          out(`❌ Failed`);
+          const reason = typeof response.response === 'string' ? response.response : 'Order rejected';
+          throw new Error(reason);
         }
       } else {
         if (currentOid !== null) {
@@ -261,23 +293,24 @@ export async function runChase(opts: ChaseOptions): Promise<ChaseResult> {
       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);
-      out(`✅ Cancelled`);
-    } catch {
-      out(`⚠️ Could not cancel (may have filled)`);
-    }
-    applyFills(currentOid);
-    if (remainingSize <= opts.size * 0.001) {
-      filled = true;
-      exitReason = 'filled';
+    // Always pull the working order before returning — even when the loop
+    // throws — so an error never strands a live resting quote at a stale price.
+    if (currentOid !== null && !filled) {
+      applyFills(currentOid);
+      out(`\nCancelling unfilled order...`);
+      try {
+        await client.cancel(opts.coin, currentOid);
+        out(`✅ Cancelled`);
+      } catch {
+        out(`⚠️ Could not cancel (may have filled)`);
+      }
+      applyFills(currentOid);
+      if (remainingSize <= opts.size * 0.001) {
+        filled = true;
+        exitReason = 'filled';
+      }
     }
+    if (ownsFillWatcher) await fillWatcher.stop();
   }
 
   const elapsed = (Date.now() - startTime) / 1000;

package/scripts/operations/scale.ts

@@ -4,7 +4,7 @@
 import { fileURLToPath } from 'url';
 import { getClient } from '../core/client.js';
 import type { CancelResponse, OrderResponse } from '../core/types.js';
-import { formatUsd, parseArgs } from '../core/utils.js';
+import { MIN_ORDER_NOTIONAL_USD, formatUsd, parseArgs } from '../core/utils.js';
 
 function printUsage() {
   console.log(`
@@ -194,11 +194,20 @@ export async function runScale(opts: ScaleOptions): Promise<ScaleResult> {
     );
   }
 
+  // Every level must clear the exchange's minimum notional (waived for
+  // reduce-only) or it gets a silent per-level rejection.
+  const thinnest = levels.reduce((min, level) => Math.min(min, level.size * level.price), Infinity);
+  const belowMinimum = !reduceOnly && thinnest < MIN_ORDER_NOTIONAL_USD;
+  const minNotionalMsg = `smallest scale level (~$${thinnest.toFixed(2)}) is below the $${MIN_ORDER_NOTIONAL_USD} exchange minimum — use fewer levels or a larger size`;
+
   if (opts.dryRun) {
+    if (belowMinimum) out(`\n⚠️ The ${minNotionalMsg}`);
     out('\n🔍 Dry run - orders not placed');
     return { status: 'dry', levels, restingOids: [], filledOids: [], errors: [], rolledBack: false };
   }
 
+  if (belowMinimum) throw new Error(`the ${minNotionalMsg}`);
+
   out('\nPlacing ladder as a bulk order...\n');
 
   const response = await client.bulkOrder(