openbroker 1.0.33

package/scripts/strategies/mm-spread.ts

@@ -0,0 +1,402 @@
+#!/usr/bin/env npx tsx
+// Simple Market Making - Place bid/ask quotes around mid price with inventory management
+
+import { getClient } from '../core/client.js';
+import { formatUsd, parseArgs, sleep } from '../core/utils.js';
+
+function printUsage() {
+  console.log(`
+Open Broker - Market Making Spread
+==================================
+
+Place bid and ask orders around the mid price, earning the spread when both sides fill.
+Includes inventory management to stay neutral and avoid directional drift.
+
+Usage:
+  npx tsx scripts/strategies/mm-spread.ts --coin <COIN> --size <SIZE> --spread <BPS>
+
+Options:
+  --coin          Asset to market make (e.g., ETH, BTC)
+  --size          Order size on each side (in base asset)
+  --spread        Spread in bps from mid (e.g., 10 = 0.1% each side)
+  --skew-factor   How aggressively to skew for inventory (default: 2.0)
+  --refresh       Refresh interval in milliseconds (default: 2000)
+  --max-position  Maximum net position before stopping that side (default: 3x size)
+  --cooldown      Cooldown after fill before same-side quote (ms, default: 5000)
+  --duration      How long to run in minutes (default: runs until stopped)
+  --dry           Dry run - show strategy parameters without trading
+
+Inventory Management:
+  The strategy automatically skews quotes based on inventory to stay neutral:
+  - If LONG: Bid is wider (less aggressive), Ask is tighter (more aggressive)
+  - If SHORT: Bid is tighter (more aggressive), Ask is wider (less aggressive)
+  - At max position: Stops quoting that side entirely
+
+Examples:
+  # Market make ETH with 0.1 size, 10bps spread
+  npx tsx scripts/strategies/mm-spread.ts --coin ETH --size 0.1 --spread 10
+
+  # Tighter position limit and faster cooldown
+  npx tsx scripts/strategies/mm-spread.ts --coin BTC --size 0.01 --spread 5 --max-position 0.03 --cooldown 3000
+
+  # Preview setup
+  npx tsx scripts/strategies/mm-spread.ts --coin SOL --size 10 --spread 15 --dry
+
+Risks:
+  - Adverse selection: getting picked off by informed traders
+  - Inventory risk: accumulating position during directional moves
+  - Use smaller --max-position for volatile assets
+`);
+}
+
+interface Quote {
+  side: 'bid' | 'ask';
+  price: number;
+  size: number;
+  oid?: number;
+  placedAt: number;
+}
+
+interface MmState {
+  bid: Quote | null;
+  ask: Quote | null;
+  lastBidFill: number;
+  lastAskFill: number;
+  totalBought: number;
+  totalSold: number;
+  totalBuyCost: number;
+  totalSellRevenue: number;
+  roundTrips: number;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  const coin = args.coin as string;
+  const size = parseFloat(args.size as string);
+  const spreadBps = parseFloat(args.spread as string);
+  const skewFactor = args['skew-factor'] ? parseFloat(args['skew-factor'] as string) : 2.0;
+  const refreshMs = args.refresh ? parseInt(args.refresh as string) : 2000;
+  const maxPosition = args['max-position'] ? parseFloat(args['max-position'] as string) : size * 3;
+  const cooldownMs = args.cooldown ? parseInt(args.cooldown as string) : 5000;
+  const durationMins = args.duration ? parseFloat(args.duration as string) : Infinity;
+  const dryRun = args.dry as boolean;
+
+  if (!coin || isNaN(size) || isNaN(spreadBps)) {
+    printUsage();
+    process.exit(1);
+  }
+
+  if (spreadBps < 1) {
+    console.error('Error: --spread must be at least 1 bps');
+    process.exit(1);
+  }
+
+  const client = getClient();
+
+  if (args.verbose) {
+    client.verbose = true;
+  }
+
+  console.log('Open Broker - Market Making');
+  console.log('===========================\n');
+
+  try {
+    // Get fresh market data
+    const mids = await client.getAllMids();
+    const midPrice = parseFloat(mids[coin]);
+    if (!midPrice) {
+      console.error(`Error: No market data for ${coin}`);
+      process.exit(1);
+    }
+
+    const baseSpread = spreadBps / 10000;
+    const halfSpread = baseSpread / 2;
+    const bidPrice = midPrice * (1 - halfSpread);
+    const askPrice = midPrice * (1 + halfSpread);
+    const notionalPerSide = size * midPrice;
+    const profitPerRoundTrip = (askPrice - bidPrice) * size;
+
+    console.log('Strategy Configuration');
+    console.log('----------------------');
+    console.log(`Coin:              ${coin}`);
+    console.log(`Current Mid:       ${formatUsd(midPrice)}`);
+    console.log(`Order Size:        ${size} ${coin}`);
+    console.log(`Notional/Side:     ${formatUsd(notionalPerSide)}`);
+    console.log(`Spread:            ${spreadBps} bps (${(spreadBps / 100).toFixed(2)}%)`);
+    console.log(`Max Position:      ±${maxPosition} ${coin}`);
+    console.log(`Skew Factor:       ${skewFactor}x`);
+    console.log(`Cooldown:          ${cooldownMs}ms`);
+    console.log(`Refresh:           ${refreshMs}ms`);
+    console.log(`\nQuote Prices (at neutral):`);
+    console.log(`  Bid: ${formatUsd(bidPrice)} (-${(halfSpread * 100).toFixed(3)}%)`);
+    console.log(`  Ask: ${formatUsd(askPrice)} (+${(halfSpread * 100).toFixed(3)}%)`);
+    console.log(`\nProfit/Round Trip: ${formatUsd(profitPerRoundTrip)}`);
+
+    console.log(`\nInventory Skewing:`);
+    console.log(`  When LONG:  Bid wider, Ask tighter (encourage selling)`);
+    console.log(`  When SHORT: Bid tighter, Ask wider (encourage buying)`);
+
+    if (dryRun) {
+      console.log('\n--- Dry run complete ---');
+      return;
+    }
+
+    console.log('\nStarting market making...\n');
+
+    const state: MmState = {
+      bid: null,
+      ask: null,
+      lastBidFill: 0,
+      lastAskFill: 0,
+      totalBought: 0,
+      totalSold: 0,
+      totalBuyCost: 0,
+      totalSellRevenue: 0,
+      roundTrips: 0,
+    };
+
+    const endTime = durationMins === Infinity ? Infinity : Date.now() + durationMins * 60 * 1000;
+
+    // Handle graceful shutdown
+    let shuttingDown = false;
+    process.on('SIGINT', async () => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      console.log('\n\nShutting down - cancelling quotes...');
+      await cancelQuotes(client, coin, state);
+      await printSummary(client, coin, state);
+      process.exit(0);
+    });
+
+    let lastLogTime = 0;
+    let iteration = 0;
+
+    while (Date.now() < endTime && !shuttingDown) {
+      iteration++;
+      const now = Date.now();
+
+      // Always get fresh mid price
+      const freshMids = await client.getAllMids();
+      const currentMid = parseFloat(freshMids[coin]);
+
+      // Get actual position from exchange for ground truth
+      const userState = await client.getUserState();
+      const position = userState.assetPositions.find(p => p.position.coin === coin);
+      const actualPosition = position ? parseFloat(position.position.szi) : 0;
+
+      // Get our open orders
+      const openOrders = await client.getOpenOrders();
+      const ourOrders = openOrders.filter(o => o.coin === coin);
+      const openOids = new Set(ourOrders.map(o => o.oid));
+
+      // Check for bid fill
+      if (state.bid && state.bid.oid && !openOids.has(state.bid.oid)) {
+        const fillPrice = state.bid.price;
+        state.totalBought += state.bid.size;
+        state.totalBuyCost += fillPrice * state.bid.size;
+        state.lastBidFill = now;
+        console.log(`[${new Date().toLocaleTimeString()}] BID FILLED @ ${formatUsd(fillPrice)} | Position: ${actualPosition.toFixed(4)}`);
+        state.bid = null;
+      }
+
+      // Check for ask fill
+      if (state.ask && state.ask.oid && !openOids.has(state.ask.oid)) {
+        const fillPrice = state.ask.price;
+        state.totalSold += state.ask.size;
+        state.totalSellRevenue += fillPrice * state.ask.size;
+        state.lastAskFill = now;
+        state.roundTrips += 0.5;
+        console.log(`[${new Date().toLocaleTimeString()}] ASK FILLED @ ${formatUsd(fillPrice)} | Position: ${actualPosition.toFixed(4)}`);
+        state.ask = null;
+      }
+
+      // Calculate inventory-based skew
+      // Skew ranges from -1 (max short) to +1 (max long)
+      const inventoryRatio = Math.max(-1, Math.min(1, actualPosition / maxPosition));
+
+      // Skew the spread: positive inventory = wider bid, tighter ask
+      const bidSkew = halfSpread * (1 + inventoryRatio * skewFactor);
+      const askSkew = halfSpread * (1 - inventoryRatio * skewFactor);
+
+      // Calculate skewed prices
+      const skewedBidPrice = currentMid * (1 - Math.max(0.0001, bidSkew));
+      const skewedAskPrice = currentMid * (1 + Math.max(0.0001, askSkew));
+
+      // Determine if we should quote each side
+      const bidCooldownOk = (now - state.lastBidFill) > cooldownMs;
+      const askCooldownOk = (now - state.lastAskFill) > cooldownMs;
+      const shouldBid = actualPosition < maxPosition && bidCooldownOk;
+      const shouldAsk = actualPosition > -maxPosition && askCooldownOk;
+
+      // Cancel stale quotes that have drifted too far from target
+      if (state.bid && state.bid.oid) {
+        const bidDrift = Math.abs(state.bid.price - skewedBidPrice) / currentMid;
+        if (bidDrift > 0.001 || !shouldBid) { // 0.1% drift threshold
+          try {
+            await client.cancel(coin, state.bid.oid);
+            state.bid = null;
+          } catch {
+            // Order may have been filled
+            state.bid = null;
+          }
+        }
+      }
+
+      if (state.ask && state.ask.oid) {
+        const askDrift = Math.abs(state.ask.price - skewedAskPrice) / currentMid;
+        if (askDrift > 0.001 || !shouldAsk) { // 0.1% drift threshold
+          try {
+            await client.cancel(coin, state.ask.oid);
+            state.ask = null;
+          } catch {
+            // Order may have been filled
+            state.ask = null;
+          }
+        }
+      }
+
+      // Place new bid if needed
+      if (shouldBid && !state.bid) {
+        const response = await client.limitOrder(coin, true, size, skewedBidPrice, 'Gtc', false);
+
+        if (response.status === 'ok' && response.response && typeof response.response === 'object') {
+          const status = response.response.data.statuses[0];
+          if (status?.resting) {
+            state.bid = {
+              side: 'bid',
+              price: skewedBidPrice,
+              size,
+              oid: status.resting.oid,
+              placedAt: now,
+            };
+          } else if (status?.filled) {
+            // Filled immediately - unusual for a bid below mid
+            const fillPrice = parseFloat(status.filled.avgPx);
+            state.totalBought += size;
+            state.totalBuyCost += fillPrice * size;
+            state.lastBidFill = now;
+            console.log(`[${new Date().toLocaleTimeString()}] BID FILLED IMMEDIATELY @ ${formatUsd(fillPrice)}`);
+          }
+        }
+      }
+
+      // Place new ask if needed
+      if (shouldAsk && !state.ask) {
+        const response = await client.limitOrder(coin, false, size, skewedAskPrice, 'Gtc', false);
+
+        if (response.status === 'ok' && response.response && typeof response.response === 'object') {
+          const status = response.response.data.statuses[0];
+          if (status?.resting) {
+            state.ask = {
+              side: 'ask',
+              price: skewedAskPrice,
+              size,
+              oid: status.resting.oid,
+              placedAt: now,
+            };
+          } else if (status?.filled) {
+            // Filled immediately - unusual for an ask above mid
+            const fillPrice = parseFloat(status.filled.avgPx);
+            state.totalSold += size;
+            state.totalSellRevenue += fillPrice * size;
+            state.lastAskFill = now;
+            state.roundTrips += 0.5;
+            console.log(`[${new Date().toLocaleTimeString()}] ASK FILLED IMMEDIATELY @ ${formatUsd(fillPrice)}`);
+          }
+        }
+      }
+
+      // Periodic status log
+      if (now - lastLogTime > 30000) {
+        const bidStatus = state.bid ? formatUsd(state.bid.price) : (shouldBid ? 'placing...' : 'paused');
+        const askStatus = state.ask ? formatUsd(state.ask.price) : (shouldAsk ? 'placing...' : 'paused');
+        const realizedPnl = state.totalSellRevenue - state.totalBuyCost;
+        const skewPct = (inventoryRatio * 100).toFixed(1);
+
+        console.log(`[${new Date().toLocaleTimeString()}] Mid: ${formatUsd(currentMid)} | Bid: ${bidStatus} | Ask: ${askStatus} | Pos: ${actualPosition.toFixed(4)} (skew: ${skewPct}%) | PnL: ${formatUsd(realizedPnl)}`);
+        lastLogTime = now;
+      }
+
+      await sleep(refreshMs);
+    }
+
+    // End of duration
+    if (!shuttingDown) {
+      console.log('\nDuration ended. Cancelling quotes...');
+      await cancelQuotes(client, coin, state);
+      await printSummary(client, coin, state);
+    }
+
+  } catch (error) {
+    console.error('Error:', error);
+    process.exit(1);
+  }
+}
+
+async function cancelQuotes(
+  client: ReturnType<typeof getClient>,
+  coin: string,
+  state: MmState
+): Promise<void> {
+  if (state.bid && state.bid.oid) {
+    try {
+      await client.cancel(coin, state.bid.oid);
+      console.log(`  Cancelled bid @ ${formatUsd(state.bid.price)}`);
+    } catch {
+      // Ignore
+    }
+  }
+  if (state.ask && state.ask.oid) {
+    try {
+      await client.cancel(coin, state.ask.oid);
+      console.log(`  Cancelled ask @ ${formatUsd(state.ask.price)}`);
+    } catch {
+      // Ignore
+    }
+  }
+}
+
+async function printSummary(
+  client: ReturnType<typeof getClient>,
+  coin: string,
+  state: MmState
+): Promise<void> {
+  // Get final position and price
+  const userState = await client.getUserState();
+  const position = userState.assetPositions.find(p => p.position.coin === coin);
+  const finalPosition = position ? parseFloat(position.position.szi) : 0;
+
+  const mids = await client.getAllMids();
+  const currentMid = parseFloat(mids[coin]);
+
+  const inventoryValue = finalPosition * currentMid;
+  const realizedPnl = state.totalSellRevenue - state.totalBuyCost;
+
+  // Calculate inventory PnL
+  let inventoryPnl = 0;
+  if (finalPosition > 0 && state.totalBought > 0) {
+    const avgBuyPrice = state.totalBuyCost / state.totalBought;
+    inventoryPnl = (currentMid - avgBuyPrice) * finalPosition;
+  } else if (finalPosition < 0 && state.totalSold > 0) {
+    const avgSellPrice = state.totalSellRevenue / state.totalSold;
+    inventoryPnl = (avgSellPrice - currentMid) * Math.abs(finalPosition);
+  }
+
+  console.log('\n========== MM Summary ==========');
+  console.log(`Total Bought:    ${state.totalBought.toFixed(6)} ${coin}`);
+  console.log(`Total Sold:      ${state.totalSold.toFixed(6)} ${coin}`);
+  console.log(`Final Position:  ${finalPosition.toFixed(6)} ${coin}`);
+  console.log(`Inventory Value: ${formatUsd(inventoryValue)}`);
+  console.log(`Round Trips:     ${state.roundTrips.toFixed(1)}`);
+  console.log(`Realized PnL:    ${formatUsd(realizedPnl)}`);
+  console.log(`Inventory PnL:   ${formatUsd(inventoryPnl)}`);
+  console.log(`Total PnL:       ${formatUsd(realizedPnl + inventoryPnl)}`);
+
+  if (Math.abs(finalPosition) > 0.0001) {
+    console.log(`\n⚠️  You have an open position of ${finalPosition.toFixed(6)} ${coin}`);
+    console.log(`   Close it manually if desired.`);
+  }
+}
+
+main();