Robinhood thin liquidity: eth_subscribe for pool reserves & depth

Paper 100x feels great until the book is paper-thin—mcap looks juicy while exit depth hugs the floor. Paraphrased tape feel from the thread around EmperorBTC. This post does one job: hang pool reserves / rough depth on eth_subscribe Sync / Swap logs, compare depth to mcap, and tag thin liquidity.

Volume density: Volume spikes. Open rhythm: Watch Robinhood opens. This one tracks reserves · depth vs mcap.

Use	Endpoint
Public HTTPS	https://robinhood-mainnet-rpc.blockreq.com/v1/rpc/public
Public WSS	wss://robinhood-mainnet-rpc.blockreq.com/v1/rpc/public
Private	Trailing public → {API_KEY} (keys stay local)

Chain: EVM chainId = 0x1237 (4663). Free 3M Requests / 30 days · Public endpoints · eth_subscribe · Pricing.

1. Pretty mcap, how depth shows up on-chain

Tape feel	On-chain signal	Watch
Paper 100x	Price × supply → shiny mcap	Background only; still read the pool
Book like paper	V2 pool reserve0 / reserve1 stays small	Sync events or getReserves
One fill punches through	Single Swap large vs reserve	Rough depth = min(r0, r1) × price
Reserve cliff	Sync leaves reserves far below window mean	Δreserve / window mean

Mcap = valuation story; exit thickness = pool reserves. Volume-watch chases density; this post chases depth / mcap.

2. Sync / Swap + rough depth (thin-liquidity recipe)

One public WSS: subscribe pool Sync (reserve refresh) + Swap; keep local reserves, compute rough depth and depth/mcap.

Step A · Subscribe Sync (reserve heartbeat)

{
  "jsonrpc": "2.0", "id": 1, "method": "eth_subscribe",
  "params": ["logs", {
    "address": "0xYourPoolAddress",
    "topics": ["0x1c411e9a96e071241c2f21f7726b17ae89e3cab4c78be50e062b03a9fffbbad1"]
  }]
}

• topics[0] = Uniswap V2-style Sync (confirm against pool ABI).
• Decode data → reserve0 / reserve1 → write local poolState.
• Boot or gap: HTTPS eth_call getReserves() for a seed, then hot-update on Sync.

Step B · Subscribe Swap (size vs reserve)

{
  "jsonrpc": "2.0", "id": 2, "method": "eth_subscribe",
  "params": ["logs", {
    "address": "0xYourPoolAddress",
    "topics": ["0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822"]
  }]
}

Log Swap size against current reserve → impact share. Large fills on thin pools are what make “paper 100x, book on the floor” feel real.

Step C · Local rough-depth metrics

Metric	Demo formula	Use
Rough depth	min(reserve0, reserve1) in quote units	Thickness at a glance
depth / mcap	roughDepth / mcap	Exitability vs valuation
Reserve cliff	reserve vs last N Sync mean	Liquidity pulled signal
Impact share	swapSize / reserve	Single-fill punch risk

Tune thresholds yourself (demo often depth/mcap under 2% → thin; single Δreserve over 15% → cliff). Tags = interpretation: JSON → dashboard chips / alert copy.

3. Preview: thin liquidity / reserves demo (StackBlitz)

Defaults to BlockReq public WSS; paste a pool address, live-refresh reserves, rough depth, depth/mcap, tag thin / cliff. Code lives in StackBlitz—article embeds the preview only:

Repo: blockreq/blog-demos → examples/robinhood-thin-liquidity-watch. For keyed: swap trailing public for {API_KEY}.

4. Alert rules (cliff / depth·mcap)

1. Sync arrives → refresh reserve0/1, recompute roughDepth, depthMcap.
2. Cliff → reserve vs window mean drops past threshold → push reserve cliff.
3. Thin → depthMcap stays under threshold → push thin liquidity (paper mcap vs book thickness).
4. Hard impact → swapSize / reserve over threshold → stack punch-through chip.

Disconnects: reconnect → re-subscribe; gap-fill with HTTPS eth_getLogs in block segments, replay the same depth rules. POST → https://robinhood-mainnet-rpc.blockreq.com/v1/rpc/public. Seed on boot: same endpoint eth_call → getReserves.

5. Summary

1. Thin liquidity = mcap story vs pool reserves; watch Sync refreshes + rough depth/mcap.
2. Recipe: narrow Sync/Swap + local reserve state + cliff / thin / impact tags.
3. Public WSS runs as-is; Free 3M covers short multi-pool sessions; long boards go keyed.
4. Series: volume density · this reserves/depth post · whale follow-flow.

Next: pin pool watch list as JSON → wire thin/cliff tags to webhooks → persist backfill checkpoints. Public endpoints · Plans & pricing.