openbroker 1.9.5 → 1.10.0

package/dist/core/utils.js

@@ -112,6 +112,33 @@ export function normalizeCoin(coin) {
 export function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
+/** Hyperliquid rejects orders below this notional (waived for reduce-only). */
+export const MIN_ORDER_NOTIONAL_USD = 10;
+/**
+ * Parse a single entry of an order response's `statuses` array. Handles the
+ * plain-string success states ("waitingForFill" / "waitingForTrigger") that
+ * Hyperliquid returns for normalTpsl children armed behind an unfilled parent,
+ * alongside the usual resting/filled/error objects.
+ */
+export function parseOrderStatus(status) {
+    if (status === 'waitingForFill' || status === 'waitingForTrigger') {
+        return { kind: 'waiting', state: status };
+    }
+    if (status && typeof status === 'object') {
+        const data = status;
+        if (data.resting) {
+            return { kind: 'resting', oid: data.resting.oid };
+        }
+        if (data.filled) {
+            const f = data.filled;
+            return { kind: 'filled', totalSz: parseFloat(f.totalSz), avgPx: parseFloat(f.avgPx), oid: f.oid };
+        }
+        if (data.error) {
+            return { kind: 'error', error: String(data.error) };
+        }
+    }
+    return { kind: 'unknown', raw: status };
+}
 /**
  * Generate a random client order ID
  */

package/dist/lib.d.ts

@@ -2,12 +2,15 @@ export { HyperliquidClient, getClient, } from './core/client.js';
 export { WebSocketManager, getWebSocket, resetWebSocket, } from './core/ws.js';
 export type { WsEventMap, WsEventType, WsEventHandler } from './core/ws.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 { roundPrice, roundSize, sleep, normalizeCoin, formatUsd, formatPercent, annualizeFundingRate, parseArgs, getSlippagePrice, getTimestampMs, generateCloid, orderToWire, checkBuilderFeeApproval, MIN_ORDER_NOTIONAL_USD, parseOrderStatus, } from './core/utils.js';
+export type { ParsedOrderStatus } 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 { runScale, calculateLevels } from './operations/scale.js';
+export type { ScaleOptions, ScaleResult, OrderLevel } from './operations/scale.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';

package/dist/lib.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../scripts/lib.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,iBAAiB,EACjB,SAAS,GACV,MAAM,kBAAkB,CAAC;AAK1B,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,cAAc,GACf,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE5E,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,eAAe,EACf,4BAA4B,EAC5B,2BAA2B,EAC3B,uBAAuB,GACxB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAErE,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,aAAa,EACb,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,oBAAoB,CAAC;AAE5B,mBAAmB,iBAAiB,CAAC"}
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../scripts/lib.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,iBAAiB,EACjB,SAAS,GACV,MAAM,kBAAkB,CAAC;AAK1B,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,cAAc,GACf,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE5E,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,EACvB,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,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;AAEvE,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAClE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAInF,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,eAAe,EACf,4BAA4B,EAC5B,2BAA2B,EAC3B,uBAAuB,GACxB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAErE,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,aAAa,EACb,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,oBAAoB,CAAC;AAE5B,mBAAmB,iBAAiB,CAAC"}

package/dist/lib.js

@@ -11,10 +11,11 @@ export { HyperliquidClient, getClient, } from './core/client.js';
 // REST-polling. `userFill` / `orderUpdate` are emitted per own-order event; see WsEventMap.
 export { WebSocketManager, getWebSocket, resetWebSocket, } from './core/ws.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 { roundPrice, roundSize, sleep, normalizeCoin, formatUsd, formatPercent, annualizeFundingRate, parseArgs, getSlippagePrice, getTimestampMs, generateCloid, orderToWire, checkBuilderFeeApproval, MIN_ORDER_NOTIONAL_USD, parseOrderStatus, } from './core/utils.js';
 // ── Operations (in-process callable) ────────────────────────────────
 export { runBracket } from './operations/bracket.js';
 export { runChase } from './operations/chase.js';
+export { runScale, calculateLevels } from './operations/scale.js';
 // ── Automation runtime ──────────────────────────────────────────────
 export { startAutomation, getRunningAutomations, getAutomation, getRegisteredAutomations, } from './auto/runtime.js';
 export { resolveScriptPath, resolveExamplePath, listAutomations, listExamples, loadExampleConfigs, ensureAutomationsDir, loadAutomation, } from './auto/loader.js';

package/dist/operations/advanced-orders.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=advanced-orders.test.d.ts.map

package/dist/operations/advanced-orders.test.d.ts.map

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

package/dist/operations/advanced-orders.test.js

@@ -0,0 +1,478 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { runBracket } from './bracket.js';
+import { runChase } from './chase.js';
+import { runScale } from './scale.js';
+import { UserFillWatcher } from './execution.js';
+const okOrder = (statuses) => ({
+    status: 'ok',
+    response: { type: 'order', data: { statuses } },
+});
+const okCancel = () => ({
+    status: 'ok',
+    response: { type: 'cancel', data: { statuses: ['success'] } },
+});
+class StaticFillWatcher {
+    fills;
+    constructor(fills) {
+        this.fills = fills;
+    }
+    async start() { }
+    async stop() { }
+    getFilled(oid) {
+        return this.fills.get(oid) ?? { size: 0, notional: 0 };
+    }
+    async waitForFill(oid) {
+        return this.getFilled(oid);
+    }
+}
+function bracketClientStub(overrides = {}) {
+    return {
+        verbose: false,
+        address: '0x0000000000000000000000000000000000000001',
+        async getAllMids() {
+            return { ETH: '1000' };
+        },
+        async marketOrder() {
+            throw new Error('marketOrder should not be called');
+        },
+        async limitOrder() {
+            throw new Error('limitOrder should not be called');
+        },
+        async tpslOrders() {
+            throw new Error('tpslOrders should not be called');
+        },
+        async bracketOrder() {
+            throw new Error('bracketOrder should not be called');
+        },
+        async cancel() {
+            throw new Error('cancel should not be called');
+        },
+        async getUserFills() {
+            return [];
+        },
+        ...overrides,
+    };
+}
+test('scale rejects invalid levels and rolls back resting orders on partial ladder placement', async () => {
+    const cancelled = [];
+    const client = {
+        verbose: false,
+        async getAllMids() {
+            return { ETH: '1000' };
+        },
+        async bulkOrder() {
+            return okOrder([
+                { resting: { oid: 101 } },
+                { error: 'insufficient margin' },
+                { resting: { oid: 103 } },
+            ]);
+        },
+        async bulkCancel(cancels) {
+            cancelled.push(...cancels);
+            return okCancel();
+        },
+    };
+    await assert.rejects(() => runScale({
+        coin: 'ETH',
+        side: 'buy',
+        size: 1,
+        levels: 0,
+        rangePct: 2,
+        client,
+        output: () => { },
+    }), /levels must be a positive integer/);
+    const result = await runScale({
+        coin: 'ETH',
+        side: 'buy',
+        size: 1,
+        levels: 3,
+        rangePct: 2,
+        client,
+        output: () => { },
+    });
+    assert.equal(result.status, 'partial');
+    assert.equal(result.rolledBack, true);
+    assert.deepEqual(cancelled, [
+        { coin: 'ETH', oid: 101 },
+        { coin: 'ETH', oid: 103 },
+    ]);
+});
+test('scale pre-checks the $10 exchange minimum on the thinnest level (waived for reduce-only)', async () => {
+    let placed = false;
+    const client = {
+        verbose: false,
+        async getAllMids() {
+            return { ETH: '1000' };
+        },
+        async bulkOrder(orders) {
+            placed = true;
+            return okOrder(orders.map((_, i) => ({ resting: { oid: 200 + i } })));
+        },
+        async bulkCancel() {
+            return okCancel();
+        },
+    };
+    // Total ~$30 over 3 linear levels → thinnest level ~$5 < $10.
+    await assert.rejects(() => runScale({
+        coin: 'ETH',
+        side: 'buy',
+        size: 0.03,
+        levels: 3,
+        rangePct: 2,
+        client,
+        output: () => { },
+    }), /below the \$10 exchange minimum/);
+    assert.equal(placed, false);
+    // Same ladder reduce-only is allowed (exchange waives the minimum).
+    const result = await runScale({
+        coin: 'ETH',
+        side: 'buy',
+        size: 0.03,
+        levels: 3,
+        rangePct: 2,
+        reduceOnly: true,
+        client,
+        output: () => { },
+    });
+    assert.equal(result.status, 'complete');
+});
+test('bracket limit entry defaults to one atomic normalTpsl batch', async () => {
+    const calls = [];
+    const client = bracketClientStub({
+        async bracketOrder(coin, isBuy, size, entryPrice, opts) {
+            calls.push({ coin, isBuy, size, entryPrice, opts: opts ?? {} });
+            return okOrder([
+                { resting: { oid: 500 } },
+                'waitingForFill',
+                'waitingForFill',
+            ]);
+        },
+    });
+    const result = await runBracket({
+        coin: 'ETH',
+        side: 'buy',
+        size: 1,
+        tpPct: 5,
+        slPct: 2,
+        entryType: 'limit',
+        entryPrice: 990,
+        client,
+        output: () => { },
+    });
+    assert.equal(result.status, 'armed');
+    assert.equal(result.entryOid, 500);
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].isBuy, true);
+    assert.equal(calls[0].entryPrice, 990);
+    assert.equal(calls[0].opts.takeProfitPrice, 990 * 1.05);
+    assert.equal(calls[0].opts.stopLossPrice, 990 * 0.98);
+    assert.equal(calls[0].opts.stopLossIsMarket, true);
+});
+test('bracket atomic batch rolls back resting orders when a leg is rejected', async () => {
+    const cancelled = [];
+    const client = bracketClientStub({
+        async bracketOrder() {
+            return okOrder([
+                { resting: { oid: 600 } },
+                'waitingForFill',
+                { error: 'Invalid TP/SL price.' },
+            ]);
+        },
+        async cancel(_coin, oid) {
+            cancelled.push(oid);
+            return okCancel();
+        },
+    });
+    const result = await runBracket({
+        coin: 'ETH',
+        side: 'buy',
+        size: 1,
+        tpPct: 5,
+        slPct: 2,
+        entryType: 'limit',
+        entryPrice: 990,
+        client,
+        output: () => { },
+    });
+    assert.equal(result.status, 'entry_failed');
+    assert.match(result.reason ?? '', /Invalid TP\/SL price/);
+    assert.deepEqual(cancelled, [600]);
+});
+test('bracket with --no-atomic waits for limit-entry fill and arms positionTpsl for confirmed size', async () => {
+    const pairCalls = [];
+    const client = bracketClientStub({
+        async limitOrder() {
+            return okOrder([{ resting: { oid: 777 } }]);
+        },
+        async tpslOrders(_coin, isBuy, size, opts) {
+            pairCalls.push({ size, isBuy, opts: opts ?? {} });
+            return okOrder([{ resting: { oid: 778 } }, { resting: { oid: 779 } }]);
+        },
+    });
+    const fillWatcher = new StaticFillWatcher(new Map([
+        [777, { size: 0.4, notional: 392, avgPrice: 980 }],
+    ]));
+    const result = await runBracket({
+        coin: 'ETH',
+        side: 'buy',
+        size: 1,
+        tpPct: 5,
+        slPct: 2,
+        entryType: 'limit',
+        entryPrice: 990,
+        entryTimeoutSec: 5,
+        atomic: false,
+        client,
+        fillWatcher,
+        output: () => { },
+    });
+    assert.equal(result.status, 'complete');
+    assert.equal(result.protectedSize, 0.4);
+    assert.equal(result.entryPrice, 980);
+    assert.equal(pairCalls.length, 1);
+    assert.equal(pairCalls[0].size, 0.4);
+    assert.equal(pairCalls[0].isBuy, false);
+    assert.equal(pairCalls[0].opts.grouping, 'positionTpsl');
+    assert.equal(pairCalls[0].opts.takeProfitPrice, 1029);
+    assert.equal(pairCalls[0].opts.stopLossPrice, 960.4);
+});
+test('bracket market entry supports a one-sided TP sized to the actual fill', async () => {
+    const calls = [];
+    const client = bracketClientStub({
+        async marketOrder() {
+            return okOrder([{ filled: { totalSz: '0.8', avgPx: '1001', oid: 1 } }]);
+        },
+        async tpslOrders(_coin, isBuy, size, opts) {
+            calls.push({ isBuy, size, opts: opts ?? {} });
+            return okOrder([{ resting: { oid: 2 } }]);
+        },
+    });
+    const result = await runBracket({
+        coin: 'ETH',
+        side: 'buy',
+        size: 1,
+        tpPct: 5,
+        entryType: 'market',
+        client,
+        fillWatcher: new StaticFillWatcher(new Map()),
+        output: () => { },
+    });
+    assert.equal(result.status, 'complete');
+    assert.equal(result.protectedSize, 0.8);
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].size, 0.8);
+    assert.equal(calls[0].isBuy, false);
+    assert.equal(calls[0].opts.grouping, 'positionTpsl');
+    assert.equal(calls[0].opts.takeProfitPrice, 1001 * 1.05);
+    assert.equal(calls[0].opts.stopLossPrice, undefined);
+});
+test('bracket validates targets before any order goes out', async () => {
+    // SL% ≥ 100 resolves to a negative price.
+    await assert.rejects(() => runBracket({
+        coin: 'ETH',
+        side: 'buy',
+        size: 1,
+        tpPct: 5,
+        slPct: 150,
+        client: bracketClientStub(),
+        output: () => { },
+    }), /SL must resolve to a positive price/);
+    // Absolute TP on the wrong side of the entry.
+    await assert.rejects(() => runBracket({
+        coin: 'ETH',
+        side: 'buy',
+        size: 1,
+        tpPrice: 900,
+        entryType: 'limit',
+        entryPrice: 990,
+        client: bracketClientStub(),
+        output: () => { },
+    }), /TP price must be above entry/);
+    // No target at all.
+    await assert.rejects(() => runBracket({
+        coin: 'ETH',
+        side: 'buy',
+        size: 1,
+        client: bracketClientStub(),
+        output: () => { },
+    }), /provide a TP target, an SL target, or both/);
+});
+test('chase requotes only the remaining size after a partial fill', async () => {
+    const limitSizes = [];
+    const cancelled = [];
+    const fills = new Map();
+    let orderCount = 0;
+    let mid = 1000;
+    const client = {
+        verbose: false,
+        address: '0x0000000000000000000000000000000000000001',
+        async getAllMids() {
+            mid += 2;
+            return { ETH: String(mid) };
+        },
+        async getOpenOrders() {
+            return [];
+        },
+        async getUserFills() {
+            return [];
+        },
+        async limitOrder(_coin, _isBuy, size) {
+            limitSizes.push(size);
+            orderCount += 1;
+            const oid = 900 + orderCount;
+            if (orderCount === 1) {
+                fills.set(oid, { size: 0.4, notional: 400, avgPrice: 1000 });
+            }
+            else {
+                fills.set(oid, { size, notional: size * 1002, avgPrice: 1002 });
+            }
+            return okOrder([{ resting: { oid } }]);
+        },
+        async cancel(_coin, oid) {
+            cancelled.push(oid);
+            return okCancel();
+        },
+    };
+    const result = await runChase({
+        coin: 'ETH',
+        side: 'buy',
+        size: 1,
+        offsetBps: 5,
+        timeoutSec: 2,
+        intervalMs: 1,
+        maxChaseBps: 1_000,
+        client,
+        fillWatcher: new StaticFillWatcher(fills),
+        output: () => { },
+    });
+    assert.equal(result.status, 'filled');
+    assert.equal(limitSizes.length, 2);
+    assert.equal(limitSizes[0], 1);
+    assert(Math.abs(limitSizes[1] - 0.6) < 1e-9);
+    assert.deepEqual(cancelled, [901]);
+});
+test('chase reprices and continues after a post-only rejection', async () => {
+    const fills = new Map();
+    let orderCount = 0;
+    const client = {
+        verbose: false,
+        address: '0x0000000000000000000000000000000000000001',
+        async getAllMids() {
+            return { ETH: '1000' };
+        },
+        async getOpenOrders() {
+            return [];
+        },
+        async getUserFills() {
+            return [];
+        },
+        async limitOrder(_coin, _isBuy, size) {
+            orderCount += 1;
+            if (orderCount === 1) {
+                return okOrder([{ error: 'Post only order would have immediately matched, bbo was 999.9@1000.1' }]);
+            }
+            const oid = 900 + orderCount;
+            fills.set(oid, { size, notional: size * 1000, avgPrice: 1000 });
+            return okOrder([{ resting: { oid } }]);
+        },
+        async cancel() {
+            return okCancel();
+        },
+    };
+    const result = await runChase({
+        coin: 'ETH',
+        side: 'buy',
+        size: 1,
+        offsetBps: 5,
+        timeoutSec: 2,
+        intervalMs: 1,
+        maxChaseBps: 1_000,
+        client,
+        fillWatcher: new StaticFillWatcher(fills),
+        output: () => { },
+    });
+    assert.equal(result.status, 'filled');
+    assert.equal(orderCount, 2);
+});
+test('chase cancels the resting order even when the loop throws', async () => {
+    const cancelled = [];
+    const client = {
+        verbose: false,
+        address: '0x0000000000000000000000000000000000000001',
+        async getAllMids() {
+            return { ETH: '1000' };
+        },
+        async getOpenOrders() {
+            throw new Error('open-orders lookup exploded');
+        },
+        async getUserFills() {
+            return [];
+        },
+        async limitOrder() {
+            return okOrder([{ resting: { oid: 950 } }]);
+        },
+        async cancel(_coin, oid) {
+            cancelled.push(oid);
+            return okCancel();
+        },
+    };
+    await assert.rejects(() => runChase({
+        coin: 'ETH',
+        side: 'buy',
+        size: 1,
+        offsetBps: 5,
+        timeoutSec: 2,
+        intervalMs: 1,
+        maxChaseBps: 1_000,
+        client,
+        fillWatcher: new StaticFillWatcher(new Map()),
+        output: () => { },
+    }), /open-orders lookup exploded/);
+    assert.deepEqual(cancelled, [950]);
+});
+test('chase rejects a start size below the $10 exchange minimum', async () => {
+    const client = {
+        verbose: false,
+        address: '0x0000000000000000000000000000000000000001',
+        async getAllMids() {
+            return { ETH: '1000' };
+        },
+        async getOpenOrders() {
+            return [];
+        },
+        async getUserFills() {
+            return [];
+        },
+        async limitOrder() {
+            throw new Error('limitOrder should not be called');
+        },
+        async cancel() {
+            return okCancel();
+        },
+    };
+    await assert.rejects(() => runChase({
+        coin: 'ETH',
+        side: 'buy',
+        size: 0.005,
+        client,
+        fillWatcher: new StaticFillWatcher(new Map()),
+        output: () => { },
+    }), /below the \$10 exchange minimum/);
+});
+test('user fill watcher de-duplicates repeated REST fallback fills', async () => {
+    const fillTime = Date.now();
+    const watcher = new UserFillWatcher({
+        verbose: false,
+        address: '0x0000000000000000000000000000000000000001',
+        async getUserFills() {
+            return [
+                { coin: 'ETH', px: '1000', sz: '0.25', time: fillTime, oid: 123 },
+            ];
+        },
+    }, { ws: null, sinceMs: fillTime - 1000 });
+    await watcher.start();
+    await watcher.waitForFill(123, 1, 1, { coin: 'ETH', pollMs: 1 });
+    await watcher.waitForFill(123, 1, 1, { coin: 'ETH', pollMs: 1 });
+    assert.equal(watcher.getFilled(123).size, 0.25);
+});

