openbroker 1.3.1 → 1.4.0

package/dist/info/search-markets.js

@@ -0,0 +1,296 @@
+#!/usr/bin/env tsx
+// Search Markets - Find specific assets across all providers (perps, HIP-3, spot, HIP-4)
+import { getClient } from '../core/client.js';
+function parseArgs() {
+    const args = { query: '', type: 'all' };
+    for (let i = 2; i < process.argv.length; i++) {
+        const arg = process.argv[i];
+        if (arg === '--query' && process.argv[i + 1]) {
+            args.query = process.argv[++i];
+        }
+        else if (arg === '--type' && process.argv[i + 1]) {
+            const val = process.argv[++i].toLowerCase();
+            if (['perp', 'spot', 'hip3', 'outcome', 'all'].includes(val)) {
+                args.type = val;
+            }
+        }
+        else if (arg === '--verbose') {
+            args.verbose = true;
+        }
+        else if (arg === '--json') {
+            args.json = true;
+        }
+        else if (arg === '--help' || arg === '-h') {
+            console.log(`
+Search Markets - Find assets across all Hyperliquid markets
+
+Usage: npx tsx scripts/info/search-markets.ts --query <search> [options]
+
+Options:
+  --query <search>  Search term (required) - matches coin name
+  --type <type>     Filter by market type: perp, spot, hip3, outcome, or all (default: all)
+  --json            Output as JSON (machine-readable)
+  --verbose         Show detailed output
+  --help            Show this help
+
+Examples:
+  npx tsx scripts/info/search-markets.ts --query GOLD       # Find all GOLD markets
+  npx tsx scripts/info/search-markets.ts --query BTC        # Find all BTC markets
+  npx tsx scripts/info/search-markets.ts --query ETH --type perp  # ETH perps only
+  npx tsx scripts/info/search-markets.ts --query PURR --type spot # PURR spot only
+  npx tsx scripts/info/search-markets.ts --query BTC --type outcome # HIP-4 outcomes only
+  npx tsx scripts/info/search-markets.ts --query HYPE --json      # JSON output
+`);
+            process.exit(0);
+        }
+        else if (!args.query && !arg.startsWith('-')) {
+            // Allow query as positional arg
+            args.query = arg;
+        }
+    }
+    if (!args.query) {
+        console.error('Error: --query is required');
+        console.log('Usage: npx tsx scripts/info/search-markets.ts --query <search>');
+        process.exit(1);
+    }
+    return args;
+}
+function formatVolume(vol) {
+    if (vol >= 1_000_000_000)
+        return `$${(vol / 1_000_000_000).toFixed(2)}B`;
+    if (vol >= 1_000_000)
+        return `$${(vol / 1_000_000).toFixed(2)}M`;
+    if (vol >= 1_000)
+        return `$${(vol / 1_000).toFixed(2)}K`;
+    return `$${vol.toFixed(2)}`;
+}
+function formatPrice(price) {
+    const p = typeof price === 'string' ? parseFloat(price) : price;
+    if (p >= 1000)
+        return p.toFixed(2);
+    if (p >= 1)
+        return p.toFixed(4);
+    if (p >= 0.01)
+        return p.toFixed(6);
+    return p.toFixed(8);
+}
+function formatFunding(rate) {
+    const r = parseFloat(rate);
+    const annualized = r * 24 * 365 * 100;
+    const sign = annualized >= 0 ? '+' : '';
+    return `${sign}${annualized.toFixed(2)}%`;
+}
+function handleMarketFetchError(kind, error, requestedType, verbose) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (requestedType === kind) {
+        throw new Error(`Failed to fetch ${kind} markets: ${message}`);
+    }
+    if (verbose) {
+        console.error(`Failed to fetch ${kind} markets:`, error);
+    }
+}
+async function main() {
+    const args = parseArgs();
+    const client = getClient();
+    client.verbose = args.verbose ?? false;
+    const query = args.query.toUpperCase();
+    if (!args.json) {
+        console.log(`Searching for "${query}" across all markets...\n`);
+    }
+    const results = [];
+    // Search main perps
+    if (args.type === 'all' || args.type === 'perp') {
+        const meta = await client.getMetaAndAssetCtxs();
+        for (let i = 0; i < meta.meta.universe.length; i++) {
+            const asset = meta.meta.universe[i];
+            const ctx = meta.assetCtxs[i];
+            if (asset.name.toUpperCase().includes(query)) {
+                results.push({
+                    type: 'perp',
+                    provider: 'Hyperliquid',
+                    coin: asset.name,
+                    assetId: i,
+                    price: ctx.markPx,
+                    volume24h: parseFloat(ctx.dayNtlVlm),
+                    funding: ctx.funding,
+                    maxLeverage: asset.maxLeverage,
+                    openInterest: ctx.openInterest,
+                });
+            }
+        }
+    }
+    // Search HIP-3 perps
+    if (args.type === 'all' || args.type === 'hip3') {
+        if (client.isTestnet) {
+            // On testnet, load specific dex if query is "dex:COIN" format
+            if (args.query.includes(':')) {
+                await client.loadSingleHip3Dex(args.query.split(':')[0]);
+            }
+            else if (!args.json) {
+                console.log('  (Testnet: HIP-3 dexes not auto-loaded. Use "dexName:COIN" to search a specific dex.)\n');
+            }
+        }
+        try {
+            const allPerpMetas = await client.getAllPerpMetas();
+            // Skip index 0 (main dex), process HIP-3 dexs
+            for (let dexIdx = 1; dexIdx < allPerpMetas.length; dexIdx++) {
+                const dexData = allPerpMetas[dexIdx];
+                if (!dexData || !dexData.meta?.universe)
+                    continue;
+                for (let i = 0; i < dexData.meta.universe.length; i++) {
+                    const asset = dexData.meta.universe[i];
+                    const ctx = dexData.assetCtxs[i];
+                    if (!asset || !ctx)
+                        continue;
+                    if (asset.name.toUpperCase().includes(query)) {
+                        let assetId = -1;
+                        try {
+                            assetId = client.getAssetIndex(asset.name);
+                        }
+                        catch { /* not registered */ }
+                        results.push({
+                            type: 'hip3',
+                            provider: dexData.dexName || `HIP-3 DEX ${dexIdx}`,
+                            coin: asset.name,
+                            assetId,
+                            price: ctx.markPx,
+                            volume24h: parseFloat(ctx.dayNtlVlm || '0'),
+                            funding: ctx.funding,
+                            maxLeverage: asset.maxLeverage,
+                            openInterest: ctx.openInterest,
+                        });
+                    }
+                }
+            }
+        }
+        catch (e) {
+            if (args.verbose)
+                console.error('Failed to fetch HIP-3 markets:', e);
+        }
+    }
+    // Search spot markets
+    if (args.type === 'all' || args.type === 'spot') {
+        try {
+            const spotData = await client.getSpotMetaAndAssetCtxs();
+            // Build token index → name lookup for matching by base token name
+            const tokenNameMap = new Map();
+            for (const token of spotData.meta.tokens) {
+                tokenNameMap.set(token.index, token.name);
+            }
+            // Build ctx map by coin name (contexts have a 'coin' field that matches pair.name).
+            // The contexts array can be longer than universe and is NOT aligned by index.
+            const ctxMap = new Map();
+            for (const ctx of spotData.assetCtxs) {
+                if (ctx.coin) {
+                    ctxMap.set(ctx.coin, ctx);
+                }
+            }
+            for (const pair of spotData.meta.universe) {
+                if (!pair)
+                    continue;
+                const ctx = ctxMap.get(pair.name);
+                if (!ctx)
+                    continue;
+                // Match against pair name, base token name, and quote token name
+                const baseTokenName = tokenNameMap.get(pair.tokens[0]) ?? '';
+                const quoteTokenName = tokenNameMap.get(pair.tokens[1]) ?? '';
+                const searchable = `${pair.name} ${baseTokenName} ${quoteTokenName}`.toUpperCase();
+                if (searchable.includes(query)) {
+                    const displayName = baseTokenName && quoteTokenName
+                        ? `${baseTokenName}/${quoteTokenName}`
+                        : pair.name;
+                    results.push({
+                        type: 'spot',
+                        provider: 'Spot',
+                        coin: displayName,
+                        assetId: 10000 + pair.index,
+                        price: ctx.markPx,
+                        volume24h: parseFloat(ctx.dayNtlVlm || '0'),
+                    });
+                }
+            }
+        }
+        catch (e) {
+            if (args.verbose)
+                console.error('Failed to fetch spot markets:', e);
+        }
+    }
+    // Search HIP-4 outcome markets
+    if (args.type === 'all' || args.type === 'outcome') {
+        try {
+            const outcomes = await client.getOutcomeMarkets();
+            for (const market of outcomes) {
+                const parsed = Object.values(market.parsedDescription).join(' ');
+                const searchable = `${market.name} ${market.description} ${parsed}`.toUpperCase();
+                if (!searchable.includes(query))
+                    continue;
+                for (const side of market.sides) {
+                    results.push({
+                        type: 'outcome',
+                        provider: 'HIP-4',
+                        coin: side.coin,
+                        assetId: side.assetId,
+                        price: side.midPx ?? side.markPx ?? '0',
+                        volume24h: parseFloat(side.dayNtlVlm || '0'),
+                        outcome: market.outcome,
+                        outcomeSide: side.name,
+                        outcomeName: market.name,
+                        tokenName: side.tokenName,
+                        parsedDescription: market.parsedDescription,
+                        description: market.description,
+                    });
+                }
+            }
+        }
+        catch (e) {
+            handleMarketFetchError('outcome', e, args.type, args.verbose);
+        }
+    }
+    // Sort by volume
+    results.sort((a, b) => b.volume24h - a.volume24h);
+    if (args.json) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+    }
+    if (results.length === 0) {
+        console.log(`No markets found matching "${query}"`);
+        return;
+    }
+    console.log(`Found ${results.length} market(s) matching "${query}":\n`);
+    console.log('Type     Provider         Coin           AssetID    Price            24h Volume    Funding (Ann.)  OI');
+    console.log('-'.repeat(112));
+    for (const m of results) {
+        const typeStr = m.type === 'hip3' ? 'HIP-3' : m.type === 'outcome' ? 'HIP-4' : m.type.charAt(0).toUpperCase() + m.type.slice(1);
+        const oi = m.openInterest ? formatVolume(parseFloat(m.openInterest)) : '-';
+        console.log(`${typeStr.padEnd(8)} ${m.provider.padEnd(16)} ${m.coin.padEnd(14)} ${String(m.assetId).padStart(7)}    ${formatPrice(m.price).padStart(16)} ${formatVolume(m.volume24h).padStart(13)} ${(m.funding ? formatFunding(m.funding) : '-').padStart(14)} ${oi.padStart(10)}`);
+        if (m.type === 'outcome' && args.verbose) {
+            console.log(`         Outcome ${m.outcome} ${m.outcomeSide}: ${m.description}`);
+        }
+    }
+    // Show comparison if same asset on multiple providers
+    const coinGroups = new Map();
+    for (const r of results) {
+        // Extract base asset name (strip /USDC, -PERP, etc.)
+        const baseCoin = r.coin.replace(/[-\/].*/, '').toUpperCase();
+        if (!coinGroups.has(baseCoin)) {
+            coinGroups.set(baseCoin, []);
+        }
+        coinGroups.get(baseCoin).push(r);
+    }
+    // Show funding comparison for assets with multiple providers
+    for (const [coin, markets] of coinGroups) {
+        const perpsWithFunding = markets.filter((m) => m.funding && m.type !== 'spot');
+        if (perpsWithFunding.length > 1) {
+            console.log(`\n=== ${coin} Funding Comparison ===\n`);
+            console.log('Provider         Coin           AssetID    Funding (Ann.)    Price');
+            console.log('-'.repeat(78));
+            for (const m of perpsWithFunding.sort((a, b) => parseFloat(b.funding) - parseFloat(a.funding))) {
+                console.log(`${m.provider.padEnd(16)} ${m.coin.padEnd(14)} ${String(m.assetId).padStart(7)}    ${formatFunding(m.funding).padStart(14)}    ${formatPrice(m.price)}`);
+            }
+        }
+    }
+}
+main().catch((e) => {
+    console.error('Error:', e.message);
+    process.exit(1);
+});

