openbroker 1.0.33

package/scripts/operations/cancel.ts

@@ -0,0 +1,124 @@
+#!/usr/bin/env npx tsx
+// Cancel orders on Hyperliquid
+
+import { getClient } from '../core/client.js';
+import { formatUsd, parseArgs } from '../core/utils.js';
+
+function printUsage() {
+  console.log(`
+Open Broker - Cancel Orders
+===========================
+
+Cancel open orders.
+
+Usage:
+  npx tsx scripts/operations/cancel.ts [--coin <COIN>] [--oid <ORDER_ID>] [--all]
+
+Options:
+  --coin      Cancel orders for specific coin only
+  --oid       Cancel specific order by ID
+  --all       Cancel all open orders
+  --dry       Dry run - show what would be cancelled
+
+Examples:
+  npx tsx scripts/operations/cancel.ts --all                    # Cancel all orders
+  npx tsx scripts/operations/cancel.ts --coin ETH               # Cancel all ETH orders
+  npx tsx scripts/operations/cancel.ts --coin ETH --oid 123456  # Cancel specific order
+  npx tsx scripts/operations/cancel.ts --all --dry              # Show all orders (dry run)
+`);
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  const coin = args.coin as string | undefined;
+  const oid = args.oid ? parseInt(args.oid as string) : undefined;
+  const all = args.all as boolean;
+  const dryRun = args.dry as boolean;
+
+  // Must specify something to cancel
+  if (!coin && !oid && !all) {
+    printUsage();
+    process.exit(1);
+  }
+
+  const client = getClient();
+
+  console.log('Open Broker - Cancel Orders');
+  console.log('===========================\n');
+
+  try {
+    // Get open orders
+    const orders = await client.getOpenOrders();
+
+    // Filter orders based on arguments
+    let targetOrders = orders;
+    if (coin) {
+      targetOrders = orders.filter(o => o.coin === coin);
+    }
+    if (oid) {
+      targetOrders = orders.filter(o => o.oid === oid);
+    }
+
+    if (targetOrders.length === 0) {
+      if (oid) {
+        console.log(`No order found with ID ${oid}`);
+      } else if (coin) {
+        console.log(`No open orders for ${coin}`);
+      } else {
+        console.log('No open orders to cancel');
+      }
+      return;
+    }
+
+    // Display orders to be cancelled
+    console.log('Orders to Cancel');
+    console.log('----------------');
+    console.log('Coin     | Side | Size       | Price      | Order ID');
+    console.log('---------|------|------------|------------|----------');
+
+    for (const order of targetOrders) {
+      const side = order.side === 'B' ? 'BUY ' : 'SELL';
+      console.log(
+        `${order.coin.padEnd(8)} | ${side} | ${parseFloat(order.sz).toFixed(4).padStart(10)} | ` +
+        `${formatUsd(parseFloat(order.limitPx)).padStart(10)} | ${order.oid}`
+      );
+    }
+
+    console.log(`\nTotal: ${targetOrders.length} order(s)`);
+
+    if (dryRun) {
+      console.log('\n🔍 Dry run - orders not cancelled');
+      return;
+    }
+
+    console.log('\nCancelling...');
+
+    let successCount = 0;
+    let failCount = 0;
+
+    for (const order of targetOrders) {
+      try {
+        const response = await client.cancel(order.coin, order.oid);
+        if (response.status === 'ok') {
+          console.log(`✅ Cancelled ${order.coin} order ${order.oid}`);
+          successCount++;
+        } else {
+          console.log(`❌ Failed to cancel ${order.coin} order ${order.oid}`);
+          failCount++;
+        }
+      } catch (err) {
+        console.log(`❌ Error cancelling ${order.coin} order ${order.oid}: ${err}`);
+        failCount++;
+      }
+    }
+
+    console.log(`\nResult: ${successCount} cancelled, ${failCount} failed`);
+
+  } catch (error) {
+    console.error('Error:', error);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/operations/chase.ts

@@ -0,0 +1,236 @@
+#!/usr/bin/env npx tsx
+// Chase Order - Follow price with limit orders until filled
+
+import { getClient } from '../core/client.js';
+import { formatUsd, parseArgs, sleep } from '../core/utils.js';
+
+function printUsage() {
+  console.log(`
+Open Broker - Chase Order
+=========================
+
+Place a limit order that chases the price until filled.
+Keeps adjusting the order to stay near the best price while avoiding taker fees.
+
+Usage:
+  npx tsx scripts/operations/chase.ts --coin <COIN> --side <buy|sell> --size <SIZE>
+
+Options:
+  --coin        Asset to trade (e.g., ETH, BTC)
+  --side        Order side: buy or sell
+  --size        Order size in base asset
+  --offset      Offset from mid price in bps (default: 5 = 0.05%)
+  --timeout     Max time to chase in seconds (default: 300 = 5 min)
+  --interval    Update interval in ms (default: 2000)
+  --max-chase   Max price to chase to in bps from start (default: 100 = 1%)
+  --reduce      Reduce-only order
+  --dry         Dry run - show chase parameters without executing
+
+Strategy:
+  - Places ALO (post-only) order at mid ± offset
+  - If not filled, cancels and replaces closer to mid
+  - Stops when filled or timeout/max-chase reached
+  - Uses ALO to ensure maker rebates
+
+Examples:
+  # Chase buy 0.5 ETH with 5 bps offset, 5 min timeout
+  npx tsx scripts/operations/chase.ts --coin ETH --side buy --size 0.5
+
+  # Chase sell with tighter offset and longer timeout
+  npx tsx scripts/operations/chase.ts --coin BTC --side sell --size 0.1 --offset 2 --timeout 600
+
+  # Quick aggressive chase (1 bps offset, 1 min timeout, 50 bps max chase)
+  npx tsx scripts/operations/chase.ts --coin SOL --side buy --size 10 --offset 1 --timeout 60 --max-chase 50
+`);
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  const coin = args.coin as string;
+  const side = args.side as string;
+  const size = parseFloat(args.size as string);
+  const offsetBps = args.offset ? parseInt(args.offset as string) : 5;
+  const timeoutSec = args.timeout ? parseInt(args.timeout as string) : 300;
+  const intervalMs = args.interval ? parseInt(args.interval as string) : 2000;
+  const maxChaseBps = args['max-chase'] ? parseInt(args['max-chase'] as string) : 100;
+  const reduceOnly = args.reduce as boolean;
+  const dryRun = args.dry as boolean;
+
+  if (!coin || !side || isNaN(size)) {
+    printUsage();
+    process.exit(1);
+  }
+
+  if (side !== 'buy' && side !== 'sell') {
+    console.error('Error: --side must be "buy" or "sell"');
+    process.exit(1);
+  }
+
+  const isBuy = side === 'buy';
+  const client = getClient();
+
+  if (args.verbose) {
+    client.verbose = true;
+  }
+
+  console.log('Open Broker - Chase Order');
+  console.log('=========================\n');
+
+  try {
+    const mids = await client.getAllMids();
+    const startMid = parseFloat(mids[coin]);
+    if (!startMid) {
+      console.error(`Error: No market data for ${coin}`);
+      process.exit(1);
+    }
+
+    const maxChasePrice = isBuy
+      ? startMid * (1 + maxChaseBps / 10000)
+      : startMid * (1 - maxChaseBps / 10000);
+
+    console.log('Chase Parameters');
+    console.log('----------------');
+    console.log(`Coin:          ${coin}`);
+    console.log(`Side:          ${isBuy ? 'BUY' : 'SELL'}`);
+    console.log(`Size:          ${size}`);
+    console.log(`Start Mid:     ${formatUsd(startMid)}`);
+    console.log(`Offset:        ${offsetBps} bps (${(offsetBps / 100).toFixed(2)}%)`);
+    console.log(`Max Chase:     ${maxChaseBps} bps to ${formatUsd(maxChasePrice)}`);
+    console.log(`Timeout:       ${timeoutSec}s`);
+    console.log(`Update Rate:   ${intervalMs}ms`);
+    console.log(`Order Type:    ALO (post-only)`);
+
+    if (dryRun) {
+      console.log('\n🔍 Dry run - chase not started');
+      return;
+    }
+
+    console.log('\nChasing...\n');
+
+    const startTime = Date.now();
+    let currentOid: number | null = null;
+    let lastPrice: number | null = null;
+    let iteration = 0;
+    let filled = false;
+
+    while (Date.now() - startTime < timeoutSec * 1000) {
+      iteration++;
+
+      // Get current mid
+      const currentMids = await client.getAllMids();
+      const currentMid = parseFloat(currentMids[coin]);
+
+      // Check max chase limit
+      if (isBuy && currentMid > maxChasePrice) {
+        console.log(`\n⚠️ Price ${formatUsd(currentMid)} exceeded max chase ${formatUsd(maxChasePrice)}`);
+        break;
+      }
+      if (!isBuy && currentMid < maxChasePrice) {
+        console.log(`\n⚠️ Price ${formatUsd(currentMid)} exceeded max chase ${formatUsd(maxChasePrice)}`);
+        break;
+      }
+
+      // Calculate order price with offset
+      const orderPrice = isBuy
+        ? currentMid * (1 - offsetBps / 10000)
+        : currentMid * (1 + offsetBps / 10000);
+
+      // Check if price moved enough to update
+      const priceChanged = !lastPrice || Math.abs(orderPrice - lastPrice) / lastPrice > 0.0001;
+
+      if (priceChanged) {
+        // Cancel existing order if any
+        if (currentOid !== null) {
+          try {
+            await client.cancel(coin, currentOid);
+          } catch {
+            // Order might have filled
+          }
+          currentOid = null;
+        }
+
+        // Check if we got filled while cancelling
+        const orders = await client.getOpenOrders();
+        const ourOrder = orders.find(o => o.coin === coin && o.oid === currentOid);
+        if (!ourOrder && currentOid !== null) {
+          // Order gone - might have filled
+          // Check position to confirm
+          const state = await client.getUserState();
+          const pos = state.assetPositions.find(p => p.position.coin === coin);
+          if (pos && Math.abs(parseFloat(pos.position.szi)) >= size * 0.99) {
+            filled = true;
+            console.log(`\n✅ Order filled!`);
+            break;
+          }
+        }
+
+        // Place new order
+        process.stdout.write(`[${iteration}] Mid: ${formatUsd(currentMid)} → Order: ${formatUsd(orderPrice)}... `);
+
+        const response = await client.limitOrder(coin, isBuy, size, orderPrice, 'Alo', reduceOnly);
+
+        if (response.status === 'ok' && response.response && typeof response.response === 'object') {
+          const status = response.response.data.statuses[0];
+          if (status?.resting) {
+            currentOid = status.resting.oid;
+            lastPrice = orderPrice;
+            console.log(`OID: ${currentOid}`);
+          } else if (status?.filled) {
+            filled = true;
+            console.log(`✅ Filled @ ${formatUsd(parseFloat(status.filled.avgPx))}`);
+            break;
+          } else if (status?.error) {
+            console.log(`❌ ${status.error}`);
+            // If ALO rejected (would be taker), try again next iteration
+          }
+        } else {
+          console.log(`❌ Failed`);
+        }
+      } else {
+        // Price stable, check if filled
+        if (currentOid !== null) {
+          const orders = await client.getOpenOrders();
+          const ourOrder = orders.find(o => o.oid === currentOid);
+          if (!ourOrder) {
+            filled = true;
+            console.log(`\n✅ Order filled!`);
+            break;
+          }
+        }
+        process.stdout.write('.');
+      }
+
+      await sleep(intervalMs);
+    }
+
+    // Cleanup
+    if (currentOid !== null && !filled) {
+      console.log(`\nCancelling unfilled order...`);
+      try {
+        await client.cancel(coin, currentOid);
+        console.log(`✅ Cancelled`);
+      } catch {
+        console.log(`⚠️ Could not cancel (may have filled)`);
+      }
+    }
+
+    // Summary
+    const elapsed = (Date.now() - startTime) / 1000;
+    const endMid = parseFloat((await client.getAllMids())[coin]);
+    const priceMove = ((endMid - startMid) / startMid) * 10000;
+
+    console.log('\n========== Chase Summary ==========');
+    console.log(`Duration:     ${elapsed.toFixed(1)}s`);
+    console.log(`Iterations:   ${iteration}`);
+    console.log(`Start Mid:    ${formatUsd(startMid)}`);
+    console.log(`End Mid:      ${formatUsd(endMid)} (${priceMove >= 0 ? '+' : ''}${priceMove.toFixed(1)} bps)`);
+    console.log(`Result:       ${filled ? '✅ Filled' : '❌ Not filled'}`);
+
+  } catch (error) {
+    console.error('Error:', error);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/operations/limit-order.ts

@@ -0,0 +1,160 @@
+#!/usr/bin/env npx tsx
+// Execute a limit order on Hyperliquid
+
+import { getClient } from '../core/client.js';
+import { formatUsd, parseArgs } from '../core/utils.js';
+
+function printUsage() {
+  console.log(`
+Open Broker - Limit Order
+=========================
+
+Place a limit order with specified price.
+
+Usage:
+  npx tsx scripts/operations/limit-order.ts --coin <COIN> --side <buy|sell> --size <SIZE> --price <PRICE>
+
+Options:
+  --coin      Asset to trade (e.g., ETH, BTC)
+  --side      Order side: buy or sell
+  --size      Order size in base asset
+  --price     Limit price
+  --tif       Time in force: GTC, IOC, or ALO (default: GTC)
+              GTC = Good Till Cancel (rests on book)
+              IOC = Immediate Or Cancel (fills or cancels)
+              ALO = Add Liquidity Only (post-only, maker only)
+  --reduce    Reduce-only order (default: false)
+  --dry       Dry run - show order details without executing
+
+Examples:
+  npx tsx scripts/operations/limit-order.ts --coin ETH --side buy --size 1 --price 3000
+  npx tsx scripts/operations/limit-order.ts --coin BTC --side sell --size 0.1 --price 100000 --tif ALO
+  npx tsx scripts/operations/limit-order.ts --coin SOL --side buy --size 10 --price 150 --reduce
+`);
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  // Parse and validate arguments
+  const coin = args.coin as string;
+  const side = args.side as string;
+  const size = parseFloat(args.size as string);
+  const price = parseFloat(args.price as string);
+  const tifArg = (args.tif as string)?.toUpperCase() || 'GTC';
+  const reduceOnly = args.reduce as boolean;
+  const dryRun = args.dry as boolean;
+
+  if (!coin || !side || isNaN(size) || isNaN(price)) {
+    printUsage();
+    process.exit(1);
+  }
+
+  if (side !== 'buy' && side !== 'sell') {
+    console.error('Error: --side must be "buy" or "sell"');
+    process.exit(1);
+  }
+
+  if (size <= 0) {
+    console.error('Error: --size must be positive');
+    process.exit(1);
+  }
+
+  if (price <= 0) {
+    console.error('Error: --price must be positive');
+    process.exit(1);
+  }
+
+  // Map uppercase CLI input to Pascal case for SDK
+  const tifMap: Record<string, 'Gtc' | 'Ioc' | 'Alo'> = {
+    'GTC': 'Gtc',
+    'IOC': 'Ioc',
+    'ALO': 'Alo'
+  };
+
+  const tif = tifMap[tifArg];
+  if (!tif) {
+    console.error(`Error: --tif must be one of: GTC, IOC, ALO`);
+    process.exit(1);
+  }
+  const isBuy = side === 'buy';
+  const client = getClient();
+
+  console.log('Open Broker - Limit Order');
+  console.log('=========================\n');
+
+  try {
+    // Get current price for reference
+    const mids = await client.getAllMids();
+    const midPrice = parseFloat(mids[coin]);
+
+    if (!midPrice) {
+      console.error(`Error: No market data for ${coin}`);
+      process.exit(1);
+    }
+
+    const notional = price * size;
+    const distanceFromMid = ((price - midPrice) / midPrice) * 100;
+
+    console.log('Order Details');
+    console.log('-------------');
+    console.log(`Coin:           ${coin}`);
+    console.log(`Side:           ${isBuy ? 'BUY' : 'SELL'}`);
+    console.log(`Size:           ${size}`);
+    console.log(`Limit Price:    ${formatUsd(price)}`);
+    console.log(`Current Mid:    ${formatUsd(midPrice)}`);
+    console.log(`Distance:       ${distanceFromMid >= 0 ? '+' : ''}${distanceFromMid.toFixed(2)}% from mid`);
+    console.log(`Notional:       ${formatUsd(notional)}`);
+    console.log(`Time in Force:  ${tif}`);
+    console.log(`Reduce Only:    ${reduceOnly ? 'Yes' : 'No'}`);
+    console.log(`Builder Fee:    ${client.builderInfo.f / 10} bps`);
+
+    // Warning if order would be aggressively priced
+    if ((isBuy && price > midPrice) || (!isBuy && price < midPrice)) {
+      console.log(`\n⚠️  Order is priced aggressively - may fill immediately as taker`);
+    }
+
+    if (dryRun) {
+      console.log('\n🔍 Dry run - order not submitted');
+      return;
+    }
+
+    console.log('\nSubmitting...');
+
+    const response = await client.limitOrder(coin, isBuy, size, price, tif, reduceOnly);
+
+    console.log('\nResult');
+    console.log('------');
+
+    if (response.status === 'ok' && response.response) {
+      const statuses = response.response.data.statuses;
+      for (const status of statuses) {
+        if (status.filled) {
+          const fillSz = parseFloat(status.filled.totalSz);
+          const avgPx = parseFloat(status.filled.avgPx);
+          const fillNotional = fillSz * avgPx;
+
+          console.log(`✅ Filled`);
+          console.log(`   Order ID:  ${status.filled.oid}`);
+          console.log(`   Size:      ${fillSz}`);
+          console.log(`   Avg Price: ${formatUsd(avgPx)}`);
+          console.log(`   Notional:  ${formatUsd(fillNotional)}`);
+        } else if (status.resting) {
+          console.log(`✅ Order placed`);
+          console.log(`   Order ID:  ${status.resting.oid}`);
+          console.log(`   Status:    Resting on book`);
+        } else if (status.error) {
+          console.log(`❌ Error: ${status.error}`);
+        }
+      }
+    } else {
+      console.log(`❌ Error: ${response.error || 'Unknown error'}`);
+    }
+
+  } catch (error) {
+    console.error('Error submitting order:', error);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/operations/market-order.ts

@@ -0,0 +1,167 @@
+#!/usr/bin/env npx tsx
+// Execute a market order on Hyperliquid
+
+import { getClient } from '../core/client.js';
+import { formatUsd, parseArgs, checkBuilderFeeApproval } from '../core/utils.js';
+
+function printUsage() {
+  console.log(`
+Open Broker - Market Order
+==========================
+
+Execute a market order with slippage protection.
+
+Usage:
+  npx tsx scripts/operations/market-order.ts --coin <COIN> --side <buy|sell> --size <SIZE>
+
+Options:
+  --coin      Asset to trade (e.g., ETH, BTC)
+  --side      Order side: buy or sell
+  --size      Order size in base asset
+  --slippage  Slippage tolerance in bps (default: from config, usually 50 = 0.5%)
+  --reduce    Reduce-only order (default: false)
+  --dry       Dry run - show order details without executing
+  --verbose   Show full API request/response for debugging
+
+Environment:
+  HYPERLIQUID_PRIVATE_KEY  Your wallet private key (0x...)
+  HYPERLIQUID_NETWORK      "mainnet" or "testnet" (default: mainnet)
+  VERBOSE=1                Enable verbose logging
+
+Examples:
+  npx tsx scripts/operations/market-order.ts --coin ETH --side buy --size 0.1
+  npx tsx scripts/operations/market-order.ts --coin BTC --side sell --size 0.01 --slippage 100
+  npx tsx scripts/operations/market-order.ts --coin SOL --side buy --size 10 --dry
+  npx tsx scripts/operations/market-order.ts --coin ETH --side buy --size 0.1 --verbose
+`);
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  // Parse and validate arguments
+  const coin = args.coin as string;
+  const side = args.side as string;
+  const size = parseFloat(args.size as string);
+  const slippage = args.slippage ? parseInt(args.slippage as string) : undefined;
+  const reduceOnly = args.reduce as boolean;
+  const dryRun = args.dry as boolean;
+
+  if (!coin || !side || isNaN(size)) {
+    printUsage();
+    process.exit(1);
+  }
+
+  if (side !== 'buy' && side !== 'sell') {
+    console.error('Error: --side must be "buy" or "sell"');
+    process.exit(1);
+  }
+
+  if (size <= 0) {
+    console.error('Error: --size must be positive');
+    process.exit(1);
+  }
+
+  const isBuy = side === 'buy';
+  const client = getClient();
+
+  // Enable verbose mode if requested
+  if (args.verbose) {
+    client.verbose = true;
+  }
+
+  console.log('Open Broker - Market Order');
+  console.log('==========================\n');
+
+  // Check builder fee approval (warning only, don't block)
+  await checkBuilderFeeApproval(client);
+
+  try {
+    // Get current price
+    const mids = await client.getAllMids();
+    const midPrice = parseFloat(mids[coin]);
+
+    if (!midPrice) {
+      console.error(`Error: No market data for ${coin}`);
+      process.exit(1);
+    }
+
+    // Calculate order details
+    const slippageBps = slippage ?? 50;
+    const slippageMultiplier = slippageBps / 10000;
+    const limitPrice = isBuy
+      ? midPrice * (1 + slippageMultiplier)
+      : midPrice * (1 - slippageMultiplier);
+    const notional = midPrice * size;
+
+    console.log('Order Details');
+    console.log('-------------');
+    console.log(`Coin:         ${coin}`);
+    console.log(`Side:         ${isBuy ? 'BUY' : 'SELL'}`);
+    console.log(`Size:         ${size}`);
+    console.log(`Mid Price:    ${formatUsd(midPrice)}`);
+    console.log(`Limit Price:  ${formatUsd(limitPrice)} (${slippageBps} bps slippage)`);
+    console.log(`Notional:     ~${formatUsd(notional)}`);
+    console.log(`Reduce Only:  ${reduceOnly ? 'Yes' : 'No'}`);
+    console.log(`Builder Fee:  ${client.builderInfo.f / 10} bps`);
+
+    if (dryRun) {
+      console.log('\n🔍 Dry run - order not submitted');
+      return;
+    }
+
+    console.log('\nExecuting...');
+
+    const response = await client.marketOrder(coin, isBuy, size, slippage);
+
+    console.log('\nResult');
+    console.log('------');
+
+    // Log full response for debugging
+    if (args.verbose || process.env.VERBOSE) {
+      console.log('\nFull Response:');
+      console.log(JSON.stringify(response, null, 2));
+    }
+
+    if (response.status === 'ok' && response.response && typeof response.response === 'object') {
+      const statuses = response.response.data.statuses;
+      for (const status of statuses) {
+        if (status.filled) {
+          const fillSz = parseFloat(status.filled.totalSz);
+          const avgPx = parseFloat(status.filled.avgPx);
+          const fillNotional = fillSz * avgPx;
+          const slippageActual = isBuy
+            ? (avgPx - midPrice) / midPrice
+            : (midPrice - avgPx) / midPrice;
+
+          console.log(`✅ Filled`);
+          console.log(`   Order ID:  ${status.filled.oid}`);
+          console.log(`   Size:      ${fillSz}`);
+          console.log(`   Avg Price: ${formatUsd(avgPx)}`);
+          console.log(`   Notional:  ${formatUsd(fillNotional)}`);
+          console.log(`   Slippage:  ${(slippageActual * 10000).toFixed(1)} bps`);
+        } else if (status.resting) {
+          console.log(`⏳ Resting (partial fill)`);
+          console.log(`   Order ID:  ${status.resting.oid}`);
+        } else if (status.error) {
+          console.log(`❌ Error: ${status.error}`);
+        } else {
+          // Unknown status - show the whole thing
+          console.log(`⚠️  Unknown status:`);
+          console.log(JSON.stringify(status, null, 2));
+        }
+      }
+    } else if (response.status === 'err') {
+      console.log(`❌ API Error: ${response.response || JSON.stringify(response)}`);
+    } else {
+      console.log(`❌ Unexpected response:`);
+      console.log(JSON.stringify(response, null, 2));
+    }
+
+  } catch (error) {
+    console.error('Error executing order:', error);
+    process.exit(1);
+  }
+}
+
+main();