@reefclaw/connect 0.1.12 → 0.1.14

package/assets/plugin/wave9/usdm-evidence-provider.d.ts

@@ -0,0 +1,42 @@
+import type { OhlcvBar } from '../signals/types.js';
+export declare const FOUR_HOURS_MS: number;
+export declare const FUNDING_INTERVAL_MS: number;
+/** Binance has emitted historical funding timestamps three milliseconds after
+ * the nominal settlement boundary. Accept only tightly bounded source jitter,
+ * then canonicalize back to the exact research event identity. */
+export declare const FUNDING_TIME_TOLERANCE_MS = 10;
+export interface Wave9FundingSettlement {
+    time: Date;
+    rate: number;
+}
+export interface Wave9SymbolEvidence {
+    symbol: string;
+    venueSymbol: string;
+    dailyBars: OhlcvBar[];
+    fourHourBars: OhlcvBar[];
+    fundingSettlements: Wave9FundingSettlement[];
+}
+export interface Wave9EvidenceBatch {
+    venue: 'binance_usdm';
+    marketType: 'future';
+    eventTime: Date;
+    evidenceFromExclusive: Date;
+    symbols: Wave9SymbolEvidence[];
+}
+interface UsdmExchange {
+    id?: string;
+    options?: Record<string, unknown>;
+    fetchOHLCV(symbol: string, timeframe: string, since?: number, limit?: number): Promise<unknown[]>;
+    fetchFundingRateHistory(symbol: string, since?: number, limit?: number): Promise<unknown[]>;
+}
+export interface Wave9EvidenceProvider {
+    fetchAtomicBatch(eventTime: Date): Promise<Wave9EvidenceBatch>;
+}
+export declare class BinanceUsdmWave9EvidenceProvider implements Wave9EvidenceProvider {
+    private readonly exchange;
+    constructor(exchange: UsdmExchange);
+    fetchAtomicBatch(eventTime: Date): Promise<Wave9EvidenceBatch>;
+}
+/** Deliberately lazy: off mode imports this module but never loads/creates CCXT. */
+export declare function createWave9UsdmEvidenceProvider(): Wave9EvidenceProvider;
+export {};

package/assets/plugin/wave9/usdm-evidence-provider.js

