solana-traderclaw 1.0.19

package/bin/traderclaw.cjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * npm `bin` entry for global `traderclaw`. Delegates to `openclaw-trader.mjs` with argv preserved.
+ * Uses .cjs so npm does not strip the bin link when `package.json` has `"type": "module"`.
+ */
+const { spawnSync } = require("node:child_process");
+const path = require("node:path");
+const script = path.join(__dirname, "openclaw-trader.mjs");
+const result = spawnSync(process.execPath, [script, ...process.argv.slice(2)], {
+  stdio: "inherit",
+  env: process.env,
+});
+process.exit(result.status === null ? 1 : result.status);

package/config/gateway-v1.json5

@@ -0,0 +1,121 @@
+// OpenClaw Gateway Configuration — TraderClaw V1 (Single Agent)
+// Single "main" agent with 5-minute heartbeat + cron jobs for autonomous operation.
+// Without this config, the agent ONLY runs when a user sends a message.
+// With this config, the agent wakes every 5 minutes AND runs scheduled maintenance jobs.
+// See: docs/scheduling-architecture.md
+{
+  agents: {
+    list: [
+      {
+        id: "main",
+        default: true,
+        heartbeat: { every: "5m", target: "last" }
+        // Core trading loop — scan, analyze, decide, execute, monitor.
+        // Wakes every 5 minutes to check alpha buffer, positions, and market conditions.
+        // Also receives all cron jobs since V1 is a single-agent system.
+      }
+    ]
+  },
+
+  cron: {
+    enabled: true,
+    maxConcurrentRuns: 2,
+    sessionRetention: "24h",
+    runLog: {
+      maxBytes: "2mb",
+      keepLines: 2000
+    },
+    jobs: [
+      // ── Strategy & Learning ───────────────────────────────────────
+      {
+        id: "strategy-evolution",
+        schedule: "0 */4 * * *",          // Every 4 hours
+        agentId: "main",
+        message: "CRON_JOB: strategy_evolution — Review trade journal, compute weight adjustments, update strategy. Only update if sufficient closed trades have accumulated.",
+        enabled: true
+      },
+      {
+        id: "source-reputation",
+        schedule: "0 */3 * * *",          // Every 3 hours
+        agentId: "main",
+        message: "CRON_JOB: source_reputation_recalc — Analyze which alpha signal sources led to wins vs losses. Update reputation tracking in memory.",
+        enabled: true
+      },
+
+      // ── Risk & Audit ──────────────────────────────────────────────
+      {
+        id: "risk-audit",
+        schedule: "0 */2 * * *",          // Every 2 hours
+        agentId: "main",
+        message: "CRON_JOB: portfolio_risk_audit — Portfolio stress tests, exposure checks, correlation analysis, drawdown monitoring.",
+        enabled: true
+      },
+
+      // ── On-Chain Intelligence ─────────────────────────────────────
+      {
+        id: "meta-rotation",
+        schedule: "30 */3 * * *",         // Every 3 hours at :30
+        agentId: "main",
+        message: "CRON_JOB: meta_rotation_analysis — Analyze narrative clusters across recent scans and trades. Identify hot vs cooling metas. Write observations to memory.",
+        enabled: true
+      },
+
+      // ── Portfolio Maintenance ─────────────────────────────────────
+      {
+        id: "dead-money-sweep",
+        schedule: "0 */2 * * *",          // Every 2 hours
+        agentId: "main",
+        message: "CRON_JOB: dead_money_sweep — Check all open LOCAL_MANAGED positions for dead money. Exit stale positions. Tag as dead_money.",
+        enabled: true
+      },
+      {
+        id: "subscription-cleanup",
+        schedule: "0 * * * *",            // Every hour
+        agentId: "main",
+        message: "CRON_JOB: subscription_cleanup — Check active Bitquery subscriptions. Unsubscribe from streams no longer needed (sold tokens, closed positions).",
+        enabled: true
+      },
+
+      // ── Reporting ─────────────────────────────────────────────────
+      {
+        id: "daily-report",
+        schedule: "0 4 * * *",            // Daily at 04:00 UTC
+        agentId: "main",
+        message: "CRON_JOB: daily_performance_report — Calculate daily PnL, aggregate win/loss stats, source reputation summary, write comprehensive memory entry.",
+        enabled: true
+      },
+
+      // ── Whale / Smart Money Tracking ──────────────────────────────
+      {
+        id: "whale-watch",
+        schedule: "0 */2 * * *",          // Every 2 hours
+        agentId: "main",
+        message: "CRON_JOB: whale_activity_scan — Scan for large wallet movements, deployer activity, and accumulation patterns across watched tokens.",
+        enabled: true
+      }
+    ]
+  },
+
+  hooks: {
+    enabled: true,
+    token: "REPLACE_WITH_SECURE_TOKEN",
+    mappings: [
+      {
+        // High-priority alpha signals from SpyFly aggregator
+        // Triggers immediate agent turn outside heartbeat cadence
+        match: { path: "alpha-signal" },
+        action: "agent",
+        agentId: "main",
+        deliver: true
+      },
+      {
+        // Bitquery firehose alerts for on-chain discovery events
+        // Wakes agent for immediate analysis
+        match: { path: "firehose-alert" },
+        action: "agent",
+        agentId: "main",
+        deliver: true
+      }
+    ]
+  }
+}

