openbroker 1.9.5 → 1.10.0

package/dist/operations/bracket.js

@@ -2,7 +2,8 @@
 // Bracket Order - Entry with Take Profit and Stop Loss
 import { fileURLToPath } from 'url';
 import { getClient } from '../core/client.js';
-import { formatUsd, parseArgs, sleep } from '../core/utils.js';
+import { formatUsd, parseArgs, parseOrderStatus, sleep } from '../core/utils.js';
+import { UserFillWatcher } from './execution.js';
 function printUsage() {
     console.log(`
 Open Broker - Bracket Order
@@ -22,10 +23,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; 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
@@ -34,9 +49,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
 `);
@@ -44,15 +62,53 @@ Examples:
 export async function runBracket(opts) {
     const out = opts.output ?? ((line) => 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');
     }
-    const client = getClient();
+    // Resolve percent targets off the reference entry and validate every provided leg.
+    const resolveTargets = (entryPrice) => {
+        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;
     out('Open Broker - Bracket Order');
@@ -62,159 +118,299 @@ export async function runBracket(opts) {
     if (!midPrice)
         throw new Error(`No market data for ${opts.coin}`);
     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);
-    const riskReward = opts.tpPct / opts.slPct;
+    // 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 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');
     out('------------');
     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 = null;
+        let filledEntry = 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 = null;
+        let slOid = 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 = null;
-    if (entryType === 'market') {
-        const entryResponse = await client.marketOrder(opts.coin, isLong, opts.size, opts.slippage, opts.leverage);
-        if (entryResponse.status === 'ok' && entryResponse.response && typeof entryResponse.response === 'object') {
-            const status = entryResponse.response.data.statuses[0];
-            if (status?.filled) {
-                actualEntry = parseFloat(status.filled.avgPx);
-                out(`  ✅ Filled @ ${formatUsd(actualEntry)}`);
+    let filledSize = 0;
+    const ownsFillWatcher = !opts.fillWatcher;
+    const fillWatcher = opts.fillWatcher ?? new UserFillWatcher(client, { sinceMs: Date.now() });
+    await fillWatcher.start();
+    try {
+        if (entryType === 'market') {
+            const entryResponse = await client.marketOrder(opts.coin, isLong, opts.size, opts.slippage, opts.leverage);
+            if (entryResponse.status === 'ok' && entryResponse.response && typeof entryResponse.response === 'object') {
+                const status = entryResponse.response.data.statuses[0];
+                if (status?.filled) {
+                    actualEntry = parseFloat(status.filled.avgPx);
+                    filledSize = parseFloat(status.filled.totalSz);
+                    out(`  ✅ Filled ${filledSize} @ ${formatUsd(actualEntry)}`);
+                }
+                else if (status?.error) {
+                    out(`  ❌ Entry failed: ${status.error}`);
+                    out('\n⚠️ Bracket aborted - no position opened');
+                    return { status: 'entry_failed', reason: status.error };
+                }
+                else {
+                    out(`  ❌ Entry failed: unexpected response`);
+                    out('\n⚠️ Bracket aborted - no confirmed position opened');
+                    return { status: 'entry_failed', reason: 'Unexpected entry response' };
+                }
             }
-            else if (status?.error) {
-                out(`  ❌ Entry failed: ${status.error}`);
+            else {
+                const reason = typeof entryResponse.response === 'string' ? entryResponse.response : 'Unknown error';
+                out(`  ❌ Entry failed: ${reason}`);
                 out('\n⚠️ Bracket aborted - no position opened');
-                return { status: 'entry_failed', reason: status.error };
+                return { status: 'entry_failed', reason };
             }
         }
         else {
-            const reason = typeof entryResponse.response === 'string' ? entryResponse.response : 'Unknown error';
-            out(`  ❌ Entry failed: ${reason}`);
-            out('\n⚠️ Bracket aborted - no position opened');
-            return { status: 'entry_failed', reason };
-        }
-    }
-    else {
-        const entryResponse = await client.limitOrder(opts.coin, isLong, opts.size, entry, 'Gtc', false, opts.leverage);
-        if (entryResponse.status === 'ok' && entryResponse.response && typeof entryResponse.response === 'object') {
-            const status = entryResponse.response.data.statuses[0];
-            if (status?.resting) {
-                entryOid = status.resting.oid;
-                out(`  ✅ Limit order placed @ ${formatUsd(entry)} (OID: ${entryOid})`);
-                out(`  ⏳ Waiting for fill before placing TP/SL...`);
-                out('\n⚠️ Note: TP/SL will be placed after entry fills. Monitor manually or use a strategy script.');
-                return { status: 'limit_resting', entryOid, entryPrice: entry };
+            const entryResponse = await client.limitOrder(opts.coin, isLong, opts.size, entry, 'Gtc', false, opts.leverage);
+            if (entryResponse.status === 'ok' && entryResponse.response && typeof entryResponse.response === 'object') {
+                const status = entryResponse.response.data.statuses[0];
+                if (status?.resting) {
+                    entryOid = status.resting.oid;
+                    const entryTimeoutSec = opts.entryTimeoutSec ?? 300;
+                    out(`  ✅ Limit order placed @ ${formatUsd(entry)} (OID: ${entryOid})`);
+                    if (entryTimeoutSec <= 0) {
+                        out(`  ⏳ Entry resting; TP/SL not armed until a fill is confirmed.`);
+                        return { status: 'limit_resting', entryOid, entryPrice: entry };
+                    }
+                    out(`  ⏳ Waiting up to ${entryTimeoutSec}s for fill confirmation...`);
+                    const fill = await fillWatcher.waitForFill(entryOid, opts.size, entryTimeoutSec * 1000, { coin: opts.coin });
+                    if (fill.size <= 0) {
+                        out(`  ⚠️ Entry still resting after ${entryTimeoutSec}s; TP/SL not armed.`);
+                        return { status: 'limit_resting', entryOid, entryPrice: entry };
+                    }
+                    filledSize = Math.min(fill.size, opts.size);
+                    actualEntry = fill.avgPrice ?? entry;
+                    out(`  ✅ Fill confirmed: ${filledSize} @ ${formatUsd(actualEntry)}`);
+                    if (filledSize < opts.size * 0.999) {
+                        out(`  ⚠️ Partial entry fill; arming TP/SL for filled size only.`);
+                    }
+                }
+                else if (status?.filled) {
+                    actualEntry = parseFloat(status.filled.avgPx);
+                    filledSize = parseFloat(status.filled.totalSz);
+                    out(`  ✅ Filled immediately ${filledSize} @ ${formatUsd(actualEntry)}`);
+                }
+                else if (status?.error) {
+                    out(`  ❌ Entry failed: ${status.error}`);
+                    return { status: 'entry_failed', reason: status.error };
+                }
+                else {
+                    out(`  ❌ Entry failed: unexpected response`);
+                    return { status: 'entry_failed', reason: 'Unexpected entry response' };
+                }
             }
-            else if (status?.filled) {
-                actualEntry = parseFloat(status.filled.avgPx);
-                out(`  ✅ Filled immediately @ ${formatUsd(actualEntry)}`);
+            else {
+                out(`  ❌ Entry failed`);
+                return { status: 'entry_failed', reason: 'Unknown error' };
             }
-            else if (status?.error) {
-                out(`  ❌ Entry failed: ${status.error}`);
-                return { status: 'entry_failed', reason: status.error };
-            }
-        }
-        else {
-            out(`  ❌ Entry failed`);
-            return { status: 'entry_failed', reason: 'Unknown error' };
         }
     }
-    // Recalculate TP/SL based on actual entry
-    if (isLong) {
-        tpPrice = actualEntry * (1 + opts.tpPct / 100);
-        slPrice = actualEntry * (1 - opts.slPct / 100);
+    finally {
+        if (ownsFillWatcher)
+            await fillWatcher.stop();
     }
-    else {
-        tpPrice = actualEntry * (1 - opts.tpPct / 100);
-        slPrice = actualEntry * (1 + opts.slPct / 100);
+    if (!Number.isFinite(filledSize) || filledSize <= 0) {
+        out('\n⚠️ Bracket aborted - no confirmed fill size');
+        return { status: 'entry_failed', reason: 'No confirmed fill size' };
     }
-    await sleep(500);
-    // Step 2: Take Profit (trigger order)
-    out('\nStep 2: Take Profit order (trigger)');
-    const tpSide = !isLong;
-    const tpResponse = await client.takeProfit(opts.coin, tpSide, opts.size, tpPrice);
-    let tpOid = null;
-    if (tpResponse.status === 'ok' && tpResponse.response && typeof tpResponse.response === 'object') {
-        const status = tpResponse.response.data.statuses[0];
-        if (status?.resting) {
-            tpOid = status.resting.oid;
-            out(`  ✅ TP trigger placed @ ${formatUsd(tpPrice)} (OID: ${tpOid})`);
-        }
-        else if (status?.error) {
-            out(`  ❌ TP failed: ${status.error}`);
-        }
-        else {
-            out(`  ⚠️ TP status: ${JSON.stringify(status)}`);
-        }
+    // 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);
     }
-    else {
-        const reason = typeof tpResponse.response === 'string' ? tpResponse.response : 'Unknown error';
-        out(`  ❌ TP failed: ${reason}`);
+    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 3: Stop Loss (trigger order)
-    out('\nStep 3: Stop Loss order (trigger)');
-    const slSide = !isLong;
-    const slResponse = await client.stopLoss(opts.coin, slSide, opts.size, slPrice);
+    // 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.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 = null;
     let slOid = null;
-    if (slResponse.status === 'ok' && slResponse.response && typeof slResponse.response === 'object') {
-        const status = slResponse.response.data.statuses[0];
-        if (status?.resting) {
-            slOid = status.resting.oid;
-            out(`  ✅ SL trigger placed @ ${formatUsd(slPrice)} (OID: ${slOid})`);
-        }
-        else if (status?.error) {
-            out(`  ❌ SL failed: ${status.error}`);
-        }
-        else {
-            out(`  ⚠️ SL status: ${JSON.stringify(status)}`);
+    let exitErrors = 0;
+    if (pairResponse.status === 'ok' && pairResponse.response && typeof pairResponse.response === 'object') {
+        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 {
-        const reason = typeof slResponse.response === 'string' ? slResponse.response : 'Unknown error';
-        out(`  ❌ SL failed: ${reason}`);
+        exitErrors++;
+        const reason = typeof pairResponse.response === 'string' ? pairResponse.response : 'Unknown error';
+        out(`  ❌ ${legsLabel} orders failed: ${reason}`);
     }
     out('\n========== Bracket Summary ==========');
-    out(`Position:    ${isLong ? 'LONG' : 'SHORT'} ${opts.size} ${opts.coin}`);
+    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 trigger orders.`);
-        out(`   They will only execute when price reaches trigger level.`);
-        out(`   When one fills, cancel the other manually.`);
+    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,
     };
 }
 async function main() {
@@ -224,12 +420,17 @@ async function main() {
     const size = parseFloat(args.size);
     const entryType = (args.entry || 'market');
     const entryPrice = args.price ? parseFloat(args.price) : undefined;
-    const tpPct = parseFloat(args.tp);
-    const slPct = parseFloat(args.sl);
+    const tpPct = args.tp ? parseFloat(args.tp) : undefined;
+    const slPct = args.sl ? parseFloat(args.sl) : undefined;
+    const tpPrice = args['tp-price'] ? parseFloat(args['tp-price']) : undefined;
+    const slPrice = args['sl-price'] ? parseFloat(args['sl-price']) : undefined;
     const slippage = args.slippage ? parseInt(args.slippage) : undefined;
+    const entryTimeoutSec = args['entry-timeout'] ? parseInt(args['entry-timeout']) : undefined;
+    const slSlippageBps = args['sl-slippage'] ? parseInt(args['sl-slippage']) : undefined;
     const leverage = args.leverage ? parseInt(args.leverage) : undefined;
     const dryRun = args.dry;
-    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);
     }
@@ -244,9 +445,15 @@ async function main() {
             size,
             tpPct,
             slPct,
+            tpPrice,
+            slPrice,
             entryType,
             entryPrice,
             slippage,
+            entryTimeoutSec,
+            slSlippageBps,
+            slMarket: !args['sl-limit'],
+            atomic: !args['no-atomic'],
             leverage,
             dryRun,
             verbose: args.verbose,

package/dist/operations/chase.d.ts

@@ -1,4 +1,6 @@
 #!/usr/bin/env npx tsx
+import type { OrderResponse, CancelResponse, OpenOrder } from '../core/types.js';
+import { type FillWatcher } from './execution.js';
 export interface ChaseOptions {
     coin: string;
     side: 'buy' | 'sell';
@@ -11,11 +13,28 @@ 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';
+    status: 'dry' | 'filled' | 'timeout' | 'max_chase_exceeded' | 'min_notional';
     iterations: number;
     durationSec: number;
     startMid: number;

package/dist/operations/chase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chase.d.ts","sourceRoot":"","sources":["../../scripts/operations/chase.ts"],"names":[],"mappings":";AAuCA,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,KAAK,GAAG,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,KAAK,GAAG,QAAQ,GAAG,SAAS,GAAG,oBAAoB,CAAC;IAC5D,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CA2JvE"}
+{"version":3,"file":"chase.d.ts","sourceRoot":"","sources":["../../scripts/operations/chase.ts"],"names":[],"mappings":";AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEjF,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAkCnE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,KAAK,GAAG,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,0DAA0D;IAC1D,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9C,aAAa,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IACtC,YAAY,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;IACjH,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,EAAE,UAAU,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IACpK,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,KAAK,GAAG,QAAQ,GAAG,SAAS,GAAG,oBAAoB,GAAG,cAAc,CAAC;IAC7E,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CA2PvE"}