@@ -0,0 +1,133 @@
+import { createRequire } from 'node:module';
+import { DAY_MS, WAVE9_CONTEXT_BARS, WAVE9_SYMBOL_PRIORITY, } from '../portfolio/wave9-policy.js';
+export const FOUR_HOURS_MS = 4 * 60 * 60 * 1_000;
+export const FUNDING_INTERVAL_MS = 8 * 60 * 60 * 1_000;
+/** Binance has emitted historical funding timestamps three milliseconds after
+ * the nominal settlement boundary. Accept only tightly bounded source jitter,
+ * then canonicalize back to the exact research event identity. */
+export const FUNDING_TIME_TOLERANCE_MS = 10;
+function venueSymbol(symbol) {
+    if (!symbol.endsWith('USDT'))
+        throw new Error(`unsupported Wave 9 symbol ${symbol}`);
+    return `${symbol.slice(0, -4)}/USDT:USDT`;
+}
+function ohlcvRows(rows, label) {
+    return rows.map((raw, index) => {
+        if (!Array.isArray(raw) || raw.length < 6) {
+            throw new Error(`${label} row ${index} is not a complete OHLCV tuple`);
+        }
+        const values = raw.slice(0, 6).map(Number);
+        if (!values.every(Number.isFinite)) {
+            throw new Error(`${label} row ${index} contains a non-finite value`);
+        }
+        const [time, open, high, low, close, volume] = values;
+        if (open <= 0 || high <= 0 || low <= 0 || close <= 0 || volume < 0) {
+            throw new Error(`${label} row ${index} has invalid market values`);
+        }
+        if (high < Math.max(open, close) || low > Math.min(open, close)) {
+            throw new Error(`${label} row ${index} has invalid OHLC geometry`);
+        }
+        return { time: new Date(time), open, high, low, close, volume };
+    });
+}
+function fundingRows(rows, label) {
+    return rows.map((raw, index) => {
+        const row = raw;
+        const info = row?.info;
+        const time = Number(row?.timestamp ?? info?.fundingTime);
+        const rate = Number(row?.fundingRate ?? info?.fundingRate);
+        if (!Number.isFinite(time) || !Number.isFinite(rate)) {
+            throw new Error(`${label} funding row ${index} is incomplete`);
+        }
+        return { time: new Date(time), rate };
+    });
+}
+function requireExactTimes(actual, expected, label) {
+    const times = actual.map((row) => row.time.getTime());
+    if (times.length !== expected.length || times.some((time, index) => time !== expected[index])) {
+        throw new Error(`${label} is partial or stale: expected [${expected.map((time) => new Date(time).toISOString()).join(', ')}], got [${times.map((time) => new Date(time).toISOString()).join(', ')}]`);
+    }
+}
+function canonicalizeFundingTimes(actual, expected, label) {
+    const times = actual.map((row) => row.time.getTime());
+    const mismatched = times.length !== expected.length
+        || times.some((time, index) => Math.abs(time - expected[index]) > FUNDING_TIME_TOLERANCE_MS);
+    if (mismatched) {
+        throw new Error(`${label} is partial or stale: expected [${expected.map((time) => new Date(time).toISOString()).join(', ')}] `
+            + `within ${FUNDING_TIME_TOLERANCE_MS}ms, got [${times.map((time) => new Date(time).toISOString()).join(', ')}]`);
+    }
+    return actual.map((row, index) => ({ ...row, time: new Date(expected[index]) }));
+}
+export class BinanceUsdmWave9EvidenceProvider {
+    exchange;
+    constructor(exchange) {
+        this.exchange = exchange;
+        if (exchange.id !== 'binanceusdm' || exchange.options?.defaultType !== 'future') {
+            throw new Error('Wave 9 evidence provider requires Binance USD-M futures (binanceusdm/defaultType=future)');
+        }
+    }
+    async fetchAtomicBatch(eventTime) {
+        const eventMs = eventTime.getTime();
+        if (!Number.isFinite(eventMs) || eventMs % DAY_MS !== 0) {
+            throw new Error('Wave 9 event must be a UTC daily boundary');
+        }
+        const fromMs = eventMs - DAY_MS;
+        const expectedDaily = Array.from({ length: WAVE9_CONTEXT_BARS }, (_, index) => eventMs - (WAVE9_CONTEXT_BARS - index) * DAY_MS);
+        const expected4h = Array.from({ length: 7 }, (_, index) => fromMs + index * FOUR_HOURS_MS);
+        const expectedFunding = [fromMs + FUNDING_INTERVAL_MS, fromMs + 2 * FUNDING_INTERVAL_MS, eventMs];
+        // Promise.all is only a transport optimization. No caller sees a batch
+        // unless every one of the eight frozen symbols validates in full.
+        const symbols = await Promise.all(WAVE9_SYMBOL_PRIORITY.map(async (symbol) => {
+            const ccxtSymbol = venueSymbol(symbol);
+            const [dailyRaw, fourHourRaw, fundingRaw] = await Promise.all([
+                this.exchange.fetchOHLCV(ccxtSymbol, '1d', eventMs - (WAVE9_CONTEXT_BARS + 2) * DAY_MS, WAVE9_CONTEXT_BARS + 2),
+                this.exchange.fetchOHLCV(ccxtSymbol, '4h', fromMs, 7),
+                this.exchange.fetchFundingRateHistory(ccxtSymbol, fromMs + 1, 16),
+            ]);
+            const dailyBars = ohlcvRows(dailyRaw, `${symbol} 1d`)
+                .filter((bar) => bar.time.getTime() + DAY_MS <= eventMs)
+                .slice(-WAVE9_CONTEXT_BARS);
+            const fourHourBars = ohlcvRows(fourHourRaw, `${symbol} 4h`)
+                .filter((bar) => bar.time.getTime() >= fromMs && bar.time.getTime() <= eventMs)
+                .sort((left, right) => left.time.getTime() - right.time.getTime());
+            const fundingRowsInWindow = fundingRows(fundingRaw, symbol)
+                .filter((row) => row.time.getTime() > fromMs
+                && row.time.getTime() <= eventMs + FUNDING_TIME_TOLERANCE_MS)
+                .sort((left, right) => left.time.getTime() - right.time.getTime());
+            requireExactTimes(dailyBars, expectedDaily, `${symbol} completed 1d evidence`);
+            requireExactTimes(fourHourBars, expected4h, `${symbol} 4h evidence`);
+            const fundingSettlements = canonicalizeFundingTimes(fundingRowsInWindow, expectedFunding, `${symbol} funding evidence`);
+            return {
+                symbol,
+                venueSymbol: ccxtSymbol,
+                dailyBars,
+                fourHourBars,
+                fundingSettlements,
+            };
+        }));
+        if (symbols.some((row, index) => row.symbol !== WAVE9_SYMBOL_PRIORITY[index])) {
+            throw new Error('Wave 9 evidence universe/order mismatch');
+        }
+        return {
+            venue: 'binance_usdm',
+            marketType: 'future',
+            eventTime: new Date(eventMs),
+            evidenceFromExclusive: new Date(fromMs),
+            symbols,
+        };
+    }
+}
+/** Deliberately lazy: off mode imports this module but never loads/creates CCXT. */
+export function createWave9UsdmEvidenceProvider() {
+    const require = createRequire(import.meta.url);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const ccxt = require('ccxt');
+    const BinanceUsdm = ccxt.binanceusdm ?? ccxt.default?.binanceusdm;
+    if (!BinanceUsdm)
+        throw new Error('CCXT binanceusdm class is unavailable');
+    const exchange = new BinanceUsdm({
+        enableRateLimit: true,
+        options: { defaultType: 'future' },
+    });
+    return new BinanceUsdmWave9EvidenceProvider(exchange);
+}