package/dist/operations/bracket.d.ts

@@ -1,27 +1,79 @@
 #!/usr/bin/env npx tsx
+import type { CancelResponse, OrderResponse } from '../core/types.js';
+import { type FillWatcher } from './execution.js';
 export interface BracketOptions {
     coin: string;
     side: 'buy' | 'sell';
     size: number;
-    tpPct: number;
-    slPct: number;
+    /** Take profit distance in % from entry. Optional if tpPrice/sl* given. */
+    tpPct?: number;
+    /** Stop loss distance in % from entry. Optional if slPrice/tp* given. */
+    slPct?: number;
+    /** Absolute take profit price (takes precedence over tpPct). */
+    tpPrice?: number;
+    /** Absolute stop loss trigger price (takes precedence over slPct). */
+    slPrice?: number;
     entryType?: 'market' | 'limit';
     entryPrice?: number;
     slippage?: number;
+    entryTimeoutSec?: number;
+    slSlippageBps?: number;
+    /** SL fires as a market trigger (default true); false = stop-limit. */
+    slMarket?: boolean;
+    /**
+     * Limit entries only: submit entry + TP/SL as one atomic normalTpsl batch
+     * (default true) — the exchange arms the exits when the entry fills, so the
+     * bracket survives this process exiting. false = legacy fill-watch path.
+     */
+    atomic?: boolean;
     leverage?: number;
     dryRun?: boolean;
     verbose?: boolean;
+    client?: BracketClient;
+    fillWatcher?: FillWatcher;
     /** Receives each output line. Defaults to console.log. */
     output?: (line: string) => void;
 }
