openbroker 1.3.1 → 1.4.0

package/dist/auto/cli.js

@@ -0,0 +1,423 @@
+// CLI entry point for `openbroker auto` commands
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import { parseArgs } from '../core/utils.js';
+import { resolveScriptPath, resolveExamplePath, listAutomations, listExamples, loadExampleConfigs, ensureAutomationsDir } from './loader.js';
+import { startAutomation, getRunningAutomations, getRegisteredAutomations } from './runtime.js';
+import { unregisterAutomation, cleanRegistry } from './registry.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function printUsage() {
+    console.log(`
+OpenBroker Automations — event-driven trading scripts
+
+Usage:
+  openbroker auto run <script> [options]    Run an automation script
+  openbroker auto run --example <name>      Run a bundled example automation
+  openbroker auto report <id>               Read the local audit report for an automation
+  openbroker auto examples                  List bundled example automations
+  openbroker auto stop <id>                 Unregister an automation (won't restart)
+  openbroker auto list                      List available automations
+  openbroker auto status                    Show running automations
+  openbroker auto clean                     Remove stale entries from registry + reconcile audit DB
+  openbroker auto prune [options]           Delete stale runs from the audit DB
+
+Options (for run):
+  --example <name>   Run a bundled example (dca, grid, funding-arb, mm-spread, mm-maker)
+  --set key=value    Set config values (repeatable, auto-parses numbers/booleans)
+  --dry              Intercept write methods (no real trades)
+  --verbose          Show debug output
+  --id <name>        Custom automation ID (default: filename)
+  --poll <ms>        Poll interval in milliseconds (default: 10000)
+  --no-ws            Disable WebSocket; fall back to REST-only polling
+  --allow-sleep      Do not request OS idle-sleep inhibition for this run
+
+Options (for prune):
+  --older-than <d>   Only prune runs started before this duration ago (e.g. 7d, 24h)
+  --status <list>    CSV of statuses to consider (default: stopped,error,stale)
+  --keep-last <N>    Keep the N most-recent runs per automation_id
+  --all              Prune everything except runs that are still alive
+  --vacuum           VACUUM the DB after deletion to reclaim disk space
+  --dry              Preview what would be deleted without writing
+
+Scripts are loaded from:
+  1. Absolute or relative path
+  2. ~/.openbroker/automations/<name>.ts
+  3. Bundled examples (via --example)
+
+Writing an automation:
+  export default function(api) {
+    api.on('price_change', async ({ coin, changePct }) => {
+      api.log.info(\`\${coin} moved \${changePct.toFixed(2)}%\`);
+    });
+  }
+
+Events: tick, price_change, funding_update, position_opened,
+        position_closed, position_changed, pnl_threshold, margin_warning
+
+Examples:
+  openbroker auto run --example dca --set coin=BTC --set amount=50 --dry
+  openbroker auto run --example grid --set coin=ETH --set lower=3000 --set upper=4000
+  openbroker auto run my-strategy --dry
+  openbroker auto report hype-mm-v2-live-r4
+  openbroker auto examples
+`);
+}
+/** Parse --set key=value flags from raw args, return parsed config object */
+function parseSetFlags(rawArgs) {
+    const config = {};
+    for (let i = 0; i < rawArgs.length; i++) {
+        if (rawArgs[i] === '--set' && i + 1 < rawArgs.length) {
+            const pair = rawArgs[i + 1];
+            const eqIdx = pair.indexOf('=');
+            if (eqIdx === -1) {
+                console.error(`Error: --set requires key=value format, got: ${pair}`);
+                process.exit(1);
+            }
+            const key = pair.slice(0, eqIdx);
+            const raw = pair.slice(eqIdx + 1);
+            const isHexLike = /^0x[0-9a-fA-F]+$/.test(raw);
+            const isDecimalLike = /^-?(?:\d+|\d+\.\d+|\.\d+)$/.test(raw);
+            // Auto-parse numbers and booleans
+            if (raw === 'true')
+                config[key] = true;
+            else if (raw === 'false')
+                config[key] = false;
+            else if (!isHexLike && isDecimalLike)
+                config[key] = Number(raw);
+            else
+                config[key] = raw;
+            i++; // skip the value
+        }
+    }
+    return config;
+}
+/** Strip --set key=value pairs from raw args so parseArgs doesn't see them */
+function stripSetFlags(rawArgs) {
+    const result = [];
+    for (let i = 0; i < rawArgs.length; i++) {
+        if (rawArgs[i] === '--set' && i + 1 < rawArgs.length) {
+            i++; // skip --set and its value
+        }
+        else {
+            result.push(rawArgs[i]);
+        }
+    }
+    return result;
+}
+async function runCommand(args, positional, initialState) {
+    const exampleName = args.example ? String(args.example) : undefined;
+    const scriptName = positional[0];
+    if (!scriptName && !exampleName) {
+        console.error('Error: script name or path required (or use --example <name>)');
+        console.log('Usage: openbroker auto run <script> [--dry] [--verbose]');
+        console.log('       openbroker auto run --example <name> [--set key=value] [--dry]');
+        process.exit(1);
+    }
+    const scriptPath = exampleName ? resolveExamplePath(exampleName) : resolveScriptPath(scriptName);
+    const dryRun = args.dry === true;
+    const verbose = args.verbose === true;
+    const useWebSocket = args['no-ws'] !== true;
+    const keepAwake = args['allow-sleep'] === true ? false : undefined;
+    const pollIntervalMs = args.poll ? parseInt(String(args.poll), 10) : undefined;
+    const id = args.id ? String(args.id) : undefined;
+    if (args.testnet === true) {
+        process.env.HYPERLIQUID_NETWORK = 'testnet';
+    }
+    else if (args.mainnet === true) {
+        process.env.HYPERLIQUID_NETWORK = 'mainnet';
+    }
+    if (pollIntervalMs !== undefined && (isNaN(pollIntervalMs) || pollIntervalMs < 1000)) {
+        console.error('Error: --poll must be at least 1000ms');
+        process.exit(1);
+    }
+    const envHooksToken = process.env.OPENCLAW_HOOKS_TOKEN;
+    const envGatewayPortStr = process.env.OPENCLAW_GATEWAY_PORT;
+    const envGatewayPort = envGatewayPortStr ? parseInt(envGatewayPortStr, 10) : undefined;
+    const automation = await startAutomation({
+        scriptPath,
+        id,
+        dryRun,
+        verbose,
+        pollIntervalMs,
+        useWebSocket,
+        keepAwake,
+        initialState: Object.keys(initialState).length > 0 ? initialState : undefined,
+        hooksToken: envHooksToken,
+        gatewayPort: envGatewayPort && !isNaN(envGatewayPort) ? envGatewayPort : undefined,
+    });
+    // Graceful shutdown on SIGINT/SIGTERM
+    const shutdown = async () => {
+        console.log('\nShutting down...');
+        await automation.stop();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    // Keep process alive
+    await new Promise(() => { });
+}
+async function examplesCommand() {
+    const configs = await loadExampleConfigs();
+    const names = Object.keys(configs);
+    if (names.length === 0) {
+        console.log('No bundled examples found.');
+        return;
+    }
+    console.log('Bundled example automations:\n');
+    for (const name of names) {
+        const cfg = configs[name];
+        console.log(`  ${name}`);
+        console.log(`    ${cfg.description}\n`);
+        console.log(`    Config (--set key=value):`);
+        for (const [key, field] of Object.entries(cfg.fields)) {
+            const def = JSON.stringify(field.default);
+            console.log(`      ${key.padEnd(14)} ${field.type.padEnd(8)} ${field.description} (default: ${def})`);
+        }
+        console.log('');
+    }
+    console.log(`Run with: openbroker auto run --example <name> [--set key=value] [--dry]`);
+    console.log('Copy to ~/.openbroker/automations/ to customize.');
+}
+function listCommand() {
+    ensureAutomationsDir();
+    const automations = listAutomations();
+    const examples = listExamples();
+    if (automations.length === 0 && examples.length === 0) {
+        console.log('No automations found in ~/.openbroker/automations/');
+        console.log('\nCreate a .ts file there with:');
+        console.log('  export default function(api) { ... }');
+        console.log('\nOr run a bundled example: openbroker auto examples');
+        return;
+    }
+    if (automations.length > 0) {
+        console.log('User automations (~/.openbroker/automations/):\n');
+        for (const a of automations) {
+            console.log(`  ${a.name.padEnd(30)} ${a.path}`);
+        }
+        console.log(`\nRun with: openbroker auto run <name>`);
+    }
+    if (examples.length > 0) {
+        if (automations.length > 0)
+            console.log('');
+        console.log(`${examples.length} bundled examples available — run: openbroker auto examples`);
+    }
+}
+function statusCommand() {
+    // Show in-process automations (if any running in this process)
+    const inProcess = getRunningAutomations();
+    // Show all registered automations from file-based registry (cross-process)
+    const registered = getRegisteredAutomations();
+    if (inProcess.length === 0 && registered.length === 0) {
+        console.log('No automations running');
+        return;
+    }
+    // Show in-process automations with live stats
+    if (inProcess.length > 0) {
+        console.log('Running in this process:\n');
+        for (const a of inProcess) {
+            const uptime = Math.round((Date.now() - a.startedAt.getTime()) / 1000);
+            console.log(`  ${a.id}`);
+            console.log(`    Script:  ${a.scriptPath}`);
+            console.log(`    Uptime:  ${uptime}s`);
+            console.log(`    Polls:   ${a.pollCount}`);
+            console.log(`    Events:  ${a.eventsEmitted}`);
+            console.log(`    Dry run: ${a.dryRun}`);
+            console.log('');
+        }
+    }
+    // Show all registered automations (may include ones from other processes)
+    const external = registered.filter(r => !inProcess.some(ip => ip.id === r.id));
+    if (external.length > 0) {
+        if (inProcess.length > 0)
+            console.log('Other processes:\n');
+        else
+            console.log('Registered automations:\n');
+        for (const a of external) {
+            const uptime = a.status === 'running'
+                ? `${Math.round((Date.now() - new Date(a.startedAt).getTime()) / 1000)}s`
+                : '-';
+            console.log(`  ${a.id}`);
+            console.log(`    Script:  ${a.scriptPath}`);
+            console.log(`    Status:  ${a.status}${a.error ? ` (${a.error})` : ''}`);
+            console.log(`    PID:     ${a.pid}`);
+            console.log(`    Uptime:  ${uptime}`);
+            console.log(`    Dry run: ${a.dryRun}`);
+            console.log('');
+        }
+    }
+}
+function stopCommand(positional) {
+    const id = positional[0];
+    if (!id) {
+        console.error('Error: automation ID required');
+        console.log('Usage: openbroker auto stop <id>');
+        process.exit(1);
+    }
+    // Check if running in this process
+    const inProcess = getRunningAutomations();
+    const running = inProcess.find(a => a.id === id);
+    if (running) {
+        running.stop().then(() => {
+            console.log(`Stopped and unregistered: ${id}`);
+        });
+        return;
+    }
+    // Otherwise just remove from file registry (prevents restart)
+    unregisterAutomation(id);
+    console.log(`Unregistered: ${id} (will not restart on next gateway start)`);
+}
+async function cleanCommand() {
+    cleanRegistry();
+    console.log('Cleaned stale entries from registry');
+    // Also reconcile the audit DB so dead processes whose rows still say
+    // 'running' get marked 'stopped'. Without this, the dashboard keeps showing
+    // 'stale' badges for automations the operator already cleaned out of the
+    // registry.
+    try {
+        const { prune } = await import('./prune.js');
+        const result = prune({ reconcileOnly: true });
+        if (result.reconciled > 0) {
+            console.log(`Reconciled ${result.reconciled} orphan run row${result.reconciled === 1 ? '' : 's'} in audit DB (status: running → stopped)`);
+        }
+        else {
+            console.log('Audit DB already consistent');
+        }
+    }
+    catch (err) {
+        console.warn(`Could not reconcile audit DB: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+async function pruneCommand(args) {
+    const { fmtBytes, parseDuration, prune } = await import('./prune.js');
+    const olderThanRaw = args['older-than'];
+    const olderThanMs = typeof olderThanRaw === 'string' ? parseDuration(olderThanRaw) : undefined;
+    const statusesRaw = typeof args.status === 'string' ? args.status : undefined;
+    const statuses = statusesRaw
+        ? new Set(statusesRaw.split(',').map((s) => s.trim()).filter(Boolean))
+        : undefined;
+    const keepLastRaw = args['keep-last'];
+    const keepLast = typeof keepLastRaw === 'string' ? Number(keepLastRaw)
+        : typeof keepLastRaw === 'number' ? keepLastRaw
+            : undefined;
+    if (keepLast !== undefined && (!Number.isFinite(keepLast) || keepLast < 0)) {
+        console.error('Error: --keep-last must be a non-negative integer');
+        process.exit(1);
+    }
+    const opts = {
+        olderThanMs,
+        statuses,
+        keepLastPerAutomation: keepLast,
+        all: args.all === true,
+        vacuum: args.vacuum === true,
+        dryRun: args.dry === true,
+    };
+    const result = prune(opts);
+    if (result.reconciled > 0) {
+        const verb = result.dryRun ? 'Would reconcile' : 'Reconciled';
+        console.log(`${verb} ${result.reconciled} orphan run row${result.reconciled === 1 ? '' : 's'} (running → stopped)`);
+    }
+    const verb = result.dryRun ? 'Would delete' : 'Deleted';
+    if (result.candidateRunIds.length === 0) {
+        console.log('No runs matched pruning filters.');
+        return;
+    }
+    console.log(`${verb} ${result.candidateRunIds.length} automation run${result.candidateRunIds.length === 1 ? '' : 's'}:`);
+    for (const id of result.candidateRunIds.slice(0, 25)) {
+        console.log(`  · ${id}`);
+    }
+    if (result.candidateRunIds.length > 25) {
+        console.log(`  … and ${result.candidateRunIds.length - 25} more`);
+    }
+    if (!result.dryRun) {
+        const totalChild = Object.values(result.deletedRows).reduce((a, b) => a + b, 0);
+        console.log(`Removed ${totalChild.toLocaleString()} child rows across ${Object.keys(result.deletedRows).length} tables`);
+        if (result.freedBytes > 0) {
+            console.log(`Reclaimed ~${fmtBytes(result.freedBytes)}${opts.vacuum ? ' (post-VACUUM)' : ''}`);
+        }
+        else if (opts.vacuum) {
+            console.log('No disk reclaimed (VACUUM completed)');
+        }
+        else {
+            console.log('Run again with --vacuum to reclaim disk space.');
+        }
+    }
+}
+function reportCommand(rawArgs) {
+    const scriptPath = path.join(__dirname, 'report.ts');
+    const result = spawnSync(process.execPath, ['--experimental-sqlite', '--no-warnings', '--import', 'tsx', scriptPath, ...rawArgs], {
+        stdio: 'inherit',
+        cwd: path.resolve(__dirname, '../..'),
+        env: { ...process.env },
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    if (typeof result.status === 'number' && result.status !== 0) {
+        process.exit(result.status);
+    }
+}
+async function main() {
+    const rawArgs = process.argv.slice(2);
+    if (rawArgs.length === 0 || rawArgs[0] === '--help' || rawArgs[0] === '-h') {
+        printUsage();
+        process.exit(0);
+    }
+    const subcommand = rawArgs[0];
+    const restArgs = rawArgs.slice(1);
+    // Parse --set flags before stripping them
+    const initialState = parseSetFlags(restArgs);
+    const cleanedArgs = stripSetFlags(restArgs);
+    // Extract positional args (non-flag args)
+    const positional = [];
+    const flagArgs = [];
+    for (let i = 0; i < cleanedArgs.length; i++) {
+        if (cleanedArgs[i].startsWith('--')) {
+            flagArgs.push(cleanedArgs[i]);
+            // If next arg doesn't start with --, it's a flag value
+            if (i + 1 < cleanedArgs.length && !cleanedArgs[i + 1].startsWith('--')) {
+                flagArgs.push(cleanedArgs[i + 1]);
+                i++;
+            }
+        }
+        else {
+            positional.push(cleanedArgs[i]);
+        }
+    }
+    const args = parseArgs(flagArgs);
+    switch (subcommand) {
+        case 'run':
+            await runCommand(args, positional, initialState);
+            break;
+        case 'stop':
+            stopCommand(positional);
+            break;
+        case 'list':
+            listCommand();
+            break;
+        case 'examples':
+            await examplesCommand();
+            break;
+        case 'status':
+            statusCommand();
+            break;
+        case 'clean':
+            await cleanCommand();
+            break;
+        case 'prune':
+            await pruneCommand(args);
+            break;
+        case 'report':
+            reportCommand(restArgs);
+            break;
+        default:
+            console.error(`Unknown subcommand: ${subcommand}`);
+            console.log('Run "openbroker auto --help" for usage');
+            process.exit(1);
+    }
+}
+main().catch(err => {
+    console.error(err.message || err);
+    process.exit(1);
+});

package/dist/auto/events.d.ts

@@ -0,0 +1,11 @@
+import type { AutomationEventType, AutomationEventPayloads, AutomationEventHandler } from './types.js';
+export declare class AutomationEventBus {
+    private handlers;
+    on<E extends AutomationEventType>(event: E, handler: AutomationEventHandler<E>): void;
+    /** Emit an event — handlers run sequentially, errors are returned (not thrown) */
+    emit<E extends AutomationEventType>(event: E, payload: AutomationEventPayloads[E]): Promise<Error[]>;
+    /** Check if any handlers are registered for an event */
+    has(event: AutomationEventType): boolean;
+    removeAll(): void;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/auto/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../scripts/auto/events.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAEpB,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAiD;IAEjE,EAAE,CAAC,CAAC,SAAS,mBAAmB,EAC9B,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,sBAAsB,CAAC,CAAC,CAAC,GACjC,IAAI;IASP,kFAAkF;IAC5E,IAAI,CAAC,CAAC,SAAS,mBAAmB,EACtC,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAClC,OAAO,CAAC,KAAK,EAAE,CAAC;IAenB,wDAAwD;IACxD,GAAG,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO;IAKxC,SAAS,IAAI,IAAI;CAGlB"}

package/dist/auto/events.js

@@ -0,0 +1,36 @@
+// Lightweight typed event bus for the automation runtime
+export class AutomationEventBus {
+    handlers = new Map();
+    on(event, handler) {
+        let set = this.handlers.get(event);
+        if (!set) {
+            set = new Set();
+            this.handlers.set(event, set);
+        }
+        set.add(handler);
+    }
+    /** Emit an event — handlers run sequentially, errors are returned (not thrown) */
+    async emit(event, payload) {
+        const set = this.handlers.get(event);
+        if (!set || set.size === 0)
+            return [];
+        const errors = [];
+        for (const handler of set) {
+            try {
+                await handler(payload);
+            }
+            catch (err) {
+                errors.push(err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+        return errors;
+    }
+    /** Check if any handlers are registered for an event */
+    has(event) {
+        const set = this.handlers.get(event);
+        return set !== undefined && set.size > 0;
+    }
+    removeAll() {
+        this.handlers.clear();
+    }
+}

package/dist/auto/examples/dca.d.ts

@@ -0,0 +1,4 @@
+import type { AutomationAPI, AutomationConfig } from '../types.js';
+export declare const config: AutomationConfig;
+export default function dca(api: AutomationAPI): void;
+//# sourceMappingURL=dca.d.ts.map

package/dist/auto/examples/dca.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dca.d.ts","sourceRoot":"","sources":["../../../scripts/auto/examples/dca.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEnE,eAAO,MAAM,MAAM,EAAE,gBAQpB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,GAAG,CAAC,GAAG,EAAE,aAAa,QAyD7C"}

package/dist/auto/examples/dca.js

@@ -0,0 +1,60 @@
+// DCA (Dollar Cost Averaging) — Buy fixed USD amounts at regular intervals
+export const config = {
+    description: 'Dollar cost averaging — buy fixed USD amounts at regular intervals',
+    fields: {
+        coin: { type: 'string', description: 'Asset to accumulate', default: 'HYPE' },
+        amount: { type: 'number', description: 'USD per purchase', default: 100 },
+        interval: { type: 'number', description: 'Milliseconds between buys (3600000 = 1h)', default: 3_600_000 },
+        count: { type: 'number', description: 'Total number of purchases', default: 24 },
+    },
+};
+export default function dca(api) {
+    const COIN = api.state.get('coin', 'HYPE');
+    const AMOUNT_USD = api.state.get('amount', 100);
+    const INTERVAL_MS = api.state.get('interval', 3_600_000);
+    const MAX_PURCHASES = api.state.get('count', 24);
+    let purchased = api.state.get('purchased', 0);
+    let totalSpent = api.state.get('totalSpent', 0);
+    let totalAcquired = api.state.get('totalAcquired', 0);
+    api.onStart(() => {
+        api.log.info(`DCA: ${MAX_PURCHASES} buys of $${AMOUNT_USD} ${COIN} every ${INTERVAL_MS / 60000}m`);
+        api.log.info(`Progress: ${purchased}/${MAX_PURCHASES} completed`);
+    });
+    api.every(INTERVAL_MS, async () => {
+        if (purchased >= MAX_PURCHASES) {
+            api.log.info(`DCA complete: ${purchased} purchases, $${totalSpent.toFixed(2)} spent, ${totalAcquired.toFixed(6)} ${COIN} acquired`);
+            return;
+        }
+        const mids = await api.client.getAllMids();
+        const price = parseFloat(mids[COIN]);
+        if (!price) {
+            api.log.warn(`No price for ${COIN}, skipping`);
+            return;
+        }
+        const size = AMOUNT_USD / price;
+        api.log.info(`[${purchased + 1}/${MAX_PURCHASES}] Buying ~$${AMOUNT_USD} of ${COIN} @ $${price.toFixed(2)}`);
+        const response = await api.client.marketOrder(COIN, true, size);
+        if (response.status === 'ok' && response.response && typeof response.response === 'object') {
+            const status = response.response.data.statuses[0];
+            if (status?.filled) {
+                const filledSize = parseFloat(status.filled.totalSz);
+                const avgPx = parseFloat(status.filled.avgPx);
+                totalSpent += filledSize * avgPx;
+                totalAcquired += filledSize;
+                purchased++;
+                api.state.set('purchased', purchased);
+                api.state.set('totalSpent', totalSpent);
+                api.state.set('totalAcquired', totalAcquired);
+                const avgPrice = totalSpent / totalAcquired;
+                api.log.info(`Filled ${filledSize.toFixed(6)} @ $${avgPx.toFixed(2)} | Avg: $${avgPrice.toFixed(2)} | Total: ${totalAcquired.toFixed(6)} ${COIN}`);
+            }
+            else if (status?.error) {
+                api.log.error(`Order failed: ${status.error}`);
+            }
+        }
+    });
+    api.onStop(() => {
+        const avgPrice = totalAcquired > 0 ? totalSpent / totalAcquired : 0;
+        api.log.info(`DCA stopped: ${purchased}/${MAX_PURCHASES} | Spent: $${totalSpent.toFixed(2)} | Acquired: ${totalAcquired.toFixed(6)} ${COIN} | Avg: $${avgPrice.toFixed(2)}`);
+    });
+}

package/dist/auto/examples/funding-arb.d.ts

@@ -0,0 +1,4 @@
+import type { AutomationAPI, AutomationConfig } from '../types.js';
+export declare const config: AutomationConfig;
+export default function fundingArb(api: AutomationAPI): void;
+//# sourceMappingURL=funding-arb.d.ts.map

package/dist/auto/examples/funding-arb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"funding-arb.d.ts","sourceRoot":"","sources":["../../../scripts/auto/examples/funding-arb.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEnE,eAAO,MAAM,MAAM,EAAE,gBASpB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,GAAG,EAAE,aAAa,QAkFpD"}

package/dist/auto/examples/funding-arb.js

@@ -0,0 +1,81 @@
+// Funding Arbitrage — Collect funding by positioning opposite to the crowd
+export const config = {
+    description: 'Funding arbitrage — collect funding by positioning opposite to the crowd',
+    fields: {
+        coin: { type: 'string', description: 'Asset to trade', default: 'HYPE' },
+        sizeUsd: { type: 'number', description: 'Position size in USD notional', default: 5000 },
+        minFunding: { type: 'number', description: 'Min annualized % to enter', default: 20 },
+        maxFunding: { type: 'number', description: 'Max annualized % — avoid squeezes', default: 200 },
+        closeAt: { type: 'number', description: 'Close when funding drops below this %', default: 5 },
+    },
+};
+export default function fundingArb(api) {
+    const COIN = api.state.get('coin', 'HYPE');
+    const SIZE_USD = api.state.get('sizeUsd', 5000);
+    const MIN_FUNDING = api.state.get('minFunding', 20);
+    const MAX_FUNDING = api.state.get('maxFunding', 200);
+    const CLOSE_AT = api.state.get('closeAt', 5);
+    let inPosition = api.state.get('inPosition', false);
+    let positionSide = api.state.get('positionSide', '');
+    let entryPrice = api.state.get('entryPrice', 0);
+    let positionSize = api.state.get('positionSize', 0);
+    let totalFunding = api.state.get('totalFunding', 0);
+    api.onStart(() => {
+        api.log.info(`Funding arb: ${COIN} | $${SIZE_USD} | Enter >${MIN_FUNDING}% | Close <${CLOSE_AT}%`);
+        if (inPosition) {
+            api.log.info(`Resuming ${positionSide} position: ${positionSize.toFixed(6)} @ $${entryPrice.toFixed(2)}`);
+        }
+    });
+    api.on('funding_update', async ({ coin, annualized }) => {
+        if (coin !== COIN)
+            return;
+        const annualizedPct = annualized * 100;
+        const absAnnualized = Math.abs(annualizedPct);
+        if (inPosition) {
+            // Check if we should close
+            const shouldClose = (positionSide === 'short' && annualizedPct < CLOSE_AT) ||
+                (positionSide === 'long' && annualizedPct > -CLOSE_AT);
+            if (shouldClose) {
+                api.log.info(`Funding dropped to ${annualizedPct.toFixed(2)}% (below ${CLOSE_AT}%), closing ${positionSide}`);
+                const closeIsBuy = positionSide === 'short';
+                await api.client.marketOrder(coin, closeIsBuy, positionSize);
+                inPosition = false;
+                api.state.set('inPosition', false);
+                api.log.info(`Position closed. Funding collected: ~$${totalFunding.toFixed(2)}`);
+            }
+            else {
+                api.log.debug(`${coin} funding: ${annualizedPct.toFixed(2)}% — holding ${positionSide}`);
+            }
+            return;
+        }
+        // Not in position — check if we should enter
+        if (absAnnualized >= MIN_FUNDING && absAnnualized <= MAX_FUNDING) {
+            const shouldShort = annualizedPct > 0; // Positive = longs pay shorts
+            const side = shouldShort ? 'short' : 'long';
+            const mids = await api.client.getAllMids();
+            const price = parseFloat(mids[coin]);
+            const size = SIZE_USD / price;
+            api.log.info(`Funding at ${annualizedPct.toFixed(2)}% — opening ${side} ${size.toFixed(6)} ${coin}`);
+            const response = await api.client.marketOrder(coin, !shouldShort, size);
+            if (response.status === 'ok' && response.response && typeof response.response === 'object') {
+                const status = response.response.data.statuses[0];
+                if (status?.filled) {
+                    positionSize = parseFloat(status.filled.totalSz);
+                    entryPrice = parseFloat(status.filled.avgPx);
+                    positionSide = side;
+                    inPosition = true;
+                    api.state.set('inPosition', true);
+                    api.state.set('positionSide', side);
+                    api.state.set('entryPrice', entryPrice);
+                    api.state.set('positionSize', positionSize);
+                    api.log.info(`Entered ${side} ${positionSize.toFixed(6)} @ $${entryPrice.toFixed(2)}`);
+                }
+            }
+        }
+    });
+    api.onStop(() => {
+        if (inPosition) {
+            api.log.warn(`Stopping with open ${positionSide} position of ${positionSize.toFixed(6)} ${COIN} — close manually if desired`);
+        }
+    });
+}

package/dist/auto/examples/grid.d.ts

@@ -0,0 +1,4 @@
+import type { AutomationAPI, AutomationConfig } from '../types.js';
+export declare const config: AutomationConfig;
+export default function grid(api: AutomationAPI): void;
+//# sourceMappingURL=grid.d.ts.map

package/dist/auto/examples/grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid.d.ts","sourceRoot":"","sources":["../../../scripts/auto/examples/grid.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEnE,eAAO,MAAM,MAAM,EAAE,gBAUpB,CAAC;AASF,MAAM,CAAC,OAAO,UAAU,IAAI,CAAC,GAAG,EAAE,aAAa,QA+G9C"}