@reefclaw/openclaw-plugin 0.1.12 → 0.1.13

package/venues/hyperliquid/hl-private.js

@@ -29,6 +29,8 @@ import { logger } from '../../logger.js';
 import { toCcxtSymbol } from '../symbols.js';
 import { assertNotLimited, noteError, noteSuccess, exchangeIpWeight, updateAddressBudget, } from './hl-rate-gate.js';
 import { isValidHlCloid } from './hl-cloid.js';
+import { normalizeHlPosition } from './hl-position.js';
+import { normalizeHlOrder } from './hl-order.js';
 // ccxt via CJS require — OpenClaw's ESM loader yields the wrong module shape
 // (same rationale as binance-private.ts / hl-public.ts).
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -124,7 +126,15 @@ export class HyperliquidPrivateApi {
     }
     // ---- Reads (null on failure — NEVER []) ----
     /** Positions for the MASTER account. `null` = fetch failed (state unknown);
-     *  `[]` = the exchange confirmed flat. */
+     *  `[]` = the exchange confirmed flat.
+     *
+     *  ★ Rows are normalized through `normalizeHlPosition` — ccxt leaves
+     *  `markPrice`/`contractSize`/`timestamp`/`datetime` UNDEFINED on this venue
+     *  (clearinghouseState carries no markPx) while `CcxtPosition` declares them
+     *  required, which crashed `get_risk_summary` and degraded every other
+     *  mark-reading consumer. See hl-position.ts for the doc-exact derivation.
+     *  A row that cannot be priced makes the WHOLE snapshot null (unknown) — never
+     *  a partial list, never a fabricated zero. */
     async fetchPositions(symbol) {
         try {
             assertNotLimited('clearinghouseState');
@@ -133,7 +143,19 @@ export class HyperliquidPrivateApi {
             noteSuccess('clearinghouseState');
             if (!Array.isArray(raw))
                 return null;
-            return raw.filter((p) => Math.abs(Number(p.contracts ?? 0)) > 0);
+            const out = [];
+            for (const p of raw) {
+                if (Math.abs(Number(p?.contracts ?? 0)) <= 0)
+                    continue; // flat row — information, not failure
+                const normalized = normalizeHlPosition(p);
+                if (!normalized) {
+                    logger.error(TAG, `fetchPositions: unparseable position row for ${String(p?.symbol ?? 'unknown symbol')} ` +
+                        '— returning null (snapshot UNTRUSTED; a dropped row would read as "flat")');
+                    return null;
+                }
+                out.push(normalized);
+            }
+            return out;
         }
         catch (err) {
             noteError(err, 'fetchPositions');
@@ -143,14 +165,19 @@ export class HyperliquidPrivateApi {
     }
     /** Open orders INCLUDING trigger/TPSL legs. CCXT's HL `fetchOpenOrders`
      *  defaults to `frontendOpenOrders`, which is the only endpoint that returns
-     *  trigger orders (plan §3.6) — the analog of Binance's merged algo endpoints. */
+     *  trigger orders (plan §3.6) — the analog of Binance's merged algo endpoints.
+     *
+     *  ★ Rows are normalized through `normalizeHlOrder` (ccxt leaves cost/fee/
+     *  average/timeInForce undefined and leaks 'take profit market' past the
+     *  type union — see hl-order.ts); `info` + `clientOrderId` survive verbatim
+     *  (protective classification + bracket reconciliation read them). */
     async fetchOpenOrders(symbol) {
         try {
             assertNotLimited('frontendOpenOrders');
             const s = symbol ? toCcxtSymbol('hyperliquid', symbol) : undefined;
             const raw = await this.exchange.fetchOpenOrders(s);
             noteSuccess('frontendOpenOrders');
-            return Array.isArray(raw) ? raw : null;
+            return Array.isArray(raw) ? raw.map((o) => normalizeHlOrder(o)) : null;
         }
         catch (err) {
             noteError(err, 'fetchOpenOrders');
@@ -173,14 +200,18 @@ export class HyperliquidPrivateApi {
     }
     /** Per-order status — the liveness resolver's REST tier (Tier 2 of the
      *  3-tier rule). Weight 2. `null` = lookup FAILED (unknown), which callers
-     *  must treat as "do not act", NOT as "gone". */
+     *  must treat as "do not act", NOT as "gone".
+     *
+     *  Normalized like fetchOpenOrders. Unknown statuses collapse to 'open'
+     *  (= not confirmed terminal — the conservative direction for both the
+     *  liveness resolver and the entry poller); raw status stays in `info`. */
     async fetchOrder(orderId, symbol) {
         try {
             assertNotLimited('orderStatus');
             const s = symbol ? toCcxtSymbol('hyperliquid', symbol) : undefined;
             const raw = await this.exchange.fetchOrder(orderId, s);
             noteSuccess('orderStatus');
-            return raw ?? null;
+            return raw ? normalizeHlOrder(raw) : null;
         }
         catch (err) {
             noteError(err, 'fetchOrder');