solana-traderclaw 1.0.89 → 1.0.91

package/dist/chunk-VR5WP5S4.js

@@ -0,0 +1,303 @@
+// src/bitquery-ws.ts
+var RECONNECT_DELAYS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
+var BitqueryStreamManager = class {
+  config;
+  ws = null;
+  authenticated = false;
+  connecting = false;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  intentionalClose = false;
+  currentAccessToken = "";
+  // FIFO queue — server doesn't echo a requestId, so we match by arrival order
+  pendingSubscribeQueue = [];
+  // keyed by subscriptionId
+  pendingUnsubscribes = /* @__PURE__ */ new Map();
+  // tracks active subscriptions for auto-resubscribe on reconnect
+  activeSubscriptions = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  async subscribe(params) {
+    await this.ensureConnected();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        const idx = this.pendingSubscribeQueue.findIndex((p) => p.resolve === resolve);
+        if (idx !== -1) this.pendingSubscribeQueue.splice(idx, 1);
+        reject(new Error("bitquery_subscribe timed out after 15 seconds"));
+      }, 15e3);
+      this.pendingSubscribeQueue.push({
+        resolve,
+        reject,
+        timeout,
+        templateKey: params.templateKey,
+        variables: params.variables || {},
+        agentId: params.agentId,
+        subscriberType: params.subscriberType
+      });
+      const msg = {
+        type: "bitquery_subscribe",
+        templateKey: params.templateKey,
+        variables: params.variables || {},
+        walletId: this.config.walletId
+      };
+      if (params.agentId) {
+        msg.agentId = params.agentId;
+        msg.subscriberType = params.subscriberType || "agent";
+      } else if (params.subscriberType) {
+        msg.subscriberType = params.subscriberType;
+      }
+      try {
+        this.ws.send(JSON.stringify(msg));
+      } catch (err) {
+        clearTimeout(timeout);
+        const idx = this.pendingSubscribeQueue.findIndex((p) => p.resolve === resolve);
+        if (idx !== -1) this.pendingSubscribeQueue.splice(idx, 1);
+        reject(new Error(`Failed to send subscribe: ${err}`));
+      }
+    });
+  }
+  async unsubscribe(subscriptionId) {
+    this.activeSubscriptions.delete(subscriptionId);
+    if (!this.ws || this.ws.readyState !== 1) {
+      return { unsubscribed: true };
+    }
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        this.pendingUnsubscribes.delete(subscriptionId);
+        resolve({ unsubscribed: true });
+      }, 1e4);
+      this.pendingUnsubscribes.set(subscriptionId, { resolve, timeout });
+      try {
+        this.ws.send(JSON.stringify({ type: "bitquery_unsubscribe", subscriptionId }));
+      } catch {
+        clearTimeout(timeout);
+        this.pendingUnsubscribes.delete(subscriptionId);
+        resolve({ unsubscribed: true });
+      }
+    });
+  }
+  /** Close the WS if no active subscriptions remain. */
+  disconnectIfIdle() {
+    if (this.activeSubscriptions.size === 0) {
+      this.close();
+    }
+  }
+  close() {
+    this.intentionalClose = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+    this.authenticated = false;
+  }
+  async ensureConnected() {
+    if (this.ws && this.ws.readyState === 1 && this.authenticated) return;
+    if (this.connecting) {
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error("Timed out waiting for connection")), 2e4);
+        const check = setInterval(() => {
+          if (this.authenticated) {
+            clearTimeout(timeout);
+            clearInterval(check);
+            resolve();
+          }
+        }, 100);
+      });
+      return;
+    }
+    this.intentionalClose = false;
+    this.connecting = true;
+    try {
+      await this.connect();
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error("Authentication timed out")), 15e3);
+        const check = setInterval(() => {
+          if (this.authenticated) {
+            clearTimeout(timeout);
+            clearInterval(check);
+            resolve();
+          }
+        }, 100);
+      });
+    } finally {
+      this.connecting = false;
+    }
+  }
+  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 ${this.config.wsUrl}`);
+    return new Promise((resolve, reject) => {
+      let ws;
+      try {
+        ws = new WebSocket(url);
+        this.ws = ws;
+      } catch (err) {
+        reject(err);
+        return;
+      }
+      const connectTimeout = setTimeout(() => {
+        if (ws.readyState !== 1) {
+          ws.close();
+          reject(new Error("WS connection timed out"));
+        }
+      }, 1e4);
+      ws.on("open", () => {
+        clearTimeout(connectTimeout);
+        this.reconnectAttempt = 0;
+        this.log("info", "Connected");
+        resolve();
+      });
+      ws.on("message", (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          this.handleMessage(msg);
+        } catch {
+          this.log("warn", "Failed to parse message");
+        }
+      });
+      ws.on("close", () => {
+        clearTimeout(connectTimeout);
+        this.authenticated = false;
+        this.log("info", "WS closed");
+        this.drainPendingOnClose();
+        if (!this.intentionalClose && this.activeSubscriptions.size > 0) {
+          this.scheduleReconnect();
+        }
+      });
+      ws.on("error", (err) => {
+        clearTimeout(connectTimeout);
+        this.log("error", `WS error: ${err.message}`);
+        if (ws.readyState !== 1) {
+          reject(err);
+        }
+      });
+    });
+  }
+  handleMessage(msg) {
+    switch (msg.type) {
+      case "connected":
+        this.log("info", "Handshake received, authenticating...");
+        if (this.ws && this.ws.readyState === 1) {
+          this.ws.send(JSON.stringify({ type: "auth", accessToken: this.currentAccessToken }));
+        }
+        break;
+      case "authenticated":
+        this.authenticated = true;
+        this.log("info", "Authenticated");
+        void this.resubscribeAll();
+        break;
+      case "bitquery_subscribed": {
+        const subscriptionId = msg.subscriptionId;
+        const streamKey = msg.streamKey;
+        const pending = this.pendingSubscribeQueue.shift();
+        if (pending) {
+          clearTimeout(pending.timeout);
+          this.activeSubscriptions.set(subscriptionId, {
+            subscriptionId,
+            templateKey: pending.templateKey,
+            variables: pending.variables,
+            agentId: pending.agentId,
+            subscriberType: pending.subscriberType
+          });
+          pending.resolve({ subscriptionId, streamKey });
+        }
+        break;
+      }
+      case "bitquery_unsubscribed": {
+        const subscriptionId = msg.subscriptionId;
+        this.activeSubscriptions.delete(subscriptionId);
+        const pending = this.pendingUnsubscribes.get(subscriptionId);
+        if (pending) {
+          clearTimeout(pending.timeout);
+          this.pendingUnsubscribes.delete(subscriptionId);
+          pending.resolve({ unsubscribed: true });
+        }
+        this.disconnectIfIdle();
+        break;
+      }
+      case "error": {
+        const code = msg.code;
+        this.log("error", `${code}: ${msg.message || ""}`);
+        if ([
+          "WS_SUBSCRIBE_VALIDATION_ERROR",
+          "BITQUERY_SUBSCRIPTION_TEMPLATE_NOT_FOUND",
+          "WS_SUBSCRIPTION_LIMIT_REACHED",
+          "WS_BRIDGE_UNAVAILABLE"
+        ].includes(code)) {
+          const pending = this.pendingSubscribeQueue.shift();
+          if (pending) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error(`${code}: ${msg.message || ""}`));
+          }
+        }
+        if (["WS_AUTH_REQUIRED", "WS_AUTH_INVALID", "ACCESS_TOKEN_EXPIRED"].includes(code)) {
+          this.close();
+        }
+        break;
+      }
+    }
+  }
+  drainPendingOnClose() {
+    for (const pending of this.pendingSubscribeQueue) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("WebSocket closed before subscription was confirmed"));
+    }
+    this.pendingSubscribeQueue = [];
+    for (const [, pending] of this.pendingUnsubscribes) {
+      clearTimeout(pending.timeout);
+      pending.resolve({ unsubscribed: true });
+    }
+    this.pendingUnsubscribes.clear();
+  }
+  async resubscribeAll() {
+    if (this.activeSubscriptions.size === 0) return;
+    const subs = [...this.activeSubscriptions.values()];
+    this.activeSubscriptions.clear();
+    this.log("info", `Re-subscribing ${subs.length} subscription(s) after reconnect`);
+    for (const sub of subs) {
+      try {
+        const result = await this.subscribe({
+          templateKey: sub.templateKey,
+          variables: sub.variables,
+          agentId: sub.agentId,
+          subscriberType: sub.subscriberType
+        });
+        this.log("info", `Re-subscribed ${sub.templateKey} \u2192 new id: ${result.subscriptionId}`);
+      } catch (err) {
+        this.log("error", `Re-subscribe failed for ${sub.templateKey}: ${err}`);
+      }
+    }
+  }
+  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) {
+    this.config.logger?.[level](`[bitquery-ws] ${msg}`);
+  }
+};
+
+export {
+  BitqueryStreamManager
+};

package/dist/index.js

@@ -16,26 +16,28 @@ import {
 import {
   AlphaStreamManager
 } from "./chunk-3YPZOXWE.js";
+import {
+  BitqueryStreamManager
+} from "./chunk-VR5WP5S4.js";
 import {
   orchestratorRequest
 } from "./chunk-NDPVVAV7.js";
 import {
   IntelligenceLab
 } from "./chunk-FBS5FGW2.js";
-import {
-  scrubUntrustedText
-} from "./chunk-AI6MTHUN.js";
-import {
-  readRecoverySecretFromDisk
-} from "./chunk-SBYHSJLU.js";
 import {
   generateBulletinDigest,
   generateDecisionDigest,
   generateEntitlementsDigest,
-  generateStateMd,
   resolveMemoryDir,
   resolveWorkspaceRoot
 } from "./chunk-JO3BXAUQ.js";
+import {
+  scrubUntrustedText
+} from "./chunk-AI6MTHUN.js";
+import {
+  readRecoverySecretFromDisk
+} from "./chunk-SBYHSJLU.js";
 
 // index.ts
 import { Type } from "@sinclair/typebox";
@@ -2206,6 +2208,16 @@ ${notes}
         })
       )
     });
+    const bitqueryStreamManager = new BitqueryStreamManager({
+      wsUrl: orchestratorUrl.replace(/^http/, "ws").replace(/\/$/, "") + "/ws",
+      walletId,
+      getAccessToken: () => sessionManager.getAccessToken(),
+      logger: {
+        info: (msg) => api.logger.info(`[solana-trader] ${msg}`),
+        warn: (msg) => api.logger.warn(`[solana-trader] ${msg}`),
+        error: (msg) => api.logger.error(`[solana-trader] ${msg}`)
+      }
+    });
     api.registerTool({
       name: "solana_bitquery_subscribe",
       description: "Subscribe to a managed real-time Bitquery data stream. The orchestrator manages the WebSocket connection and broadcasts events. Available templates: realtimeTokenPricesSolana, ohlc1s, dexPoolLiquidityChanges, pumpFunTokenCreation, pumpFunTrades, pumpSwapTrades, raydiumNewPools. Returns a subscriptionId for tracking. Pass agentId to enable event-to-agent forwarding \u2014 orchestrator delivers each event to your Gateway via /v1/responses in addition to normal WS delivery. Subscriptions expire after 24h and emit subscription_expiring/subscription_expired events. See websocket-streaming.md in the solana-trader skill for the full message contract and usage patterns.",
@@ -2216,18 +2228,13 @@ ${notes}
         subscriberType: Type.Optional(Type.Union([Type.Literal("agent"), Type.Literal("client")], { description: "Subscriber type. Inferred as 'agent' when agentId is present. Defaults to 'client'." }))
       }),
       execute: wrapExecute("solana_bitquery_subscribe", async (_id, params) => {
-        const body = {
-          templateKey: params.templateKey,
-          variables: params.variables || {}
-        };
         const effectiveAgentId = params.agentId || config.agentId;
-        if (effectiveAgentId) {
-          body.agentId = effectiveAgentId;
-          body.subscriberType = params.subscriberType || "agent";
-        } else if (params.subscriberType) {
-          body.subscriberType = params.subscriberType;
-        }
-        return post("/api/bitquery/subscribe", body);
+        return bitqueryStreamManager.subscribe({
+          templateKey: params.templateKey,
+          variables: params.variables || {},
+          agentId: effectiveAgentId,
+          subscriberType: params.subscriberType || (effectiveAgentId ? "agent" : void 0)
+        });
       })
     });
     api.registerTool({
@@ -2238,9 +2245,7 @@ ${notes}
       }),
       execute: wrapExecute(
         "solana_bitquery_unsubscribe",
-        async (_id, params) => post("/api/bitquery/unsubscribe", {
-          subscriptionId: params.subscriptionId
-        })
+        async (_id, params) => bitqueryStreamManager.unsubscribe(params.subscriptionId)
       )
     });
     api.registerTool({
@@ -3905,7 +3910,7 @@ ${String(params.summary)}
         const stateFile = path.join(stateDir, `${bootAgentId}.json`);
         const stateData = readJsonFile(stateFile);
         if (stateData) {
-          const stateMd = generateStateMd(stateData.state || null);
+          const stateMd = generateMemoryMd(bootAgentId, stateData.state || null);
           context.bootstrapFiles.push({
             name: `${bootAgentId}-state.md`,
             path: `state/${bootAgentId}-state.md`,
@@ -4124,7 +4129,7 @@ Context compaction triggered. STATE.md synced from last persisted state. Decisio
             const stateFile = path.join(stateDir, `${assembleAgentId}.json`);
             const stateData = readJsonFile(stateFile);
             if (stateData?.state) {
-              lines.push(generateStateMd(stateData.state));
+              lines.push(generateMemoryMd(assembleAgentId, stateData.state));
             }
           } catch {
           }

package/dist/src/bitquery-ws.js

@@ -0,0 +1,6 @@
+import {
+  BitqueryStreamManager
+} from "../chunk-VR5WP5S4.js";
+export {
+  BitqueryStreamManager
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solana-traderclaw",
-  "version": "1.0.89",
+  "version": "1.0.91",
   "description": "TraderClaw V1-Upgraded — Solana trading for OpenClaw with intelligence lab, tool envelopes, prompt scrubbing, read-only X social intel, and split skill docs",
   "type": "module",
   "main": "./dist/index.js",