@reefclaw/openclaw-plugin 0.1.5 → 0.1.6

package/venues/hyperliquid/hl-user-stream.js

@@ -0,0 +1,220 @@
+// Hyperliquid user data stream (plan §5.4/§5.9) — the HL analog of
+// `live/user-data-stream.ts`.
+//
+// ★ THE MEASURED FACT THAT SHAPES THIS FILE (T-5, testnet 2026-07-12):
+//   **HL's WS replays NOTHING on reconnect.** We killed the socket, placed an
+//   order inside the gap, re-subscribed — and received ZERO events for it, while
+//   REST showed it plainly. There is no `isSnapshot` backfill for the gap.
+//
+//   ⇒ WS is a FAST PATH, never the ledger. Every reconnect MUST be followed by a
+//     REST truth-check (positions + open orders + fills since the disconnect), and
+//     the caller is REQUIRED to wire `onResyncNeeded`. This class refuses to
+//     pretend otherwise: it tracks `lastEventAt`/`disconnectedAt` and hands them
+//     to the resync callback so the gap window is explicit.
+//
+// Other HL-specific rules honoured here:
+//   - No listenKey. Auth is by SUBSCRIBING with the MASTER address (agent wallets
+//     sign; queries always name the master).
+//   - Server closes an idle socket after 60s of silence ⇒ app-level ping every 30s
+//     (same cadence the intel HL client uses).
+//   - Subscriptions are NOT auto-restored by the server: they must be re-sent on
+//     every (re)connect.
+//   - `orderUpdates` carries trigger orders natively (statuses incl. `triggered`,
+//     `siblingFilledCanceled`, `liquidatedCanceled`, `delistedCanceled`,
+//     `marginCanceled`) — simpler than Binance, where brackets needed a separate
+//     ALGO_UPDATE channel.
+import WebSocket from 'ws';
+import { logger } from '../../logger.js';
+const TAG = 'hl-user-stream';
+const PING_INTERVAL_MS = 30_000; // server cuts idle sockets at 60s
+const STALE_AFTER_MS = 90_000; // no frame at all for 90s ⇒ terminate + reconnect
+const RECONNECT_BASE_MS = 1_000;
+const RECONNECT_MAX_MS = 60_000;
+export class HyperliquidUserStream {
+    opts;
+    ws = null;
+    pingTimer = null;
+    staleTimer = null;
+    reconnectTimer = null;
+    reconnectAttempts = 0;
+    stopped = false;
+    lastFrameAt = 0;
+    /** Last event we actually processed — the low-water mark for the REST gap-fill. */
+    lastEventAt = 0;
+    disconnectedAt = 0;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    get isConnected() {
+        return this.ws?.readyState === WebSocket.OPEN;
+    }
+    /** Epoch-ms of the last processed event (0 = none yet). */
+    get lastEventTimestamp() {
+        return this.lastEventAt;
+    }
+    start() {
+        this.stopped = false;
+        this.connect();
+    }
+    stop() {
+        this.stopped = true;
+        this.clearTimers();
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+        try {
+            this.ws?.close();
+        }
+        catch {
+            /* best-effort */
+        }
+        this.ws = null;
+    }
+    url() {
+        return this.opts.testnet
+            ? 'wss://api.hyperliquid-testnet.xyz/ws'
+            : 'wss://api.hyperliquid.xyz/ws';
+    }
+    connect() {
+        if (this.stopped)
+            return;
+        const url = this.url();
+        logger.info(TAG, `connecting ${url}`);
+        const ws = new WebSocket(url);
+        this.ws = ws;
+        ws.on('open', () => {
+            this.reconnectAttempts = 0;
+            this.lastFrameAt = Date.now();
+            this.subscribeAll();
+            this.armTimers();
+            // ★ T-5: the server sends NO backfill for the gap. Tell the caller exactly
+            // how blind we were so it can REST-reconcile that window. `lastEventAt || 0`
+            // makes the first connect a full-snapshot request too.
+            const wasDisconnectedMs = this.disconnectedAt ? Date.now() - this.disconnectedAt : 0;
+            const sinceMs = this.lastEventAt || Date.now() - 60_000;
+            logger.info(TAG, `connected — REST resync required (blind ${Math.round(wasDisconnectedMs / 1000)}s; ` +
+                'HL WS does not replay missed events — verified testnet 2026-07-12)');
+            this.opts.callbacks.onResyncNeeded({ sinceMs, wasDisconnectedMs });
+            this.disconnectedAt = 0;
+        });
+        ws.on('message', (raw) => {
+            this.lastFrameAt = Date.now();
+            let msg;
+            try {
+                msg = JSON.parse(raw.toString());
+            }
+            catch {
+                return;
+            }
+            this.handle(msg);
+        });
+        ws.on('close', (code, reason) => {
+            logger.warn(TAG, `closed code=${code} reason=${reason?.toString().slice(0, 80)}`);
+            this.onDisconnected();
+        });
+        ws.on('error', (err) => {
+            logger.warn(TAG, `socket error: ${err.message}`);
+            // 'close' follows — reconnect is handled there.
+        });
+    }
+    subscribeAll() {
+        const user = this.opts.walletAddress;
+        // Subscriptions are NOT restored by the server after a reconnect — always re-send.
+        const subs = [
+            { type: 'orderUpdates', user },
+            { type: 'userFills', user },
+            { type: 'userEvents', user },
+            { type: 'userFundings', user },
+        ];
+        for (const subscription of subs) {
+            this.send({ method: 'subscribe', subscription });
+        }
+    }
+    handle(msg) {
+        const { channel, data } = msg;
+        if (!channel || channel === 'subscriptionResponse' || channel === 'pong')
+            return;
+        switch (channel) {
+            case 'userFills': {
+                const payload = data;
+                for (const fill of payload?.fills ?? []) {
+                    this.lastEventAt = Math.max(this.lastEventAt, fill.time ?? Date.now());
+                    this.opts.callbacks.onFill(fill);
+                }
+                break;
+            }
+            case 'orderUpdates': {
+                const updates = (Array.isArray(data) ? data : []);
+                for (const u of updates) {
+                    this.lastEventAt = Math.max(this.lastEventAt, u.statusTimestamp ?? Date.now());
+                    this.opts.callbacks.onOrderUpdate(u);
+                }
+                break;
+            }
+            case 'userEvents': {
+                this.lastEventAt = Date.now();
+                this.opts.callbacks.onUserEvent((data ?? {}));
+                break;
+            }
+            case 'userFundings': {
+                this.lastEventAt = Date.now();
+                this.opts.callbacks.onUserEvent({ fundings: data });
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    send(payload) {
+        if (this.ws?.readyState !== WebSocket.OPEN)
+            return;
+        try {
+            this.ws.send(JSON.stringify(payload));
+        }
+        catch (err) {
+            logger.warn(TAG, `send failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    armTimers() {
+        this.clearTimers();
+        // App-level ping — the server cuts an idle socket at 60s.
+        this.pingTimer = setInterval(() => this.send({ method: 'ping' }), PING_INTERVAL_MS);
+        // Frame-staleness watchdog — a silent socket is worse than a closed one
+        // (we would believe stale positions). Terminate ⇒ reconnect ⇒ REST resync.
+        this.staleTimer = setInterval(() => {
+            if (!this.lastFrameAt)
+                return;
+            const silentMs = Date.now() - this.lastFrameAt;
+            if (silentMs > STALE_AFTER_MS) {
+                logger.warn(TAG, `no frames for ${Math.round(silentMs / 1000)}s — terminating socket`);
+                try {
+                    this.ws?.terminate();
+                }
+                catch {
+                    /* the close handler drives the reconnect */
+                }
+            }
+        }, 15_000);
+    }
+    clearTimers() {
+        if (this.pingTimer)
+            clearInterval(this.pingTimer);
+        if (this.staleTimer)
+            clearInterval(this.staleTimer);
+        this.pingTimer = null;
+        this.staleTimer = null;
+    }
+    onDisconnected() {
+        this.clearTimers();
+        this.ws = null;
+        if (this.stopped)
+            return;
+        if (!this.disconnectedAt)
+            this.disconnectedAt = Date.now();
+        const delay = Math.min(RECONNECT_BASE_MS * 2 ** this.reconnectAttempts, RECONNECT_MAX_MS);
+        const jittered = delay * (0.8 + Math.random() * 0.4);
+        this.reconnectAttempts += 1;
+        logger.info(TAG, `reconnecting in ${Math.round(jittered / 1000)}s (attempt ${this.reconnectAttempts})`);
+        this.reconnectTimer = setTimeout(() => this.connect(), jittered);
+    }
+}

package/venues/registry.d.ts

@@ -1,5 +1,6 @@
-import { fillExchangeId, parseVenue, type VenueId } from '@reefclaw/shared';
 import { LiveAdapter } from '../live/live-adapter.js';
+import { HyperliquidLiveAdapter, type HlLiveAdapterOptions } from './hyperliquid/hl-live-adapter.js';
+import { fillExchangeId, parseVenue, type VenueId } from './symbols.js';
 export type { VenueId };
 export { fillExchangeId, parseVenue };
 /** Venues this build can construct a LIVE adapter for. PAPER mode is
@@ -13,12 +14,25 @@ export declare function isLiveVenueSupported(venue: VenueId): boolean;
  *  USDC venue reads as $0 equity and every order fails "Insufficient USDC". */
 export declare function venueQuoteCurrency(venue: VenueId): 'USDT' | 'USDC';
 type BinanceLiveAdapterArgs = ConstructorParameters<typeof LiveAdapter>;
-/** Construct the live adapter for a venue.
+/** Every live adapter this build can construct. Both are EventEmitters exposing
+ *  the same lifecycle events (`drift_detected`) and both implement
+ *  IExchangeAdapter — the boot path treats them identically. */
+export type AnyLiveAdapter = LiveAdapter | HyperliquidLiveAdapter;
+/** Venue-typed construction spec. A discriminated union so the compiler — not a
+ *  runtime branch in the boot path — guarantees each venue gets ITS OWN args
+ *  (Binance takes API key/secret; Hyperliquid takes a master address + agent key,
+ *  a completely different credential shape). */
+export type LiveAdapterSpec = {
+    venue: 'binance';
+    args: BinanceLiveAdapterArgs;
+} | {
+    venue: 'hyperliquid';
+    args: HlLiveAdapterOptions;
+};
+/** Construct the live adapter for a venue — the ONLY place either class is newed.
  *
- *  Binance: a pure pass-through to `new LiveAdapter(...)` — byte-identical to
- *  the inline construction this factory replaced (Phase 0 no-behavior-change
- *  rule; the args tuple is derived from the constructor so the two can never
- *  drift). Hyperliquid: throws — reaching this arm means the boot-time
- *  isLiveVenueSupported() fallback-to-PAPER gate was bypassed, which is a bug,
- *  not a user state. */
-export declare function createLiveAdapter(venue: VenueId, ...args: BinanceLiveAdapterArgs): LiveAdapter;
+ *  Binance: a pure pass-through to `new LiveAdapter(...)` — byte-identical to the
+ *  inline construction this factory replaced (the args tuple is derived from the
+ *  constructor so the two can never drift).
+ *  Hyperliquid: `new HyperliquidLiveAdapter(...)` (Phase 3). */
+export declare function createLiveAdapter(spec: LiveAdapterSpec): AnyLiveAdapter;

package/venues/registry.js

@@ -12,13 +12,14 @@
 // rule: it holds keys + is part of the safety floor) — it is read from
 // ~/.reefclaw/plugin-config.json `exchange.venue` and MUST never be settable
 // from the central config channel.
-import { fillExchangeId, parseVenue } from '@reefclaw/shared';
 import { LiveAdapter } from '../live/live-adapter.js';
+import { HyperliquidLiveAdapter } from './hyperliquid/hl-live-adapter.js';
+import { fillExchangeId, parseVenue } from './symbols.js';
 export { fillExchangeId, parseVenue };
 /** Venues this build can construct a LIVE adapter for. PAPER mode is
  *  venue-flavored only by its market-data source (PaperMarketFeed / chart) and
  *  is not gated here. */
-export const SUPPORTED_LIVE_VENUES = new Set(['binance']);
+export const SUPPORTED_LIVE_VENUES = new Set(['binance', 'hyperliquid']);
 export function isLiveVenueSupported(venue) {
     return SUPPORTED_LIVE_VENUES.has(venue);
 }
@@ -29,19 +30,17 @@ export function isLiveVenueSupported(venue) {
 export function venueQuoteCurrency(venue) {
     return venue === 'hyperliquid' ? 'USDC' : 'USDT';
 }
-/** Construct the live adapter for a venue.
+/** Construct the live adapter for a venue — the ONLY place either class is newed.
  *
- *  Binance: a pure pass-through to `new LiveAdapter(...)` — byte-identical to
- *  the inline construction this factory replaced (Phase 0 no-behavior-change
- *  rule; the args tuple is derived from the constructor so the two can never
- *  drift). Hyperliquid: throws — reaching this arm means the boot-time
- *  isLiveVenueSupported() fallback-to-PAPER gate was bypassed, which is a bug,
- *  not a user state. */
-export function createLiveAdapter(venue, ...args) {
-    switch (venue) {
+ *  Binance: a pure pass-through to `new LiveAdapter(...)` — byte-identical to the
+ *  inline construction this factory replaced (the args tuple is derived from the
+ *  constructor so the two can never drift).
+ *  Hyperliquid: `new HyperliquidLiveAdapter(...)` (Phase 3). */
+export function createLiveAdapter(spec) {
+    switch (spec.venue) {
         case 'binance':
-            return new LiveAdapter(...args);
+            return new LiveAdapter(...spec.args);
         case 'hyperliquid':
-            throw new Error("venue 'hyperliquid' has no live adapter in this build — arrives in Phase 3 of docs/HYPERLIQUID_INTEGRATION_PLAN.md");
+            return new HyperliquidLiveAdapter(spec.args);
     }
 }

package/venues/symbols.d.ts

@@ -0,0 +1,43 @@
+export type VenueId = 'binance' | 'hyperliquid';
+export declare const VENUE_IDS: readonly VenueId[];
+export declare function isVenueId(value: unknown): value is VenueId;
+/** Parse a raw config value into a venue.
+ *  Absent/empty → 'binance' (every pre-venue config file keeps today's
+ *  behavior byte-identically). An unrecognized string is surfaced to the
+ *  caller instead of being silently coerced — mis-spelling a venue must be
+ *  loud, never quietly become "trade on Binance". */
+export declare function parseVenue(raw: unknown): {
+    venue: VenueId;
+    unrecognized?: string;
+};
+/** `FillEvent.exchange` / webapp `trades.exchange` value — half of the
+ *  audit-trail idempotency key `(exchange, exchange_trade_id)` (migration
+ *  0042). 'binance_futures' is the historical literal on every existing row;
+ *  NEVER change these strings once a venue has written rows. */
+export declare const FILL_EXCHANGE_ID: Record<VenueId, string>;
+export declare function fillExchangeId(venue: VenueId): string;
+/** Quote/settle asset of the venue's linear perps. */
+export declare const VENUE_QUOTE_ASSET: Record<VenueId, string>;
+/** Prefix that namespaces Hyperliquid rows inside the intel symbol column. */
+export declare const HL_INTEL_PREFIX = "HL_";
+/** Canonical symbol → the venue's CCXT unified symbol.
+ *  'BTC/USDT' (binance) → 'BTC/USDT:USDT'; 'BTC/USDC' (hyperliquid) →
+ *  'BTC/USDC:USDC'. Accepts an already-suffixed input (idempotent). */
+export declare function toCcxtSymbol(venue: VenueId, canonical: string): string;
+/** Canonical symbol → intel DB symbol.
+ *  binance: 'BTC/USDT' → 'BTCUSDT' (the historical concatenated form intel has
+ *  always stored); hyperliquid: 'BTC/USDC' → 'HL_BTC' (namespaced coin, case
+ *  preserved). */
+export declare function toIntelSymbol(venue: VenueId, canonical: string): string;
+/** Inverse of toIntelSymbol. 'HL_'-prefixed → hyperliquid; everything else is
+ *  the historical Binance namespace. Binance symbols that are not
+ *  USDT-concatenated (none exist in INTEL_SYMBOLS today) come back verbatim as
+ *  canonical — honest passthrough, not a guess. */
+export declare function fromIntelSymbol(intelSymbol: string): {
+    venue: VenueId;
+    canonical: string;
+};
+/** The Hyperliquid venue-native coin name for a canonical symbol
+ *  ('BTC/USDC' → 'BTC'). Orders address assets by integer index resolved from
+ *  `meta.universe` at runtime — the coin name is the stable half. */
+export declare function toHyperliquidCoin(canonical: string): string;

package/venues/symbols.js

@@ -0,0 +1,107 @@
+// ⚠️ GENERATED FILE — DO NOT EDIT.
+// Canonical source of truth: shared/src/venues/symbols.ts
+// Regenerate: node scripts/sync-shared-code.mjs  (enforced by shared-code-sync.test.ts)
+//
+// This copy exists because this package builds with tsc and deploys as a
+// self-contained tree that strips workspace deps, so it cannot import
+// @reefclaw/shared runtime code across the deploy boundary.
+export const VENUE_IDS = ['binance', 'hyperliquid'];
+export function isVenueId(value) {
+    return value === 'binance' || value === 'hyperliquid';
+}
+/** Parse a raw config value into a venue.
+ *  Absent/empty → 'binance' (every pre-venue config file keeps today's
+ *  behavior byte-identically). An unrecognized string is surfaced to the
+ *  caller instead of being silently coerced — mis-spelling a venue must be
+ *  loud, never quietly become "trade on Binance". */
+export function parseVenue(raw) {
+    if (raw === undefined || raw === null || raw === '')
+        return { venue: 'binance' };
+    if (isVenueId(raw))
+        return { venue: raw };
+    return { venue: 'binance', unrecognized: String(raw) };
+}
+/** `FillEvent.exchange` / webapp `trades.exchange` value — half of the
+ *  audit-trail idempotency key `(exchange, exchange_trade_id)` (migration
+ *  0042). 'binance_futures' is the historical literal on every existing row;
+ *  NEVER change these strings once a venue has written rows. */
+export const FILL_EXCHANGE_ID = {
+    binance: 'binance_futures',
+    hyperliquid: 'hyperliquid',
+};
+export function fillExchangeId(venue) {
+    return FILL_EXCHANGE_ID[venue];
+}
+/** Quote/settle asset of the venue's linear perps. */
+export const VENUE_QUOTE_ASSET = {
+    binance: 'USDT',
+    hyperliquid: 'USDC',
+};
+/** Prefix that namespaces Hyperliquid rows inside the intel symbol column. */
+export const HL_INTEL_PREFIX = 'HL_';
+/** Strip a CCXT settle suffix ('BTC/USDT:USDT' → 'BTC/USDT'). Same regex as
+ *  webapp/src/lib/symbols.ts normalizeSymbol — kept inline so this module has
+ *  zero imports and survives the sync-copy deploy boundary. */
+function stripSettleSuffix(symbol) {
+    return symbol.replace(/:[A-Z]+$/, '');
+}
+function splitCanonical(canonical) {
+    const stripped = stripSettleSuffix(canonical.trim());
+    const parts = stripped.split('/');
+    if (parts.length !== 2 || parts[0].length === 0 || parts[1].length === 0) {
+        throw new Error(`Not a canonical BASE/QUOTE symbol: '${canonical}'`);
+    }
+    return { base: parts[0], quote: parts[1] };
+}
+/** Canonical symbol → the venue's CCXT unified symbol.
+ *  'BTC/USDT' (binance) → 'BTC/USDT:USDT'; 'BTC/USDC' (hyperliquid) →
+ *  'BTC/USDC:USDC'. Accepts an already-suffixed input (idempotent). */
+export function toCcxtSymbol(venue, canonical) {
+    const { base, quote } = splitCanonical(canonical);
+    if (quote !== VENUE_QUOTE_ASSET[venue]) {
+        throw new Error(`Symbol '${canonical}' is not ${VENUE_QUOTE_ASSET[venue]}-quoted — not a ${venue} linear perp`);
+    }
+    return `${base}/${quote}:${quote}`;
+}
+/** Canonical symbol → intel DB symbol.
+ *  binance: 'BTC/USDT' → 'BTCUSDT' (the historical concatenated form intel has
+ *  always stored); hyperliquid: 'BTC/USDC' → 'HL_BTC' (namespaced coin, case
+ *  preserved). */
+export function toIntelSymbol(venue, canonical) {
+    const { base, quote } = splitCanonical(canonical);
+    if (venue === 'hyperliquid') {
+        if (quote !== VENUE_QUOTE_ASSET.hyperliquid) {
+            throw new Error(`Symbol '${canonical}' is not USDC-quoted — not a Hyperliquid perp`);
+        }
+        return `${HL_INTEL_PREFIX}${base}`;
+    }
+    return `${base}${quote}`;
+}
+/** Inverse of toIntelSymbol. 'HL_'-prefixed → hyperliquid; everything else is
+ *  the historical Binance namespace. Binance symbols that are not
+ *  USDT-concatenated (none exist in INTEL_SYMBOLS today) come back verbatim as
+ *  canonical — honest passthrough, not a guess. */
+export function fromIntelSymbol(intelSymbol) {
+    if (intelSymbol.startsWith(HL_INTEL_PREFIX)) {
+        const coin = intelSymbol.slice(HL_INTEL_PREFIX.length);
+        if (coin.length === 0) {
+            throw new Error(`Malformed intel symbol '${intelSymbol}' — empty coin after HL_ prefix`);
+        }
+        return { venue: 'hyperliquid', canonical: `${coin}/${VENUE_QUOTE_ASSET.hyperliquid}` };
+    }
+    if (intelSymbol.endsWith(VENUE_QUOTE_ASSET.binance) && intelSymbol.length > 4) {
+        const base = intelSymbol.slice(0, -VENUE_QUOTE_ASSET.binance.length);
+        return { venue: 'binance', canonical: `${base}/${VENUE_QUOTE_ASSET.binance}` };
+    }
+    return { venue: 'binance', canonical: intelSymbol };
+}
+/** The Hyperliquid venue-native coin name for a canonical symbol
+ *  ('BTC/USDC' → 'BTC'). Orders address assets by integer index resolved from
+ *  `meta.universe` at runtime — the coin name is the stable half. */
+export function toHyperliquidCoin(canonical) {
+    const { base, quote } = splitCanonical(canonical);
+    if (quote !== VENUE_QUOTE_ASSET.hyperliquid) {
+        throw new Error(`Symbol '${canonical}' is not USDC-quoted — not a Hyperliquid perp`);
+    }
+    return base;
+}

package/wave9/live-account-capture.d.ts

@@ -0,0 +1,67 @@
+import type { IExchangeAdapter } from '../exchange-adapter.js';
+import { type Wave9ExecutionMode } from './paper-admission-guard.js';
+import { type Wave9LiveExecutionLedger } from './live-execution-ledger.js';
+export interface Wave9NativeStopObservation {
+    verified: boolean;
+    reason: string;
+    bracketId: string | null;
+    bracketState: string | null;
+    entryClientOrderId: string | null;
+    stopClientOrderId: string | null;
+    exchangeOrderId: string | null;
+    entrySide: 'buy' | 'sell' | null;
+    stopSide: 'buy' | 'sell' | null;
+    stopPrice: number | null;
+    bracketQuantity: number | null;
+    closePosition: boolean | null;
+    liveness: 'live' | 'terminal' | 'unknown' | null;
+}
+export interface Wave9LiveStopConfirmationInput {
+    candidateId: string;
+    symbol: string;
+    entryClientOrderId: string;
+    entrySide: 'buy' | 'sell';
+    stopPrice: number;
+    filledQuantity: number;
+}
+export interface Wave9LiveObservedPosition {
+    symbol: string;
+    side: 'long' | 'short';
+    quantity: number;
+    entryPrice: number;
+    markPrice: number;
+    stopPrice?: number;
+    missionId?: string;
+    setupType?: string;
+    candidateId?: string;
+    strategy?: 'tsmom_28d_long_flat_reversal_1d' | 'tsmom_28d_short_flat_reversal_1d';
+    accruedFundingUsd?: number;
+    openedAt?: string;
+    initialStopPrice?: number;
+    nativeStop?: Wave9NativeStopObservation;
+    positionFingerprint?: string;
+}
+export interface Wave9LiveAccountCapture {
+    fingerprint: string;
+    cashEquityUsd: number;
+    positions: Wave9LiveObservedPosition[];
+    pendingExposureOrderCount: number;
+    executedCandidateIds: string[];
+    nativeStopProtectionComplete: boolean;
+    nativeStopIssues: string[];
+    authoritative: true;
+    runtimeParity: false;
+    provenance: 'live_exchange_structural_snapshot_and_durable_wave9_ledger';
+}
+/** One-shot post-fill confirmation used after the bracket row becomes active. */
+export declare function confirmWave9LiveNativeStop(adapter: IExchangeAdapter, input: Wave9LiveStopConfirmationInput): Promise<boolean>;
+/**
+ * Capture exchange-authoritative LIVE geometry without volatile mark prices in
+ * the authorization fingerprint. Wallet cash, positions, pending
+ * exposure-increasing orders, and durable Wave 9 identities are all bound.
+ */
+export declare function captureWave9LiveAccount(adapter: IExchangeAdapter, ledger: Wave9LiveExecutionLedger, mode: Wave9ExecutionMode): Promise<Wave9LiveAccountCapture>;
+export declare function captureWave9LivePosition(adapter: IExchangeAdapter, ledger: Wave9LiveExecutionLedger, mode: Wave9ExecutionMode, symbol: string): Promise<{
+    fingerprint: string;
+    position: Wave9LiveObservedPosition;
+}>;