package/dist/chunk-3UQIQJPQ.js

@@ -0,0 +1,144 @@
+// src/alpha-buffer.ts
+var MAX_BUFFER_SIZE = 200;
+var SEEN_EVENT_TTL_MS = 60 * 60 * 1e3;
+var MAX_SEEN_EVENTS = 500;
+function dedupKey(signal) {
+  const minuteBucket = Math.floor(signal.ts / 6e4);
+  return `${signal.sourceName}|${signal.tokenAddress}|${signal.kind}|${minuteBucket}`;
+}
+var AlphaBuffer = class {
+  signals = [];
+  dedupSet = /* @__PURE__ */ new Set();
+  seenEventIds = /* @__PURE__ */ new Map();
+  sourceStats = /* @__PURE__ */ new Map();
+  tokenIndex = /* @__PURE__ */ new Map();
+  push(raw) {
+    if (raw.chain && raw.chain.toLowerCase() === "bsc") {
+      return false;
+    }
+    const key = dedupKey(raw);
+    if (this.dedupSet.has(key)) {
+      return false;
+    }
+    const signal = {
+      ...raw,
+      systemScore: raw.systemScore ?? 0,
+      _seen: false,
+      _ingestedAt: Date.now()
+    };
+    if (raw.eventId && this.seenEventIds.has(raw.eventId)) {
+      signal._seen = true;
+    }
+    this.dedupSet.add(key);
+    if (this.signals.length >= MAX_BUFFER_SIZE) {
+      const evicted = this.signals.shift();
+      const evictedKey = dedupKey(evicted);
+      this.dedupSet.delete(evictedKey);
+      this.decrementSourceStats(evicted);
+      this.rebuildTokenIndex();
+    }
+    const idx = this.signals.length;
+    this.signals.push(signal);
+    const tokenIdxList = this.tokenIndex.get(signal.tokenAddress) || [];
+    tokenIdxList.push(idx);
+    this.tokenIndex.set(signal.tokenAddress, tokenIdxList);
+    this.updateSourceStats(signal);
+    return true;
+  }
+  getSignals(opts = {}) {
+    const { minScore, chain, kinds, unseen = true } = opts;
+    const results = [];
+    for (const signal of this.signals) {
+      if (unseen && signal._seen) continue;
+      if (minScore !== void 0 && signal.systemScore < minScore) continue;
+      if (chain && signal.chain.toLowerCase() !== chain.toLowerCase()) continue;
+      if (kinds && kinds.length > 0 && !kinds.includes(signal.kind)) continue;
+      results.push(signal);
+    }
+    if (unseen) {
+      for (const signal of results) {
+        signal._seen = true;
+      }
+    }
+    return results;
+  }
+  getTokenHistory(tokenAddress) {
+    const indices = this.tokenIndex.get(tokenAddress);
+    if (!indices) return [];
+    return indices.filter((i) => i < this.signals.length).map((i) => this.signals[i]).filter((s) => s.tokenAddress === tokenAddress);
+  }
+  getSourceStatsAll() {
+    return Array.from(this.sourceStats.values());
+  }
+  markEventSeen(eventId) {
+    this.seenEventIds.set(eventId, Date.now());
+    this.pruneSeenEvents();
+    for (const signal of this.signals) {
+      if (signal.eventId === eventId) {
+        signal._seen = true;
+      }
+    }
+  }
+  hasSeenEvent(eventId) {
+    return this.seenEventIds.has(eventId);
+  }
+  getBufferSize() {
+    return this.signals.length;
+  }
+  updateSourceStats(signal) {
+    const existing = this.sourceStats.get(signal.sourceName);
+    if (existing) {
+      existing.signalCount++;
+      existing.totalScore += signal.systemScore;
+      existing.avgScore = existing.totalScore / existing.signalCount;
+    } else {
+      this.sourceStats.set(signal.sourceName, {
+        name: signal.sourceName,
+        type: signal.sourceType,
+        signalCount: 1,
+        avgScore: signal.systemScore,
+        totalScore: signal.systemScore
+      });
+    }
+  }
+  decrementSourceStats(signal) {
+    const existing = this.sourceStats.get(signal.sourceName);
+    if (!existing) return;
+    existing.signalCount--;
+    existing.totalScore -= signal.systemScore;
+    if (existing.signalCount <= 0) {
+      this.sourceStats.delete(signal.sourceName);
+    } else {
+      existing.avgScore = existing.totalScore / existing.signalCount;
+    }
+  }
+  rebuildTokenIndex() {
+    this.tokenIndex.clear();
+    for (let i = 0; i < this.signals.length; i++) {
+      const addr = this.signals[i].tokenAddress;
+      const list = this.tokenIndex.get(addr) || [];
+      list.push(i);
+      this.tokenIndex.set(addr, list);
+    }
+  }
+  pruneSeenEvents() {
+    if (this.seenEventIds.size <= MAX_SEEN_EVENTS) return;
+    const now = Date.now();
+    for (const [id, timestamp] of this.seenEventIds) {
+      if (now - timestamp > SEEN_EVENT_TTL_MS) {
+        this.seenEventIds.delete(id);
+      }
+    }
+    if (this.seenEventIds.size > MAX_SEEN_EVENTS) {
+      const sorted = Array.from(this.seenEventIds.entries()).sort((a, b) => a[1] - b[1]);
+      const toRemove = sorted.slice(0, sorted.length - MAX_SEEN_EVENTS);
+      for (const [id] of toRemove) {
+        this.seenEventIds.delete(id);
+      }
+    }
+  }
+};
+
+export {
+  AlphaBuffer
+};

