From b8a296064c7c3029bcb436ac3967725018b8fca8 Mon Sep 17 00:00:00 2001
From: 0xFantomMenace <93462858+0xFantomMenace@users.noreply.github.com>
Date: Thu, 8 Oct 2026 03:00:48 +0000
Subject: [PATCH 1/2] 1.11.0: stream pending Hyperliquid transactions with oxa
 stream subscribe mempool

- oxa stream subscribe mempool [symbol]: signed Hyperliquid transactions
  before they are included in a block, on every Hyperliquid product. The
  symbol is optional on this channel only; HIP-4 coins are bare numerics.
  Live only, with the Pro, Scale and Enterprise plans.
- A channel served on one endpoint only connects there by default, read
  from the SDK's channel table: mempool connects to
  wss://stream.0xarchive.io/ws. --url and OXA_WS_URL still take precedence;
  the default endpoint is refused for mempool before connecting.
- oxa stream replay mempool is refused before connecting.
- oxa capabilities --format pretty prints a row's WebSocket endpoint and
  plans when it sets them.
- Requires @0xarchive/sdk 1.13.0. Version 1.11.0.
---
 CHANGELOG.md                 |  13 +++
 README.md                    |  44 +++++++-
 package.json                 |   4 +-
 src/cli.ts                   |  19 ++--
 src/commands/capabilities.ts |   4 +
 src/commands/replay.ts       |   1 +
 src/commands/stream.ts       |  88 ++++++++++++----
 src/lib/client.ts            |   7 +-
 src/lib/sdk.ts               |  17 ++++
 tests/analytics.test.ts      |   6 +-
 tests/contract.test.ts       |  36 ++++++-
 tests/positions.test.ts      |   2 +-
 tests/replay.test.ts         |  23 ++++-
 tests/stream.test.ts         | 191 ++++++++++++++++++++++++++++++++++-
 14 files changed, 408 insertions(+), 47 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f9583ff..026cbea 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,18 @@
 # Changelog
 
+## 1.11.0 - 2026-10-08
+
+### Added
+
+- `oxa stream subscribe mempool [symbol]`: pending Hyperliquid transactions (orders, cancels, modifies, TWAPs, leverage changes, transfers, and every other action type) as our Hyperliquid node receives them from its peers, before they are included in a block, on every Hyperliquid product (perps, HIP-3, HIP-4, and spot). Leave the symbol out for every pending transaction, or pass one (`BTC`, `xyz:TSLA`, `HYPE-USDC`, or a bare numeric HIP-4 coin) for only the actions that reference that market. Each NDJSON line is one message, holding the signed actions of one batch our node received. A pending transaction can still be rejected, expire, or never land. The channel is live only, and `oxa stream replay mempool` is refused before connecting because pending transactions are not stored. It is included with the Pro, Scale, and Enterprise plans; on other plans the server answers `forbidden` and the CLI exits with code 3. When the unfiltered stream is at capacity the server answers `rate_limited` (exit code 4); subscribe with a symbol instead.
+- `oxa capabilities --format pretty` prints a row's WebSocket endpoint and plans when the row sets them, as the `mempool` row does. JSON output includes them as `wsEndpoint` and `plans`.
+
+### Changed
+
+- `oxa stream subscribe <channel> [symbol]`: the symbol is optional for `mempool`. Every other channel still needs one, and the CLI says so before connecting.
+- A channel served on one WebSocket endpoint only connects there by default: `mempool` connects to `wss://stream.0xarchive.io/ws`. The CLI reads the endpoint from the SDK's channel table. `--url` and `OXA_WS_URL` still take precedence; pointing them at `wss://api.0xarchive.io/ws` for `mempool` exits with code 2 before connecting. Every other channel keeps `wss://api.0xarchive.io/ws` as its default.
+- Requires `@0xarchive/sdk` 1.13.0 or newer, the release with the `mempool` channel and the endpoint and plans in its channel table.
+
 ## 1.10.0 - 2026-10-05
 
 This release adopts the 0xArchive API contract `2026-10-01`. Every request selects that API version (the `0xArchive-Version: 2026-10-01` header on REST, `version=2026-10-01` on WebSocket connections), and the CLI reads the response shapes of that version. The changes this brings are listed under Added and Changed.
