openbroker 1.0.33

package/scripts/operations/scale.ts

@@ -0,0 +1,263 @@
+#!/usr/bin/env npx tsx
+// Scale In/Out - Place a grid of limit orders
+
+import { getClient } from '../core/client.js';
+import { formatUsd, parseArgs, sleep } from '../core/utils.js';
+
+function printUsage() {
+  console.log(`
+Open Broker - Scale In/Out
+==========================
+
+Place a grid of limit orders to scale into or out of a position.
+Orders are distributed across price levels based on the specified range and distribution.
+
+Usage:
+  npx tsx scripts/operations/scale.ts --coin <COIN> --side <buy|sell> --size <SIZE> --levels <N> --range <PCT>
+
+Options:
+  --coin          Asset to trade (e.g., ETH, BTC)
+  --side          Order side: buy or sell
+  --size          Total order size in base asset
+  --levels        Number of price levels (orders)
+  --range         Price range from current mid (e.g., 2 for ±2%)
+  --distribution  Size distribution: linear, exponential, or flat (default: linear)
+                  - linear: more size at better prices
+                  - exponential: much more size at better prices
+                  - flat: equal size at all levels
+  --reduce        Reduce-only orders (for scaling out of position)
+  --tif           Time in force: GTC, ALO (default: GTC)
+  --dry           Dry run - show order plan without executing
+
+Examples:
+  # Scale into 1 ETH with 5 buy orders, 2% below current price
+  npx tsx scripts/operations/scale.ts --coin ETH --side buy --size 1 --levels 5 --range 2
+
+  # Scale out of 0.5 BTC with 4 sell orders, 3% above current price (reduce-only)
+  npx tsx scripts/operations/scale.ts --coin BTC --side sell --size 0.5 --levels 4 --range 3 --reduce
+
+  # Use exponential distribution for more aggressive scaling
+  npx tsx scripts/operations/scale.ts --coin ETH --side buy --size 2 --levels 8 --range 5 --distribution exponential
+`);
+}
+
+interface OrderLevel {
+  level: number;
+  price: number;
+  size: number;
+  distanceFromMid: number;
+}
+
+function calculateLevels(
+  midPrice: number,
+  isBuy: boolean,
+  totalSize: number,
+  numLevels: number,
+  rangePct: number,
+  distribution: 'linear' | 'exponential' | 'flat'
+): OrderLevel[] {
+  const levels: OrderLevel[] = [];
+
+  // Calculate weights based on distribution
+  let weights: number[] = [];
+  for (let i = 0; i < numLevels; i++) {
+    switch (distribution) {
+      case 'flat':
+        weights.push(1);
+        break;
+      case 'linear':
+        weights.push(i + 1); // 1, 2, 3, 4, 5... (more at worse prices = better for buyer)
+        break;
+      case 'exponential':
+        weights.push(Math.pow(2, i)); // 1, 2, 4, 8, 16...
+        break;
+    }
+  }
+
+  const totalWeight = weights.reduce((a, b) => a + b, 0);
+
+  // Calculate price levels
+  for (let i = 0; i < numLevels; i++) {
+    // Distance increases with level (i=0 is closest to mid)
+    const distancePct = ((i + 1) / numLevels) * rangePct;
+
+    // Buy orders go below mid, sell orders go above
+    const price = isBuy
+      ? midPrice * (1 - distancePct / 100)
+      : midPrice * (1 + distancePct / 100);
+
+    const size = (weights[i] / totalWeight) * totalSize;
+
+    levels.push({
+      level: i + 1,
+      price,
+      size,
+      distanceFromMid: distancePct,
+    });
+  }
+
+  return levels;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  const coin = args.coin as string;
+  const side = args.side as string;
+  const totalSize = parseFloat(args.size as string);
+  const numLevels = parseInt(args.levels as string);
+  const rangePct = parseFloat(args.range as string);
+  const distribution = (args.distribution as string || 'linear') as 'linear' | 'exponential' | 'flat';
+  const reduceOnly = args.reduce as boolean;
+  const tifArg = ((args.tif as string)?.toUpperCase() || 'GTC');
+  const dryRun = args.dry as boolean;
+
+  if (!coin || !side || isNaN(totalSize) || isNaN(numLevels) || isNaN(rangePct)) {
+    printUsage();
+    process.exit(1);
+  }
+
+  if (side !== 'buy' && side !== 'sell') {
+    console.error('Error: --side must be "buy" or "sell"');
+    process.exit(1);
+  }
+
+  if (!['linear', 'exponential', 'flat'].includes(distribution)) {
+    console.error('Error: --distribution must be linear, exponential, or flat');
+    process.exit(1);
+  }
+
+  // Map uppercase CLI input to Pascal case for SDK
+  const tifMap: Record<string, 'Gtc' | 'Alo'> = {
+    'GTC': 'Gtc',
+    'ALO': 'Alo'
+  };
+
+  const tif = tifMap[tifArg];
+  if (!tif) {
+    console.error('Error: --tif must be GTC or ALO');
+    process.exit(1);
+  }
+
+  const isBuy = side === 'buy';
+  const client = getClient();
+
+  if (args.verbose) {
+    client.verbose = true;
+  }
+
+  console.log('Open Broker - Scale In/Out');
+  console.log('==========================\n');
+
+  try {
+    const mids = await client.getAllMids();
+    const midPrice = parseFloat(mids[coin]);
+    if (!midPrice) {
+      console.error(`Error: No market data for ${coin}`);
+      process.exit(1);
+    }
+
+    const levels = calculateLevels(midPrice, isBuy, totalSize, numLevels, rangePct, distribution);
+    const notional = levels.reduce((sum, l) => sum + l.price * l.size, 0);
+    const avgPrice = notional / totalSize;
+
+    console.log('Order Plan');
+    console.log('----------');
+    console.log(`Coin:           ${coin}`);
+    console.log(`Side:           ${isBuy ? 'BUY' : 'SELL'}`);
+    console.log(`Total Size:     ${totalSize}`);
+    console.log(`Current Mid:    ${formatUsd(midPrice)}`);
+    console.log(`Levels:         ${numLevels}`);
+    console.log(`Range:          ${rangePct}% ${isBuy ? 'below' : 'above'} mid`);
+    console.log(`Distribution:   ${distribution}`);
+    console.log(`Time in Force:  ${tif}`);
+    console.log(`Reduce Only:    ${reduceOnly ? 'Yes' : 'No'}`);
+    console.log(`Est. Notional:  ${formatUsd(notional)}`);
+    console.log(`Avg Price:      ${formatUsd(avgPrice)}`);
+
+    console.log('\nOrder Grid');
+    console.log('----------');
+    console.log('Level | Price        | Size       | Distance');
+    console.log('------|--------------|------------|----------');
+
+    for (const level of levels) {
+      console.log(
+        `  ${level.level.toString().padStart(2)}  | ` +
+        `${formatUsd(level.price).padStart(12)} | ` +
+        `${level.size.toFixed(6).padStart(10)} | ` +
+        `${level.distanceFromMid.toFixed(2)}%`
+      );
+    }
+
+    if (dryRun) {
+      console.log('\n🔍 Dry run - orders not placed');
+      return;
+    }
+
+    console.log('\nPlacing orders...\n');
+
+    const results: { level: number; oid?: number; error?: string }[] = [];
+
+    for (const level of levels) {
+      process.stdout.write(`Level ${level.level}: ${formatUsd(level.price)} x ${level.size.toFixed(6)}... `);
+
+      try {
+        const response = await client.limitOrder(
+          coin,
+          isBuy,
+          level.size,
+          level.price,
+          tif,
+          reduceOnly
+        );
+
+        if (response.status === 'ok' && response.response && typeof response.response === 'object') {
+          const status = response.response.data.statuses[0];
+          if (status?.resting) {
+            console.log(`✅ OID: ${status.resting.oid}`);
+            results.push({ level: level.level, oid: status.resting.oid });
+          } else if (status?.filled) {
+            console.log(`✅ Filled immediately @ ${formatUsd(parseFloat(status.filled.avgPx))}`);
+            results.push({ level: level.level, oid: status.filled.oid });
+          } else if (status?.error) {
+            console.log(`❌ ${status.error}`);
+            results.push({ level: level.level, error: status.error });
+          } else {
+            console.log(`⚠️ Unknown status`);
+            results.push({ level: level.level, error: 'Unknown status' });
+          }
+        } else {
+          const error = typeof response.response === 'string' ? response.response : 'Failed';
+          console.log(`❌ ${error}`);
+          results.push({ level: level.level, error });
+        }
+      } catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        console.log(`❌ ${error}`);
+        results.push({ level: level.level, error });
+      }
+
+      // Small delay between orders
+      await sleep(100);
+    }
+
+    // Summary
+    const successful = results.filter(r => r.oid).length;
+    const failed = results.filter(r => r.error).length;
+
+    console.log('\n========== Summary ==========');
+    console.log(`Orders Placed:  ${successful}/${numLevels}`);
+    if (failed > 0) {
+      console.log(`Failed:         ${failed}`);
+    }
+    if (successful > 0) {
+      console.log(`Order IDs:      ${results.filter(r => r.oid).map(r => r.oid).join(', ')}`);
+    }
+
+  } catch (error) {
+    console.error('Error:', error);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/operations/set-tpsl.ts

@@ -0,0 +1,302 @@
+#!/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';
+
+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.
+
+Usage:
+  npx tsx scripts/operations/set-tpsl.ts --coin <COIN> [--tp <PRICE>] [--sl <PRICE>]
+
+Options:
+  --coin        Asset with open position (e.g., ETH, BTC, HYPE)
+  --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%)
+  --dry         Dry run - show orders without placing
+  --verbose     Show debug output
+
+Price Formats:
+  --tp 40       Absolute price ($40)
+  --tp +10%     Percentage above entry price
+  --sl -5%      Percentage below entry price (for longs)
+  --sl entry    Stop loss at entry price (breakeven)
+
+Examples:
+  # Set TP at $40 and SL at $30 on HYPE long
+  npx tsx scripts/operations/set-tpsl.ts --coin HYPE --tp 40 --sl 30
+
+  # Set TP at +10% from entry, SL at entry (breakeven)
+  npx tsx scripts/operations/set-tpsl.ts --coin HYPE --tp +10% --sl entry
+
+  # Set only stop loss at -5% from entry
+  npx tsx scripts/operations/set-tpsl.ts --coin ETH --sl -5%
+
+  # Set TP/SL on partial position
+  npx tsx scripts/operations/set-tpsl.ts --coin ETH --tp 4000 --sl 3500 --size 0.5
+
+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
+  - These are reduce-only orders (close position, don't reverse)
+  - SL has slippage buffer to ensure fill in fast markets
+`);
+}
+
+function parsePrice(input: string, entryPrice: number, isLong: boolean): number | null {
+  if (!input) return null;
+
+  // Handle "entry" keyword for breakeven
+  if (input.toLowerCase() === 'entry') {
+    return entryPrice;
+  }
+
+  // Handle percentage format: +10%, -5%
+  const pctMatch = input.match(/^([+-]?)(\d+(?:\.\d+)?)%$/);
+  if (pctMatch) {
+    const sign = pctMatch[1] || '+';
+    const pct = parseFloat(pctMatch[2]) / 100;
+
+    if (sign === '+') {
+      return entryPrice * (1 + pct);
+    } else {
+      return entryPrice * (1 - pct);
+    }
+  }
+
+  // Handle absolute price
+  const price = parseFloat(input);
+  if (!isNaN(price) && price > 0) {
+    return price;
+  }
+
+  return null;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.help) {
+    printUsage();
+    process.exit(0);
+  }
+
+  const coin = args.coin as string;
+  const tpInput = args.tp as string | undefined;
+  const slInput = args.sl as string | undefined;
+  const sizeOverride = args.size ? parseFloat(args.size as string) : undefined;
+  const slSlippage = args['sl-slippage'] ? parseInt(args['sl-slippage'] as string) : 100;
+  const dryRun = args.dry as boolean;
+
+  if (!coin) {
+    printUsage();
+    process.exit(1);
+  }
+
+  if (!tpInput && !slInput) {
+    console.error('Error: Must specify at least --tp or --sl');
+    process.exit(1);
+  }
+
+  const client = getClient();
+
+  if (args.verbose) {
+    client.verbose = true;
+  }
+
+  console.log('Open Broker - Set TP/SL');
+  console.log('=======================\n');
+
+  try {
+    // Get current position
+    const userState = await client.getUserState();
+    const position = userState.assetPositions.find(p => p.position.coin === coin);
+
+    if (!position) {
+      console.error(`Error: No open position for ${coin}`);
+      console.log('\nYour positions:');
+      for (const pos of userState.assetPositions) {
+        const size = parseFloat(pos.position.szi);
+        if (Math.abs(size) > 0) {
+          console.log(`  ${pos.position.coin}: ${size > 0 ? 'LONG' : 'SHORT'} ${Math.abs(size)}`);
+        }
+      }
+      process.exit(1);
+    }
+
+    const posSize = parseFloat(position.position.szi);
+    const entryPrice = parseFloat(position.position.entryPx);
+    const isLong = posSize > 0;
+    const absSize = Math.abs(posSize);
+    const size = sizeOverride ?? absSize;
+
+    // Get current price
+    const mids = await client.getAllMids();
+    const currentPrice = parseFloat(mids[coin]);
+
+    // Parse TP and SL prices
+    const tpPrice = tpInput ? parsePrice(tpInput, entryPrice, isLong) : null;
+    const slPrice = slInput ? parsePrice(slInput, entryPrice, isLong) : null;
+
+    if (tpInput && tpPrice === null) {
+      console.error(`Error: Invalid TP price format: ${tpInput}`);
+      console.log('Use absolute price (e.g., 40), percentage (e.g., +10%), or "entry"');
+      process.exit(1);
+    }
+
+    if (slInput && slPrice === null) {
+      console.error(`Error: Invalid SL price format: ${slInput}`);
+      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
+    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');
+      }
+      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');
+      }
+    } 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');
+      }
+      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');
+      }
+    }
+
+    // Calculate risk/reward
+    let tpDistance = 0, slDistance = 0, riskReward = 0;
+    if (tpPrice) {
+      tpDistance = isLong
+        ? (tpPrice - entryPrice) / entryPrice * 100
+        : (entryPrice - tpPrice) / entryPrice * 100;
+    }
+    if (slPrice) {
+      slDistance = isLong
+        ? (entryPrice - slPrice) / entryPrice * 100
+        : (slPrice - entryPrice) / entryPrice * 100;
+    }
+    if (tpDistance > 0 && slDistance > 0) {
+      riskReward = tpDistance / slDistance;
+    }
+
+    console.log('Current Position');
+    console.log('----------------');
+    console.log(`Coin:          ${coin}`);
+    console.log(`Direction:     ${isLong ? 'LONG' : 'SHORT'}`);
+    console.log(`Size:          ${absSize}`);
+    console.log(`Entry Price:   ${formatUsd(entryPrice)}`);
+    console.log(`Current Price: ${formatUsd(currentPrice)}`);
+    console.log(`Unrealized:    ${formatUsd(parseFloat(position.position.unrealizedPnl))}`);
+
+    console.log('\nOrders to Place');
+    console.log('---------------');
+    if (tpPrice) {
+      const tpSide = isLong ? 'SELL' : 'BUY';
+      console.log(`Take Profit:   ${tpSide} ${size} @ ${formatUsd(tpPrice)} (+${tpDistance.toFixed(2)}% from entry)`);
+    }
+    if (slPrice) {
+      const slSide = isLong ? 'SELL' : 'BUY';
+      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)}%)`);
+    }
+    if (riskReward > 0) {
+      console.log(`Risk/Reward:   1:${riskReward.toFixed(2)}`);
+    }
+
+    // Potential outcomes
+    const potentialProfit = tpPrice ? Math.abs(tpPrice - entryPrice) * size : 0;
+    const potentialLoss = slPrice ? Math.abs(entryPrice - slPrice) * size : 0;
+    console.log('\nPotential Outcomes');
+    console.log('------------------');
+    if (tpPrice) console.log(`If TP hits:    +${formatUsd(potentialProfit)}`);
+    if (slPrice) console.log(`If SL hits:    -${formatUsd(potentialLoss)}`);
+
+    if (dryRun) {
+      console.log('\n🔍 Dry run - orders not placed');
+      return;
+    }
+
+    console.log('\nPlacing trigger orders...\n');
+
+    // Place Take Profit
+    let tpOid: number | null = 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: number | null = 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})`);
+        } else if (status?.error) {
+          console.log(`❌ SL failed: ${status.error}`);
+        } else {
+          console.log(`⚠️  SL status:`, JSON.stringify(status));
+        }
+      } else {
+        console.log(`❌ SL failed: ${typeof response.response === 'string' ? response.response : 'Unknown error'}`);
+      }
+    }
+
+    // Summary
+    console.log('\n========== Summary ==========');
+    console.log(`Position:    ${isLong ? 'LONG' : 'SHORT'} ${absSize} ${coin}`);
+    console.log(`Entry:       ${formatUsd(entryPrice)}`);
+    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>`);
+    }
+
+  } catch (error) {
+    console.error('Error:', error);
+    process.exit(1);
+  }
+}
+
+main();