package/dist/chunk-3YPZOXWE.js

@@ -0,0 +1,238 @@
+// src/alpha-ws.ts
+var RECONNECT_DELAYS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
+var AlphaStreamManager = class {
+  config;
+  ws = null;
+  subscribed = false;
+  authenticated = false;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  intentionalClose = false;
+  messageCount = 0;
+  lastEventTs = 0;
+  connectedAt = 0;
+  tier = "";
+  premiumAccess = false;
+  currentAccessToken = "";
+  constructor(config) {
+    this.config = config;
+  }
+  async subscribe() {
+    if (this.subscribed && this.ws && this.ws.readyState === 1) {
+      return { subscribed: true, premiumAccess: this.premiumAccess, tier: this.tier };
+    }
+    this.intentionalClose = false;
+    await this.connect();
+    return new Promise((resolve, reject) => {
+      const checkSubscribed = setInterval(() => {
+        if (this.subscribed) {
+          clearTimeout(timeout);
+          clearInterval(checkSubscribed);
+          resolve({ subscribed: true, premiumAccess: this.premiumAccess, tier: this.tier });
+        }
+      }, 100);
+      const timeout = setTimeout(() => {
+        clearInterval(checkSubscribed);
+        reject(new Error("Alpha stream subscription timed out after 15 seconds"));
+      }, 15e3);
+    });
+  }
+  async unsubscribe() {
+    this.intentionalClose = true;
+    this.subscribed = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      try {
+        if (this.ws.readyState === 1) {
+          this.ws.send(JSON.stringify({ type: "alpha_stream_unsubscribe" }));
+        }
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+    return { unsubscribed: true };
+  }
+  getAgentId() {
+    return this.config.agentId;
+  }
+  setAgentId(agentId) {
+    this.config.agentId = agentId;
+  }
+  setSubscriberType(subscriberType) {
+    this.config.subscriberType = subscriberType;
+  }
+  isSubscribed() {
+    return this.subscribed && this.ws !== null && this.ws.readyState === 1;
+  }
+  getStats() {
+    return {
+      subscribed: this.isSubscribed(),
+      messageCount: this.messageCount,
+      lastEventTs: this.lastEventTs,
+      connectedAt: this.connectedAt,
+      uptimeSeconds: this.connectedAt ? Math.floor((Date.now() - this.connectedAt) / 1e3) : 0
+    };
+  }
+  sendAlphaSubscribe() {
+    if (!this.ws || this.ws.readyState !== 1) return;
+    const subscribeMsg = { type: "alpha_stream_subscribe" };
+    if (this.config.agentId) {
+      subscribeMsg.agentId = this.config.agentId;
+    }
+    if (this.config.subscriberType) {
+      subscribeMsg.subscriberType = this.config.subscriberType;
+    } else if (this.config.agentId) {
+      subscribeMsg.subscriberType = "agent";
+    }
+    this.log("info", "Sending alpha_stream_subscribe");
+    this.ws.send(JSON.stringify(subscribeMsg));
+  }
+  async connect() {
+    const WebSocket = (await import("ws")).default;
+    this.currentAccessToken = await this.config.getAccessToken();
+    const url = `${this.config.wsUrl}?accessToken=${encodeURIComponent(this.currentAccessToken)}`;
+    this.authenticated = false;
+    this.log("info", `Connecting to alpha stream: ${this.config.wsUrl}`);
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new WebSocket(url);
+      } catch (err) {
+        reject(err);
+        return;
+      }
+      const connectTimeout = setTimeout(() => {
+        if (this.ws && this.ws.readyState !== 1) {
+          this.ws.close();
+          reject(new Error("WebSocket connection timed out"));
+        }
+      }, 1e4);
+      this.ws.on("open", () => {
+        clearTimeout(connectTimeout);
+        this.connectedAt = Date.now();
+        this.reconnectAttempt = 0;
+        this.log("info", "WebSocket connected, waiting for server handshake...");
+        resolve();
+      });
+      this.ws.on("message", (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          this.handleMessage(msg);
+        } catch {
+          this.log("warn", "Failed to parse WebSocket message");
+        }
+      });
+      this.ws.on("close", () => {
+        clearTimeout(connectTimeout);
+        this.subscribed = false;
+        this.authenticated = false;
+        this.log("info", "WebSocket closed");
+        if (!this.intentionalClose) {
+          this.scheduleReconnect();
+        }
+      });
+      this.ws.on("error", (err) => {
+        clearTimeout(connectTimeout);
+        this.log("error", `WebSocket error: ${err.message}`);
+        if (this.ws && this.ws.readyState !== 1) {
+          reject(err);
+        }
+      });
+    });
+  }
+  handleMessage(msg) {
+    switch (msg.type) {
+      case "connected":
+        if (!this.authenticated) {
+          this.log("info", "Server handshake received, sending auth...");
+          if (this.ws && this.ws.readyState === 1) {
+            this.ws.send(JSON.stringify({ type: "auth", accessToken: this.currentAccessToken }));
+          }
+        }
+        break;
+      case "authenticated":
+        this.tier = msg.tier || "";
+        if (!this.authenticated) {
+          this.authenticated = true;
+          this.log("info", `Authenticated: tier=${this.tier}`);
+          this.sendAlphaSubscribe();
+        }
+        break;
+      case "alpha_stream_subscribed":
+        this.subscribed = true;
+        this.tier = msg.tier || this.tier;
+        this.premiumAccess = msg.premiumAccess || false;
+        this.log("info", `Subscribed to alpha stream: tier=${this.tier}, premium=${this.premiumAccess}`);
+        break;
+      case "alpha_stream_unsubscribed":
+        this.subscribed = false;
+        this.log("info", "Unsubscribed from alpha stream");
+        break;
+      case "alpha_signal": {
+        this.messageCount++;
+        this.lastEventTs = Date.now();
+        const data = msg.data;
+        if (data) {
+          const signal = {
+            sourceName: data.sourceName || "",
+            sourceType: data.sourceType || "telegram",
+            externalRef: data.externalRef,
+            isPremium: data.isPremium || false,
+            tokenAddress: data.tokenAddress || "",
+            tokenName: data.tokenName || "",
+            tokenSymbol: data.tokenSymbol || "",
+            chain: data.chain || "solana",
+            marketCap: data.marketCap,
+            price: data.price,
+            kind: data.kind || "ca_drop",
+            signalStage: data.signalStage || "early",
+            summary: data.summary || "",
+            confidence: data.confidence || "low",
+            calledAgainCount: data.calledAgainCount ?? 0,
+            systemScore: data.systemScore ?? 0,
+            ts: msg.ts || Date.now(),
+            eventId: data.eventId
+          };
+          this.config.buffer.push(signal);
+        }
+        break;
+      }
+      case "error": {
+        const code = msg.code;
+        this.log("error", `WebSocket error: ${code} \u2014 ${msg.message || ""}`);
+        if (code === "WS_AUTH_REQUIRED" || code === "WS_AUTH_INVALID" || code === "WS_SESSION_INVALID" || code === "ACCESS_TOKEN_FORMAT_INVALID" || code === "ACCESS_TOKEN_EXPIRED") {
+          this.authenticated = false;
+          this.log("warn", "Auth error \u2014 closing and will reconnect with fresh token");
+          if (this.ws) this.ws.close();
+        }
+        break;
+      }
+    }
+  }
+  scheduleReconnect() {
+    if (this.intentionalClose) return;
+    const delay = RECONNECT_DELAYS[Math.min(this.reconnectAttempt, RECONNECT_DELAYS.length - 1)];
+    this.reconnectAttempt++;
+    this.log("info", `Reconnecting in ${delay}ms (attempt ${this.reconnectAttempt})`);
+    this.reconnectTimer = setTimeout(async () => {
+      try {
+        await this.connect();
+      } catch (err) {
+        this.log("error", `Reconnect failed: ${err instanceof Error ? err.message : String(err)}`);
+        this.scheduleReconnect();
+      }
+    }, delay);
+  }
+  log(level, msg) {
+    if (this.config.logger) {
+      this.config.logger[level](`[alpha-stream] ${msg}`);
+    }
+  }
+};
+
+export {
+  AlphaStreamManager
+};