@reefclaw/openclaw-plugin 0.1.6 → 0.1.8

package/tools/set-trading-mode.js

@@ -9,6 +9,7 @@
 // because the caller chain is currently controlled end-to-end by the skill.
 import { readPluginConfig } from '../config/plugin-config-io.js';
 import { validateModeTransition, modeRequiresCredentials } from '../onboarding/mode-ladder.js';
+import { parseVenue } from '../venues/registry.js';
 import { logger } from '../logger.js';
 import { recordModeTransition } from '../audit/mode-transition-audit.js';
 const TAG = 'set-trading-mode';
@@ -49,12 +50,26 @@ export async function setTradingModeTool(args, deps) {
             readiness: deps.runtime.adapter.readiness,
         };
     }
-    // 3. Credential requirement check.
+    // 3. Credential requirement check — PER VENUE (issue #217: this gate was
+    //    Binance-only, so the go-live flip on the hyperliquid venue was rejected
+    //    despite valid walletAddress+agentPrivateKey in plugin-config).
     let exchange = null;
+    let hlCredentials = null;
+    let venue = 'binance';
     if (modeRequiresCredentials(target)) {
         try {
             const cfg = readPluginConfig(deps.configPath);
-            if (cfg.exchange?.apiKey && cfg.exchange?.secret) {
+            venue = parseVenue(cfg.exchange?.venue).venue;
+            if (venue === 'hyperliquid') {
+                if (cfg.exchange?.walletAddress && cfg.exchange?.agentPrivateKey) {
+                    hlCredentials = {
+                        walletAddress: String(cfg.exchange.walletAddress),
+                        agentPrivateKey: String(cfg.exchange.agentPrivateKey),
+                        testnet: cfg.exchange.testnet === true,
+                    };
+                }
+            }
+            else if (cfg.exchange?.apiKey && cfg.exchange?.secret) {
                 exchange = {
                     apiKey: cfg.exchange.apiKey,
                     secret: cfg.exchange.secret,
@@ -74,11 +89,13 @@ export async function setTradingModeTool(args, deps) {
                 reason: 'config_read_error',
             };
         }
-        if (!exchange) {
+        if (!exchange && !hlCredentials) {
             recordModeTransition({ previousMode, targetMode: target, acknowledged, ok: false, reason: 'missing_credentials' });
             return {
                 ok: false,
-                message: `${target} mode requires exchange credentials. Run set_exchange_credentials first.`,
+                message: venue === 'hyperliquid'
+                    ? `${target} mode on Hyperliquid requires exchange.walletAddress (master) + exchange.agentPrivateKey (agent wallet) in plugin-config.`
+                    : `${target} mode requires exchange credentials. Run set_exchange_credentials first.`,
                 previousMode,
                 mode: previousMode,
                 readiness: deps.runtime.adapter.readiness,
@@ -116,14 +133,14 @@ export async function setTradingModeTool(args, deps) {
         };
     }
     // 6. Swap the adapter.
-    await deps.runtime.reconnect({ mode: target, exchange }, { adapterDeps: deps.adapterDeps });
+    await deps.runtime.reconnect({ mode: target, exchange, venue, hlCredentials }, { adapterDeps: deps.adapterDeps });
     logger.info(TAG, `Transitioned ${previousMode} → ${target}`);
     recordModeTransition({
         previousMode,
         targetMode: target,
         acknowledged,
         ok: true,
-        testnet: exchange?.testnet,
+        testnet: exchange?.testnet ?? hlCredentials?.testnet,
     });
     return {
         ok: true,

package/venues/hyperliquid/hl-bracket-coordinator.d.ts

@@ -0,0 +1,123 @@
+import { EventEmitter } from 'node:events';
+import type { CcxtOrder, CcxtPosition } from '../../types.js';
+import type { CloseReason } from '../../simulator/types.js';
+import type { BracketId, BracketRequest, BracketState } from '../../live/bracket-types.js';
+import type { BracketLedger } from '../../live/bracket-ledger.js';
+import type { HlOrderUpdateEvent } from './hl-user-stream.js';
+/** Narrow execution surface the coordinator needs — the HyperliquidLiveAdapter
+ *  implements it; tests mock it without a network. */
+export interface HlBracketExecutor {
+    attachBrackets(args: {
+        bracketId: BracketId;
+        symbol: string;
+        positionSide: 'long' | 'short';
+        positionSize: number;
+        stopPrice?: number;
+        targetPrice?: number;
+    }): Promise<{
+        orders: CcxtOrder[];
+        slCid?: string;
+        tpCid?: string;
+    }>;
+    resizeBrackets(args: {
+        bracketId: BracketId;
+        symbol: string;
+        positionSide: 'long' | 'short';
+        positionSize: number;
+    }): Promise<{
+        resized: boolean;
+        slCid?: string;
+        tpCid?: string;
+    }>;
+    /** Cancel one leg by cloid. Idempotent — "already gone" must not throw. */
+    cancelBracketLeg(cloid: string, symbol: string): Promise<void>;
+    /** Coverage audit — THROWS when order state is unknown (null ≠ empty). */
+    auditBracketCoverage(symbol: string, positionSize: number): Promise<{
+        covered: boolean;
+        shortfall: {
+            stop: number;
+            target: number;
+        };
+        missing: ('stop' | 'target')[];
+    }>;
+    getPositionsOrNull(symbol?: string): Promise<CcxtPosition[] | null>;
+    closePosition(symbol: string, closeReason?: CloseReason): Promise<CcxtOrder>;
+}
+export interface HlAttachResult {
+    ok: boolean;
+    latencyMs: number;
+    slCid?: string;
+    tpCid?: string;
+    error?: string;
+    attempts: number;
+}
+export interface HlCoordinatorOpts {
+    maxAttempts?: number;
+    retryBackoffMs?: (attempt: number) => number;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+}
+export declare function isTerminalBracketState(state: BracketState): boolean;
+export declare class HlBracketCoordinator extends EventEmitter {
+    private readonly executor;
+    private readonly ledger;
+    private readonly maxAttempts;
+    private readonly backoff;
+    private readonly now;
+    private readonly sleep;
+    /** Per-symbol in-flight guard so a WS fill + the createOrder return path
+     *  can't both run attachOnFill concurrently (double-submit). */
+    private readonly inFlight;
+    /** Cloids WE deliberately cancelled (resize/modify supersede, retry cleanup,
+     *  cancelBrackets). Their WS 'canceled' events are OUR OWN and must never
+     *  trip the stripped-protection canary — the T-8 testnet run proved the WS
+     *  event can arrive BEFORE the ledger's fresh-cid update lands, so a
+     *  generation check alone loses the race. Entries pruned after 5 min. */
+    private readonly ownCancels;
+    constructor(executor: HlBracketExecutor, ledger: BracketLedger, opts?: HlCoordinatorOpts);
+    getLedger(): BracketLedger;
+    /** Record a leg cancel WE initiated (see `ownCancels`). The adapter calls
+     *  this for every deliberate leg cancel, including the resize path's direct
+     *  api cancels, BEFORE the cancel request goes out. */
+    noteOwnLegCancel(cloid: string): void;
+    /** Same anti-clobber contract as BracketManager.registerEntry: a duplicate
+     *  fill signal against a non-terminal row is a warned NO-OP, never a fresh
+     *  bracketId that orphans the live legs' ledger identity. */
+    registerEntry(req: BracketRequest, bracketId: BracketId, entryCid: string): void;
+    /** Attach both legs (ONE batched signed action) with retries. Idempotent on
+     *  a non-pending row. On exhaustion: ledger 'failed' + attach_failed event —
+     *  the ADAPTER escalates to auto-flatten (it owns closePosition). */
+    attachOnFill(symbol: string, filledSize: number): Promise<HlAttachResult>;
+    /** ★ T-2: bring the legs to the CURRENT position size (scale-in / partial
+     *  fill growth). Submit-first-then-cancel inside the adapter. Updates the
+     *  ledger's qty + fresh cids on success. */
+    resizeToPosition(symbol: string, newPositionSize: number): Promise<{
+        resized: boolean;
+    }>;
+    /** Move the stop. HL ordering: submit the NEW leg first, then cancel the old
+     *  one — over-protection for a moment beats a naked window (see header). */
+    modifyStop(symbol: string, newStopPrice: number): Promise<void>;
+    modifyTarget(symbol: string, newTargetPrice: number): Promise<void>;
+    private modifyLeg;
+    /** Cancel both legs, mark cancelled. Risk-reducing; best-effort per leg. */
+    cancelBrackets(symbol: string, reason: string): Promise<void>;
+    /**
+     * The HL analog of the Binance ALGO_UPDATE handler — `orderUpdates` is
+     * authoritative for bracket-leg lifecycle. Returns the transition applied
+     * (for the adapter to emit drift/close-bypass signals on triggers).
+     */
+    handleOrderUpdate(update: HlOrderUpdateEvent): 'triggered_sl' | 'triggered_tp' | 'forced_close' | null;
+    /**
+     * ★ T-5 mandate: REST truth-check. Runs after every WS (re)connect AND on the
+     * periodic sweep. TRUSTED reads only — a null positions fetch skips the pass
+     * (never act on unknown). Self-heals: pending rows whose entry filled while
+     * we were blind get their legs attached; undersized legs get resized; flat
+     * positions get their rows closed out (T-1 already cancelled the legs).
+     * Returns symbols whose rows were closed out (close-bypass signals for the
+     * adapter's drift pipeline).
+     */
+    resyncAgainstExchange(reasonTag: string): Promise<{
+        closedSymbols: string[];
+    }>;
+    private emitEvent;
+}