package/dist/plugin.js

@@ -48,27 +48,36 @@ export function installPlugin() {
     const cli = which('openclaw');
     if (!cli) {
         fail('the `openclaw` CLI is not on your PATH — cannot register the plugin.');
-        info(`Once OpenClaw is on PATH, run:  openclaw plugins install --force --link ${PLUGIN_DIR}`);
+        info(`Once OpenClaw is on PATH, run:  openclaw plugins install --link ${PLUGIN_DIR}`);
+        info('(if OpenClaw asks you to rerun with --force, add --force before --link)');
         return { registered: false };
     }
-    // --force is REQUIRED on openclaw >= 2026.7.2 (issue #216): non-ClawHub
-    // sources (incl. local paths) need an acknowledgement, and in a non-TTY
-    // context the install is cancelled with "rerun with --force" instead of
-    // prompting. Acknowledging is correct here — the "source" is our own bundled
-    // plugin the user explicitly chose to install by running this installer.
-    // On <= 2026.7.1, --force only means overwrite-an-existing-install, which
-    // also makes installer re-runs idempotent instead of failing on the exists
-    // check. Verified against both dists' plugins-install command + the beta's
-    // confirmNonClawHubInstall (install cancelled when !TTY && !force).
+    // Two OpenClaw generations have MUTUALLY EXCLUSIVE requirements here
+    // (issue #216, verified against both npm dists):
+    //  - <= 2026.7.1 hard-REJECTS --force with --link ("--force is not
+    //    supported with --link", plugins-install-command guard);
+    //  - >= 2026.7.2 REQUIRES --force for non-ClawHub sources in a non-TTY
+    //    context (confirmNonClawHubInstall cancels with "rerun with --force").
+    // So: try plain --link first (correct on every version that doesn't gate),
+    // and only when the CLI's own output asks for --force, retry with it.
+    // Acknowledging is correct here — the "source" is our own bundled plugin the
+    // user explicitly chose to install by running this installer. The first
+    // attempt never passes --force, so any mention of --force in its output is
+    // the CLI requesting it, not an echo of our own arguments.
     info('registering the plugin with OpenClaw…');
-    const r = run('openclaw', ['plugins', 'install', '--force', '--link', PLUGIN_DIR], {
-        timeoutMs: 300_000,
-    });
+    let r = run('openclaw', ['plugins', 'install', '--link', PLUGIN_DIR], { timeoutMs: 300_000 });
+    if (!r.ok && `${r.stderr}\n${r.stdout}`.includes('--force')) {
+        info('this OpenClaw requires acknowledging non-ClawHub sources — retrying with --force…');
+        r = run('openclaw', ['plugins', 'install', '--force', '--link', PLUGIN_DIR], {
+            timeoutMs: 300_000,
+        });
+    }
     if (!r.ok) {
-        warn('`openclaw plugins install --force --link` returned non-zero:');
+        warn('`openclaw plugins install --link` returned non-zero:');
         if (r.stderr.trim())
             info(r.stderr.trim().split('\n').slice(-3).join('\n'));
-        info(`Retry manually:  openclaw plugins install --force --link ${PLUGIN_DIR}`);
+        info(`Retry manually:  openclaw plugins install --link ${PLUGIN_DIR}`);
+        info('(if OpenClaw asks you to rerun with --force, add --force before --link)');
         return { registered: false };
     }
     ok('plugin registered with OpenClaw');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reefclaw/connect",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "One-command installer that connects your OpenClaw agent to ReefClaw (paper trading, no exchange keys).",
   "type": "module",
   "bin": {