package/dist/info/spot.d.ts

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

package/dist/info/spot.d.ts.map

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

package/dist/info/spot.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env tsx
+// Spot Markets - View spot markets and balances
+import { getClient } from '../core/client.js';
+function parseArgs() {
+    const args = {};
+    for (let i = 2; i < process.argv.length; i++) {
+        const arg = process.argv[i];
+        if (arg === '--coin' && process.argv[i + 1]) {
+            args.coin = process.argv[++i].toUpperCase();
+        }
+        else if (arg === '--balances') {
+            args.balances = true;
+        }
+        else if (arg === '--top' && process.argv[i + 1]) {
+            args.top = parseInt(process.argv[++i], 10);
+        }
+        else if (arg === '--address' && process.argv[i + 1]) {
+            args.address = process.argv[++i].toLowerCase();
+        }
+        else if (arg === '--verbose') {
+            args.verbose = true;
+        }
+        else if (arg === '--json') {
+            args.json = true;
+        }
+        else if (arg === '--help' || arg === '-h') {
+            console.log(`
+Spot Markets - View Hyperliquid spot markets and balances
+
+Usage: npx tsx scripts/info/spot.ts [options]
+
+Options:
+  --coin <symbol>      Filter by coin symbol
+  --balances           Show your spot token balances
+  --address <0x...>    Look up another account's spot balances (with --balances)
+  --top <n>            Show only top N markets by volume
+  --json               Output as JSON (machine-readable)
+  --verbose            Show detailed output
+  --help               Show this help
+
+Examples:
+  npx tsx scripts/info/spot.ts                  # Show all spot markets
+  npx tsx scripts/info/spot.ts --coin PURR     # Show PURR market info
+  npx tsx scripts/info/spot.ts --balances      # Show your spot balances
+  npx tsx scripts/info/spot.ts --top 20        # Show top 20 by volume
+`);
+            process.exit(0);
+        }
+    }
+    return args;
+}
+function formatVolume(vol) {
+    if (vol >= 1_000_000_000)
+        return `$${(vol / 1_000_000_000).toFixed(2)}B`;
+    if (vol >= 1_000_000)
+        return `$${(vol / 1_000_000).toFixed(2)}M`;
+    if (vol >= 1_000)
+        return `$${(vol / 1_000).toFixed(2)}K`;
+    return `$${vol.toFixed(2)}`;
+}
+function formatPrice(price) {
+    const p = typeof price === 'string' ? parseFloat(price) : price;
+    if (p >= 1000)
+        return p.toFixed(2);
+    if (p >= 1)
+        return p.toFixed(4);
+    if (p >= 0.01)
+        return p.toFixed(6);
+    return p.toFixed(8);
+}
+function formatChange(current, prev) {
+    const c = parseFloat(current);
+    const p = parseFloat(prev);
+    if (p === 0)
+        return '-';
+    const change = ((c - p) / p) * 100;
+    const sign = change >= 0 ? '+' : '';
+    return `${sign}${change.toFixed(2)}%`;
+}
+async function main() {
+    const args = parseArgs();
+    const client = getClient();
+    client.verbose = args.verbose ?? false;
+    // Show balances
+    if (args.balances) {
+        const lookupAddress = args.address ?? client.address;
+        if (!args.json)
+            console.log(`Fetching spot balances for ${lookupAddress}...\n`);
+        const balances = await client.getSpotBalances(args.address);
+        if (args.json) {
+            console.log(JSON.stringify(balances.balances ?? [], null, 2));
+            return;
+        }
+        if (!balances.balances || balances.balances.length === 0) {
+            console.log('No spot token balances found.');
+            return;
+        }
+        console.log('=== Spot Balances ===\n');
+        console.log('Token          Total              Hold               Entry Value');
+        console.log('-'.repeat(70));
+        for (const b of balances.balances) {
+            const total = parseFloat(b.total);
+            const hold = parseFloat(b.hold);
+            const entry = parseFloat(b.entryNtl);
+            if (total === 0)
+                continue;
+            console.log(`${b.coin.padEnd(14)} ${total.toFixed(6).padStart(18)} ${hold.toFixed(6).padStart(18)} ${formatVolume(entry).padStart(15)}`);
+        }
+        return;
+    }
+    // Show markets
+    if (!args.json)
+        console.log('Fetching spot market data...\n');
+    const spotData = await client.getSpotMetaAndAssetCtxs();
+    const markets = [];
+    // Build ctx map by coin name — the contexts array is NOT aligned with universe by index.
+    // Each context has a 'coin' field matching pair.name.
+    const ctxMap = new Map();
+    for (const ctx of spotData.assetCtxs) {
+        if (ctx.coin)
+            ctxMap.set(ctx.coin, ctx);
+    }
+    // Build token name map for filtering by base token name
+    const tokenNameMap = new Map();
+    for (const token of spotData.meta.tokens) {
+        tokenNameMap.set(token.index, token.name);
+    }
+    for (const pair of spotData.meta.universe) {
+        if (!pair)
+            continue;
+        const ctx = ctxMap.get(pair.name);
+        if (!ctx)
+            continue;
+        // Filter by coin — match pair name or base token name
+        if (args.coin) {
+            const baseTokenName = tokenNameMap.get(pair.tokens[0]) ?? '';
+            const searchable = `${pair.name} ${baseTokenName}`.toUpperCase();
+            if (!searchable.includes(args.coin))
+                continue;
+        }
+        markets.push({
+            name: pair.name,
+            index: pair.index,
+            assetId: 10000 + pair.index,
+            price: ctx.markPx,
+            volume24h: parseFloat(ctx.dayNtlVlm || '0'),
+            change24h: formatChange(ctx.markPx, ctx.prevDayPx),
+            tokens: pair.tokens,
+            base: tokenNameMap.get(pair.tokens[0]),
+            quote: tokenNameMap.get(pair.tokens[1]),
+        });
+    }
+    // Sort by volume
+    markets.sort((a, b) => b.volume24h - a.volume24h);
+    // Apply top filter
+    const displayMarkets = args.top ? markets.slice(0, args.top) : markets;
+    if (args.json) {
+        console.log(JSON.stringify(displayMarkets, null, 2));
+        return;
+    }
+    if (displayMarkets.length === 0) {
+        console.log(args.coin ? `No spot markets found for "${args.coin}"` : 'No spot markets found');
+        return;
+    }
+    // Get token info for detailed display
+    const tokenMap = new Map();
+    for (const token of spotData.meta.tokens) {
+        tokenMap.set(token.index, { name: token.name, tokenId: token.tokenId });
+    }
+    console.log(`=== Spot Markets (${displayMarkets.length} total) ===\n`);
+    console.log('Pair           AssetID    Price            24h Volume    24h Change   Base/Quote');
+    console.log('-'.repeat(92));
+    for (const m of displayMarkets) {
+        const baseToken = tokenMap.get(m.tokens[0]);
+        const quoteToken = tokenMap.get(m.tokens[1]);
+        const pairStr = `${baseToken?.name || '?'}/${quoteToken?.name || '?'}`;
+        console.log(`${m.name.padEnd(14)} ${String(m.assetId).padStart(7)}    ${formatPrice(m.price).padStart(16)} ${formatVolume(m.volume24h).padStart(13)} ${m.change24h.padStart(11)}   ${pairStr}`);
+    }
+    // Show tokens if verbose
+    if (args.verbose) {
+        console.log('\n=== Tokens ===\n');
+        console.log('Name           Token ID         Decimals');
+        console.log('-'.repeat(50));
+        for (const token of spotData.meta.tokens) {
+            console.log(`${token.name.padEnd(14)} ${token.tokenId.padEnd(16)} sz=${token.szDecimals}, wei=${token.weiDecimals}`);
+        }
+    }
+}
+main().catch((e) => {
+    console.error('Error:', e.message);
+    process.exit(1);
+});

