openbroker 1.9.6 → 1.10.0

package/dist/operations/set-tpsl.js

@@ -1,14 +1,15 @@
 #!/usr/bin/env npx tsx
 // Set Take Profit and/or Stop Loss on an existing position
 import { getClient } from '../core/client.js';
-import { formatUsd, parseArgs, sleep } from '../core/utils.js';
+import { formatUsd, parseArgs, parseOrderStatus } from '../core/utils.js';
 function printUsage() {
     console.log(`
 Open Broker - Set TP/SL
 =======================
 
 Add take profit and/or stop loss orders to an existing position.
-Uses trigger orders that execute when price reaches the target.
+Placed as one batch with Hyperliquid's positionTpsl grouping: the triggers
+track the open position and OCO-cancel each other when one fires.
 
 Usage:
   npx tsx scripts/operations/set-tpsl.ts --coin <COIN> [--tp <PRICE>] [--sl <PRICE>]
@@ -18,7 +19,10 @@ Options:
   --tp          Take profit trigger price
   --sl          Stop loss trigger price
   --size        Size to protect (default: full position size)
-  --sl-slippage Stop loss slippage in bps (default: 100 = 1%)
+  --sl-slippage Stop loss fill cap past the trigger in bps (default: 100 = 1%)
+  --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.
   --dry         Dry run - show orders without placing
   --verbose     Show debug output
 
@@ -44,9 +48,11 @@ Examples:
 How Trigger Orders Work:
   - TP/SL are trigger orders, NOT regular limit orders
   - They sit dormant until price reaches the trigger level
-  - Once triggered, they execute as limit orders
+  - TP executes as a limit order at the target; SL executes as a market
+    order capped by the slippage band (use --sl-limit for a stop-limit)
   - These are reduce-only orders (close position, don't reverse)
-  - SL has slippage buffer to ensure fill in fast markets
+  - positionTpsl grouping ties them to the position: when one fires and
+    closes the position, the venue cancels the other automatically
 `);
 }
 function parsePrice(input, entryPrice, isLong) {
@@ -86,6 +92,7 @@ async function main() {
     const slInput = args.sl;
     const sizeOverride = args.size ? parseFloat(args.size) : undefined;
     const slSlippage = args['sl-slippage'] ? parseInt(args['sl-slippage']) : 100;
+    const slMarket = !args['sl-limit'];
     const dryRun = args.dry;
     if (!coin) {
         printUsage();
@@ -137,27 +144,31 @@ async function main() {
             console.log('Use absolute price (e.g., 35), percentage (e.g., -5%), or "entry"');
             process.exit(1);
         }
-        // Validate TP/SL make sense for position direction
+        // Triggers must sit on the correct side of the LIVE price, or the
+        // exchange fires them immediately on placement.
+        const directionErrors = [];
         if (isLong) {
             if (tpPrice && tpPrice <= currentPrice) {
-                console.warn(`⚠️  Warning: TP (${formatUsd(tpPrice)}) is at or below current price (${formatUsd(currentPrice)})`);
-                console.warn('   For LONG positions, TP should be above current price');
+                directionErrors.push(`TP (${formatUsd(tpPrice)}) must be above the current price (${formatUsd(currentPrice)}) for a LONG`);
             }
             if (slPrice && slPrice >= currentPrice) {
-                console.warn(`⚠️  Warning: SL (${formatUsd(slPrice)}) is at or above current price (${formatUsd(currentPrice)})`);
-                console.warn('   For LONG positions, SL should be below current price');
+                directionErrors.push(`SL (${formatUsd(slPrice)}) must be below the current price (${formatUsd(currentPrice)}) for a LONG`);
             }
         }
         else {
             if (tpPrice && tpPrice >= currentPrice) {
-                console.warn(`⚠️  Warning: TP (${formatUsd(tpPrice)}) is at or above current price (${formatUsd(currentPrice)})`);
-                console.warn('   For SHORT positions, TP should be below current price');
+                directionErrors.push(`TP (${formatUsd(tpPrice)}) must be below the current price (${formatUsd(currentPrice)}) for a SHORT`);
             }
             if (slPrice && slPrice <= currentPrice) {
-                console.warn(`⚠️  Warning: SL (${formatUsd(slPrice)}) is at or below current price (${formatUsd(currentPrice)})`);
-                console.warn('   For SHORT positions, SL should be above current price');
+                directionErrors.push(`SL (${formatUsd(slPrice)}) must be above the current price (${formatUsd(currentPrice)}) for a SHORT`);
             }
         }
+        if (directionErrors.length > 0) {
+            for (const err of directionErrors)
+                console.error(`Error: ${err}`);
+            console.error('A trigger on the wrong side of the live price fires immediately on placement.');
+            process.exit(1);
+        }
         // Calculate risk/reward
         let tpDistance = 0, slDistance = 0, riskReward = 0;
         if (tpPrice) {
@@ -192,7 +203,7 @@ async function main() {
             const slLimitPrice = isLong
                 ? slPrice * (1 - slSlippage / 10000)
                 : slPrice * (1 + slSlippage / 10000);
-            console.log(`Stop Loss:     ${slSide} ${size} @ ${formatUsd(slPrice)} trigger, ${formatUsd(slLimitPrice)} limit (-${slDistance.toFixed(2)}%)`);
+            console.log(`Stop Loss:     ${slSide} ${size} @ ${formatUsd(slPrice)} trigger, ${slMarket ? `market (fill capped at ${formatUsd(slLimitPrice)})` : `${formatUsd(slLimitPrice)} limit`} (-${slDistance.toFixed(2)}%)`);
         }
         if (riskReward > 0) {
             console.log(`Risk/Reward:   1:${riskReward.toFixed(2)}`);
@@ -210,51 +221,51 @@ async function main() {
             console.log('\n🔍 Dry run - orders not placed');
             return;
         }
-        console.log('\nPlacing trigger orders...\n');
-        // Place Take Profit
+        console.log('\nPlacing trigger orders (positionTpsl batch)...\n');
+        // One batch with positionTpsl grouping: the venue ties the triggers to
+        // the open position and OCO-cancels the survivor when one fires.
+        const exitSide = !isLong; // Opposite of position direction
+        const response = await client.tpslOrders(coin, exitSide, size, {
+            takeProfitPrice: tpPrice ?? undefined,
+            stopLossPrice: slPrice ?? undefined,
+            stopLossSlippageBps: slSlippage,
+            stopLossIsMarket: slMarket,
+            grouping: 'positionTpsl',
+        });
         let tpOid = null;
-        if (tpPrice) {
-            const tpSide = !isLong; // Opposite of position direction
-            const response = await client.takeProfit(coin, tpSide, size, tpPrice);
-            if (response.status === 'ok' && response.response && typeof response.response === 'object') {
-                const status = response.response.data.statuses[0];
-                if (status?.resting) {
-                    tpOid = status.resting.oid;
-                    console.log(`✅ Take Profit placed @ ${formatUsd(tpPrice)} (OID: ${tpOid})`);
-                }
-                else if (status?.error) {
-                    console.log(`❌ TP failed: ${status.error}`);
-                }
-                else {
-                    console.log(`⚠️  TP status:`, JSON.stringify(status));
-                }
-            }
-            else {
-                console.log(`❌ TP failed: ${typeof response.response === 'string' ? response.response : 'Unknown error'}`);
-            }
-            await sleep(200);
-        }
-        // Place Stop Loss
         let slOid = null;
-        if (slPrice) {
-            const slSide = !isLong; // Opposite of position direction
-            const response = await client.stopLoss(coin, slSide, size, slPrice, slSlippage);
-            if (response.status === 'ok' && response.response && typeof response.response === 'object') {
-                const status = response.response.data.statuses[0];
-                if (status?.resting) {
-                    slOid = status.resting.oid;
-                    console.log(`✅ Stop Loss placed @ ${formatUsd(slPrice)} (OID: ${slOid})`);
+        let placementErrors = 0;
+        if (response.status === 'ok' && response.response && typeof response.response === 'object') {
+            const statuses = response.response.data.statuses.map(parseOrderStatus);
+            let idx = 0;
+            for (const leg of [tpPrice ? 'Take Profit' : null, slPrice ? 'Stop Loss' : null]) {
+                if (!leg)
+                    continue;
+                const status = statuses[idx++];
+                const price = leg === 'Take Profit' ? tpPrice : slPrice;
+                if (status?.kind === 'resting') {
+                    if (leg === 'Take Profit')
+                        tpOid = status.oid;
+                    else
+                        slOid = status.oid;
+                    console.log(`✅ ${leg} placed @ ${formatUsd(price)} (OID: ${status.oid})`);
+                }
+                else if (status?.kind === 'waiting') {
+                    console.log(`✅ ${leg} armed @ ${formatUsd(price)} (${status.state})`);
                 }
-                else if (status?.error) {
-                    console.log(`❌ SL failed: ${status.error}`);
+                else if (status?.kind === 'error') {
+                    placementErrors++;
+                    console.log(`❌ ${leg} failed: ${status.error}`);
                 }
                 else {
-                    console.log(`⚠️  SL status:`, JSON.stringify(status));
+                    placementErrors++;
+                    console.log(`⚠️  ${leg} status:`, JSON.stringify(status));
                 }
             }
-            else {
-                console.log(`❌ SL failed: ${typeof response.response === 'string' ? response.response : 'Unknown error'}`);
-            }
+        }
+        else {
+            placementErrors++;
+            console.log(`❌ TP/SL failed: ${typeof response.response === 'string' ? response.response : 'Unknown error'}`);
         }
         // Summary
         console.log('\n========== Summary ==========');
@@ -263,11 +274,12 @@ async function main() {
         if (tpOid)
             console.log(`Take Profit: ${formatUsd(tpPrice)} (OID: ${tpOid})`);
         if (slOid)
-            console.log(`Stop Loss:   ${formatUsd(slPrice)} (OID: ${slOid})`);
-        if (tpOid && slOid) {
-            console.log(`\n💡 Tip: When one order fills, cancel the other manually:`);
-            console.log(`   npx tsx scripts/operations/cancel.ts --coin ${coin} --oid <OID>`);
+            console.log(`Stop Loss:   ${formatUsd(slPrice)} (OID: ${slOid}, ${slMarket ? 'market trigger' : 'stop-limit'})`);
+        if (placementErrors === 0 && tpPrice && slPrice) {
+            console.log(`\n💡 The triggers track the position: when one fires, the venue cancels the other.`);
         }
+        if (placementErrors > 0)
+            process.exit(1);
     }
     catch (error) {
         console.error('Error:', error);

package/dist/operations/trigger-order.js

@@ -21,15 +21,18 @@ Options:
   --type        Order type: tp (take profit) or sl (stop loss)
   --limit       Limit price when triggered (default: trigger price for TP, with slippage for SL)
   --slippage    Slippage for SL in bps (default: 100 = 1%)
+  --exec        Execution when triggered: market or limit
+                (default: market for SL, limit for TP)
   --leverage    Set leverage (e.g., 10 for 10x). Cross for main perps, isolated for HIP-3
   --reduce      Reduce-only order (default: true for TP/SL)
   --dry         Dry run - show order without placing
 
 Trigger Order Behavior:
   - Order is dormant until price reaches trigger level
-  - Once triggered, becomes a limit order at the limit price
-  - TP: Limit price = trigger price (favorable)
-  - SL: Limit price = trigger ± slippage (ensures fill)
+  - TP: rests as a limit order at the limit price (favorable)
+  - SL: fires as a market order capped by the limit price (trigger ± slippage);
+    pass --exec limit for a stop-limit, but note a gap move past the band can
+    skip the stop entirely and leave the position unprotected
 
 Examples:
   # Take profit: sell 0.5 HYPE when price rises to $40
@@ -58,6 +61,11 @@ async function main() {
     const orderType = args.type;
     const limitPriceOverride = args.limit ? parseFloat(args.limit) : undefined;
     const slippageBps = args.slippage ? parseInt(args.slippage) : 100;
+    const execOverride = args.exec;
+    if (execOverride && execOverride !== 'market' && execOverride !== 'limit') {
+        console.error('Error: --exec must be "market" or "limit"');
+        process.exit(1);
+    }
     const leverage = args.leverage ? parseInt(args.leverage) : undefined;
     const reduceOnly = args.reduce !== 'false'; // Default true
     const dryRun = args.dry;
@@ -103,12 +111,16 @@ async function main() {
             limitPrice = triggerPrice;
         }
         else {
-            // SL: add slippage to ensure fill
+            // SL: slippage band past the trigger — caps the market fill, or is the
+            // resting price for a stop-limit
             const slippageMult = slippageBps / 10000;
             limitPrice = isBuy
                 ? triggerPrice * (1 + slippageMult)
                 : triggerPrice * (1 - slippageMult);
         }
+        // SL fires as a market trigger by default (a stop-limit can be gapped
+        // over and never fill); TP rests as a limit at the target.
+        const isMarket = execOverride ? execOverride === 'market' : tpsl === 'sl';
         const distanceFromCurrent = ((triggerPrice - currentPrice) / currentPrice) * 100;
         const notional = triggerPrice * size;
         console.log('Trigger Order Details');
@@ -119,7 +131,7 @@ async function main() {
         console.log(`Size:          ${size}`);
         console.log(`Current Price: ${formatUsd(currentPrice)}`);
         console.log(`Trigger Price: ${formatUsd(triggerPrice)} (${distanceFromCurrent >= 0 ? '+' : ''}${distanceFromCurrent.toFixed(2)}%)`);
-        console.log(`Limit Price:   ${formatUsd(limitPrice)}`);
+        console.log(`Execution:     ${isMarket ? `market (fill capped at ${formatUsd(limitPrice)})` : `limit @ ${formatUsd(limitPrice)}`}`);
         console.log(`Reduce Only:   ${reduceOnly ? 'Yes' : 'No'}`);
         console.log(`Est. Notional: ${formatUsd(notional)}`);
         // Sanity checks
@@ -144,7 +156,7 @@ async function main() {
             return;
         }
         console.log('\nPlacing trigger order...');
-        const response = await client.triggerOrder(coin, isBuy, size, triggerPrice, limitPrice, tpsl, reduceOnly, leverage);
+        const response = await client.triggerOrder(coin, isBuy, size, triggerPrice, limitPrice, tpsl, reduceOnly, leverage, isMarket);
         console.log('\nResult');
         console.log('------');
         if (response.status === 'ok' && response.response && typeof response.response === 'object') {

package/dist/operations/twap.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env npx tsx
 // TWAP (Time-Weighted Average Price) execution using Hyperliquid's native TWAP orders
 import { getClient } from '../core/client.js';
-import { formatUsd, parseArgs } from '../core/utils.js';
+import { MIN_ORDER_NOTIONAL_USD, formatUsd, parseArgs } from '../core/utils.js';
 function printUsage() {
     console.log(`
 Open Broker - TWAP Order (Native)
@@ -77,6 +77,10 @@ async function main() {
             process.exit(1);
         }
         const notional = midPrice * totalSize;
+        // Native TWAP fires a sub-order every 30s; each must clear the exchange minimum.
+        const sliceCount = durationMinutes * 2;
+        const perSliceNotional = notional / sliceCount;
+        const sliceBelowMinimum = !reduceOnly && perSliceNotional < MIN_ORDER_NOTIONAL_USD;
         console.log('Order Details');
         console.log('-------------');
         console.log(`Coin:           ${coin}`);
@@ -85,16 +89,24 @@ async function main() {
         console.log(`Current Price:  ${formatUsd(midPrice)}`);
         console.log(`Est. Notional:  ${formatUsd(notional)}`);
         console.log(`Duration:       ${formatDuration(durationMinutes * 60)}`);
+        console.log(`Slices:         ~${sliceCount} (every 30s, ~${formatUsd(perSliceNotional)} each)`);
         console.log(`Randomize:      ${randomize ? 'yes' : 'no'}`);
         console.log(`Reduce Only:    ${reduceOnly ? 'yes' : 'no'}`);
         if (leverage) {
             console.log(`Leverage:       ${leverage}x`);
         }
         if (dryRun) {
+            if (sliceBelowMinimum) {
+                console.log(`\n⚠️ TWAP slices of ~${formatUsd(perSliceNotional)} fall below the $${MIN_ORDER_NOTIONAL_USD} exchange minimum — shorten the duration or increase the size.`);
+            }
             console.log('\nDry run - no order placed.');
             console.log('The exchange will handle order slicing and timing automatically.');
             return;
         }
+        if (sliceBelowMinimum) {
+            console.error(`Error: TWAP slices of ~${formatUsd(perSliceNotional)} fall below the $${MIN_ORDER_NOTIONAL_USD} exchange minimum — shorten the duration or increase the size.`);
+            process.exit(1);
+        }
         console.log('\nPlacing native TWAP order...\n');
         const response = await client.twapOrder(coin, isBuy, totalSize, durationMinutes, randomize, reduceOnly, leverage);
         // SDK's TwapOrderSuccessResponse excludes the error variant — the SDK

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbroker",
-  "version": "1.9.6",
+  "version": "1.10.0",
   "description": "Hyperliquid trading CLI - execute orders, manage positions, and run trading strategies",
   "type": "module",
   "bin": {