@solard/cli 0.2.25 → 0.2.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solard/cli",
-  "version": "0.2.25",
+  "version": "0.2.27",
   "description": "Command-line interface for the Solard SDK.",
   "type": "module",
   "main": "./src/index.ts",
@@ -19,8 +19,8 @@
   },
   "dependencies": {
     "@solana/web3.js": "^1.98.4",
-    "@solard/core": "0.2.25",
-    "@solard/sdk": "0.2.25",
+    "@solard/core": "0.2.27",
+    "@solard/sdk": "0.2.27",
     "bs58": "^6.0.0",
     "measure-fn": "5.2.0"
   },

package/src/launch-watch-command.ts

@@ -1,12 +1,9 @@
 import { configure, createMeasure } from "measure-fn";
-import { Connection } from "@solana/web3.js";
-import {
-  subscribeLaunches,
-  subscribeTrades,
+import slrd, {
   type LaunchEvent,
   type TradeEvent,
-  type TradeSubscription,
-} from "@solard/core";
+  type TradeListener,
+} from "@solard/sdk";
 
 type Flags = Map<string, string>;
 type Emit = (value: string) => void;
@@ -63,25 +60,15 @@ function venueList(flags: Flags): VenueId[] {
   return out as VenueId[];
 }
 
-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)
+function requireSingleEndpoint(flags: Flags): void {
+  if (flags.has("rpc") || flags.has("ws"))
     throw new Error(
-      "Missing --rpc, RPC_ENDPOINT, SOLANA_RPC_URL, or HELIUS_RPC_URL",
+      "Set only RPC_ENDPOINT in the environment. --rpc and --ws are intentionally unsupported.",
+    );
+  if (!process.env.RPC_ENDPOINT?.trim())
+    throw new Error(
+      "Missing RPC_ENDPOINT. Set one Solana RPC URL in RPC_ENDPOINT; WebSocket access is derived from the same endpoint.",
     );
-  return value;
-}
-
-function wsUrl(flags: Flags): string | undefined {
-  return (
-    flag(flags, "ws") ??
-    process.env.SOLANA_WS_URL?.trim() ??
-    process.env.HELIUS_WS_URL?.trim()
-  );
 }
 
 export async function runLaunchWatchCommand(args: {
@@ -118,12 +105,7 @@ 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 rpc = rpcUrl(args.flags);
-  const ws = wsUrl(args.flags);
-  const connection = new Connection(
-    rpc,
-    ws ? { commitment: "confirmed", wsEndpoint: ws } : "confirmed",
-  );
+  requireSingleEndpoint(args.flags);
   const states = new Map<string, WatchState>();
   let launches = 0;
   let prices = 0;
@@ -132,7 +114,7 @@ export async function runLaunchWatchCommand(args: {
   let athNotifications = 0;
   let ignoredMayhem = 0;
   let stopped = false;
-  let tradeSubscription: TradeSubscription | null = null;
+  let tradeSubscription: TradeListener | null = null;
 
   const onLaunch = (event: LaunchEvent) => {
     if (!venues.includes(event.venue)) return;
@@ -150,7 +132,7 @@ export async function runLaunchWatchCommand(args: {
       athMarketCapUsd: null,
       lastNotifiedAthUsd: null,
     });
-    void tradeSubscription?.addTokens(event.mint);
+    void tradeSubscription?.add(event.mint);
     launches += 1;
     if (showNew)
       report("new launch", {
@@ -238,8 +220,7 @@ export async function runLaunchWatchCommand(args: {
   };
 
   const controller = new AbortController();
-  tradeSubscription = await subscribeTrades({
-    connection,
+  tradeSubscription = await slrd.listenTrades({
     tokens: [],
     venues: [
       ...(venues.includes("pump") ? (["pump", "pumpswap"] as const) : []),
@@ -248,13 +229,12 @@ export async function runLaunchWatchCommand(args: {
         : []),
     ],
     signal: controller.signal,
-    onTrade,
     onStatus(event, data) {
       report(`trades ${event}`, data ?? {});
     },
   });
-  const launchSubscription = await subscribeLaunches({
-    connection,
+  tradeSubscription.onTrade(onTrade);
+  const launchSubscription = await slrd.subscribeLaunches({
     venues,
     signal: controller.signal,
     onLaunch,
@@ -270,8 +250,8 @@ export async function runLaunchWatchCommand(args: {
   process.once("SIGINT", stop);
   process.once("SIGTERM", stop);
   report("ready", {
-    rpc,
-    ws: ws ?? "connection-default",
+    rpc: "RPC_ENDPOINT",
+    websocket: "derived-from-RPC_ENDPOINT",
     venues,
     minMarketCapUsd,
     athStepPct,
@@ -285,7 +265,7 @@ export async function runLaunchWatchCommand(args: {
       for (const [mint, state] of states) {
         if (!state.qualified && now - state.lastSeenAtMs > trackTtlMs) {
           states.delete(mint);
-          void tradeSubscription?.removeTokens(mint);
+          void tradeSubscription?.remove(mint);
         }
       }
       report("heartbeat", {
@@ -296,7 +276,7 @@ export async function runLaunchWatchCommand(args: {
         prices,
         thresholdNotifications,
         athNotifications,
-        watchedTokens: tradeSubscription?.listTokens().length ?? 0,
+        watchedTokens: tradeSubscription?.list().length ?? 0,
       });
     },
     Math.max(1_000, Math.trunc(numberFlag(args.flags, "heartbeat-ms", 15_000))),

package/src/price-feed-client.ts

@@ -14,18 +14,22 @@ function text(value: unknown): string {
   return String(value ?? "");
 }
 
+function errorText(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 export type PriceFeedClient = {
   readonly connected: boolean;
-  send(command: PriceFeedCommand): void;
-  subscribeMints(mints: string[]): void;
-  unsubscribeMints(mints: string[]): void;
+  subscribeMints(mints: string | readonly string[]): void;
+  unsubscribeMints(mints: string | readonly string[]): void;
+  listMints(): string[];
   close(): void;
   closed: Promise<void>;
 };
 
 export async function connectPriceFeed(args: {
   url: string;
-  subscribe: Extract<PriceFeedCommand, { op: "subscribe" }>;
+  mints?: string | readonly string[];
   onMessage: (message: PriceFeedMessage) => void | Promise<void>;
   onStatus?: (event: string, data?: Record<string, unknown>) => void;
   signal?: AbortSignal;
@@ -33,18 +37,26 @@ export async function connectPriceFeed(args: {
   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;
+  const desiredMints = new Set(
+    (typeof args.mints === "string" ? [args.mints] : [...(args.mints ?? [])])
+      .map((mint) => mint.trim())
+      .filter(Boolean),
+  );
   let reconnectDelay = 250;
   let resolveClosed!: () => void;
   const closed = new Promise<void>((resolve) => {
     resolveClosed = resolve;
   });
 
-  const stop = () => {
+  const send = (command: PriceFeedCommand): void => {
+    if (!connected || !ws || ws.readyState !== WebSocket.OPEN) return;
+    ws.send(JSON.stringify(command));
+  };
+
+  const stop = (): void => {
     if (stopped) return;
     stopped = true;
+    connected = false;
     try {
       ws?.close();
     } catch {}
@@ -60,13 +72,12 @@ export async function connectPriceFeed(args: {
         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"));
-            }
+            if (settled) return;
+            settled = true;
+            try {
+              socket.close();
+            } catch {}
+            reject(new Error("price feed websocket handshake timed out"));
           }, 5_000);
           socket.addEventListener("open", () => {
             if (settled) return;
@@ -74,22 +85,17 @@ export async function connectPriceFeed(args: {
             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 });
+            const mints = [...desiredMints];
+            if (mints.length)
+              socket.send(JSON.stringify({ op: "subscribe", mints }));
+            args.onStatus?.("connected", { url: args.url, mints });
             resolve();
           });
           socket.addEventListener("error", () => {
             if (settled) return;
             settled = true;
             clearTimeout(timeout);
-            reject(new Error("feed websocket error"));
+            reject(new Error("price feed websocket error"));
           });
         });
 
@@ -102,13 +108,12 @@ export async function connectPriceFeed(args: {
               return;
             }
             void Promise.resolve(args.onMessage(message)).catch((error) =>
-              args.onStatus?.("callback-error", {
-                error: error instanceof Error ? error.message : String(error),
-              }),
+              args.onStatus?.("callback-error", { error: errorText(error) }),
             );
           });
           socket.addEventListener("close", () => {
             connected = false;
+            args.onStatus?.("disconnected", { url: args.url });
             resolve();
           });
           socket.addEventListener("error", () => {
@@ -118,7 +123,7 @@ export async function connectPriceFeed(args: {
       } catch (error) {
         connected = false;
         args.onStatus?.("connect-error", {
-          error: error instanceof Error ? error.message : String(error),
+          error: errorText(error),
           retryInMs: reconnectDelay,
         });
       }
@@ -136,32 +141,33 @@ export async function connectPriceFeed(args: {
   if (!connected && !stopped) {
     stop();
     throw new Error(
-      `Could not connect to Solard price feed at ${args.url}. Start it with: slrd feed serve`,
+      `Could not connect to Solard price feed at ${args.url}. Start the shared price feed before starting traders.`,
     );
   }
 
-  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[]) {
+    subscribeMints(value) {
+      const mints = (typeof value === "string" ? [value] : [...value])
+        .map((mint) => mint.trim())
+        .filter((mint) => mint && !desiredMints.has(mint));
+      if (!mints.length) return;
+      for (const mint of mints) desiredMints.add(mint);
       send({ op: "subscribe", mints });
     },
-    unsubscribeMints(mints: string[]) {
+    unsubscribeMints(value) {
+      const mints = (typeof value === "string" ? [value] : [...value])
+        .map((mint) => mint.trim())
+        .filter((mint) => mint && desiredMints.has(mint));
+      if (!mints.length) return;
+      for (const mint of mints) desiredMints.delete(mint);
       send({ op: "unsubscribe", mints });
     },
+    listMints() {
+      return [...desiredMints];
+    },
     close: stop,
     closed,
   };

package/src/price-feed-protocol.ts

@@ -1,33 +1,33 @@
-export type PriceFeedVenue =
-  "pump" | "pumpswap" | "raydium-launchlab" | "rpc-fallback";
+import type { SolUsdSource, TradeSide, TradeVenue } from "@solard/sdk";
 
-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 PriceFeedMarket = {
+  quoteMint: string;
+  baseDecimals: number;
+  quoteDecimals: number;
+  supply: number;
+  baseReserve: number;
+  quoteReserve: number;
+  priceQuotePerToken: number;
+  marketCapQuote: number;
+  priceSol: number | null;
+  marketCapSol: number | null;
+  solUsd: number | null;
+  solUsdSource: SolUsdSource | null;
+  solUsdAtMs: number | null;
+  priceUsd: number | null;
+  marketCapUsd: number | null;
 };
 
 export type PriceFeedPrice = {
   type: "price";
   atMs: number;
-  signature: string | null;
-  slot: number | null;
+  signature: string;
+  slot: number;
   mint: string;
-  venue: PriceFeedVenue;
-  priceSol: number | null;
-  priceUsd: number | null;
-  marketCapUsd: number | null;
-  source: string;
+  pool: string | null;
+  venue: TradeVenue;
+  side: TradeSide | null;
+  market: PriceFeedMarket;
 };
 
 export type PriceFeedStatus = {
@@ -37,15 +37,9 @@ export type PriceFeedStatus = {
   data?: Record<string, unknown>;
 };
 
-export type PriceFeedMessage =
-  PriceFeedLaunch | PriceFeedPrice | PriceFeedStatus;
+export type PriceFeedMessage = PriceFeedPrice | PriceFeedStatus;
 
 export type PriceFeedCommand =
-  | {
-      op: "subscribe";
-      mints?: string[];
-      launches?: boolean;
-      allPrices?: boolean;
-    }
-  | { op: "unsubscribe"; mints?: string[] }
+  | { op: "subscribe"; mints: string[] }
+  | { op: "unsubscribe"; mints: string[] }
   | { op: "ping" };

package/src/price-feed-server.architecture.test.ts

@@ -8,14 +8,13 @@ const source = readFileSync(
 );
 
 describe("price feed application boundary", () => {
-  test("consumes sdk subscriptions instead of protocol internals", () => {
-    expect(source).toContain("subscribeLaunches");
-    expect(source).toContain("subscribeTrades");
-    expect(source).toContain('from "@solard/sdk"');
+  test("owns one sdk trade subscription and changes its token set dynamically", () => {
+    expect(source).toContain("slrd.listenTrades");
+    expect(source).toContain("tradeSubscription.add");
+    expect(source).toContain("tradeSubscription?.remove");
+    expect(source).toContain("const refs = new Map<string, number>()");
+    expect(source).not.toContain("subscribeLaunches");
     expect(source).not.toContain('from "@solard/core"');
-    expect(source).not.toMatch(
-      /PUMP_(?:CREATE|TRADE)_EVENT|PUMPSWAP_(?:BUY|SELL|CREATE)_EVENT|LAUNCHLAB_(?:CREATE|TRADE)_EVENT/,
-    );
     expect(source).not.toMatch(/logsSubscribe|onLogs\(/);
   });
 });

package/src/price-feed-server.ts

@@ -1,31 +1,14 @@
 import { configure, createMeasure } from "measure-fn";
-import { Connection } from "@solana/web3.js";
-import {
-  getSolUsdPrice,
-  subscribeLaunches,
-  subscribeTrades,
-  type LaunchEvent,
-  type TradeEvent,
-  type TradeSubscription,
-} from "@solard/sdk";
+import slrd, { type TradeEvent, type TradeListener } from "@solard/sdk";
 import type {
   PriceFeedCommand,
-  PriceFeedLaunch,
   PriceFeedMessage,
   PriceFeedPrice,
 } from "./price-feed-protocol.ts";
 
 type Flags = Map<string, string>;
 type Emit = (value: string) => void;
-type Client = {
-  mints: Set<string>;
-  launches: boolean;
-  allPrices: boolean;
-};
-type MintState = {
-  supplyUi: number | null;
-  isMayhemMode: boolean | null;
-};
+type Client = { mints: Set<string> };
 
 function flag(flags: Flags, key: string): string | undefined {
   const value = flags.get(key);
@@ -40,56 +23,60 @@ function numberFlag(flags: Flags, key: string, fallback: number): number {
   return value;
 }
 
-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) {
+function feedAddress(flags: Flags): { host: string; port: number } {
+  if (flags.has("rpc") || flags.has("ws")) {
     throw new Error(
-      "feed serve requires RPC_ENDPOINT, SOLANA_RPC_URL, HELIUS_RPC_URL, or --rpc <url>",
+      "Set only RPC_ENDPOINT in the environment. --rpc and --ws are intentionally unsupported.",
     );
   }
-  return value;
-}
-
-function websocketUrl(flags: Flags): string | undefined {
-  return (
-    flag(flags, "ws") ??
-    process.env.SOLANA_WS_URL?.trim() ??
-    process.env.HELIUS_WS_URL?.trim()
-  );
-}
-
-function feedAddress(flags: Flags): { host: string; port: number } {
   const host = flag(flags, "host") ?? "127.0.0.1";
+  if (host !== "127.0.0.1" && host !== "localhost" && host !== "::1") {
+    throw new Error("The trader price feed is loopback-only");
+  }
   const port = Math.trunc(numberFlag(flags, "port", 8788));
   if (!(port > 0 && port <= 65_535)) throw new Error("--port must be 1..65535");
   return { host, port };
 }
 
-function publicEndpoint(value: string): string {
-  try {
-    const url = new URL(value);
-    for (const key of [...url.searchParams.keys()]) {
-      if (/key|token|secret|auth/i.test(key)) {
-        url.searchParams.set(key, "<redacted>");
-      }
-    }
-    return url.toString();
-  } catch {
-    return value.replace(
-      /([?&](?:api-?key|token|secret|auth)=)[^&]+/gi,
-      "$1<redacted>",
-    );
-  }
-}
-
 function errorText(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
+function uniqueMints(value: unknown): string[] {
+  if (!Array.isArray(value)) throw new Error("mints must be an array");
+  return [...new Set(value.map((mint) => String(mint).trim()).filter(Boolean))];
+}
+
+function priceMessage(event: TradeEvent): PriceFeedPrice {
+  return {
+    type: "price",
+    atMs: event.atMs,
+    signature: event.signature,
+    slot: event.slot,
+    mint: event.mint,
+    pool: event.pool,
+    venue: event.venue,
+    side: event.side,
+    market: {
+      quoteMint: event.market.quoteMint,
+      baseDecimals: event.market.baseDecimals,
+      quoteDecimals: event.market.quoteDecimals,
+      supply: event.market.supply,
+      baseReserve: event.market.baseReserve,
+      quoteReserve: event.market.quoteReserve,
+      priceQuotePerToken: event.market.priceQuotePerToken,
+      marketCapQuote: event.market.marketCapQuote,
+      priceSol: event.market.priceSol,
+      marketCapSol: event.market.marketCapSol,
+      solUsd: event.market.solUsd,
+      solUsdSource: event.market.solUsdSource,
+      solUsdAtMs: event.market.solUsdAtMs,
+      priceUsd: event.market.priceUsd,
+      marketCapUsd: event.market.marketCapUsd,
+    },
+  };
+}
+
 export async function runPriceFeedServerCommand(args: {
   flags: Flags;
   emit: Emit;
@@ -107,34 +94,14 @@ export async function runPriceFeedServerCommand(args: {
   ): T =>
     m.sync({ start: () => label, end: (result: T) => result }, () => value);
   const { host, port } = feedAddress(args.flags);
-  const rpc = rpcUrl(args.flags);
-  const ws = websocketUrl(args.flags);
-  const includeMayhem = args.flags.has("include-mayhem");
-  const connection = new Connection(
-    rpc,
-    ws ? { commitment: "confirmed", wsEndpoint: ws } : "confirmed",
-  );
   const controller = new AbortController();
   const clients = new Map<unknown, Client>();
-  const launches = new Map<string, PriceFeedLaunch>();
+  const refs = new Map<string, number>();
   const latest = new Map<string, PriceFeedPrice>();
-  const mintState = new Map<string, MintState>();
-  const discoveredMints = new Set<string>();
-  const explicitMintRefs = new Map<string, number>();
-  let tradeSubscription: TradeSubscription | null = null;
-  let allPriceClients = 0;
-  let solUsd: number | null = null;
-  try {
-    const quote = await getSolUsdPrice();
-    solUsd = quote.price;
-    report("sol-usd", quote);
-  } catch (error) {
-    report("sol-usd-unavailable", { error: errorText(error) });
-  }
-  let launchCount = 0;
+  let tradeSubscription: TradeListener | null = null;
   let tradeCount = 0;
-  let priceCount = 0;
   let stopped = false;
+  let commandQueue = Promise.resolve();
 
   const send = (
     socket: { send(value: string): unknown },
@@ -145,112 +112,40 @@ export async function runPriceFeedServerCommand(args: {
     } catch {}
   };
 
-  const broadcast = (value: PriceFeedMessage): void => {
-    for (const [socket, client] of clients) {
-      const target = socket as { send(value: string): unknown };
-      if (value.type === "launch") {
-        if (client.launches) send(target, value);
-        continue;
-      }
-      if (value.type === "price") {
-        if (client.allPrices || client.mints.has(value.mint))
-          send(target, value);
-        continue;
-      }
-      send(target, value);
-    }
-  };
-
-  const shouldWatchMint = (mint: string): boolean =>
-    (explicitMintRefs.get(mint) ?? 0) > 0 ||
-    (allPriceClients > 0 && discoveredMints.has(mint));
-
-  const syncMintSubscription = async (mint: string): Promise<void> => {
-    if (!tradeSubscription) return;
-    const watched = tradeSubscription.hasToken(mint);
-    const desired = shouldWatchMint(mint);
-    if (desired && !watched) await tradeSubscription.addTokens(mint);
-    if (!desired && watched) await tradeSubscription.removeTokens(mint);
-  };
-
-  const syncDiscoveredSubscriptions = async (): Promise<void> => {
-    await Promise.allSettled(
-      [...discoveredMints].map((mint) => syncMintSubscription(mint)),
-    );
-  };
-
-  const onLaunch = async (event: LaunchEvent): Promise<void> => {
-    if (event.isMayhemMode === true && !includeMayhem) return;
-    const value: PriceFeedLaunch = {
-      type: "launch",
-      atMs: event.atMs,
-      signature: event.signature,
-      slot: event.slot,
-      mint: event.mint,
-      venue: event.venue,
-      decimals: event.decimals,
-      supplyUi: event.supplyUi,
-      quoteMint: event.quoteMint,
-      pool: event.pool,
-      name: event.name,
-      symbol: event.symbol,
-      isMayhemMode: event.isMayhemMode,
-    };
-    mintState.set(event.mint, {
-      supplyUi: event.supplyUi,
-      isMayhemMode: event.isMayhemMode,
-    });
-    launches.set(event.mint, value);
-    discoveredMints.add(event.mint);
-    launchCount += 1;
-    broadcast(value);
-    await syncMintSubscription(event.mint);
-  };
+  const status = (
+    socket: { send(value: string): unknown },
+    event: string,
+    data?: Record<string, unknown>,
+  ): void => send(socket, { type: "status", atMs: Date.now(), event, data });
 
   const onTrade = (event: TradeEvent): void => {
     tradeCount += 1;
-    const state = mintState.get(event.mint);
-    if (state?.isMayhemMode === true && !includeMayhem) return;
-    solUsd = event.market.solUsd ?? solUsd;
-    const value: PriceFeedPrice = {
-      type: "price",
-      atMs: event.atMs,
-      signature: event.signature,
-      slot: event.slot,
-      mint: event.mint,
-      venue: event.venue,
-      priceSol: event.market.priceSol,
-      priceUsd: event.market.priceUsd,
-      marketCapUsd: event.market.marketCapUsd,
-      source: `${event.venue}-trade`,
-    };
+    const value = priceMessage(event);
     latest.set(event.mint, value);
-    priceCount += 1;
-    broadcast(value);
-  };
-
-  const updateExplicitMintRef = async (
-    mint: string,
-    delta: 1 | -1,
-  ): Promise<void> => {
-    const next = Math.max(0, (explicitMintRefs.get(mint) ?? 0) + delta);
-    if (next === 0) explicitMintRefs.delete(mint);
-    else explicitMintRefs.set(mint, next);
-    await syncMintSubscription(mint);
+    for (const [socket, client] of clients) {
+      if (!client.mints.has(event.mint)) continue;
+      send(socket as { send(value: string): unknown }, value);
+    }
   };
 
-  const enableAllPrices = async (client: Client): Promise<void> => {
-    if (client.allPrices) return;
-    client.allPrices = true;
-    allPriceClients += 1;
-    if (allPriceClients === 1) await syncDiscoveredSubscriptions();
+  const addRef = async (mint: string): Promise<void> => {
+    const current = refs.get(mint) ?? 0;
+    if (current === 0) {
+      if (!tradeSubscription) throw new Error("Price feed is not ready");
+      await tradeSubscription.add(mint);
+    }
+    refs.set(mint, current + 1);
   };
 
-  const disableAllPrices = async (client: Client): Promise<void> => {
-    if (!client.allPrices) return;
-    client.allPrices = false;
-    allPriceClients = Math.max(0, allPriceClients - 1);
-    if (allPriceClients === 0) await syncDiscoveredSubscriptions();
+  const removeRef = async (mint: string): Promise<void> => {
+    const current = refs.get(mint) ?? 0;
+    if (current <= 0) return;
+    if (current === 1) {
+      refs.delete(mint);
+      await tradeSubscription?.remove(mint);
+      return;
+    }
+    refs.set(mint, current - 1);
   };
 
   const applyCommand = async (
@@ -261,65 +156,56 @@ export async function runPriceFeedServerCommand(args: {
     if (!client) return;
     const target = socket as { send(value: string): unknown };
     if (command.op === "ping") {
-      send(target, { type: "status", atMs: Date.now(), event: "pong" });
+      status(target, "pong", {
+        watchedMints: client.mints.size,
+        upstreamMints: refs.size,
+      });
       return;
     }
-    const mints: string[] = [...new Set((command.mints ?? []).filter(Boolean))];
+    const mints = uniqueMints(command.mints);
     if (command.op === "subscribe") {
-      if (command.launches === true && !client.launches) {
-        client.launches = true;
-        for (const value of launches.values()) send(target, value);
-      }
-      if (command.allPrices === true && !client.allPrices) {
-        await enableAllPrices(client);
-        for (const value of latest.values()) send(target, value);
-      }
       for (const mint of mints) {
         if (!client.mints.has(mint)) {
+          await addRef(mint);
           client.mints.add(mint);
-          await updateExplicitMintRef(mint, 1);
         }
-        const value = latest.get(mint);
-        if (value) send(target, value);
+        const cached = latest.get(mint);
+        if (cached) send(target, cached);
       }
+      status(target, "subscribed", {
+        mints,
+        watchedMints: client.mints.size,
+        upstreamMints: refs.size,
+      });
       return;
     }
     for (const mint of mints) {
       if (!client.mints.delete(mint)) continue;
-      await updateExplicitMintRef(mint, -1);
+      await removeRef(mint);
     }
+    status(target, "unsubscribed", {
+      mints,
+      watchedMints: client.mints.size,
+      upstreamMints: refs.size,
+    });
   };
 
   const releaseClient = async (socket: unknown): Promise<void> => {
     const client = clients.get(socket);
     clients.delete(socket);
     if (!client) return;
-    await disableAllPrices(client);
-    await Promise.allSettled(
-      [...client.mints].map((mint) => updateExplicitMintRef(mint, -1)),
-    );
+    for (const mint of client.mints) await removeRef(mint);
   };
 
-  tradeSubscription = await subscribeTrades({
-    connection,
+  tradeSubscription = await slrd.listenTrades({
     tokens: [],
     commitment: "confirmed",
     signal: controller.signal,
-    onTrade,
     onStatus(event, data) {
       report(`trades ${event}`, data ?? {});
     },
   });
-  const launchSubscription = await subscribeLaunches({
-    connection,
-    commitment: "confirmed",
-    metadata: false,
-    signal: controller.signal,
-    onLaunch,
-    onStatus(event, data) {
-      report(`launches ${event}`, data ?? {});
-    },
-  });
+  tradeSubscription.onTrade(onTrade);
 
   const server = Bun.serve({
     hostname: host,
@@ -335,54 +221,52 @@ export async function runPriceFeedServerCommand(args: {
       if (url.pathname === "/health") {
         return Response.json({
           ok: true,
+          service: "solard-price-feed",
           clients: clients.size,
-          launchCount,
+          upstreamMints: refs.size,
+          watchedTokens: tradeSubscription?.list().length ?? 0,
+          cachedPrices: latest.size,
           tradeCount,
-          priceCount,
-          cachedLaunches: launches.size,
-          latestPrices: latest.size,
-          discoveredMints: discoveredMints.size,
-          explicitMints: explicitMintRefs.size,
-          allPriceClients,
-          watchedTokens: tradeSubscription?.listTokens().length ?? 0,
-          solUsd,
+          subscriptions: Object.fromEntries(refs),
         });
       }
-      return new Response("Solard price feed\n");
+      return new Response("Solard trader price feed\n");
     },
     websocket: {
       open(socket) {
-        clients.set(socket, {
-          mints: new Set(),
-          launches: false,
-          allPrices: false,
+        clients.set(socket, { mints: new Set() });
+        status(socket, "ready", {
+          upstreamMints: refs.size,
         });
-        send(socket, { type: "status", atMs: Date.now(), event: "ready" });
       },
       message(socket, message) {
+        let command: PriceFeedCommand;
         try {
-          void applyCommand(
-            socket,
-            JSON.parse(String(message)) as PriceFeedCommand,
-          ).catch((error) => {
-            send(socket, {
-              type: "status",
-              atMs: Date.now(),
-              event: "client-error",
-              data: { error: errorText(error) },
-            });
-          });
+          command = JSON.parse(String(message)) as PriceFeedCommand;
+          if (
+            !command ||
+            (command.op !== "subscribe" &&
+              command.op !== "unsubscribe" &&
+              command.op !== "ping")
+          ) {
+            throw new Error("op must be subscribe, unsubscribe, or ping");
+          }
         } catch (error) {
-          send(socket, {
-            type: "status",
-            atMs: Date.now(),
-            event: "client-error",
-            data: { error: errorText(error) },
-          });
+          status(socket, "client-error", { error: errorText(error) });
+          return;
         }
+        commandQueue = commandQueue
+          .then(() => applyCommand(socket, command))
+          .catch((error) => {
+            status(socket, "client-error", { error: errorText(error) });
+          });
       },
       close(socket) {
-        void releaseClient(socket);
+        commandQueue = commandQueue
+          .then(() => releaseClient(socket))
+          .catch((error) => {
+            report("release-client-error", { error: errorText(error) });
+          });
       },
     },
   });
@@ -391,16 +275,11 @@ export async function runPriceFeedServerCommand(args: {
     () =>
       report("heartbeat", {
         clients: clients.size,
-        launchCount,
+        upstreamMints: refs.size,
+        watchedTokens: tradeSubscription?.list().length ?? 0,
+        cachedPrices: latest.size,
         tradeCount,
-        priceCount,
-        cachedLaunches: launches.size,
-        latestPrices: latest.size,
-        discoveredMints: discoveredMints.size,
-        explicitMints: explicitMintRefs.size,
-        allPriceClients,
-        watchedTokens: tradeSubscription?.listTokens().length ?? 0,
-        solUsd,
+        subscriptions: Object.fromEntries(refs),
       }),
     Math.max(1_000, Math.trunc(numberFlag(args.flags, "heartbeat-ms", 15_000))),
   );
@@ -408,9 +287,6 @@ export async function runPriceFeedServerCommand(args: {
   report("ready", {
     url: `ws://${host}:${server.port}/ws`,
     health: `http://${host}:${server.port}/health`,
-    rpc: publicEndpoint(rpc),
-    ws: ws ? publicEndpoint(ws) : "connection-default",
-    includeMayhem,
   });
 
   const stop = (): void => {
@@ -422,19 +298,18 @@ export async function runPriceFeedServerCommand(args: {
   process.once("SIGTERM", stop);
 
   try {
-    await Promise.all([launchSubscription.closed, tradeSubscription.closed]);
+    await tradeSubscription.closed;
   } finally {
     clearInterval(heartbeat);
     process.removeListener("SIGINT", stop);
     process.removeListener("SIGTERM", stop);
-    await launchSubscription.close();
     await tradeSubscription.close();
+    await commandQueue.catch(() => undefined);
     server.stop(true);
     report("stopped", {
-      launchCount,
-      tradeCount,
-      priceCount,
       clients: clients.size,
+      upstreamMints: refs.size,
+      tradeCount,
     });
   }
 }

package/src/trade-strategy-command.ts

@@ -208,14 +208,14 @@ function required(flags: Flags, key: string): 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 (flags.has("rpc") || flags.has("ws"))
+    throw new Error(
+      "Set only RPC_ENDPOINT in the environment. --rpc and --ws are intentionally unsupported.",
+    );
+  const value = process.env.RPC_ENDPOINT?.trim();
   if (!value)
     throw new Error(
-      "strategy run requires RPC_ENDPOINT, SOLANA_RPC_URL, HELIUS_RPC_URL, or --rpc <url>",
+      "strategy run requires RPC_ENDPOINT. WebSocket access is derived from the same endpoint.",
     );
   return value;
 }