@solard/cli 0.2.20 → 0.2.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solard/cli",
-  "version": "0.2.20",
+  "version": "0.2.21",
   "description": "Command-line interface for the Solard SDK.",
   "type": "module",
   "main": "./src/index.ts",
@@ -18,9 +18,9 @@
     "bun": ">=1.1.0"
   },
   "dependencies": {
-    "@solard/core": "0.2.20",
-    "bs58": "^6.0.0",
+    "@solard/core": "0.2.21",
     "@solana/web3.js": "^1.98.4",
+    "bs58": "^6.0.0",
     "measure-fn": "5.2.0"
   },
   "scripts": {

package/src/index.ts

@@ -385,17 +385,13 @@ Vanity mints
   slrd vanity pool release <mint-address>               Release an ambiguous/failed launch reservation
   launch/vamp: add --mint-pool pump [--mint-pool-address <address>] to consume a pooled mint
 
-Shared market feed
-  slrd feed serve [--host 127.0.0.1] [--port 8788] [--rpc-rps 5] [--rpc-read-rps 2] [--max-fallback-subs 200]
-                                                        One upstream Pump/PumpSwap/LaunchLab feed shared by watchers, agents, and future UI clients
-
 Launch discovery
-  slrd launch watch [--venue pump,raydium-launchlab] [--min-mcap 5000] [--ath-step-pct 20] [--track-ttl 30m] [--feed ws://127.0.0.1:8788/ws] [--show-new] [--prices] [--json]
-                                                        Consume the shared feed; ignore Pump Mayhem and notify on first $5k cross and each +20% notified ATH step
+  slrd launch watch [--venue pump,raydium-launchlab] [--min-mcap 5000] [--ath-step-pct 20] [--track-ttl 30m] [--show-new] [--prices] [--json]
+                                                        Subscribe directly to launch/trade logs; ignore Pump Mayhem and notify on first $5k cross and each +20% notified ATH step
 
 Pump discovery
   slrd pump pairs [--json]                              Read Pump-supported quote mints from the on-chain Global account
-  slrd pump watch [--min-mcap 5000] [--ath-step-pct 20] [--track-ttl 30m] [--feed ws://127.0.0.1:8788/ws] [--show-new] [--prices] [--json]
+  slrd pump watch [--min-mcap 5000] [--ath-step-pct 20] [--track-ttl 30m] [--show-new] [--prices] [--json]
                                                         Compatibility alias for: slrd launch watch --venue pump
 
 Metadata and launching
@@ -474,8 +470,8 @@ Scripts and event strategies
   slrd scripts                              List scripts registered in slrd.config.ts
   slrd run <name-or-path> [script flags...] Execute a script that imports slrd
   slrd run snipe --name <exact_name> --group <group> --sol 0.05 --sender jito
-  slrd strategy run <file.ts> --token <mint|alias> --wallet <wallet> [--params <json>] [--feed ws://127.0.0.1:8788/ws] [--live]
-                                                        Run an onPrice strategy from the shared feed; wallet/execution state remains isolated per agent
+  slrd strategy run <file.ts> --token <mint|alias> --wallet <wallet> [--params <json>] [--live]
+                                                        Run an onPrice strategy from direct token trade subscriptions; wallet/execution state remains isolated per agent
   slrd strategy backtest <file.ts> --token <mint> [--params <json>] [--capital-sol 1] [--price-sample 5s] [--sol-usd N] [--json]
                                                         Replay the same strategy file over durable token history
 
@@ -818,12 +814,6 @@ async function main() {
     process.exitCode = await runScript(script, scriptArgs);
     return;
   }
-  if (command === "feed" && values[0] === "serve") {
-    const { runPriceFeedServerCommand } =
-      await import("./price-feed-server.ts");
-    await runPriceFeedServerCommand({ flags, emit });
-    return;
-  }
   if (command === "strategy" && values[0] === "backtest") {
     const { runStrategyBacktestCommand } =
       await import("./strategy-backtest-command.ts");

package/src/launch-watch-command.ts

@@ -1,6 +1,12 @@
 import { configure, createMeasure } from "measure-fn";
-import { connectPriceFeed } from "./price-feed-client.ts";
-import type { PriceFeedLaunch, PriceFeedPrice } from "./price-feed-protocol.ts";
+import { Connection } from "@solana/web3.js";
+import {
+  subscribeLaunches,
+  subscribeTrades,
+  type LaunchEvent,
+  type TradeEvent,
+  type TradeSubscription,
+} from "@solard/core";
 
 type Flags = Map<string, string>;
 type Emit = (value: string) => void;
@@ -10,11 +16,15 @@ type WatchState = {
   venue: VenueId;
   createdAtMs: number;
   lastSeenAtMs: number;
+  supplyUi: number;
   qualified: boolean;
   athMarketCapUsd: number | null;
   lastNotifiedAthUsd: number | null;
 };
 
+const WSOL_MINT = "So11111111111111111111111111111111111111112";
+const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+
 function flag(flags: Flags, key: string): string | undefined {
   const value = flags.get(key);
   return value && value !== "true" ? value : undefined;
@@ -56,14 +66,59 @@ function venueList(flags: Flags): VenueId[] {
   return out as VenueId[];
 }
 
-function feedUrl(flags: Flags): string {
+function rpcUrl(flags: Flags): string {
+  const value =
+    flag(flags, "rpc") ??
+    process.env.RPC_ENDPOINT?.trim() ??
+    process.env.SOLANA_RPC_URL?.trim() ??
+    process.env.HELIUS_RPC_URL?.trim();
+  if (!value)
+    throw new Error(
+      "Missing --rpc, RPC_ENDPOINT, SOLANA_RPC_URL, or HELIUS_RPC_URL",
+    );
+  return value;
+}
+
+function wsUrl(flags: Flags): string | undefined {
   return (
-    flag(flags, "feed") ??
-    process.env.SOLARD_FEED_URL?.trim() ??
-    "ws://127.0.0.1:8788/ws"
+    flag(flags, "ws") ??
+    process.env.SOLANA_WS_URL?.trim() ??
+    process.env.HELIUS_WS_URL?.trim()
   );
 }
 
+async function fetchJson(url: string): Promise<unknown> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 5_000);
+  try {
+    const response = await fetch(url, {
+      headers: { accept: "application/json" },
+      signal: controller.signal,
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    return await response.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function loadSolUsd(): Promise<number> {
+  try {
+    const raw = (await fetchJson(
+      "https://api.coinbase.com/v2/prices/SOL-USD/spot",
+    )) as { data?: { amount?: unknown } };
+    const value = Number(raw.data?.amount);
+    if (Number.isFinite(value) && value > 0) return value;
+  } catch {}
+  const raw = (await fetchJson(
+    "https://api.coingecko.com/api/v3/simple/price?ids=solana&vs_currencies=usd",
+  )) as { solana?: { usd?: unknown } };
+  const value = Number(raw.solana?.usd);
+  if (!Number.isFinite(value) || value <= 0)
+    throw new Error("SOL/USD unavailable");
+  return value;
+}
+
 export async function runLaunchWatchCommand(args: {
   flags: Flags;
   emit: Emit;
@@ -98,7 +153,12 @@ export async function runLaunchWatchCommand(args: {
   const trackTtlMs = duration(flag(args.flags, "track-ttl"), 30 * 60_000);
   const showNew = args.flags.has("show-new");
   const showPrices = args.flags.has("trades") || args.flags.has("prices");
-  const url = feedUrl(args.flags);
+  const rpc = rpcUrl(args.flags);
+  const ws = wsUrl(args.flags);
+  const connection = new Connection(
+    rpc,
+    ws ? { commitment: "confirmed", wsEndpoint: ws } : "confirmed",
+  );
   const states = new Map<string, WatchState>();
   let launches = 0;
   let prices = 0;
@@ -106,11 +166,22 @@ export async function runLaunchWatchCommand(args: {
   let thresholdNotifications = 0;
   let athNotifications = 0;
   let ignoredMayhem = 0;
-  let feedConnected = false;
+  let solUsd: number | null = null;
   let stopped = false;
-  let feedClient: Awaited<ReturnType<typeof connectPriceFeed>> | null = null;
+  let tradeSubscription: TradeSubscription | null = null;
+
+  const refreshSolUsd = async () => {
+    try {
+      solUsd = await loadSolUsd();
+    } catch (error) {
+      report("sol/usd unavailable", {
+        error: error instanceof Error ? error.message : String(error),
+        cached: solUsd,
+      });
+    }
+  };
 
-  const onLaunch = (event: PriceFeedLaunch) => {
+  const onLaunch = (event: LaunchEvent) => {
     if (!venues.includes(event.venue)) return;
     if (event.isMayhemMode === true) {
       ignoredMayhem += 1;
@@ -121,10 +192,12 @@ export async function runLaunchWatchCommand(args: {
       venue: event.venue,
       createdAtMs: event.atMs,
       lastSeenAtMs: event.atMs,
+      supplyUi: event.supplyUi,
       qualified: false,
       athMarketCapUsd: null,
       lastNotifiedAthUsd: null,
     });
+    void tradeSubscription?.addTokens(event.mint);
     launches += 1;
     if (showNew)
       report("new launch", {
@@ -137,92 +210,115 @@ export async function runLaunchWatchCommand(args: {
       });
   };
 
-  const onPrice = (event: PriceFeedPrice) => {
-    let state = states.get(event.mint);
-    if (!state) return;
-    if (!venues.includes(state.venue)) return;
+  const onTrade = (event: TradeEvent) => {
+    const state = states.get(event.mint);
+    if (!state || event.priceQuote == null) return;
     state.lastSeenAtMs = event.atMs;
+    let priceSol: number | null = null;
+    let priceUsd: number | null = null;
+    if (event.quoteMint === WSOL_MINT) {
+      priceSol = event.priceQuote;
+      priceUsd = solUsd == null ? null : event.priceQuote * solUsd;
+    } else if (event.quoteMint === USDC_MINT) {
+      priceUsd = event.priceQuote;
+      priceSol = solUsd == null ? null : event.priceQuote / solUsd;
+    }
+    const marketCapUsd = priceUsd == null ? null : priceUsd * state.supplyUi;
     prices += 1;
     if (showPrices)
       report("price", {
         at: new Date(event.atMs).toISOString(),
         venue: event.venue,
         mint: event.mint,
-        marketCapUsd: event.marketCapUsd,
-        priceUsd: event.priceUsd,
-        priceSol: event.priceSol,
-        source: event.source,
+        marketCapUsd,
+        priceUsd,
+        priceSol,
+        source: `${event.venue}-trade`,
       });
-    const mcap = event.marketCapUsd;
-    if (!(mcap != null && Number.isFinite(mcap) && mcap > 0)) return;
-    state.athMarketCapUsd = Math.max(state.athMarketCapUsd ?? 0, mcap);
+    if (!(
+      marketCapUsd != null &&
+      Number.isFinite(marketCapUsd) &&
+      marketCapUsd > 0
+    ))
+      return;
+    state.athMarketCapUsd = Math.max(state.athMarketCapUsd ?? 0, marketCapUsd);
     if (!state.qualified) {
-      if (mcap < minMarketCapUsd) return;
+      if (marketCapUsd < minMarketCapUsd) return;
       state.qualified = true;
-      state.lastNotifiedAthUsd = mcap;
-      if (state.venue === "raydium-launchlab")
-        feedClient?.subscribeMints([event.mint]);
+      state.lastNotifiedAthUsd = marketCapUsd;
       qualified += 1;
       thresholdNotifications += 1;
-      const nextAthNotifyUsd = mcap * (1 + athStepPct / 100);
+      const nextAthNotifyUsd = marketCapUsd * (1 + athStepPct / 100);
       if (!args.flags.has("no-bell") && !json) process.stderr.write("\x07");
       report("market cap threshold", {
         at: new Date(event.atMs).toISOString(),
         venue: state.venue,
         mint: event.mint,
-        marketCapUsd: mcap,
+        marketCapUsd,
         thresholdMarketCapUsd: minMarketCapUsd,
         nextAthNotifyUsd,
         athStepPct,
-        priceUsd: event.priceUsd,
-        priceSol: event.priceSol,
+        priceUsd,
+        priceSol,
         signature: event.signature,
       });
       return;
     }
     const previous = state.lastNotifiedAthUsd;
     if (!(previous != null && previous > 0)) {
-      state.lastNotifiedAthUsd = mcap;
+      state.lastNotifiedAthUsd = marketCapUsd;
       return;
     }
     const target = previous * (1 + athStepPct / 100);
-    if (mcap + 1e-12 < target) return;
-    state.lastNotifiedAthUsd = mcap;
+    if (marketCapUsd + 1e-12 < target) return;
+    state.lastNotifiedAthUsd = marketCapUsd;
     athNotifications += 1;
-    const increasePct = (mcap / previous - 1) * 100;
-    const nextAthNotifyUsd = mcap * (1 + athStepPct / 100);
+    const increasePct = (marketCapUsd / previous - 1) * 100;
+    const nextAthNotifyUsd = marketCapUsd * (1 + athStepPct / 100);
     if (!args.flags.has("no-bell") && !json) process.stderr.write("\x07");
     report("new ath", {
       at: new Date(event.atMs).toISOString(),
       venue: state.venue,
       mint: event.mint,
-      marketCapUsd: mcap,
+      marketCapUsd,
       previousNotifiedAthUsd: previous,
       nextAthNotifyUsd,
       athStepPct,
       increasePct,
-      priceUsd: event.priceUsd,
-      priceSol: event.priceSol,
+      priceUsd,
+      priceSol,
       signature: event.signature,
     });
   };
 
   const controller = new AbortController();
-  feedClient = await connectPriceFeed({
-    url,
-    subscribe: { op: "subscribe", launches: true, allPrices: true },
+  tradeSubscription = await subscribeTrades({
+    connection,
+    tokens: [],
+    venues: [
+      ...(venues.includes("pump") ? (["pump", "pumpswap"] as const) : []),
+      ...(venues.includes("raydium-launchlab")
+        ? (["raydium-launchlab"] as const)
+        : []),
+    ],
     signal: controller.signal,
+    onTrade,
     onStatus(event, data) {
-      if (event === "connected") feedConnected = true;
-      if (event === "connect-error") feedConnected = false;
-      report(`feed ${event}`, data ?? {});
+      report(`trades ${event}`, data ?? {});
     },
-    onMessage(message) {
-      if (message.type === "launch") onLaunch(message);
-      if (message.type === "price") onPrice(message);
+  });
+  const launchSubscription = await subscribeLaunches({
+    connection,
+    venues,
+    signal: controller.signal,
+    onLaunch,
+    onStatus(event, data) {
+      report(`launches ${event}`, data ?? {});
     },
   });
 
+  await refreshSolUsd();
+  const solTimer = setInterval(() => void refreshSolUsd(), 60_000);
   const stop = () => {
     stopped = true;
     controller.abort();
@@ -230,23 +326,25 @@ export async function runLaunchWatchCommand(args: {
   process.once("SIGINT", stop);
   process.once("SIGTERM", stop);
   report("ready", {
-    feed: url,
+    rpc,
+    ws: ws ?? "connection-default",
     venues,
     minMarketCapUsd,
     athStepPct,
     excludeMayhem: true,
     trackTtlMs,
-    upstreamSubscriptions: 0,
+    upstreamSubscriptions: venues.length,
   });
   const heartbeat = setInterval(
     () => {
       const now = Date.now();
       for (const [mint, state] of states) {
-        if (!state.qualified && now - state.lastSeenAtMs > trackTtlMs)
+        if (!state.qualified && now - state.lastSeenAtMs > trackTtlMs) {
           states.delete(mint);
+          void tradeSubscription?.removeTokens(mint);
+        }
       }
       report("heartbeat", {
-        feedConnected,
         launches,
         ignoredMayhem,
         tracked: states.size,
@@ -254,7 +352,8 @@ export async function runLaunchWatchCommand(args: {
         prices,
         thresholdNotifications,
         athNotifications,
-        upstreamSubscriptions: 0,
+        watchedTokens: tradeSubscription?.listTokens().length ?? 0,
+        solUsd,
       });
     },
     Math.max(1_000, Math.trunc(numberFlag(args.flags, "heartbeat-ms", 15_000))),
@@ -263,9 +362,11 @@ export async function runLaunchWatchCommand(args: {
   try {
     while (!stopped) await new Promise((resolve) => setTimeout(resolve, 250));
   } finally {
+    clearInterval(solTimer);
     clearInterval(heartbeat);
     controller.abort();
-    feedClient?.close();
+    await launchSubscription.close();
+    await tradeSubscription.close();
     process.removeListener("SIGINT", stop);
     process.removeListener("SIGTERM", stop);
     report("stopped", {

package/src/price-feed-client.ts

@@ -1,2 +1,168 @@
-export { connectPriceFeed } from "@solard/core";
-export type { PriceFeedClient } from "@solard/core";
+import type {
+  PriceFeedCommand,
+  PriceFeedMessage,
+} from "./price-feed-protocol.ts";
+
+function text(value: unknown): string {
+  if (typeof value === "string") return value;
+  if (value instanceof ArrayBuffer)
+    return new TextDecoder().decode(new Uint8Array(value));
+  if (ArrayBuffer.isView(value))
+    return new TextDecoder().decode(
+      new Uint8Array(value.buffer, value.byteOffset, value.byteLength),
+    );
+  return String(value ?? "");
+}
+
+export type PriceFeedClient = {
+  readonly connected: boolean;
+  send(command: PriceFeedCommand): void;
+  subscribeMints(mints: string[]): void;
+  unsubscribeMints(mints: string[]): void;
+  close(): void;
+  closed: Promise<void>;
+};
+
+export async function connectPriceFeed(args: {
+  url: string;
+  subscribe: Extract<PriceFeedCommand, { op: "subscribe" }>;
+  onMessage: (message: PriceFeedMessage) => void | Promise<void>;
+  onStatus?: (event: string, data?: Record<string, unknown>) => void;
+  signal?: AbortSignal;
+}): Promise<PriceFeedClient> {
+  let stopped = false;
+  let connected = false;
+  let ws: WebSocket | null = null;
+  const desiredMints = new Set(args.subscribe.mints ?? []);
+  let desiredLaunches = args.subscribe.launches === true;
+  let desiredAllPrices = args.subscribe.allPrices === true;
+  let reconnectDelay = 250;
+  let resolveClosed!: () => void;
+  const closed = new Promise<void>((resolve) => {
+    resolveClosed = resolve;
+  });
+
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    try {
+      ws?.close();
+    } catch {}
+    resolveClosed();
+  };
+  args.signal?.addEventListener("abort", stop, { once: true });
+
+  const open = async (): Promise<void> => {
+    while (!stopped) {
+      try {
+        const socket = new WebSocket(args.url);
+        ws = socket;
+        await new Promise<void>((resolve, reject) => {
+          let settled = false;
+          const timeout = setTimeout(() => {
+            if (!settled) {
+              settled = true;
+              try {
+                socket.close();
+              } catch {}
+              reject(new Error("feed websocket handshake timed out"));
+            }
+          }, 5_000);
+          socket.addEventListener("open", () => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeout);
+            connected = true;
+            reconnectDelay = 250;
+            socket.send(
+              JSON.stringify({
+                op: "subscribe",
+                mints: [...desiredMints],
+                launches: desiredLaunches,
+                allPrices: desiredAllPrices,
+              } satisfies PriceFeedCommand),
+            );
+            args.onStatus?.("connected", { url: args.url });
+            resolve();
+          });
+          socket.addEventListener("error", () => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeout);
+            reject(new Error("feed websocket error"));
+          });
+        });
+
+        await new Promise<void>((resolve) => {
+          socket.addEventListener("message", (event) => {
+            let message: PriceFeedMessage;
+            try {
+              message = JSON.parse(text(event.data)) as PriceFeedMessage;
+            } catch {
+              return;
+            }
+            void Promise.resolve(args.onMessage(message)).catch((error) =>
+              args.onStatus?.("callback-error", {
+                error: error instanceof Error ? error.message : String(error),
+              }),
+            );
+          });
+          socket.addEventListener("close", () => {
+            connected = false;
+            resolve();
+          });
+          socket.addEventListener("error", () => {
+            connected = false;
+          });
+        });
+      } catch (error) {
+        connected = false;
+        args.onStatus?.("connect-error", {
+          error: error instanceof Error ? error.message : String(error),
+          retryInMs: reconnectDelay,
+        });
+      }
+      if (stopped) break;
+      await new Promise((resolve) => setTimeout(resolve, reconnectDelay));
+      reconnectDelay = Math.min(10_000, reconnectDelay * 2);
+    }
+    resolveClosed();
+  };
+
+  void open();
+  const startedAt = Date.now();
+  while (!connected && !stopped && Date.now() - startedAt < 6_000)
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  if (!connected && !stopped) {
+    stop();
+    throw new Error(
+      `Could not connect to Solard price feed at ${args.url}. Start it with: slrd feed serve`,
+    );
+  }
+
+  const send = (command: PriceFeedCommand) => {
+    if (command.op === "subscribe") {
+      for (const mint of command.mints ?? []) desiredMints.add(mint);
+      if (command.launches === true) desiredLaunches = true;
+      if (command.allPrices === true) desiredAllPrices = true;
+    } else if (command.op === "unsubscribe") {
+      for (const mint of command.mints ?? []) desiredMints.delete(mint);
+    }
+    if (!connected || !ws || ws.readyState !== WebSocket.OPEN) return;
+    ws.send(JSON.stringify(command));
+  };
+  return {
+    get connected() {
+      return connected;
+    },
+    send,
+    subscribeMints(mints: string[]) {
+      send({ op: "subscribe", mints });
+    },
+    unsubscribeMints(mints: string[]) {
+      send({ op: "unsubscribe", mints });
+    },
+    close: stop,
+    closed,
+  };
+}

package/src/price-feed-protocol.ts

@@ -1,8 +1,51 @@
-export type {
-  PriceFeedCommand,
-  PriceFeedLaunch,
-  PriceFeedMessage,
-  PriceFeedPrice,
-  PriceFeedStatus,
-  PriceFeedVenue,
-} from "@solard/core";
+export type PriceFeedVenue =
+  "pump" | "pumpswap" | "raydium-launchlab" | "rpc-fallback";
+
+export type PriceFeedLaunch = {
+  type: "launch";
+  atMs: number;
+  signature: string | null;
+  slot: number | null;
+  mint: string;
+  venue: "pump" | "raydium-launchlab";
+  decimals: number;
+  supplyUi: number;
+  quoteMint: string | null;
+  pool: string | null;
+  name: string | null;
+  symbol: string | null;
+  isMayhemMode: boolean | null;
+};
+
+export type PriceFeedPrice = {
+  type: "price";
+  atMs: number;
+  signature: string | null;
+  slot: number | null;
+  mint: string;
+  venue: PriceFeedVenue;
+  priceSol: number | null;
+  priceUsd: number | null;
+  marketCapUsd: number | null;
+  source: string;
+};
+
+export type PriceFeedStatus = {
+  type: "status";
+  atMs: number;
+  event: string;
+  data?: Record<string, unknown>;
+};
+
+export type PriceFeedMessage =
+  PriceFeedLaunch | PriceFeedPrice | PriceFeedStatus;
+
+export type PriceFeedCommand =
+  | {
+      op: "subscribe";
+      mints?: string[];
+      launches?: boolean;
+      allPrices?: boolean;
+    }
+  | { op: "unsubscribe"; mints?: string[] }
+  | { op: "ping" };

package/src/price-feed-server.ts

@@ -1,4 +1,5 @@
 import { configure, createMeasure } from "measure-fn";
+import WebSocket, { type RawData } from "ws";
 import bs58 from "bs58";
 import { bondingCurvePda } from "@solard/core";
 import {
@@ -140,6 +141,16 @@ function errorText(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
+function safeErrorText(error: unknown, endpoint?: string): string {
+  let value = errorText(error);
+  if (endpoint) value = value.split(endpoint).join(publicEndpoint(endpoint));
+  value = value.replace(
+    /([?&](?:api-?key|token|secret|auth)=)[^&\s'"]+/gi,
+    "$1<redacted>",
+  );
+  return value;
+}
+
 class RpcPacer {
   private tail: Promise<unknown> = Promise.resolve();
   private nextAt = 0;
@@ -259,6 +270,7 @@ class StandardLogsMux {
 
   async start(timeoutMs = 15_000): Promise<void> {
     if (this.connected) return;
+    if (this.stopped) throw new Error("WebSocket transport is stopped");
     if (!this.initialResolve) {
       const ready = new Promise<void>((resolve, reject) => {
         this.initialResolve = resolve;
@@ -268,11 +280,12 @@ class StandardLogsMux {
         const reject = this.initialReject;
         this.initialResolve = null;
         this.initialReject = null;
+        this.initialTimer = null;
         const error = new Error(
           `WebSocket did not connect within ${timeoutMs}ms`,
         );
         this.stop();
-        if (reject) reject(error);
+        reject?.(error);
       }, timeoutMs);
       this.connect();
       return await ready;
@@ -283,6 +296,9 @@ class StandardLogsMux {
         if (this.connected) {
           clearInterval(timer);
           resolve();
+        } else if (this.stopped) {
+          clearInterval(timer);
+          reject(new Error("WebSocket transport stopped"));
         } else if (Date.now() - started >= timeoutMs) {
           clearInterval(timer);
           reject(new Error(`WebSocket did not connect within ${timeoutMs}ms`));
@@ -292,20 +308,26 @@ class StandardLogsMux {
   }
 
   stop(): void {
+    if (this.stopped && !this.socket) return;
     this.stopped = true;
     if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
     this.reconnectTimer = null;
     if (this.initialTimer) clearTimeout(this.initialTimer);
     this.initialTimer = null;
+    const reject = this.initialReject;
     this.initialResolve = null;
     this.initialReject = null;
     const socket = this.socket;
     this.socket = null;
     this.connected = false;
     this.connecting = false;
+    reject?.(new Error("WebSocket transport stopped"));
     try {
       socket?.close(1000, "shutdown");
     } catch {}
+    try {
+      socket?.terminate();
+    } catch {}
   }
 
   private connect(): void {
@@ -313,18 +335,22 @@ class StandardLogsMux {
     this.connecting = true;
     let socket: WebSocket;
     try {
-      socket = new WebSocket(this.url);
+      socket = new WebSocket(this.url, {
+        handshakeTimeout: 10_000,
+        perMessageDeflate: false,
+      });
     } catch (error) {
       this.connecting = false;
       this.report("upstream websocket error", {
         endpoint: publicEndpoint(this.url),
-        error: errorText(error),
+        error: safeErrorText(error, this.url),
       });
       this.scheduleReconnect();
       return;
     }
     this.socket = socket;
-    socket.onopen = () => {
+
+    socket.on("open", () => {
       if (this.socket !== socket || this.stopped) return;
       this.connecting = false;
       this.connected = true;
@@ -344,13 +370,27 @@ class StandardLogsMux {
       this.initialResolve = null;
       this.initialReject = null;
       resolve?.();
-    };
-    socket.onmessage = (event) => {
+    });
+
+    socket.on("unexpected-response", (_request, response) => {
+      if (this.socket !== socket || this.stopped) return;
+      this.report("upstream websocket handshake rejected", {
+        endpoint: publicEndpoint(this.url),
+        statusCode: response.statusCode ?? null,
+        statusMessage: response.statusMessage ?? null,
+        retryAfter: response.headers["retry-after"] ?? null,
+      });
+      try {
+        response.resume();
+      } catch {}
+    });
+
+    socket.on("message", (raw: RawData) => {
       if (this.socket !== socket) return;
       this._lastMessageAtMs = Date.now();
       let message: any;
       try {
-        message = JSON.parse(String(event.data));
+        message = JSON.parse(raw.toString());
       } catch {
         return;
       }
@@ -410,24 +450,21 @@ class StandardLogsMux {
         } catch (error) {
           this.report("upstream callback error", {
             pubkey: key,
-            error: errorText(error),
+            error: safeErrorText(error, this.url),
           });
         }
       }
-    };
-    socket.onerror = (event: any) => {
+    });
+
+    socket.on("error", (error) => {
       if (this.socket !== socket || this.stopped) return;
       this.report("upstream websocket error", {
         endpoint: publicEndpoint(this.url),
-        error: String(
-          event?.message ?? event?.error?.message ?? "websocket error",
-        ),
+        error: safeErrorText(error, this.url),
       });
-      try {
-        socket.close();
-      } catch {}
-    };
-    socket.onclose = (event) => {
+    });
+
+    socket.on("close", (code, reason) => {
       if (this.socket !== socket) return;
       this.socket = null;
       const wasConnected = this.connected;
@@ -440,12 +477,12 @@ class StandardLogsMux {
       if (wasConnected) this._reconnects += 1;
       this.report("upstream websocket disconnected", {
         endpoint: publicEndpoint(this.url),
-        code: event.code,
-        reason: event.reason || null,
+        code,
+        reason: reason.length ? reason.toString() : null,
         retryInMs: this.reconnectDelayMs,
       });
       this.scheduleReconnect();
-    };
+    });
   }
 
   private scheduleReconnect(): void {
@@ -482,7 +519,7 @@ class StandardLogsMux {
       this.requests.delete(id);
       this.report("upstream websocket send error", {
         endpoint: publicEndpoint(this.url),
-        error: errorText(error),
+        error: safeErrorText(error, this.url),
       });
     }
   }
@@ -1516,80 +1553,101 @@ export async function runPriceFeedServerCommand(args: {
     }
   };
 
+  let heartbeat: ReturnType<typeof setInterval> | null = null;
+  let solTimer: ReturnType<typeof setInterval> | null = null;
+  let pruneTimer: ReturnType<typeof setInterval> | null = null;
+
   const stop = () => {
+    if (stopped) return;
     stopped = true;
+    logsMux.stop();
+    try {
+      server.stop(true);
+    } catch {}
   };
   process.once("SIGINT", stop);
   process.once("SIGTERM", stop);
-  await logsMux.start();
-  await refreshSolUsd();
-  report("ready", {
-    url: `ws://${host}:${port}/ws`,
-    health: `http://${host}:${port}/health`,
-    upstreamEndpoint: publicEndpoint(ws),
-    upstreamState: logsMux.state,
-    upstreamProgramSubscriptions: programSubs.length,
-    maxFallbackSubscriptions,
-    rpcReadRps: readRps,
-    rpcHardRps: hardRps,
-    includeMayhem,
-  });
 
-  const heartbeat = setInterval(
-    () => {
-      report("heartbeat", {
-        clients: clients.size,
-        clientConnections,
-        upstreamState: logsMux.state,
-        upstreamSubscriptions: logsMux.subscriptionCount,
-        upstreamProgramSubscriptions: programSubs.length,
-        upstreamReconnects: logsMux.reconnects,
-        upstreamLastMessageAgeMs: logsMux.lastMessageAtMs
-          ? Date.now() - logsMux.lastMessageAtMs
-          : null,
-        fallbackSubscriptions: fallbackSubs.size,
-        knownMints: mints.size,
-        cachedLaunches: launchesByMint.size,
-        pools: pools.size,
-        latestPrices: latest.size,
-        launches,
-        prices,
-        pendingFallbackMints: pendingFallback.size,
-        coalescedFallbackUpdates: coalescedFallback,
-        rpcQueue: pacer.queued,
-        rpcErrors,
-        solUsd,
-        solUsdAgeMs: solUsdAt ? Date.now() - solUsdAt : null,
-      });
-    },
-    Math.max(1_000, Math.trunc(numberFlag(args.flags, "heartbeat-ms", 15_000))),
-  );
-  const solTimer = setInterval(() => void refreshSolUsd(), 30_000);
-  const pruneTimer = setInterval(() => {
-    const cutoff = Date.now() - 6 * 60 * 60_000;
-    if (mints.size > 50_000) {
-      for (const [mint, state] of mints) {
-        if (state.lastSeenAtMs < cutoff && !fallbackSubs.has(mint)) {
-          mints.delete(mint);
-          latest.delete(mint);
-          launchesByMint.delete(mint);
+  try {
+    try {
+      await logsMux.start();
+    } catch (error) {
+      if (!stopped) throw error;
+      return;
+    }
+    if (stopped) return;
+    await refreshSolUsd();
+    report("ready", {
+      url: `ws://${host}:${port}/ws`,
+      health: `http://${host}:${port}/health`,
+      upstreamEndpoint: publicEndpoint(ws),
+      upstreamState: logsMux.state,
+      upstreamProgramSubscriptions: programSubs.length,
+      maxFallbackSubscriptions,
+      rpcReadRps: readRps,
+      rpcHardRps: hardRps,
+      includeMayhem,
+    });
+
+    heartbeat = setInterval(
+      () => {
+        report("heartbeat", {
+          clients: clients.size,
+          clientConnections,
+          upstreamState: logsMux.state,
+          upstreamSubscriptions: logsMux.subscriptionCount,
+          upstreamProgramSubscriptions: programSubs.length,
+          upstreamReconnects: logsMux.reconnects,
+          upstreamLastMessageAgeMs: logsMux.lastMessageAtMs
+            ? Date.now() - logsMux.lastMessageAtMs
+            : null,
+          fallbackSubscriptions: fallbackSubs.size,
+          knownMints: mints.size,
+          cachedLaunches: launchesByMint.size,
+          pools: pools.size,
+          latestPrices: latest.size,
+          launches,
+          prices,
+          pendingFallbackMints: pendingFallback.size,
+          coalescedFallbackUpdates: coalescedFallback,
+          rpcQueue: pacer.queued,
+          rpcErrors,
+          solUsd,
+          solUsdAgeMs: solUsdAt ? Date.now() - solUsdAt : null,
+        });
+      },
+      Math.max(
+        1_000,
+        Math.trunc(numberFlag(args.flags, "heartbeat-ms", 15_000)),
+      ),
+    );
+    solTimer = setInterval(() => void refreshSolUsd(), 30_000);
+    pruneTimer = setInterval(() => {
+      const cutoff = Date.now() - 6 * 60 * 60_000;
+      if (mints.size > 50_000) {
+        for (const [mint, state] of mints) {
+          if (state.lastSeenAtMs < cutoff && !fallbackSubs.has(mint)) {
+            mints.delete(mint);
+            latest.delete(mint);
+            launchesByMint.delete(mint);
+          }
         }
       }
-    }
-  }, 60_000);
+    }, 60_000);
 
-  try {
     await fallbackLoop();
   } finally {
-    clearInterval(heartbeat);
-    clearInterval(solTimer);
-    clearInterval(pruneTimer);
+    if (heartbeat) clearInterval(heartbeat);
+    if (solTimer) clearInterval(solTimer);
+    if (pruneTimer) clearInterval(pruneTimer);
     process.removeListener("SIGINT", stop);
     process.removeListener("SIGTERM", stop);
     for (const id of programSubs) logsMux.unsubscribe(id);
     for (const row of fallbackSubs.values()) logsMux.unsubscribe(row.id);
     logsMux.stop();
-    server.stop(true);
+    try {
+      server.stop(true);
+    } catch {}
     report("stopped", { clients: clients.size, launches, prices, rpcErrors });
   }
 }

package/src/trade-strategy-command.ts

@@ -7,13 +7,13 @@ import {
   type Logs,
   type ParsedTransactionWithMeta,
 } from "@solana/web3.js";
-import { connectPriceFeed } from "./price-feed-client.ts";
-import type { PriceFeedPrice } from "./price-feed-protocol.ts";
 import {
   RaydiumService,
   createTraderSolard,
   resolveTradeAsset,
   sol,
+  subscribeTrades,
+  type TradeEvent,
 } from "@solard/core";
 
 type Flags = Map<string, string>;
@@ -1003,14 +1003,10 @@ export async function runTradeStrategyCommand(args: {
     Math.trunc(numberFlag(args.flags, "heartbeat-ms", 15_000)),
   );
   const rpc = rpcUrl(args.flags);
-  const feed =
-    flag(args.flags, "feed") ??
-    process.env.SOLARD_FEED_URL?.trim() ??
-    "ws://127.0.0.1:8788/ws";
   const strategy = await loadStrategy(path);
   if (typeof strategy.onPrice !== "function")
     throw new Error(
-      `Live shared-feed strategy ${path} must define onPrice(ctx, price). ` +
+      `Live trade strategy ${path} must define onPrice(ctx, price). ` +
         `Legacy onTrade is retained for historical exact-trade backtests, not per-agent live RPC subscriptions.`,
     );
   const state = await initialState(strategy);
@@ -1021,8 +1017,7 @@ export async function runTradeStrategyCommand(args: {
   let priceCount = 0;
   let lastPrice: StrategyPriceTick | null = null;
   let callbackErrors = 0;
-  let feedErrors = 0;
-  let feedConnected = false;
+  let marketErrors = 0;
   let callbackQueue: Promise<void> = Promise.resolve();
 
   try {
@@ -1139,18 +1134,20 @@ export async function runTradeStrategyCommand(args: {
       }
     };
 
-    const onPrice = async (event: PriceFeedPrice) => {
-      if (event.mint !== mint || stopped) return;
+    const onPrice = async (event: TradeEvent) => {
+      if (event.mint !== mint || stopped || event.priceQuote == null) return;
+      const priceSol = event.quoteMint === WSOL_MINT ? event.priceQuote : null;
+      const priceUsd = event.quoteMint === USDC_MINT ? event.priceQuote : null;
+      if (priceSol == null && priceUsd == null) return;
       const price: StrategyPriceTick = {
-        signature: event.signature ?? "feed",
-        slot: event.slot ?? 0,
+        signature: event.signature,
+        slot: event.slot,
         atMs: event.atMs,
         mint,
-        priceSol: event.priceSol,
-        priceUsd: event.priceUsd,
-        marketCapUsd: event.marketCapUsd,
+        priceSol,
+        priceUsd,
+        marketCapUsd: null,
       };
-      if (price.priceSol == null && price.priceUsd == null) return;
       priceCount += 1;
       lastPrice = price;
       if (json) report("price", price as any);
@@ -1162,21 +1159,16 @@ export async function runTradeStrategyCommand(args: {
     };
 
     const controller = new AbortController();
-    const feedClient = await connectPriceFeed({
-      url: feed,
-      subscribe: { op: "subscribe", mints: [mint] },
+    const marketSubscription = await subscribeTrades({
+      connection: slrd.connection(),
+      tokens: [mint],
       signal: controller.signal,
-      onStatus(event, data) {
-        if (event === "connected") feedConnected = true;
-        if (event === "connect-error") {
-          feedConnected = false;
-          feedErrors += 1;
-        }
-        report(`feed ${event}`, data ?? {});
+      onTrade(event) {
+        callbackQueue = callbackQueue.then(() => onPrice(event));
       },
-      onMessage(message) {
-        if (message.type !== "price" || message.mint !== mint) return;
-        callbackQueue = callbackQueue.then(() => onPrice(message));
+      onStatus(event, data) {
+        if (event.includes("error")) marketErrors += 1;
+        report(`market ${event}`, data ?? {});
       },
     });
 
@@ -1186,9 +1178,8 @@ export async function runTradeStrategyCommand(args: {
       wallet: walletRef,
       walletAddress,
       live,
-      feed,
-      event: "shared-price-feed",
-      upstreamMarketSubscriptions: 0,
+      event: "direct-trade-subscription",
+      upstreamMarketSubscriptions: marketSubscription.listTokens().length,
     });
 
     if (strategy.onStart) {
@@ -1208,11 +1199,10 @@ export async function runTradeStrategyCommand(args: {
     process.once("SIGTERM", stopSignal);
     const heartbeatTimer = setInterval(() => {
       report("strategy heartbeat", {
-        feedConnected,
         prices: priceCount,
         callbackErrors,
-        feedErrors,
-        upstreamMarketSubscriptions: 0,
+        marketErrors,
+        upstreamMarketSubscriptions: marketSubscription.listTokens().length,
         executionVenue: executor.venue ?? "unresolved",
       });
     }, heartbeatMs);
@@ -1224,7 +1214,7 @@ export async function runTradeStrategyCommand(args: {
       process.removeListener("SIGINT", stopSignal);
       process.removeListener("SIGTERM", stopSignal);
       controller.abort();
-      feedClient.close();
+      await marketSubscription.close();
       await callbackQueue.catch(() => undefined);
       if (strategy.onStop) {
         try {
@@ -1238,7 +1228,7 @@ export async function runTradeStrategyCommand(args: {
         reason: stopReason,
         prices: priceCount,
         callbackErrors,
-        feedErrors,
+        marketErrors,
       });
     }
   } finally {