package/dist/info/trades.d.ts

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

package/dist/info/trades.d.ts.map

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

package/dist/info/trades.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env npx tsx
+// View recent trades (tape) for an asset on Hyperliquid
+import { getClient } from '../core/client.js';
+import { formatUsd, parseArgs, normalizeCoin } from '../core/utils.js';
+function printUsage() {
+    console.log(`
+Usage: openbroker trades --coin <symbol> [options]
+
+Options:
+  --coin <symbol>   Asset symbol (required, e.g. ETH, BTC)
+  --top <n>         Show last N trades (default: 30)
+  --json            Output as JSON (machine-readable)
+  --help, -h        Show this help
+
+Examples:
+  openbroker trades --coin ETH
+  openbroker trades --coin BTC --top 50
+`);
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help || args.h) {
+        printUsage();
+        process.exit(0);
+    }
+    const coin = args.coin;
+    if (!coin) {
+        console.error('Error: --coin is required');
+        printUsage();
+        process.exit(1);
+    }
+    const top = parseInt(args.top) || 30;
+    const jsonOutput = args.json;
+    const client = getClient();
+    if (!jsonOutput) {
+        console.log(`Open Broker - ${normalizeCoin(coin)} Recent Trades`);
+        console.log('='.repeat(40) + '\n');
+    }
+    try {
+        // Load metadata (needed for HIP-3 coin resolution)
+        await client.getMetaAndAssetCtxs();
+        if (client.isTestnet && coin.includes(':')) {
+            await client.loadSingleHip3Dex(coin.split(':')[0]);
+        }
+        let trades = await client.getRecentTrades(normalizeCoin(coin));
+        // Most recent first
+        trades.sort((a, b) => b.time - a.time);
+        trades = trades.slice(0, top);
+        if (jsonOutput) {
+            let assetId = -1;
+            try {
+                assetId = client.getAssetIndex(normalizeCoin(coin));
+            }
+            catch { /* noop */ }
+            console.log(JSON.stringify({ coin: normalizeCoin(coin), assetId, trades }, null, 2));
+            return;
+        }
+        if (trades.length === 0) {
+            console.log('No recent trades found');
+            return;
+        }
+        // Table header
+        console.log('Time'.padEnd(20) +
+            'Side'.padEnd(6) +
+            'Size'.padEnd(14) +
+            'Price');
+        console.log('─'.repeat(55));
+        let totalVol = 0;
+        let buyVol = 0;
+        let sellVol = 0;
+        for (const trade of trades) {
+            const time = new Date(trade.time).toLocaleString();
+            const side = trade.side === 'B' ? 'BUY' : 'SELL';
+            const notional = parseFloat(trade.px) * parseFloat(trade.sz);
+            totalVol += notional;
+            if (trade.side === 'B')
+                buyVol += notional;
+            else
+                sellVol += notional;
+            console.log(time.padEnd(20) +
+                side.padEnd(6) +
+                trade.sz.padEnd(14) +
+                formatUsd(parseFloat(trade.px)));
+        }
+        // Summary
+        console.log('─'.repeat(55));
+        console.log(`Trades: ${trades.length}  |  Volume: ${formatUsd(totalVol)}`);
+        const buyPct = totalVol > 0 ? (buyVol / totalVol * 100).toFixed(1) : '0';
+        const sellPct = totalVol > 0 ? (sellVol / totalVol * 100).toFixed(1) : '0';
+        console.log(`Buy: ${buyPct}%  |  Sell: ${sellPct}%`);
+    }
+    catch (error) {
+        console.error('Error fetching trades:', error);
+        process.exit(1);
+    }
+}
+main();

