openbroker 1.3.2 → 1.4.0

package/dist/operations/scale.js

@@ -0,0 +1,212 @@
+#!/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
+  --leverage      Set leverage (e.g., 10 for 10x). Cross for main perps, isolated for HIP-3
+  --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
+`);
+}
+function calculateLevels(midPrice, isBuy, totalSize, numLevels, rangePct, distribution) {
+    const levels = [];
+    // Calculate weights based on distribution
+    let weights = [];
+    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;
+    const side = args.side;
+    const totalSize = parseFloat(args.size);
+    const numLevels = parseInt(args.levels);
+    const rangePct = parseFloat(args.range);
+    const distribution = (args.distribution || 'linear');
+    const leverage = args.leverage ? parseInt(args.leverage) : undefined;
+    const reduceOnly = args.reduce;
+    const tifArg = (args.tif?.toUpperCase() || 'GTC');
+    const dryRun = args.dry;
+    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 = {
+        '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 = [];
+        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, leverage);
+                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/dist/operations/set-tpsl.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env npx tsx
+export {};
+//# sourceMappingURL=set-tpsl.d.ts.map

package/dist/operations/set-tpsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-tpsl.d.ts","sourceRoot":"","sources":["../../scripts/operations/set-tpsl.ts"],"names":[],"mappings":""}

package/dist/operations/set-tpsl.js

@@ -0,0 +1,277 @@
+#!/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, entryPrice, isLong) {
+    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;
+    const tpInput = args.tp;
+    const slInput = args.sl;
+    const sizeOverride = args.size ? parseFloat(args.size) : undefined;
+    const slSlippage = args['sl-slippage'] ? parseInt(args['sl-slippage']) : 100;
+    const dryRun = args.dry;
+    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 = 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})`);
+                }
+                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();

package/dist/operations/spot-order.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env npx tsx
+export {};
+//# sourceMappingURL=spot-order.d.ts.map

package/dist/operations/spot-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spot-order.d.ts","sourceRoot":"","sources":["../../scripts/operations/spot-order.ts"],"names":[],"mappings":""}

