@solard/cli 0.2.20 → 0.2.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solard/cli",
-  "version": "0.2.20",
+  "version": "0.2.22",
   "description": "Command-line interface for the Solard SDK.",
   "type": "module",
   "main": "./src/index.ts",
@@ -18,12 +18,14 @@
     "bun": ">=1.1.0"
   },
   "dependencies": {
-    "@solard/core": "0.2.20",
-    "bs58": "^6.0.0",
     "@solana/web3.js": "^1.98.4",
+    "@solard/core": "0.2.22",
+    "@solard/sdk": "0.2.22",
+    "bs58": "^6.0.0",
     "measure-fn": "5.2.0"
   },
   "scripts": {
-    "typecheck": "tsc --noEmit -p ../../tsconfig.json"
+    "typecheck": "tsc --noEmit -p ../../tsconfig.json",
+    "test": "bun test src"
   }
 }

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");
@@ -1082,11 +1072,10 @@ async function main() {
         throw new Error(
           "Usage: slrd export <wallet|address> [--json] [--out <path>]",
         );
-      const bs58 = (await import("bs58")).default;
-      const { signer, row } = slrd.wallets.signer(ref);
-      const secret = flags.has("json")
-        ? JSON.stringify(Array.from(signer.secretKey))
-        : bs58.encode(signer.secretKey);
+      const exported = slrd.exportWalletPrivateKey(
+        ref,
+        flags.has("json") ? "json" : "base58",
+      );
 
       const out = flags.get("out");
       if (out && out !== "true") {
@@ -1094,18 +1083,20 @@ async function main() {
         const { dirname, resolve } = await import("node:path");
         const path = resolve(out);
         mkdirSync(dirname(path), { recursive: true });
-        writeFileSync(path, `${secret}\n`, { mode: 0o600, flag: "wx" });
+        writeFileSync(path, `${exported.privateKey}\n`, {
+          mode: 0o600,
+          flag: "wx",
+        });
         emit(
-          `${OWL} exported @${row?.name ?? "?"} ${signer.publicKey.toBase58()} -> ${path}\n`,
+          `${OWL} exported @${exported.wallet.name ?? "?"} ${exported.wallet.address} -> ${path}\n`,
         );
         return;
       }
 
-      // Secret to stdout only; metadata to stderr so piping stays clean.
       process.stderr.write(
-        `${OWL} @${row?.name ?? "?"} ${signer.publicKey.toBase58()} (${flags.has("json") ? "keypair-json" : "base58"})\n`,
+        `${OWL} @${exported.wallet.name ?? "?"} ${exported.wallet.address} (${exported.format === "json" ? "keypair-json" : "base58"})\n`,
       );
-      process.stdout.write(`${secret}\n`);
+      process.stdout.write(`${exported.privateKey}\n`);
       return;
     }
     if (command === "import") {

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,
+  };
+}