Market Making Thin Stock-Token Pools on Robinhood Chain

A market maker's job on any two-sided pool is the same regardless of venue: post a bid, post an ask, capture the spread, and don't let the inventory that accumulates from one-sided flow blow up the book. On Robinhood Chain's stock token pools, ten days into mainnet, that job comes with a specific set of headaches. Depth is thin because the chain is new. The reference price — the actual NVDA or GOOG print on NASDAQ — only exists for about six and a half hours a day, five days a week. And the same token is quotable at the same time on Uniswap, Arcus, Lighter, 1inch, and Rialto, with no shared order book connecting any of them. A stock token market making bot built for this environment has to solve a different problem than one built for a mature pair on an L1 DEX.

Why thin pools change the math

On a deep pool, a market maker can quote tight and let the law of large numbers do the work — enough two-way flow arrives that inventory mean-reverts toward zero without much intervention. On a thin pool, a single retail-sized buy order can move the AMM price meaningfully and leave the maker holding a directional position that isn't going to get flattened by the next few trades, because there might not be a next few trades for minutes. That's not a Robinhood Chain problem specifically; it's what every new pool on every AMM looks like in its first weeks. Uniswap v2 pairs behaved the same way in 2020. The difference here is what sits underneath the token: a real, continuously-priced equity that the on-chain price is supposed to track, and that tracking gets much harder to enforce when the arbitrage path back to the real price is itself thin or, during market hours, requires a broker-dealer relationship most bots don't have.

The practical consequence is that spread width on a stock token pool needs to do two jobs at once — compensate for adverse selection like any market maker's spread does, and price in the cost of carrying inventory for longer than usual before an arbitrageur (possibly you, running a separate desk) closes the gap. Quoting too tight on a thin pool isn't generous, it's underpriced risk.

Inventory risk doesn't sleep when the reference market does

Here's the part that's genuinely different from making markets in a crypto-native asset. NASDAQ and NYSE close for roughly sixteen hours on weeknights and stay closed all weekend. Stock tokens on Robinhood Chain keep trading through all of it. During those closed hours, there is no live reference price at all — the on-chain price is set purely by whatever thin flow shows up against the AMM curve, and it can drift meaningfully before the market reopens and the gap resolves in one move. If you're holding inventory on either side of a stock token pool when the underlying closes, you are not hedged by anything except correlated crypto assets or another venue's token, and you're carrying that position into a window where the primary price discovery mechanism is switched off.

That's a structurally different overnight risk than holding an ETH inventory position, where the reference price (the asset itself) never stops trading. It argues for either much wider quotes going into a close, actively shrinking inventory targets before the close, or having a hedge leg ready — which is really a separate strategy sitting next to the market-making bot. We've written about the mechanics of that gap directly in our piece on weekend and overnight stock token dislocation, and the hedging side of it in our basis-hedge bot writeup. If you're running size, a standalone basis hedge bot sitting next to your quoting engine is usually the cleaner design than trying to cram hedging logic into the market maker itself.

A minimal inventory-skew quoting loop

The standard fix for inventory risk in market making is skewing quotes based on current position — the more inventory you're long, the more you lower both your bid and ask to encourage selling and discourage further buying. On an EVM chain this is straightforward to implement against a Uniswap v3-style pool using viem, since Robinhood Chain runs the Arbitrum stack and normal EVM tooling applies without modification:

import { createPublicClient, http, formatUnits } from 'viem';

const client = createPublicClient({
  chain: robinhoodChain, // custom chain config, Arbitrum-stack RPC
  transport: http(process.env.RPC_URL),
});

function skewedQuotes(midPrice, inventory, targetInventory, skewFactor, baseSpreadBps) {
  // positive inventory deviation pushes both quotes down
  const deviation = inventory - targetInventory;
  const skew = deviation * skewFactor;
  const halfSpread = midPrice * (baseSpreadBps / 10_000);

  return {
    bid: midPrice - halfSpread - skew,
    ask: midPrice + halfSpread - skew,
  };
}

// widen baseSpreadBps and shrink targetInventory as US market close approaches
function sessionAdjustedParams(hoursToClose, baseSpreadBps, targetInventory) {
  if (hoursToClose < 1) {
    return { baseSpreadBps: baseSpreadBps * 2.5, targetInventory: targetInventory * 0.3 };
  }
  return { baseSpreadBps, targetInventory };
}

This is the skeleton, not the strategy. The parts that actually determine whether this makes money — the skew factor, base spread, rebalancing thresholds, and how aggressively to pull quotes around volatility — need to be calibrated against real fill data from the specific pool, and that data doesn't exist yet in any depth. Anyone telling you they've already tuned this for Robinhood Chain stock tokens is guessing.

Quoting regime: market hours vs. closed hours

Factor	US market open	US market closed
Reference price	Live, continuously updating	None — no live equity print
Arbitrage path	Broker-dealer + on-chain, tighter	On-chain only, thin or absent
Appropriate spread	Standard, adverse-selection priced	Wider, carry-risk priced
Inventory target	Normal	Reduced ahead of close
Gap risk on reopen	N/A	High — price can jump at open

Fragmentation across five venues

Uniswap, Arcus, Lighter, 1inch, and Rialto all launched with stock token support on day one. Arcus in particular is zero-fee, which changes the calculus for where retail flow routes and where a maker should concentrate depth. A pool that looks attractively wide on one venue may just be reflecting the fact that tighter liquidity already migrated to Arcus. Before committing capital to any single pool, it's worth mapping where flow is actually clearing rather than assuming your venue is representative — the kind of cross-venue view we build into infrastructure and data tooling for clients running multi-venue strategies. It's also worth comparing this fragmentation pattern to what's well understood in CEX-versus-DEX arbitrage, since the same spread-capture logic applies across five DEXes quoting one underlying with no shared book.

What we don't know yet

Be honest about the limits here. Ten days of mainnet data isn't enough to know typical realized spread capture, how quickly arbitrageurs close overnight gaps in practice, or whether Arcus's zero-fee structure pulls enough volume to make other venues' pools permanently thinner. Anyone quoting specific historical fill rates or Sharpe numbers for stock token market making right now is fabricating them. What can be reasoned from precedent — thin-pool AMM mechanics, equity market structure, prior L2 launches — is the skew and session-adjustment logic above. The rest gets calibrated live, with small size, as real fill data accumulates.

If you're setting up a quoting desk for this and want the inventory-skew logic, session adjustments, and hedge leg built and audited properly rather than assembled from a template, our Robinhood Chain market maker build is the place to start.