+export interface BracketClient {
+    verbose: boolean;
+    getAllMids(): Promise<Record<string, string>>;
+    marketOrder(coin: string, isBuy: boolean, size: number, slippageBps?: number, leverage?: number): Promise<OrderResponse>;
+    limitOrder(coin: string, isBuy: boolean, size: number, price: number, tif?: 'Gtc' | 'Ioc' | 'Alo', reduceOnly?: boolean, leverage?: number): Promise<OrderResponse>;
+    tpslOrders(coin: string, isBuy: boolean, size: number, opts?: {
+        takeProfitPrice?: number;
+        stopLossPrice?: number;
+        stopLossSlippageBps?: number;
+        stopLossIsMarket?: boolean;
+        grouping?: 'positionTpsl' | 'normalTpsl';
+        leverage?: number;
+    }): Promise<OrderResponse>;
+    bracketOrder(coin: string, isBuy: boolean, size: number, entryPrice: number, opts?: {
+        entryTif?: 'Gtc' | 'Alo';
+        takeProfitPrice?: number;
+        stopLossPrice?: number;
+        stopLossSlippageBps?: number;
+        stopLossIsMarket?: boolean;
+        leverage?: number;
+    }): Promise<OrderResponse>;
+    cancel(coin: string, oid: number): Promise<CancelResponse>;
+    address: string;
+    getUserFills(user?: string): Promise<Array<{
+        coin: string;
+        px: string;
+        sz: string;
+        time: number;
+        oid: number;
+    }>>;
+}
 export interface BracketResult {
-    status: 'dry' | 'limit_resting' | 'complete' | 'entry_failed' | 'partial';
+    status: 'dry' | 'armed' | 'limit_resting' | 'complete' | 'entry_failed' | 'partial';
     entryPrice?: number;
     tpPrice?: number;
     slPrice?: number;
     tpOid?: number | null;
     slOid?: number | null;
     entryOid?: number | null;
+    protectedSize?: number;
     reason?: string;
 }
 export declare function runBracket(opts: BracketOptions): Promise<BracketResult>;

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

@@ -1 +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"}
+{"version":3,"file":"bracket.d.ts","sourceRoot":"","sources":["../../scripts/operations/bracket.ts"],"names":[],"mappings":"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"}