package/dist/operations/spot-order.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env npx tsx
+// Execute a spot order on Hyperliquid
+import { getClient } from '../core/client.js';
+import { formatUsd, parseArgs, checkBuilderFeeApproval } from '../core/utils.js';
+function printUsage() {
+    console.log(`
+Open Broker - Spot Order
+========================
+
+Buy or sell spot tokens on Hyperliquid.
+
+Usage:
+  npx tsx scripts/operations/spot-order.ts --coin <COIN> --side <buy|sell> --size <SIZE>
+
+Options:
+  --coin      Base token to trade (e.g., PURR, HYPE)
+  --side      Order side: buy or sell
+  --size      Order size in base token units
+  --price     Limit price (omit for market order)
+  --tif       Time-in-force for limit orders: Gtc, Ioc, Alo (default: Gtc)
+  --slippage  Slippage tolerance in bps for market orders (default: from config, usually 50 = 0.5%)
+  --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)
+
+Examples:
+  npx tsx scripts/operations/spot-order.ts --coin PURR --side buy --size 1000
+  npx tsx scripts/operations/spot-order.ts --coin HYPE --side sell --size 50 --price 25.50
+  npx tsx scripts/operations/spot-order.ts --coin PURR --side buy --size 500 --dry
+`);
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const coin = args.coin;
+    const side = args.side;
+    const size = parseFloat(args.size);
+    const price = args.price ? parseFloat(args.price) : undefined;
+    const tif = args.tif ?? 'Gtc';
+    const slippage = args.slippage ? parseInt(args.slippage) : undefined;
+    const dryRun = args.dry;
+    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();
+    if (args.verbose) {
+        client.verbose = true;
+    }
+    console.log('Open Broker - Spot Order');
+    console.log('========================\n');
+    await checkBuilderFeeApproval(client);
+    try {
+        // Load spot metadata to get the pair index, then use allMids for accurate price
+        const spotMeta = await client.getSpotMeta();
+        const tokenMap = new Map();
+        for (const t of spotMeta.tokens)
+            tokenMap.set(t.index, t.name);
+        // Find the USDC-quoted pair for this coin (prefer quote token 0 = USDC)
+        let pairName = '';
+        let spotCoinKey = '';
+        for (const pair of spotMeta.universe) {
+            const baseName = tokenMap.get(pair.tokens[0]) ?? '';
+            if (baseName.toUpperCase() !== coin.toUpperCase())
+                continue;
+            const quoteName = tokenMap.get(pair.tokens[1]) ?? 'USDC';
+            // Prefer USDC pair; if already found a USDC pair, skip non-USDC pairs
+            if (pairName && pair.tokens[1] !== 0)
+                continue;
+            pairName = `${baseName}/${quoteName}`;
+            spotCoinKey = pair.name; // "@107" or "PURR/USDC"
+            if (pair.tokens[1] === 0)
+                break; // USDC pair found, stop
+        }
+        if (!spotCoinKey) {
+            console.error(`Error: No spot market found for ${coin}`);
+            console.error('Use "openbroker spot" to see available spot markets.');
+            process.exit(1);
+        }
+        // Use allMids for live price (spotMetaAndAssetCtxs contexts can be misaligned)
+        const mids = await client.getAllMids();
+        const midPrice = parseFloat(mids[spotCoinKey] || '0');
+        if (!midPrice || midPrice === 0) {
+            console.error(`Error: No spot price for ${coin} (${spotCoinKey})`);
+            process.exit(1);
+        }
+        const isMarket = price === undefined;
+        const slippageBps = slippage ?? 50;
+        const displayPrice = isMarket
+            ? (isBuy ? midPrice * (1 + slippageBps / 10000) : midPrice * (1 - slippageBps / 10000))
+            : price;
+        const notional = midPrice * size;
+        console.log('Order Details');
+        console.log('-------------');
+        console.log(`Pair:         ${pairName}`);
+        console.log(`Side:         ${isBuy ? 'BUY' : 'SELL'}`);
+        console.log(`Size:         ${size} ${coin}`);
+        console.log(`Mid Price:    ${formatUsd(midPrice)}`);
+        if (isMarket) {
+            console.log(`Type:         Market (IOC)`);
+            console.log(`Limit Price:  ${formatUsd(displayPrice)} (${slippageBps} bps slippage)`);
+        }
+        else {
+            console.log(`Type:         Limit (${tif})`);
+            console.log(`Limit Price:  ${formatUsd(price)}`);
+        }
+        console.log(`Notional:     ~${formatUsd(notional)}`);
+        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 = isMarket
+            ? await client.spotMarketOrder(coin, isBuy, size, slippage)
+            : await client.spotLimitOrder(coin, isBuy, size, price, tif);
+        console.log('\nResult');
+        console.log('------');
+        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;
+                    console.log(`✅ Filled`);
+                    console.log(`   Order ID:  ${status.filled.oid}`);
+                    console.log(`   Size:      ${fillSz} ${coin}`);
+                    console.log(`   Avg Price: ${formatUsd(avgPx)}`);
+                    console.log(`   Notional:  ${formatUsd(fillNotional)}`);
+                }
+                else if (status.resting) {
+                    console.log(`⏳ Resting`);
+                    console.log(`   Order ID:  ${status.resting.oid}`);
+                }
+                else if (status.error) {
+                    console.log(`❌ Error: ${status.error}`);
+                }
+                else {
+                    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 spot order:', error);
+        process.exit(1);
+    }
+}
+main();

package/dist/operations/trigger-order.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env npx tsx
+export {};
+//# sourceMappingURL=trigger-order.d.ts.map

package/dist/operations/trigger-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger-order.d.ts","sourceRoot":"","sources":["../../scripts/operations/trigger-order.ts"],"names":[],"mappings":""}