package/dist/lib.d.ts

@@ -0,0 +1,14 @@
+export { HyperliquidClient, getClient, } from './core/client.js';
+export { loadConfig, isConfigured, getNetwork, isMainnet, ensureConfigDir, getConfigPath, GLOBAL_CONFIG_DIR, GLOBAL_ENV_PATH, OPEN_BROKER_BUILDER_ADDRESS, } from './core/config.js';
+export { roundPrice, roundSize, sleep, normalizeCoin, formatUsd, formatPercent, annualizeFundingRate, parseArgs, getSlippagePrice, getTimestampMs, generateCloid, orderToWire, checkBuilderFeeApproval, } from './core/utils.js';
+export type * from './core/types.js';
+export { runBracket } from './operations/bracket.js';
+export type { BracketOptions, BracketResult } from './operations/bracket.js';
+export { runChase } from './operations/chase.js';
+export type { ChaseOptions, ChaseResult } from './operations/chase.js';
+export { startAutomation, getRunningAutomations, getAutomation, getRegisteredAutomations, } from './auto/runtime.js';
+export type { RuntimeOptions } from './auto/runtime.js';
+export { resolveScriptPath, resolveExamplePath, listAutomations, listExamples, loadExampleConfigs, ensureAutomationsDir, loadAutomation, } from './auto/loader.js';
+export { registerAutomation, unregisterAutomation, cleanRegistry, getAutomationsToRestart, markAutomationError, } from './auto/registry.js';
+export type * from './auto/types.js';
+//# sourceMappingURL=lib.d.ts.map