diff --git a/README.md b/README.md
index 4536690..7b425c9 100644
--- a/README.md
+++ b/README.md
@@ -131,7 +131,7 @@ Which venue serves which datatype, over REST and WebSocket, and from when, is `o
 
 ## Plans and Data Access
 
-Every command below works on every plan, including Free. Free includes every market, route, schema, and served depth, with history limited to the most recent rolling 30 days and a maximum 30-day span per request or replay. Build and above keep the full retained archive. Plans gate capacity and Free's 30-day history window, not route families, schemas, or served depth. See [Pricing](https://www.0xarchive.io/pricing) for plan capacity.
+Every command below works on every plan, including Free, except the live `mempool` stream (`oxa stream subscribe mempool`), which is included with the Pro, Scale, and Enterprise plans. Free includes every market, route, schema, and served depth, with history limited to the most recent rolling 30 days and a maximum 30-day span per request or replay. Build and above keep the full retained archive. Plans gate capacity and Free's 30-day history window, not route families, schemas, or served depth. See [Pricing](https://www.0xarchive.io/pricing) for plan capacity.
 
 ## Commands
 
@@ -981,7 +981,7 @@ oxa stream trades HYPE-USDC --exchange spot --duration-ms 60000
 
 ### `oxa stream ...` (realtime WebSocket)
 
-Stream live market data over a single WebSocket subscription, or replay stored data with `oxa stream replay` (see [Replay](#replay)). Output is NDJSON on stdout (one JSON record per line) by default; `--format pretty` adds a one-line summary per event. WebSocket streaming is available on every plan, including Free. Connection counts, subscription caps, and replay speed scale with plan; on Free, replay is limited to the most recent rolling 30 days with a maximum 30-day span per replay (see [Plans and Data Access](#plans-and-data-access)). Each `oxa stream` process opens one WebSocket connection, which counts toward your plan's connection limit; the default endpoint is `wss://api.0xarchive.io/ws`. Live streams and replays run on the SDK's WebSocket client, which connects with the `ws` package in Node.js. They work on Node.js 18 or later, and large messages, such as the L4 snapshot of a deep book, arrive intact.
+Stream live market data over a single WebSocket subscription, or replay stored data with `oxa stream replay` (see [Replay](#replay)). Output is NDJSON on stdout (one JSON record per line) by default; `--format pretty` adds a one-line summary per event. WebSocket streaming is available on every plan, including Free; the `mempool` channel is included with the Pro, Scale, and Enterprise plans. Connection counts, subscription caps, and replay speed scale with plan; on Free, replay is limited to the most recent rolling 30 days with a maximum 30-day span per replay (see [Plans and Data Access](#plans-and-data-access)). Each `oxa stream` process opens one WebSocket connection, which counts toward your plan's connection limit; the default endpoint is `wss://api.0xarchive.io/ws`, and `mempool` connects to `wss://stream.0xarchive.io/ws`, the only endpoint that serves it. Live streams and replays run on the SDK's WebSocket client, which connects with the `ws` package in Node.js. They work on Node.js 18 or later, and large messages, such as the L4 snapshot of a deep book, arrive intact.
 
 ```bash
 # Realtime liquidations (Hyperliquid; pass `--exchange hip3` for HIP-3 builder perps)
@@ -1016,6 +1016,10 @@ oxa stream subscribe hip3_orderbook_full xyz:SP500
 oxa stream subscribe hip4_trades "$COIN"
 oxa stream subscribe hip4_l4_diffs "$COIN"
 
+# Pending Hyperliquid transactions, before they are in a block (Pro, Scale, and Enterprise plans)
+oxa stream subscribe mempool BTC --duration-ms 10000
+oxa stream subscribe mempool --duration-ms 10000   # every pending transaction
+
 # Replay ten minutes of stored trades at 10x real time (one minute), then exit
 oxa stream replay trades BTC --start $HOUR_AGO --end $(( HOUR_AGO + 600000 )) --speed 10
 
@@ -1033,7 +1037,7 @@ oxa stream replay hip3_l4_diffs xyz:TSLA --start $HOUR_AGO --end $(( HOUR_AGO +
 | `--url` | All | Override the WebSocket URL (or set `OXA_WS_URL`) |
 | `--format` | All | `json` (NDJSON, default) or `pretty` |
 
-`oxa stream subscribe` accepts every channel that `oxa capabilities` lists as live. The CLI reads that list from the SDK's channel table, which mirrors `/v1/capabilities`: `orderbook`, `trades`, `liquidations`, `open_interest`, `funding`, `ticker`, `all_tickers`, `l4_diffs`, `l4_orders`, `orderbook_full` (Hyperliquid); `hip3_orderbook`, `hip3_trades`, `hip3_open_interest`, `hip3_funding`, `hip3_liquidations`, `hip3_l4_diffs`, `hip3_l4_orders`, `hip3_orderbook_full` (HIP-3); `hip4_trades`, `hip4_l4_diffs`, `hip4_l4_orders` (HIP-4); `spot_orderbook`, `spot_trades`, `spot_l4_diffs`, `spot_l4_orders` (Spot); and the four live channels of each Lighter deployment. The replay-only channels (`candles`, `hip3_candles`, `hip4_orderbook`, `hip4_open_interest`, `lighter_candles`, `lighter_l3_orderbook`, `rh_lighter_candles`) are refused before a socket opens, with a pointer to the command that serves their data, and so is `spot_twap`, whose TWAP statuses are served over REST only (`oxa spot twap history`).
+`oxa stream subscribe` accepts every channel that `oxa capabilities` lists as live. The CLI reads that list from the SDK's channel table, which mirrors `/v1/capabilities`: `orderbook`, `trades`, `liquidations`, `open_interest`, `funding`, `ticker`, `all_tickers`, `l4_diffs`, `l4_orders`, `orderbook_full` (Hyperliquid); `hip3_orderbook`, `hip3_trades`, `hip3_open_interest`, `hip3_funding`, `hip3_liquidations`, `hip3_l4_diffs`, `hip3_l4_orders`, `hip3_orderbook_full` (HIP-3); `hip4_trades`, `hip4_l4_diffs`, `hip4_l4_orders` (HIP-4); `spot_orderbook`, `spot_trades`, `spot_l4_diffs`, `spot_l4_orders` (Spot); the four live channels of each Lighter deployment; and `mempool` (pending transactions on every Hyperliquid product, see [Pending transactions (mempool)](#pending-transactions-mempool)). Every channel needs a symbol except `mempool`, where it is optional. The replay-only channels (`candles`, `hip3_candles`, `hip4_orderbook`, `hip4_open_interest`, `lighter_candles`, `lighter_l3_orderbook`, `rh_lighter_candles`) are refused before a socket opens, with a pointer to the command that serves their data, and so is `spot_twap`, whose TWAP statuses are served over REST only (`oxa spot twap history`).
 
 Each `liquidations` / `hip3_liquidations` event is delivered as a fill row with `is_liquidation: true`. To stop early, send SIGINT (Ctrl-C) or pass `--duration-ms`; both exit with code 0. An error message from the server is written to stderr with its `error_code`, and the CLI exits with the code for that class (see [Exit Codes](#exit-codes)): an unknown symbol (`invalid_symbol`) exits with code 2, and a connection that fell behind (`slow_consumer`) exits with code 4, so a supervising script can restart the stream. The one exception is a Lighter drop notice, which the CLI reports as a warning while the stream continues (see [Lighter live channels](#lighter-live-channels)). Every connection selects API version `2026-10-01` (`version=2026-10-01` on the URL).
 
@@ -1076,6 +1080,38 @@ WebSocket replay of all six Lighter mainnet channels, and of the five Robinhood
 
 HIP-4 streams live on `hip4_trades`, `hip4_l4_diffs`, and `hip4_l4_orders`. `hip4_orderbook` and `hip4_open_interest` replay stored data but do not stream live, so `oxa stream subscribe` refuses them; read the current book and open interest with `oxa hip4 orderbook get` and `oxa hip4 oi current`. Pass HIP-4 coins as bare numerics (`82260`); the CLI sends them to the WebSocket API in its `#82260` form. `hip4_l4_diffs` starts with an L4 snapshot of the book.
 
+#### Pending transactions (mempool)
+
+`mempool` streams signed Hyperliquid transactions (orders, cancels, modifies, TWAPs, leverage changes, transfers, and every other action type) as our Hyperliquid node receives them from its peers, before they are included in a block. It covers every Hyperliquid product: perps, HIP-3, HIP-4, and spot.
+
+- Live only: there is no replay, no history, and no REST route. Pending transactions are not stored, and `oxa stream replay mempool` is refused before connecting.
+- Pending is not executed: a transaction seen here can still be rejected, expire, or never land.
+- The same signed action can occasionally arrive twice; deduplicate on `signature` if needed.
+- Served on `wss://stream.0xarchive.io/ws` only, with the same API key. The CLI connects there unless `--url` or `OXA_WS_URL` is set; pointing either at `wss://api.0xarchive.io/ws` exits with code 2 before connecting.
+- Included with the Pro, Scale, and Enterprise plans. On other plans the server answers `forbidden`, and the CLI exits with code 3. Each message counts like any other WebSocket message.
+
+```bash
+oxa stream subscribe mempool BTC          # actions that reference BTC
+oxa stream subscribe mempool xyz:TSLA     # HIP-3
+oxa stream subscribe mempool HYPE-USDC    # spot
+oxa stream subscribe mempool "$COIN"      # HIP-4, bare numeric coin
+oxa stream subscribe mempool              # every pending transaction
+```
+
+Leave the symbol out for every pending transaction. The unfiltered stream is several megabytes per second before compression, and the number of unfiltered subscriptions is limited: when it is at capacity, the server answers `rate_limited` and the CLI exits with code 4; subscribe with a symbol, or try again later. A symbol subscription receives every action whose asset ids include that market, whole, so an order batch touching BTC and ETH reaches both BTC and ETH subscribers. An unknown symbol gets `invalid_symbol` (exit code 2).
+
+Each NDJSON line is one message, holding the signed actions of one batch our node received from a peer. `coin` and `symbol` are the subscription's symbol, or `null` on the unfiltered stream. Example message (one item, signature shortened):
+
+```json
+{"type":"data","channel":"mempool","coin":"BTC","symbol":"BTC","data":[{"received_at":"2026-10-08T01:57:23.548737209Z","received_at_ms":1791424643548,"symbols":["BTC"],"action":{"type":"order","orders":[{"a":0,"b":true,"p":"83276","s":"0.40011","r":false,"t":{"limit":{"tif":"Alo"}},"c":"0x7849acc2c6c2f6f0fe4bc80ef13d1504"}],"grouping":"na"},"nonce":1791424643400,"vault_address":null,"expires_after_ms":null,"signature":{"r":"0x5afc...","s":"0x57e2...","v":28}}]}
+```
+
+- **`received_at`**, **`received_at_ms`**: when our node received the transaction, as RFC 3339 UTC with nanosecond precision and as Unix milliseconds. Not a block time.
+- **`symbols`**: the markets the action's asset ids reference, in canonical spelling and first-seen order, without repeats. Empty for actions with no market, such as transfers.
+- **`action`**: the action exactly as signed, in Hyperliquid's exchange-action format: asset ids (`a`, `asset`), not symbols, and prices and sizes as strings. `action.type` names it (`order`, `cancel`, `modify`, `twapOrder`, `updateLeverage`, `usdSend`, and others); Hyperliquid adds types over time.
+- **`nonce`**: the action's nonce. **`vault_address`**: the vault or subaccount it acts for, or `null`. **`expires_after_ms`**: the action's `expiresAfter` in Unix milliseconds, or `null`.
+- **`signature`**: `{r, s, v}`. The signer can be recovered from it and `action`; the signer's address is not included.
+
 #### Replay
 
 `oxa stream replay <channel> <symbol> --start <time> --end <time>` replays stored data over one WebSocket connection through the SDK's replay client. Every server message (`replay_started`, the `historical_data` rows, `l4_snapshot` and `l4_batch` pages on the bulk channels, `gap_detected`, and `replay_completed`) is written to stdout as one JSON record per line, and the command exits with code 0 when the replay completes. A server error is written to stderr with its `error_code` and exits with the code for its class (see [Exit Codes](#exit-codes)). In pretty format, bulk pages are summarized (`l4_batch 5000 events`, `l4_snapshot block=... bids=... asks=...`) rather than printed.
@@ -1098,7 +1134,7 @@ oxa stream replay lighter_orderbook ETH --start $HOUR_AGO --end $(( HOUR_AGO + 6
 | `--url` | No | Override the WebSocket URL (or set `OXA_WS_URL`) |
 | `--format` | No | `json` (NDJSON, default) or `pretty` |
 
-Replayable channels are the ones `oxa capabilities` lists with replay; the CLI reads them from the SDK's channel table, which mirrors `/v1/capabilities`. Timed channels keep their original timing, scaled by `--speed`: `orderbook`, `trades`, `candles`, `liquidations`, `open_interest`, `funding` (Hyperliquid); `hip3_orderbook`, `hip3_trades`, `hip3_candles`, `hip3_open_interest`, `hip3_funding`, `hip3_liquidations` (HIP-3); `hip4_orderbook`, `hip4_trades`, `hip4_open_interest` (HIP-4); the six `lighter_*` and five `rh_lighter_*` channels. Bulk channels replay as fast as they are read, with `--speed` ignored: every L4 channel on every venue (`l4_diffs`, `l4_orders`, `hip3_l4_diffs`, `hip3_l4_orders`, `hip4_l4_diffs`, `hip4_l4_orders`, `spot_l4_diffs`, `spot_l4_orders`) and the full-depth books (`orderbook_full`, `hip3_orderbook_full`). A bulk replay starts with an `l4_snapshot` from the nearest checkpoint at or before `--start` and sends `l4_batch` pages in block order until `--end`. The live-only channels (`ticker`, `all_tickers`, `spot_orderbook`, `spot_trades`) and the REST-only `spot_twap` are refused before a socket is opened, with a pointer to the REST commands that serve their history. On Free, replay covers the most recent rolling 30 days with a maximum 30-day span.
+Replayable channels are the ones `oxa capabilities` lists with replay; the CLI reads them from the SDK's channel table, which mirrors `/v1/capabilities`. Timed channels keep their original timing, scaled by `--speed`: `orderbook`, `trades`, `candles`, `liquidations`, `open_interest`, `funding` (Hyperliquid); `hip3_orderbook`, `hip3_trades`, `hip3_candles`, `hip3_open_interest`, `hip3_funding`, `hip3_liquidations` (HIP-3); `hip4_orderbook`, `hip4_trades`, `hip4_open_interest` (HIP-4); the six `lighter_*` and five `rh_lighter_*` channels. Bulk channels replay as fast as they are read, with `--speed` ignored: every L4 channel on every venue (`l4_diffs`, `l4_orders`, `hip3_l4_diffs`, `hip3_l4_orders`, `hip4_l4_diffs`, `hip4_l4_orders`, `spot_l4_diffs`, `spot_l4_orders`) and the full-depth books (`orderbook_full`, `hip3_orderbook_full`). A bulk replay starts with an `l4_snapshot` from the nearest checkpoint at or before `--start` and sends `l4_batch` pages in block order until `--end`. The live-only channels (`ticker`, `all_tickers`, `spot_orderbook`, `spot_trades`, `mempool`) and the REST-only `spot_twap` are refused before a socket is opened, with a pointer to the REST commands that serve their history where there is one. On Free, replay covers the most recent rolling 30 days with a maximum 30-day span.
 
 ### `oxa webhooks ...`
 
diff --git a/package.json b/package.json
index e81efa9..4237130 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@0xarchive/cli",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "Terminal-first 0xArchive client for Hyperliquid and Lighter market data and account positions, including Hyperliquid HIP-3, HIP-4, Spot, and Lighter on Robinhood Chain",
   "type": "module",
   "bin": {
@@ -48,7 +48,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@0xarchive/sdk": "^1.12.0",
+    "@0xarchive/sdk": "^1.13.0",
     "commander": "^13.0.0",
     "chalk": "^5.4.0"
   },
diff --git a/src/cli.ts b/src/cli.ts
index ab8ead8..f507afd 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -123,7 +123,7 @@ import {
 import { capabilitiesCommand } from './commands/capabilities.js';
 import { exitError, EXIT } from './lib/output.js';
 
-const VERSION = '1.10.0';
+const VERSION = '1.11.0';
 
 const EXCHANGE_DESC =
   'Exchange: hyperliquid, hip3, hip4, lighter, or rh-lighter. ' +
@@ -1178,15 +1178,20 @@ stream
   .option('--format <format>', 'Output format: json (NDJSON) or pretty', 'json')
   .action(streamOrderbookCommand);
 
-// Generic channel subscription by name. Which channels stream live is the
-// SDK's channel table (WS_CHANNEL_CAPABILITIES, which mirrors
-// /v1/capabilities); replay-only channels are refused before a socket opens.
+// Generic channel subscription by name. Which channels stream live, and the
+// endpoint a channel served on one endpoint only connects to, is the SDK's
+// channel table (WS_CHANNEL_CAPABILITIES, which mirrors /v1/capabilities);
+// replay-only channels are refused before a socket opens. The symbol is
+// optional on `mempool` only.
 stream
-  .command('subscribe <channel> <symbol>')
+  .command('subscribe <channel> [symbol]')
   .description(
     'Subscribe to a live WebSocket channel by name: every channel `oxa capabilities` lists as live, ' +
-      'e.g. l4_diffs, orderbook_full, hip3_l4_orders, hip4_trades, spot_l4_diffs, lighter_funding, rh_lighter_trades. ' +
+      'e.g. l4_diffs, orderbook_full, hip3_l4_orders, hip4_trades, spot_l4_diffs, lighter_funding, rh_lighter_trades, mempool. ' +
       'Symbols are dashed canonical for spot (HYPE-USDC); HIP-4 coins are bare numerics. ' +
+      'Every channel needs a symbol except mempool (pending Hyperliquid transactions; Pro, Scale and Enterprise plans), ' +
+      'where it is optional: without one, every pending transaction streams. ' +
+      'mempool is served on wss://stream.0xarchive.io/ws only, and the CLI connects there unless --url or OXA_WS_URL is set. ' +
       'Full-depth books (orderbook_full, hip3_orderbook_full) send an l4_snapshot with every level, then l4_batch changes. ' +
       'Replay-only channels (candles, hip3_candles, hip4_orderbook, hip4_open_interest, lighter_candles, ' +
       'lighter_l3_orderbook, rh_lighter_candles) and spot_twap, which is served over REST only, are refused.',
@@ -1207,7 +1212,7 @@ stream
     'Replay stored data over WebSocket, as NDJSON, until the replay completes: every channel `oxa capabilities` lists with replay. ' +
       'Timed channels keep their original timing (scaled by --speed). L4 channels on every venue and the full-depth books ' +
       '(orderbook_full, hip3_orderbook_full) replay in bulk: an l4_snapshot, then l4_batch pages, with --speed ignored. ' +
-      'Live-only channels (ticker, all_tickers, spot_orderbook, spot_trades) and spot_twap, which is served over REST only, ' +
+      'Live-only channels (ticker, all_tickers, spot_orderbook, spot_trades, mempool) and spot_twap, which is served over REST only, ' +
       'are refused before connecting.',
   )
   .requiredOption('--start <time>', 'Start time (ISO 8601 or Unix ms)')
diff --git a/src/commands/capabilities.ts b/src/commands/capabilities.ts
index 38ad36b..684da52 100644
--- a/src/commands/capabilities.ts
+++ b/src/commands/capabilities.ts
@@ -51,6 +51,10 @@ function printRow(row: CapabilityRow): void {
   prettyField('Cadence', row.cadence);
   prettyField('Page limit', row.pageLimit ?? '-');
   prettyField('Intervals', list(row.intervals));
+  // Set only on rows served on one WebSocket endpoint, or included with some
+  // plans rather than all (the mempool row).
+  if (row.wsEndpoint) prettyField('WebSocket endpoint', row.wsEndpoint);
+  if (row.plans) prettyField('Plans', list(row.plans));
   prettyField('Notes', row.notes);
 }
 
diff --git a/src/commands/replay.ts b/src/commands/replay.ts
index 03888ec..8cacd82 100644
--- a/src/commands/replay.ts
+++ b/src/commands/replay.ts
@@ -28,6 +28,7 @@ export const LIVE_ONLY_HINTS: Readonly<Record<string, string>> = {
   spot_twap: 'Use `oxa spot twap history <symbol> --start ... --end ...` for Spot TWAP history.',
   ticker: 'Use `oxa summary get` or `oxa prices history` for stored prices.',
   all_tickers: 'Use `oxa summary get` or `oxa prices history` for stored prices.',
+  mempool: 'Pending transactions are not stored; stream them live with `oxa stream subscribe mempool [symbol]`.',
 };
 
 /** The channels the SDK's table marks as replayable, sorted. */
diff --git a/src/commands/stream.ts b/src/commands/stream.ts
index cb178e0..fe87308 100644
--- a/src/commands/stream.ts
+++ b/src/commands/stream.ts
@@ -6,7 +6,9 @@
 // Each `oxa stream <channel> <symbol>` command opens a single subscription,
 // emits one JSON record per stdout line (NDJSON), and runs until the user
 // hits Ctrl-C. JSON mode is the default; `--format pretty` adds a one-line
-// human-readable summary per event.
+// human-readable summary per event. `mempool` is the one channel whose symbol
+// is optional, and a channel served on one endpoint only (the SDK's table
+// names it, as for `mempool`) connects there unless --url or OXA_WS_URL is set.
 
 import { OxArchiveWs } from '@0xarchive/sdk';
 import { resolveApiKey } from '../lib/client.js';
@@ -75,17 +77,48 @@ export const REST_ONLY_HINTS: Readonly<Record<string, string>> = {
   spot_twap: 'Use `oxa spot twap history <symbol> --start ... --end ...` for Spot TWAP statuses.',
 };
 
+/**
+ * Channels whose symbol is optional. Without one, `mempool` streams every
+ * pending transaction; every other channel needs a symbol.
+ */
+export const OPTIONAL_SYMBOL_CHANNELS: readonly string[] = ['mempool'];
+
+/** Exit with a validation error when a channel that needs a symbol has none. */
+export function requireSymbol(channel: string, symbol: string | undefined): void {
+  if ((symbol !== undefined && symbol !== '') || OPTIONAL_SYMBOL_CHANNELS.includes(channel)) return;
+  exitError(`${channel} needs a symbol: \`oxa stream subscribe ${channel} <symbol>\`.`, EXIT.VALIDATION);
+}
+
+/**
+ * The WebSocket URL for a channel: --url, then OXA_WS_URL, then the only
+ * endpoint that serves the channel when the SDK's table names one (`mempool`
+ * is served on wss://stream.0xarchive.io/ws only), then the default endpoint.
+ */
+export function streamUrl(capability: Pick<WsChannelCapability, 'wsEndpoint'>, url?: string): string {
+  return url ?? process.env.OXA_WS_URL ?? capability.wsEndpoint ?? DEFAULT_WS_URL;
+}
+
+/** True when `url` points at the default endpoint, wss://api.0xarchive.io/ws. */
+function isDefaultEndpoint(url: string): boolean {
+  try {
+    return new URL(url).host === new URL(DEFAULT_WS_URL).host;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Exit with a validation error unless the SDK's channel table marks the
- * channel live. Unknown channels list the live ones.
+ * channel live, and return its row. Unknown channels list the live ones.
  */
-export function requireLiveChannel(channel: string): void {
+export function requireLiveChannel(channel: string): WsChannelCapability {
   const table = wsChannelCapabilities();
   const capability = Object.hasOwn(table, channel) ? table[channel] : undefined;
   if (!capability) {
     exitError(`Unknown stream channel "${channel}". Live channels: ${liveChannels().join(', ')}.`, EXIT.VALIDATION);
   }
   refuseUnlessLive(channel, capability);
+  return capability;
 }
 
 function refuseUnlessLive(channel: string, capability: WsChannelCapability): void {
@@ -217,20 +250,23 @@ export function parseIntervalMs(raw: string | undefined, channel: string): numbe
 /**
  * HIP-4 WebSocket channels name coins in their on-chain form (`#0`). The CLI
  * takes bare numerics everywhere else, so `0` and `%230` become `#0` here.
+ * `mempool` takes HIP-4 coins in the same form; no other market it accepts is
+ * a bare number.
  */
 export function wsSymbol(channel: string, symbol: string): string {
-  if (!channel.startsWith('hip4_')) return symbol;
+  if (!channel.startsWith('hip4_') && channel !== 'mempool') return symbol;
   const trimmed = String(symbol).trim();
   const digits = trimmed.replace(/^(#|%23)/i, '');
   return /^\d+$/.test(digits) ? `#${digits}` : trimmed;
 }
 
 // Best-effort event time for the pretty summary line. Replay rows carry
-// `timestamp`; live books and fills carry `time` (fills arrive as an array).
+// `timestamp`; live books and fills carry `time` (fills arrive as an array);
+// pending transactions carry `received_at_ms`.
 function eventTime(payload: any): string | number {
   const data = payload?.data;
   const first = Array.isArray(data) ? data[0] : data;
-  return first?.timestamp ?? first?.time ?? payload?.timestamp ?? '';
+  return first?.timestamp ?? first?.time ?? first?.received_at_ms ?? payload?.timestamp ?? '';
 }
 
 /**
@@ -245,27 +281,38 @@ interface LiveClient {
     onClose?: (code: number, reason: string) => void;
     onError?: (error: Error) => void;
   }): Promise<void>;
-  subscribe(channel: string, symbol: string, options?: { intervalMs?: number }): void;
+  subscribe(channel: string, symbol?: string, options?: { intervalMs?: number }): void;
   disconnect(): void;
 }
 
 async function streamChannel(
   channel: string,
-  symbol: string,
+  symbol: string | undefined,
   options: StreamOptions,
+  capability: WsChannelCapability,
 ): Promise<void> {
   const format = validateFormat(options.format);
-  symbol = wsSymbol(channel, symbol);
+  symbol = symbol === undefined || symbol === '' ? undefined : wsSymbol(channel, symbol);
   const durationMs = parseDuration(options.durationMs);
   const intervalMs = parseIntervalMs(options.intervalMs, channel);
   const apiKey = resolveApiKey(options.apiKey);
 
+  // A channel served on one endpoint only is refused on the default endpoint,
+  // which is known not to serve it. Any other URL is left to the server.
+  const wsUrl = streamUrl(capability, options.url);
+  if (capability.wsEndpoint !== undefined && isDefaultEndpoint(wsUrl)) {
+    exitError(
+      `${channel} is served on ${capability.wsEndpoint} only. Leave out --url and OXA_WS_URL to connect there.`,
+      EXIT.VALIDATION,
+    );
+  }
+
   // The SDK adds the key and the API version (`version=`) to the URL. A
   // dropped connection ends the command rather than reconnecting, so the
   // output never joins two sessions without a sign of the gap.
   const ws = new OxArchiveWs({
     apiKey,
-    wsUrl: options.url ?? process.env.OXA_WS_URL ?? DEFAULT_WS_URL,
+    wsUrl,
     autoReconnect: false,
   }) as unknown as LiveClient;
 
@@ -297,7 +344,8 @@ async function streamChannel(
     opened = true;
     if (format === 'pretty') {
       const interval = intervalMs !== undefined ? ` interval_ms=${intervalMs}` : '';
-      prettyDim(`subscribed: channel=${channel} symbol=${symbol}${interval}`);
+      const target = symbol !== undefined ? ` symbol=${symbol}` : '';
+      prettyDim(`subscribed: channel=${channel}${target}${interval}`);
     }
     if (durationMs !== undefined) {
       timer = setTimeout(closeSocket, durationMs);
@@ -370,31 +418,31 @@ async function streamChannel(
 
 export async function streamLiquidationsCommand(symbol: string, options: StreamOptions): Promise<void> {
   const channel = resolveChannel('liquidations', options.exchange);
-  requireLiveChannel(channel);
-  return streamChannel(channel, symbol, options);
+  return streamChannel(channel, symbol, options, requireLiveChannel(channel));
 }
 
 export async function streamTradesCommand(symbol: string, options: StreamOptions): Promise<void> {
   const channel = resolveChannel('trades', options.exchange);
-  requireLiveChannel(channel);
-  return streamChannel(channel, symbol, options);
+  return streamChannel(channel, symbol, options, requireLiveChannel(channel));
 }
 
 export async function streamOrderbookCommand(symbol: string, options: StreamOptions): Promise<void> {
   const channel = resolveChannel('orderbook', options.exchange);
-  requireLiveChannel(channel);
-  return streamChannel(channel, symbol, options);
+  return streamChannel(channel, symbol, options, requireLiveChannel(channel));
 }
 
+// `oxa stream subscribe <channel> [symbol]`: the symbol is optional on
+// `mempool` only.
 export async function streamGenericCommand(
   channel: string,
-  symbol: string,
+  symbol: string | undefined,
   options: StreamOptions,
 ): Promise<void> {
   const ch = String(channel).toLowerCase();
   if (!Object.hasOwn(wsChannelCapabilities(), ch)) {
     exitError(`Unknown stream channel "${channel}". Live channels: ${liveChannels().join(', ')}.`, EXIT.VALIDATION);
   }
-  requireLiveChannel(ch);
-  return streamChannel(ch, symbol, options);
+  const capability = requireLiveChannel(ch);
+  requireSymbol(ch, symbol);
+  return streamChannel(ch, symbol, options, capability);
 }
diff --git a/src/lib/client.ts b/src/lib/client.ts
index c053431..0936a82 100644
--- a/src/lib/client.ts
+++ b/src/lib/client.ts
@@ -55,9 +55,10 @@ export function exchangeLabel(exchange: string): string {
 }
 
 // The oldest @0xarchive/sdk release with the Robinhood Chain client, the
-// positions resources, and Lighter liquidations. package.json pins it as the
-// floor; this message covers a stale install that predates the floor.
-export const SDK_FLOOR = '1.12.0';
+// positions resources, Lighter liquidations, and the `mempool` channel.
+// package.json pins it as the floor; this message covers a stale install that
+// predates the floor.
+export const SDK_FLOOR = '1.13.0';
 
 export function sdkTooOld(feature: string): never {
   exitError(
diff --git a/src/lib/sdk.ts b/src/lib/sdk.ts
index 54a02ab..d0b4861 100644
--- a/src/lib/sdk.ts
+++ b/src/lib/sdk.ts
@@ -159,6 +159,14 @@ export interface CapabilityRow {
   pageLimit: number | null;
   intervals: string[];
   notes: string | null;
+  /**
+   * The only WebSocket endpoint that serves the datatype's channels, e.g.
+   * `wss://stream.0xarchive.io/ws` for `mempool`. Absent when they are served
+   * on the default endpoint, `wss://api.0xarchive.io/ws`.
+   */
+  wsEndpoint?: string;
+  /** The plans that include the datatype. Absent when every plan includes it. */
+  plans?: string[];
 }
 
 /** What one WebSocket channel offers, from the SDK's channel table. */
@@ -169,6 +177,15 @@ export interface WsChannelCapability {
   replay: boolean;
   /** Bulk replay: single-channel, an explicit end, speed ignored, an `l4_snapshot` then `l4_batch` pages. */
   bulkReplay: boolean;
+  /**
+   * The only endpoint that serves the channel, e.g.
+   * `wss://stream.0xarchive.io/ws` for `mempool`. Absent when it is served on
+   * the default endpoint. `oxa stream` connects there unless `--url` or
+   * `OXA_WS_URL` says otherwise.
+   */
+  wsEndpoint?: string;
+  /** The plans that include the channel. Absent when every plan includes it. */
+  plans?: readonly string[];
 }
 
 /** `client.capabilities()`: `GET /v1/capabilities`. */
diff --git a/tests/analytics.test.ts b/tests/analytics.test.ts
index e3f4505..f03df1c 100644
--- a/tests/analytics.test.ts
+++ b/tests/analytics.test.ts
@@ -202,7 +202,7 @@ describe('new analytics commands', () => {
       else sdk.state.clients.hyperliquid.breadth = undefined;
       expect(await runCli('breadth', 'current', '--exchange', exchange)).toBe(5);
       expect(lastError().error).toBe(
-        `Support for ${label} breadth requires @0xarchive/sdk 1.12.0 or newer. Reinstall @0xarchive/cli to pick it up.`,
+        `Support for ${label} breadth requires @0xarchive/sdk 1.13.0 or newer. Reinstall @0xarchive/cli to pick it up.`,
       );
     });
   });
@@ -464,7 +464,7 @@ describe('new analytics commands', () => {
     it('names the SDK floor when the installed SDK has no symbol list', async () => {
       sdk.state.clients.symbols = undefined;
       expect(await runCli('symbols')).toBe(5);
-      expect(lastError().error).toMatch(/^Support for the symbol list requires @0xarchive\/sdk 1\.12\.0 or newer/);
+      expect(lastError().error).toMatch(/^Support for the symbol list requires @0xarchive\/sdk 1\.13\.0 or newer/);
     });
   });
 
@@ -815,7 +815,7 @@ describe('new analytics commands', () => {
     it('names the SDK floor when positions freshness is missing', async () => {
       delete dq().positionsFreshness;
       expect(await runCli('data-quality', 'positions-freshness')).toBe(5);
-      expect(lastError().error).toMatch(/^Support for positions freshness requires @0xarchive\/sdk 1\.12\.0 or newer/);
+      expect(lastError().error).toMatch(/^Support for positions freshness requires @0xarchive\/sdk 1\.13\.0 or newer/);
     });
   });
 
diff --git a/tests/contract.test.ts b/tests/contract.test.ts
index 9553eb4..cab0b7b 100644
--- a/tests/contract.test.ts
+++ b/tests/contract.test.ts
@@ -314,6 +314,38 @@ describe('API contract 2026-10-01 in the CLI', () => {
       expect(out).toContain('Notes: WebSocket replay is bulk');
     });
 
+    it('prints the WebSocket endpoint and plans of a row that sets them', async () => {
+      const mempool = {
+        venue: 'hyperliquid',
+        datatype: 'mempool',
+        restRoutes: [],
+        wsChannels: ['mempool'],
+        live: true,
+        replay: false,
+        availableFrom: null,
+        cadence: 'event',
+        pageLimit: null,
+        intervals: [],
+        notes: 'Live only.',
+        wsEndpoint: 'wss://stream.0xarchive.io/ws',
+        plans: ['pro', 'scale', 'enterprise'],
+      };
+      sdk.state.clients.capabilities!.mockResolvedValue([...sdk.CAPABILITIES, mempool]);
+      expect(await runCli('capabilities', '--datatype', 'mempool', '--format', 'pretty')).toBe(0);
+      const out = stdoutText();
+      expect(out).toContain('WebSocket endpoint: wss://stream.0xarchive.io/ws');
+      expect(out).toContain('Plans: pro, scale, enterprise');
+
+      vi.mocked(process.stdout.write).mockClear();
+      expect(await runCli('capabilities', '--datatype', 'mempool')).toBe(0);
+      expect(stdoutJson()).toEqual([mempool]);
+
+      vi.mocked(process.stdout.write).mockClear();
+      expect(await runCli('capabilities', '--exchange', 'hip3', '--datatype', 'l4_diffs', '--format', 'pretty')).toBe(0);
+      expect(stdoutText()).not.toContain('WebSocket endpoint');
+      expect(stdoutText()).not.toContain('Plans');
+    });
+
     it('names the datatypes a venue serves when the datatype is unknown', async () => {
       expect(await runCli('capabilities', '--exchange', 'spot', '--datatype', 'funding')).toBe(2);
       expect(lastError().error).toBe('No datatype "funding". Hyperliquid Spot serves: candles or trades.');
@@ -334,7 +366,7 @@ describe('API contract 2026-10-01 in the CLI', () => {
     it('asks for the SDK floor on an SDK without capabilities()', async () => {
       sdk.state.clients.capabilities = undefined;
       expect(await runCli('capabilities')).toBe(5);
-      expect(lastError().error).toMatch(/^Support for capabilities requires @0xarchive\/sdk 1\.12\.0 or newer/);
+      expect(lastError().error).toMatch(/^Support for capabilities requires @0xarchive\/sdk 1\.13\.0 or newer/);
     });
   });
 
@@ -447,7 +479,7 @@ describe('API contract 2026-10-01 in the CLI', () => {
     it('asks for the SDK floor for --side on recent trades on an older SDK', async () => {
       delete (sdk.state.clients.lighter.trades as Record<string, unknown>).history;
       expect(await runCli('trades', 'history', '--exchange', 'lighter', '--symbol', 'BTC', '--side', 'buy')).toBe(5);
-      expect(lastError().error).toMatch(/--side on recent trades requires @0xarchive\/sdk 1\.12\.0/);
+      expect(lastError().error).toMatch(/--side on recent trades requires @0xarchive\/sdk 1\.13\.0/);
     });
 
     it('refuses a --side other than buy or sell before any request', async () => {
diff --git a/tests/positions.test.ts b/tests/positions.test.ts
index 35d8aef..a137a44 100644
--- a/tests/positions.test.ts
+++ b/tests/positions.test.ts
@@ -546,7 +546,7 @@ describe('oxa positions', () => {
     await expectExit(
       () => positionsGetCommand({ exchange: 'rh-lighter', account: '1', format: 'json' }),
       5,
-      'Support for Lighter on Robinhood Chain (--exchange rh-lighter) requires @0xarchive/sdk 1.12.0 or newer. ' +
+      'Support for Lighter on Robinhood Chain (--exchange rh-lighter) requires @0xarchive/sdk 1.13.0 or newer. ' +
         'Reinstall @0xarchive/cli to pick it up.',
     );
   });
diff --git a/tests/replay.test.ts b/tests/replay.test.ts
index 2500262..60dc7af 100644
--- a/tests/replay.test.ts
+++ b/tests/replay.test.ts
@@ -217,13 +217,32 @@ describe.runIf(CHANNEL_TABLE)('oxa stream replay', () => {
 
   it('refuses exactly the channels the SDK table does not mark replayable', async () => {
     const liveOnly = Object.entries(CHANNEL_TABLE!).filter(([, c]) => !c.replay).map(([channel]) => channel);
-    expect(liveOnly.sort()).toEqual(['all_tickers', 'spot_orderbook', 'spot_trades', 'spot_twap', 'ticker']);
+    // `mempool` is in the table from SDK 1.13.0. Until that release is on npm,
+    // CI runs on the newest published SDK, whose table does not have it.
+    const expected = ['all_tickers', 'spot_orderbook', 'spot_trades', 'spot_twap', 'ticker'];
+    if (Object.hasOwn(CHANNEL_TABLE!, 'mempool')) expected.push('mempool');
+    expect(liveOnly.sort()).toEqual(expected.sort());
     for (const channel of liveOnly) {
       expect(await runCli('stream', 'replay', channel, 'BTC', '--start', START, '--end', END)).toBe(2);
     }
     expect(FakeSdkSocket.instances).toHaveLength(0);
   });
 
+  it.runIf(CHANNEL_TABLE && Object.hasOwn(CHANNEL_TABLE, 'mempool'))(
+    'refuses mempool, whose pending transactions are not stored, before opening a socket',
+    async () => {
+      expect(await runCli('stream', 'replay', 'mempool', 'BTC', '--start', START, '--end', END)).toBe(2);
+      expect(lastError()).toEqual({
+        error:
+          'mempool is live only; the API does not replay it. ' +
+          'Pending transactions are not stored; stream them live with `oxa stream subscribe mempool [symbol]`.',
+        code: 2,
+        type: 'validation',
+      });
+      expect(FakeSdkSocket.instances).toHaveLength(0);
+    },
+  );
+
   it.each([
     ['orderbook_full', 'BTC', 'BTC'],
     ['hip3_orderbook_full', 'km:US500', 'km:US500'],
@@ -299,7 +318,7 @@ describe.skipIf(CHANNEL_TABLE)('oxa stream replay on an SDK older than the floor
 
   it('asks for the SDK release with the channel table', async () => {
     expect(await runCli('stream', 'replay', 'trades', 'BTC', '--start', START, '--end', END)).toBe(5);
-    expect(lastError().error).toMatch(/requires @0xarchive\/sdk 1\.12\.0 or newer/);
+    expect(lastError().error).toMatch(/requires @0xarchive\/sdk 1\.13\.0 or newer/);
     expect(FakeSdkSocket.instances).toHaveLength(0);
   });
 });
diff --git a/tests/stream.test.ts b/tests/stream.test.ts
index a6bb23a..4c0de97 100644
--- a/tests/stream.test.ts
+++ b/tests/stream.test.ts
@@ -1,24 +1,35 @@
 import * as sdk from '@0xarchive/sdk';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
+  OPTIONAL_SYMBOL_CHANNELS,
   REPLAY_ONLY_HINTS,
   REST_ONLY_HINTS,
   isLighterDropNotice,
   parseIntervalMs,
+  requireSymbol,
   resolveChannel,
   streamGenericCommand,
   streamLiquidationsCommand,
   streamOrderbookCommand,
   streamTradesCommand,
+  streamUrl,
   wsSymbol,
 } from '../src/commands/stream.js';
+import { parseCli } from './helpers.js';
 
 // `oxa stream` runs on the SDK's WebSocket client and allows the channels the
 // SDK's channel table marks live. The SDK release the CLI requires exports
 // that table; on an older install (CI before that release reaches npm) the
 // socket tests are skipped and the commands ask for that release instead.
-const CHANNEL_TABLE = (sdk as unknown as { WS_CHANNEL_CAPABILITIES?: Record<string, { live: boolean; replay: boolean }> })
-  .WS_CHANNEL_CAPABILITIES;
+const CHANNEL_TABLE = (
+  sdk as unknown as {
+    WS_CHANNEL_CAPABILITIES?: Record<string, { live: boolean; replay: boolean; wsEndpoint?: string }>;
+  }
+).WS_CHANNEL_CAPABILITIES;
+
+// `mempool` is in the SDK's table from 1.13.0. Until that release is on npm,
+// CI runs on the newest published SDK, and the socket tests for it are skipped.
+const HAS_MEMPOOL = CHANNEL_TABLE !== undefined && Object.hasOwn(CHANNEL_TABLE, 'mempool');
 
 class ProcessExit extends Error {
   constructor(readonly code: number) {
@@ -578,7 +589,7 @@ describe.skipIf(CHANNEL_TABLE)('oxa stream on an SDK older than the floor', () =
     () => streamGenericCommand('l4_diffs', 'BTC', { format: 'json' }),
   ])('asks for the SDK release with the channel table (%#)', async (run) => {
     await expect(Promise.resolve().then(run)).rejects.toMatchObject({ code: 5 });
-    expect(stderrPayloads().at(-1)?.error).toMatch(/requires @0xarchive\/sdk 1\.12\.0 or newer/);
+    expect(stderrPayloads().at(-1)?.error).toMatch(/requires @0xarchive\/sdk 1\.13\.0 or newer/);
     expect(FakeWebSocket.instances).toHaveLength(0);
   });
 });
@@ -760,6 +771,172 @@ describe.runIf(CHANNEL_TABLE)('oxa stream subscribe, driven by the channel table
   });
 });
 
+const MEMPOOL_ITEM = {
+  received_at: '2026-10-08T01:57:23.548737209Z',
+  received_at_ms: 1791424643548,
+  symbols: ['BTC'],
+  action: {
+    type: 'order',
+    orders: [{ a: 0, b: true, p: '83276', s: '0.40011', r: false, t: { limit: { tif: 'Alo' } }, c: '0x7849acc2c6c2f6f0fe4bc80ef13d1504' }],
+    grouping: 'na',
+  },
+  nonce: 1791424643400,
+  vault_address: null,
+  expires_after_ms: null,
+  signature: { r: '0x5afc', s: '0x57e2', v: 28 },
+};
+
+describe('stream endpoint and optional symbol', () => {
+  let savedWsUrl: string | undefined;
+
+  beforeEach(() => {
+    savedWsUrl = process.env.OXA_WS_URL;
+    delete process.env.OXA_WS_URL;
+    vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    vi.spyOn(process, 'exit').mockImplementation(((code?: number) => {
+      throw new ProcessExit(code ?? 0);
+    }) as never);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.unstubAllEnvs();
+    if (savedWsUrl !== undefined) process.env.OXA_WS_URL = savedWsUrl;
+  });
+
+  it('connects a channel served on one endpoint there, and every other channel to the default', () => {
+    expect(streamUrl({ wsEndpoint: 'wss://stream.0xarchive.io/ws' })).toBe('wss://stream.0xarchive.io/ws');
+    expect(streamUrl({})).toBe('wss://api.0xarchive.io/ws');
+  });
+
+  it('puts --url, then OXA_WS_URL, ahead of that endpoint', () => {
+    const capability = { wsEndpoint: 'wss://stream.0xarchive.io/ws' };
+    vi.stubEnv('OXA_WS_URL', 'wss://env.example/ws');
+    expect(streamUrl(capability)).toBe('wss://env.example/ws');
+    expect(streamUrl(capability, 'wss://flag.example/ws')).toBe('wss://flag.example/ws');
+    expect(streamUrl({}, 'wss://flag.example/ws')).toBe('wss://flag.example/ws');
+  });
+
+  it('makes the symbol optional on mempool only', () => {
+    expect(OPTIONAL_SYMBOL_CHANNELS).toEqual(['mempool']);
+    expect(() => requireSymbol('mempool', undefined)).not.toThrow();
+    expect(() => requireSymbol('trades', 'BTC')).not.toThrow();
+    for (const symbol of [undefined, '']) {
+      expect(() => requireSymbol('trades', symbol)).toThrow(ProcessExit);
+      expect(stderrPayloads().at(-1)).toEqual({
+        error: 'trades needs a symbol: `oxa stream subscribe trades <symbol>`.',
+        code: 2,
+        type: 'validation',
+      });
+    }
+  });
+});
+
+describe.runIf(HAS_MEMPOOL)('oxa stream subscribe mempool', () => {
+  let savedWsUrl: string | undefined;
+
+  beforeEach(() => {
+    FakeWebSocket.instances = [];
+    vi.stubGlobal('WebSocket', FakeWebSocket);
+    // The SDK client's keep-alive ping runs on an interval; keep it off the clock.
+    vi.useFakeTimers({ toFake: ['setInterval', 'clearInterval'] });
+    vi.stubEnv('OXA_API_KEY', 'test-key');
+    savedWsUrl = process.env.OXA_WS_URL;
+    delete process.env.OXA_WS_URL;
+    vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    vi.spyOn(process, 'on').mockImplementation(() => process);
+    vi.spyOn(process, 'exit').mockImplementation(((code?: number) => {
+      throw new ProcessExit(code ?? 0);
+    }) as never);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+    vi.unstubAllEnvs();
+    if (savedWsUrl !== undefined) process.env.OXA_WS_URL = savedWsUrl;
+  });
+
+  it('takes the stream endpoint from the SDK table', () => {
+    expect(CHANNEL_TABLE!.mempool).toMatchObject({ live: true, replay: false, wsEndpoint: 'wss://stream.0xarchive.io/ws' });
+  });
+
+  it('streams every pending transaction from the stream endpoint when the symbol is left out', async () => {
+    await parseCli('stream', 'subscribe', 'mempool');
+    const ws = FakeWebSocket.instances[0];
+    expect(ws.url).toBe('wss://stream.0xarchive.io/ws?apiKey=test-key&version=2026-10-01');
+    ws.fire('open');
+    expect(ws.frames()).toEqual([{ op: 'subscribe', channel: 'mempool' }]);
+
+    ws.message({ type: 'subscribed', channel: 'mempool', coin: null, symbol: null });
+    const frame = { type: 'data', channel: 'mempool', coin: null, symbol: null, data: [MEMPOOL_ITEM] };
+    ws.message(frame);
+    expect(stdoutLines()).toEqual([JSON.stringify(frame) + '\n']);
+  });
+
+  it('filters to one market with a symbol', async () => {
+    await parseCli('stream', 'subscribe', 'MEMPOOL', 'BTC', '--format', 'pretty');
+    const ws = FakeWebSocket.instances[0];
+    expect(ws.url).toBe('wss://stream.0xarchive.io/ws?apiKey=test-key&version=2026-10-01');
+    ws.fire('open');
+    expect(ws.frames()).toEqual([{ op: 'subscribe', channel: 'mempool', symbol: 'BTC' }]);
+    ws.message({ type: 'data', channel: 'mempool', coin: 'BTC', symbol: 'BTC', data: [MEMPOOL_ITEM] });
+    expect(stdoutLines().at(-1)).toBe(`[mempool] 1791424643548 ${JSON.stringify([MEMPOOL_ITEM])}\n`);
+  });
+
+  it('keeps --url and OXA_WS_URL ahead of the stream endpoint', async () => {
+    process.env.OXA_WS_URL = 'wss://env.example/ws';
+    await streamGenericCommand('mempool', undefined, { format: 'json' });
+    expect(FakeWebSocket.instances[0].url).toBe('wss://env.example/ws?apiKey=test-key&version=2026-10-01');
+
+    FakeWebSocket.instances = [];
+    await streamGenericCommand('mempool', 'BTC', { format: 'json', url: 'wss://proxy.example/ws' });
+    expect(FakeWebSocket.instances[0].url).toBe('wss://proxy.example/ws?apiKey=test-key&version=2026-10-01');
+  });
+
+  it('refuses mempool on the default endpoint before opening a socket', async () => {
+    await expectValidationExit(
+      () => streamGenericCommand('mempool', undefined, { format: 'json', url: 'wss://api.0xarchive.io/ws' }),
+      'mempool is served on wss://stream.0xarchive.io/ws only. Leave out --url and OXA_WS_URL to connect there.',
+    );
+  });
+
+  it('still connects every other channel to the default endpoint', async () => {
+    await streamGenericCommand('l4_diffs', 'BTC', { format: 'json' });
+    expect(FakeWebSocket.instances[0].url).toBe('wss://api.0xarchive.io/ws?apiKey=test-key&version=2026-10-01');
+  });
+
+  it('refuses another channel without a symbol before opening a socket', async () => {
+    await expect(parseCli('stream', 'subscribe', 'trades')).rejects.toMatchObject({ code: 2 });
+    expect(stderrPayloads().at(-1)).toEqual({
+      error: 'trades needs a symbol: `oxa stream subscribe trades <symbol>`.',
+      code: 2,
+      type: 'validation',
+    });
+    expect(FakeWebSocket.instances).toHaveLength(0);
+  });
+
+  it.each([
+    [
+      'forbidden',
+      'The mempool channel is included with the Pro, Scale and Enterprise plans. Upgrade at https://0xarchive.io/pricing.',
+      3,
+      'auth',
+    ],
+    ['rate_limited', 'The unfiltered mempool stream is at capacity. Subscribe with a symbol, or try again later.', 4, 'network'],
+    ['upstream_unavailable', 'The mempool channel is temporarily unavailable. Please try again shortly.', 4, 'network'],
+  ])('exits on %s with the error_code', async (code, message, exit, type) => {
+    await streamGenericCommand('mempool', undefined, { format: 'json' });
+    const ws = FakeWebSocket.instances[0];
+    ws.fire('open');
+    ws.message({ type: 'error', message, error_code: code });
+    expect(exitCodes()).toEqual([exit]);
+    expect(stderrPayloads().at(-1)).toEqual({ error: `stream error: ${message}`, code: exit, type, error_code: code });
+  });
+});
+
 describe('WebSocket symbols', () => {
   it('uses the #<n> form on HIP-4 channels only', () => {
     expect(wsSymbol('hip4_l4_diffs', '42')).toBe('#42');
@@ -768,4 +945,12 @@ describe('WebSocket symbols', () => {
     expect(wsSymbol('trades', '42')).toBe('42');
     expect(wsSymbol('hip3_trades', 'km:US500')).toBe('km:US500');
   });
+
+  it('uses the #<n> form for HIP-4 coins on mempool, and leaves other markets alone', () => {
+    expect(wsSymbol('mempool', '49720')).toBe('#49720');
+    expect(wsSymbol('mempool', '#49720')).toBe('#49720');
+    expect(wsSymbol('mempool', 'BTC')).toBe('BTC');
+    expect(wsSymbol('mempool', 'xyz:TSLA')).toBe('xyz:TSLA');
+    expect(wsSymbol('mempool', 'HYPE-USDC')).toBe('HYPE-USDC');
+  });
 });

From 710593cc7afe7e30b4c4e03cc4e3404f25405b8b Mon Sep 17 00:00:00 2001
From: 0xFantomMenace <93462858+0xFantomMenace@users.noreply.github.com>
Date: Thu, 8 Oct 2026 03:10:24 +0000
Subject: [PATCH 2/2] oxa stream subscribe all_tickers takes no symbol; mempool
 docs wording

all_tickers data is sent only to a subscription without a symbol, so the
CLI subscribes without one and refuses a symbol instead of opening a stream
that receives nothing. The mempool docs state that the unfiltered stream
carries the pending transactions our Hyperliquid node receives, that
unfiltered subscriptions share a server-wide capacity limit, and that the
mempool stream is the only datatype plans gate.
---
 CHANGELOG.md           |  4 ++--
 README.md              | 18 +++++++++---------
 src/cli.ts             |  8 ++++----
 src/commands/stream.ts | 35 +++++++++++++++++++++++++----------
 tests/stream.test.ts   | 39 ++++++++++++++++++++++++++++++++-------
 5 files changed, 72 insertions(+), 32 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 026cbea..c7ea20c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,12 +4,12 @@
 
 ### Added
 
-- `oxa stream subscribe mempool [symbol]`: pending Hyperliquid transactions (orders, cancels, modifies, TWAPs, leverage changes, transfers, and every other action type) as our Hyperliquid node receives them from its peers, before they are included in a block, on every Hyperliquid product (perps, HIP-3, HIP-4, and spot). Leave the symbol out for every pending transaction, or pass one (`BTC`, `xyz:TSLA`, `HYPE-USDC`, or a bare numeric HIP-4 coin) for only the actions that reference that market. Each NDJSON line is one message, holding the signed actions of one batch our node received. A pending transaction can still be rejected, expire, or never land. The channel is live only, and `oxa stream replay mempool` is refused before connecting because pending transactions are not stored. It is included with the Pro, Scale, and Enterprise plans; on other plans the server answers `forbidden` and the CLI exits with code 3. When the unfiltered stream is at capacity the server answers `rate_limited` (exit code 4); subscribe with a symbol instead.
+- `oxa stream subscribe mempool [symbol]`: pending Hyperliquid transactions (orders, cancels, modifies, TWAPs, leverage changes, transfers, and every other action type) as our Hyperliquid node receives them from its peers, before they are included in a block, on every Hyperliquid product (perps, HIP-3, HIP-4, and spot). Leave the symbol out for every pending transaction our Hyperliquid node receives, or pass one (`BTC`, `xyz:TSLA`, `HYPE-USDC`, or a bare numeric HIP-4 coin) for only the actions that reference that market. Each mempool data message is written as one NDJSON line holding the signed actions of one batch our node received. A pending transaction can still be rejected, expire, or never land. The channel is live only, and `oxa stream replay mempool` is refused before connecting because pending transactions are not stored. It is included with the Pro, Scale and Enterprise plans; on other plans the server answers `forbidden` and the CLI exits with code 3. When the unfiltered stream is at capacity the server answers `rate_limited` (exit code 4); subscribe with a symbol instead.
 - `oxa capabilities --format pretty` prints a row's WebSocket endpoint and plans when the row sets them, as the `mempool` row does. JSON output includes them as `wsEndpoint` and `plans`.
 
 ### Changed
 
-- `oxa stream subscribe <channel> [symbol]`: the symbol is optional for `mempool`. Every other channel still needs one, and the CLI says so before connecting.
+- `oxa stream subscribe <channel> [symbol]`: `mempool` takes an optional symbol, `all_tickers` takes none, and every other channel needs one; the CLI says so before connecting. The server sends `all_tickers` data only to a subscription without a symbol, so a symbol given for it is now refused instead of opening a stream that receives nothing.
 - A channel served on one WebSocket endpoint only connects there by default: `mempool` connects to `wss://stream.0xarchive.io/ws`. The CLI reads the endpoint from the SDK's channel table. `--url` and `OXA_WS_URL` still take precedence; pointing them at `wss://api.0xarchive.io/ws` for `mempool` exits with code 2 before connecting. Every other channel keeps `wss://api.0xarchive.io/ws` as its default.
 - Requires `@0xarchive/sdk` 1.13.0 or newer, the release with the `mempool` channel and the endpoint and plans in its channel table.
 
diff --git a/README.md b/README.md
index 7b425c9..254e0d2 100644
--- a/README.md
+++ b/README.md
@@ -131,7 +131,7 @@ Which venue serves which datatype, over REST and WebSocket, and from when, is `o
 
 ## Plans and Data Access
 
-Every command below works on every plan, including Free, except the live `mempool` stream (`oxa stream subscribe mempool`), which is included with the Pro, Scale, and Enterprise plans. Free includes every market, route, schema, and served depth, with history limited to the most recent rolling 30 days and a maximum 30-day span per request or replay. Build and above keep the full retained archive. Plans gate capacity and Free's 30-day history window, not route families, schemas, or served depth. See [Pricing](https://www.0xarchive.io/pricing) for plan capacity.
+Every command below works on every plan, including Free, except the live `mempool` stream (`oxa stream subscribe mempool`), which is included with the Pro, Scale and Enterprise plans. Apart from the live mempool stream, Free includes every market, route, schema, and served depth, with history limited to the most recent rolling 30 days and a maximum 30-day span per request or replay. Build and above keep the full retained archive. Plans gate capacity, Free's 30-day history window and the live mempool stream; every other route family, schema and served depth is on every plan. See [Pricing](https://www.0xarchive.io/pricing) for plan capacity.
 
 ## Commands
 
@@ -981,7 +981,7 @@ oxa stream trades HYPE-USDC --exchange spot --duration-ms 60000
 
 ### `oxa stream ...` (realtime WebSocket)
 
-Stream live market data over a single WebSocket subscription, or replay stored data with `oxa stream replay` (see [Replay](#replay)). Output is NDJSON on stdout (one JSON record per line) by default; `--format pretty` adds a one-line summary per event. WebSocket streaming is available on every plan, including Free; the `mempool` channel is included with the Pro, Scale, and Enterprise plans. Connection counts, subscription caps, and replay speed scale with plan; on Free, replay is limited to the most recent rolling 30 days with a maximum 30-day span per replay (see [Plans and Data Access](#plans-and-data-access)). Each `oxa stream` process opens one WebSocket connection, which counts toward your plan's connection limit; the default endpoint is `wss://api.0xarchive.io/ws`, and `mempool` connects to `wss://stream.0xarchive.io/ws`, the only endpoint that serves it. Live streams and replays run on the SDK's WebSocket client, which connects with the `ws` package in Node.js. They work on Node.js 18 or later, and large messages, such as the L4 snapshot of a deep book, arrive intact.
+Stream live market data over a single WebSocket subscription, or replay stored data with `oxa stream replay` (see [Replay](#replay)). Output is NDJSON on stdout (one JSON record per line) by default; `--format pretty` adds a one-line summary per event. WebSocket streaming is available on every plan, including Free; the `mempool` channel is included with the Pro, Scale and Enterprise plans. Connection counts, subscription caps, and replay speed scale with plan; on Free, replay is limited to the most recent rolling 30 days with a maximum 30-day span per replay (see [Plans and Data Access](#plans-and-data-access)). Each `oxa stream` process opens one WebSocket connection, which counts toward your plan's connection limit; the default endpoint is `wss://api.0xarchive.io/ws`, and `mempool` connects to `wss://stream.0xarchive.io/ws`, the only endpoint that serves it. Live streams and replays run on the SDK's WebSocket client, which connects with the `ws` package in Node.js. They work on Node.js 18 or later, and large messages, such as the L4 snapshot of a deep book, arrive intact.
 
 ```bash
 # Realtime liquidations (Hyperliquid; pass `--exchange hip3` for HIP-3 builder perps)
@@ -1016,9 +1016,9 @@ oxa stream subscribe hip3_orderbook_full xyz:SP500
 oxa stream subscribe hip4_trades "$COIN"
 oxa stream subscribe hip4_l4_diffs "$COIN"
 
-# Pending Hyperliquid transactions, before they are in a block (Pro, Scale, and Enterprise plans)
+# Pending Hyperliquid transactions, before they are in a block (Pro, Scale and Enterprise plans)
 oxa stream subscribe mempool BTC --duration-ms 10000
-oxa stream subscribe mempool --duration-ms 10000   # every pending transaction
+oxa stream subscribe mempool --duration-ms 10000   # every pending transaction our Hyperliquid node receives
 
 # Replay ten minutes of stored trades at 10x real time (one minute), then exit
 oxa stream replay trades BTC --start $HOUR_AGO --end $(( HOUR_AGO + 600000 )) --speed 10
@@ -1037,7 +1037,7 @@ oxa stream replay hip3_l4_diffs xyz:TSLA --start $HOUR_AGO --end $(( HOUR_AGO +
 | `--url` | All | Override the WebSocket URL (or set `OXA_WS_URL`) |
 | `--format` | All | `json` (NDJSON, default) or `pretty` |
 
-`oxa stream subscribe` accepts every channel that `oxa capabilities` lists as live. The CLI reads that list from the SDK's channel table, which mirrors `/v1/capabilities`: `orderbook`, `trades`, `liquidations`, `open_interest`, `funding`, `ticker`, `all_tickers`, `l4_diffs`, `l4_orders`, `orderbook_full` (Hyperliquid); `hip3_orderbook`, `hip3_trades`, `hip3_open_interest`, `hip3_funding`, `hip3_liquidations`, `hip3_l4_diffs`, `hip3_l4_orders`, `hip3_orderbook_full` (HIP-3); `hip4_trades`, `hip4_l4_diffs`, `hip4_l4_orders` (HIP-4); `spot_orderbook`, `spot_trades`, `spot_l4_diffs`, `spot_l4_orders` (Spot); the four live channels of each Lighter deployment; and `mempool` (pending transactions on every Hyperliquid product, see [Pending transactions (mempool)](#pending-transactions-mempool)). Every channel needs a symbol except `mempool`, where it is optional. The replay-only channels (`candles`, `hip3_candles`, `hip4_orderbook`, `hip4_open_interest`, `lighter_candles`, `lighter_l3_orderbook`, `rh_lighter_candles`) are refused before a socket opens, with a pointer to the command that serves their data, and so is `spot_twap`, whose TWAP statuses are served over REST only (`oxa spot twap history`).
+`oxa stream subscribe` accepts every channel that `oxa capabilities` lists as live. The CLI reads that list from the SDK's channel table, which mirrors `/v1/capabilities`: `orderbook`, `trades`, `liquidations`, `open_interest`, `funding`, `ticker`, `all_tickers`, `l4_diffs`, `l4_orders`, `orderbook_full` (Hyperliquid); `hip3_orderbook`, `hip3_trades`, `hip3_open_interest`, `hip3_funding`, `hip3_liquidations`, `hip3_l4_diffs`, `hip3_l4_orders`, `hip3_orderbook_full` (HIP-3); `hip4_trades`, `hip4_l4_diffs`, `hip4_l4_orders` (HIP-4); `spot_orderbook`, `spot_trades`, `spot_l4_diffs`, `spot_l4_orders` (Spot); the four live channels of each Lighter deployment; and `mempool` (pending transactions on every Hyperliquid product, see [Pending transactions (mempool)](#pending-transactions-mempool)). `mempool` takes an optional symbol, `all_tickers` takes none, and every other channel needs one. The replay-only channels (`candles`, `hip3_candles`, `hip4_orderbook`, `hip4_open_interest`, `lighter_candles`, `lighter_l3_orderbook`, `rh_lighter_candles`) are refused before a socket opens, with a pointer to the command that serves their data, and so is `spot_twap`, whose TWAP statuses are served over REST only (`oxa spot twap history`).
 
 Each `liquidations` / `hip3_liquidations` event is delivered as a fill row with `is_liquidation: true`. To stop early, send SIGINT (Ctrl-C) or pass `--duration-ms`; both exit with code 0. An error message from the server is written to stderr with its `error_code`, and the CLI exits with the code for that class (see [Exit Codes](#exit-codes)): an unknown symbol (`invalid_symbol`) exits with code 2, and a connection that fell behind (`slow_consumer`) exits with code 4, so a supervising script can restart the stream. The one exception is a Lighter drop notice, which the CLI reports as a warning while the stream continues (see [Lighter live channels](#lighter-live-channels)). Every connection selects API version `2026-10-01` (`version=2026-10-01` on the URL).
 
@@ -1088,19 +1088,19 @@ HIP-4 streams live on `hip4_trades`, `hip4_l4_diffs`, and `hip4_l4_orders`. `hip
 - Pending is not executed: a transaction seen here can still be rejected, expire, or never land.
 - The same signed action can occasionally arrive twice; deduplicate on `signature` if needed.
 - Served on `wss://stream.0xarchive.io/ws` only, with the same API key. The CLI connects there unless `--url` or `OXA_WS_URL` is set; pointing either at `wss://api.0xarchive.io/ws` exits with code 2 before connecting.
-- Included with the Pro, Scale, and Enterprise plans. On other plans the server answers `forbidden`, and the CLI exits with code 3. Each message counts like any other WebSocket message.
+- Included with the Pro, Scale and Enterprise plans. On other plans the server answers `forbidden`, and the CLI exits with code 3. Each data message counts like any other WebSocket data message.
 
 ```bash
 oxa stream subscribe mempool BTC          # actions that reference BTC
 oxa stream subscribe mempool xyz:TSLA     # HIP-3
 oxa stream subscribe mempool HYPE-USDC    # spot
 oxa stream subscribe mempool "$COIN"      # HIP-4, bare numeric coin
-oxa stream subscribe mempool              # every pending transaction
+oxa stream subscribe mempool              # every pending transaction our Hyperliquid node receives
 ```
 
-Leave the symbol out for every pending transaction. The unfiltered stream is several megabytes per second before compression, and the number of unfiltered subscriptions is limited: when it is at capacity, the server answers `rate_limited` and the CLI exits with code 4; subscribe with a symbol, or try again later. A symbol subscription receives every action whose asset ids include that market, whole, so an order batch touching BTC and ETH reaches both BTC and ETH subscribers. An unknown symbol gets `invalid_symbol` (exit code 2).
+Leave the symbol out for every pending transaction our Hyperliquid node receives. The unfiltered stream is several megabytes per second before compression, and unfiltered subscriptions share a server-wide capacity limit, which does not apply to symbol subscriptions: when that capacity is reached, the server answers `rate_limited` and the CLI exits with code 4; subscribe with a symbol, or try again later. A symbol subscription receives every action whose asset ids include that market, whole, so an order batch touching BTC and ETH reaches both BTC and ETH subscribers. An unknown symbol gets `invalid_symbol` (exit code 2).
 
-Each NDJSON line is one message, holding the signed actions of one batch our node received from a peer. `coin` and `symbol` are the subscription's symbol, or `null` on the unfiltered stream. Example message (one item, signature shortened):
+Each mempool data message is written as one NDJSON line holding the signed actions of one batch our node received from a peer. `coin` and `symbol` are the subscription's symbol, or `null` on the unfiltered stream. Example message (one item, signature shortened):
 
 ```json
 {"type":"data","channel":"mempool","coin":"BTC","symbol":"BTC","data":[{"received_at":"2026-10-08T01:57:23.548737209Z","received_at_ms":1791424643548,"symbols":["BTC"],"action":{"type":"order","orders":[{"a":0,"b":true,"p":"83276","s":"0.40011","r":false,"t":{"limit":{"tif":"Alo"}},"c":"0x7849acc2c6c2f6f0fe4bc80ef13d1504"}],"grouping":"na"},"nonce":1791424643400,"vault_address":null,"expires_after_ms":null,"signature":{"r":"0x5afc...","s":"0x57e2...","v":28}}]}
diff --git a/src/cli.ts b/src/cli.ts
index f507afd..a20c2f8 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -1181,16 +1181,16 @@ stream
 // Generic channel subscription by name. Which channels stream live, and the
 // endpoint a channel served on one endpoint only connects to, is the SDK's
 // channel table (WS_CHANNEL_CAPABILITIES, which mirrors /v1/capabilities);
-// replay-only channels are refused before a socket opens. The symbol is
-// optional on `mempool` only.
+// replay-only channels are refused before a socket opens. `mempool` takes an
+// optional symbol, `all_tickers` takes none, and every other channel needs one.
 stream
   .command('subscribe <channel> [symbol]')
   .description(
     'Subscribe to a live WebSocket channel by name: every channel `oxa capabilities` lists as live, ' +
       'e.g. l4_diffs, orderbook_full, hip3_l4_orders, hip4_trades, spot_l4_diffs, lighter_funding, rh_lighter_trades, mempool. ' +
       'Symbols are dashed canonical for spot (HYPE-USDC); HIP-4 coins are bare numerics. ' +
-      'Every channel needs a symbol except mempool (pending Hyperliquid transactions; Pro, Scale and Enterprise plans), ' +
-      'where it is optional: without one, every pending transaction streams. ' +
+      'mempool (pending Hyperliquid transactions; Pro, Scale and Enterprise plans) takes an optional symbol: without one, ' +
+      'every pending transaction our Hyperliquid node receives streams. all_tickers takes no symbol, and every other channel needs one. ' +
       'mempool is served on wss://stream.0xarchive.io/ws only, and the CLI connects there unless --url or OXA_WS_URL is set. ' +
       'Full-depth books (orderbook_full, hip3_orderbook_full) send an l4_snapshot with every level, then l4_batch changes. ' +
       'Replay-only channels (candles, hip3_candles, hip4_orderbook, hip4_open_interest, lighter_candles, ' +
diff --git a/src/commands/stream.ts b/src/commands/stream.ts
index fe87308..e77fc72 100644
--- a/src/commands/stream.ts
+++ b/src/commands/stream.ts
@@ -6,9 +6,10 @@
 // Each `oxa stream <channel> <symbol>` command opens a single subscription,
 // emits one JSON record per stdout line (NDJSON), and runs until the user
 // hits Ctrl-C. JSON mode is the default; `--format pretty` adds a one-line
-// human-readable summary per event. `mempool` is the one channel whose symbol
-// is optional, and a channel served on one endpoint only (the SDK's table
-// names it, as for `mempool`) connects there unless --url or OXA_WS_URL is set.
+// human-readable summary per event. `mempool` takes an optional symbol,
+// `all_tickers` takes none, and every other channel needs one. A channel
+// served on one endpoint only (the SDK's table names it, as for `mempool`)
+// connects there unless --url or OXA_WS_URL is set.
 
 import { OxArchiveWs } from '@0xarchive/sdk';
 import { resolveApiKey } from '../lib/client.js';
@@ -79,13 +80,27 @@ export const REST_ONLY_HINTS: Readonly<Record<string, string>> = {
 
 /**
  * Channels whose symbol is optional. Without one, `mempool` streams every
- * pending transaction; every other channel needs a symbol.
+ * pending transaction our Hyperliquid node receives.
  */
 export const OPTIONAL_SYMBOL_CHANNELS: readonly string[] = ['mempool'];
 
-/** Exit with a validation error when a channel that needs a symbol has none. */
-export function requireSymbol(channel: string, symbol: string | undefined): void {
-  if ((symbol !== undefined && symbol !== '') || OPTIONAL_SYMBOL_CHANNELS.includes(channel)) return;
+/**
+ * Channels that take no symbol. The server sends `all_tickers` data only to a
+ * subscription without one, so a symbol would stream nothing.
+ */
+export const NO_SYMBOL_CHANNELS: readonly string[] = ['all_tickers'];
+
+/**
+ * Exit with a validation error when a channel that needs a symbol has none,
+ * or a channel that takes none has one. Every other channel needs a symbol.
+ */
+export function checkSymbol(channel: string, symbol: string | undefined): void {
+  const given = symbol !== undefined && symbol !== '';
+  if (NO_SYMBOL_CHANNELS.includes(channel)) {
+    if (given) exitError(`${channel} takes no symbol: \`oxa stream subscribe ${channel}\`.`, EXIT.VALIDATION);
+    return;
+  }
+  if (given || OPTIONAL_SYMBOL_CHANNELS.includes(channel)) return;
   exitError(`${channel} needs a symbol: \`oxa stream subscribe ${channel} <symbol>\`.`, EXIT.VALIDATION);
 }
 
@@ -431,8 +446,8 @@ export async function streamOrderbookCommand(symbol: string, options: StreamOpti
   return streamChannel(channel, symbol, options, requireLiveChannel(channel));
 }
 
-// `oxa stream subscribe <channel> [symbol]`: the symbol is optional on
-// `mempool` only.
+// `oxa stream subscribe <channel> [symbol]`: `mempool` takes an optional
+// symbol, `all_tickers` takes none, and every other channel needs one.
 export async function streamGenericCommand(
   channel: string,
   symbol: string | undefined,
@@ -443,6 +458,6 @@ export async function streamGenericCommand(
     exitError(`Unknown stream channel "${channel}". Live channels: ${liveChannels().join(', ')}.`, EXIT.VALIDATION);
   }
   const capability = requireLiveChannel(ch);
-  requireSymbol(ch, symbol);
+  checkSymbol(ch, symbol);
   return streamChannel(ch, symbol, options, capability);
 }
diff --git a/tests/stream.test.ts b/tests/stream.test.ts
index 4c0de97..9446c88 100644
--- a/tests/stream.test.ts
+++ b/tests/stream.test.ts
@@ -1,12 +1,13 @@
 import * as sdk from '@0xarchive/sdk';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
+  NO_SYMBOL_CHANNELS,
   OPTIONAL_SYMBOL_CHANNELS,
   REPLAY_ONLY_HINTS,
   REST_ONLY_HINTS,
+  checkSymbol,
   isLighterDropNotice,
   parseIntervalMs,
-  requireSymbol,
   resolveChannel,
   streamGenericCommand,
   streamLiquidationsCommand,
@@ -696,7 +697,6 @@ describe.runIf(CHANNEL_TABLE)('oxa stream subscribe, driven by the channel table
     ['spot_orderbook', 'HYPE-USDC', 'HYPE-USDC'],
     ['spot_l4_orders', 'HYPE-USDC', 'HYPE-USDC'],
     ['hip3_l4_orders', 'xyz:TSLA', 'xyz:TSLA'],
-    ['all_tickers', 'BTC', 'BTC'],
   ])('subscribes to the live channel %s the table allows', async (channel, symbol, sent) => {
     expect(CHANNEL_TABLE![channel].live).toBe(true);
     await streamGenericCommand(channel, symbol, { format: 'json' });
@@ -705,6 +705,22 @@ describe.runIf(CHANNEL_TABLE)('oxa stream subscribe, driven by the channel table
     expect(JSON.parse(ws.sent[0])).toEqual({ op: 'subscribe', channel, symbol: sent });
   });
 
+  it('subscribes to all_tickers without a symbol', async () => {
+    expect(CHANNEL_TABLE!.all_tickers.live).toBe(true);
+    await parseCli('stream', 'subscribe', 'all_tickers');
+    const ws = FakeWebSocket.instances[0];
+    expect(ws.url).toBe('wss://api.0xarchive.io/ws?apiKey=test-key&version=2026-10-01');
+    ws.fire('open');
+    expect(ws.frames()).toEqual([{ op: 'subscribe', channel: 'all_tickers' }]);
+  });
+
+  it('refuses a symbol on all_tickers before opening a socket', async () => {
+    await expectValidationExit(
+      () => streamGenericCommand('all_tickers', 'BTC', { format: 'json' }),
+      'all_tickers takes no symbol: `oxa stream subscribe all_tickers`.',
+    );
+  });
+
   it('lists the live channels when the channel is unknown', async () => {
     await expect(
       Promise.resolve().then(() => streamGenericCommand('bogus', 'BTC', { format: 'json' })),
@@ -817,18 +833,27 @@ describe('stream endpoint and optional symbol', () => {
     expect(streamUrl({}, 'wss://flag.example/ws')).toBe('wss://flag.example/ws');
   });
 
-  it('makes the symbol optional on mempool only', () => {
+  it('makes the symbol optional on mempool, takes none on all_tickers, and needs one elsewhere', () => {
     expect(OPTIONAL_SYMBOL_CHANNELS).toEqual(['mempool']);
-    expect(() => requireSymbol('mempool', undefined)).not.toThrow();
-    expect(() => requireSymbol('trades', 'BTC')).not.toThrow();
+    expect(NO_SYMBOL_CHANNELS).toEqual(['all_tickers']);
+    expect(() => checkSymbol('mempool', undefined)).not.toThrow();
+    expect(() => checkSymbol('mempool', 'BTC')).not.toThrow();
+    expect(() => checkSymbol('all_tickers', undefined)).not.toThrow();
+    expect(() => checkSymbol('trades', 'BTC')).not.toThrow();
     for (const symbol of [undefined, '']) {
-      expect(() => requireSymbol('trades', symbol)).toThrow(ProcessExit);
+      expect(() => checkSymbol('trades', symbol)).toThrow(ProcessExit);
       expect(stderrPayloads().at(-1)).toEqual({
         error: 'trades needs a symbol: `oxa stream subscribe trades <symbol>`.',
         code: 2,
         type: 'validation',
       });
     }
+    expect(() => checkSymbol('all_tickers', 'BTC')).toThrow(ProcessExit);
+    expect(stderrPayloads().at(-1)).toEqual({
+      error: 'all_tickers takes no symbol: `oxa stream subscribe all_tickers`.',
+      code: 2,
+      type: 'validation',
+    });
   });
 });
 
@@ -863,7 +888,7 @@ describe.runIf(HAS_MEMPOOL)('oxa stream subscribe mempool', () => {
     expect(CHANNEL_TABLE!.mempool).toMatchObject({ live: true, replay: false, wsEndpoint: 'wss://stream.0xarchive.io/ws' });
   });
 
-  it('streams every pending transaction from the stream endpoint when the symbol is left out', async () => {
+  it('streams the unfiltered pending transactions from the stream endpoint when the symbol is left out', async () => {
     await parseCli('stream', 'subscribe', 'mempool');
     const ws = FakeWebSocket.instances[0];
     expect(ws.url).toBe('wss://stream.0xarchive.io/ws?apiKey=test-key&version=2026-10-01');