package/dist/lib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../scripts/lib.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,iBAAiB,EACjB,SAAS,GACV,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,UAAU,EACV,YAAY,EACZ,UAAU,EACV,SAAS,EACT,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,2BAA2B,GAC5B,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,UAAU,EACV,SAAS,EACT,KAAK,EACL,aAAa,EACb,SAAS,EACT,aAAa,EACb,oBAAoB,EACpB,SAAS,EACT,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,WAAW,EACX,uBAAuB,GACxB,MAAM,iBAAiB,CAAC;AAEzB,mBAAmB,iBAAiB,CAAC;AAIrC,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7E,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAIvE,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,aAAa,EACb,wBAAwB,GACzB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,YAAY,EACZ,kBAAkB,EAClB,oBAAoB,EACpB,cAAc,GACf,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,aAAa,EACb,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,oBAAoB,CAAC;AAE5B,mBAAmB,iBAAiB,CAAC"}

package/dist/lib.js

@@ -0,0 +1,17 @@
+// Public library API for `openbroker`.
+//
+// External packages — notably `openbroker-plugin` — import from here to
+// drive the CLI's functionality in-process (no `child_process` dispatch).
+//
+// Stability: every symbol re-exported here is a public API. Renames or
+// removals are breaking changes and require a major version bump.
+export { HyperliquidClient, getClient, } from './core/client.js';
+export { loadConfig, isConfigured, getNetwork, isMainnet, ensureConfigDir, getConfigPath, GLOBAL_CONFIG_DIR, GLOBAL_ENV_PATH, OPEN_BROKER_BUILDER_ADDRESS, } from './core/config.js';
+export { roundPrice, roundSize, sleep, normalizeCoin, formatUsd, formatPercent, annualizeFundingRate, parseArgs, getSlippagePrice, getTimestampMs, generateCloid, orderToWire, checkBuilderFeeApproval, } from './core/utils.js';
+// ── Operations (in-process callable) ────────────────────────────────
+export { runBracket } from './operations/bracket.js';
+export { runChase } from './operations/chase.js';
+// ── Automation runtime ──────────────────────────────────────────────
+export { startAutomation, getRunningAutomations, getAutomation, getRegisteredAutomations, } from './auto/runtime.js';
+export { resolveScriptPath, resolveExamplePath, listAutomations, listExamples, loadExampleConfigs, ensureAutomationsDir, loadAutomation, } from './auto/loader.js';
+export { registerAutomation, unregisterAutomation, cleanRegistry, getAutomationsToRestart, markAutomationError, } from './auto/registry.js';

package/dist/operations/bracket.d.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env npx tsx
+export interface BracketOptions {
+    coin: string;
+    side: 'buy' | 'sell';
+    size: number;
+    tpPct: number;
+    slPct: number;
+    entryType?: 'market' | 'limit';
+    entryPrice?: number;
+    slippage?: number;
+    leverage?: number;
+    dryRun?: boolean;
+    verbose?: boolean;
+    /** Receives each output line. Defaults to console.log. */
+    output?: (line: string) => void;
+}
+export interface BracketResult {
+    status: 'dry' | 'limit_resting' | 'complete' | 'entry_failed' | 'partial';
+    entryPrice?: number;
+    tpPrice?: number;
+    slPrice?: number;
+    tpOid?: number | null;
+    slOid?: number | null;
+    entryOid?: number | null;
+    reason?: string;
+}
+export declare function runBracket(opts: BracketOptions): Promise<BracketResult>;
+//# sourceMappingURL=bracket.d.ts.map

package/dist/operations/bracket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bracket.d.ts","sourceRoot":"","sources":["../../scripts/operations/bracket.ts"],"names":[],"mappings":";AA8CA,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,KAAK,GAAG,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,KAAK,GAAG,eAAe,GAAG,UAAU,GAAG,cAAc,GAAG,SAAS,CAAC;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAsL7E"}