How Hyperliquid's HLP Vault Actually Makes (and Loses) Money

HLP is not a yield product. It's a market maker with your money in it, and on March 26, 2025 it came within roughly $2 million of losing north of $10 million on a single memecoin perp before Hyperliquid's validators stepped in and unwound the trade. That event tells you more about how the vault actually works than any docs page does, so we'll use it as the spine of this explainer.

What HLP is, mechanically

HLP (Hyperliquidity Provider) is a vault deployed on Hyperliquid's L1 that anyone can deposit USDC into. Depositors receive a pro-rata claim on the vault's equity, and the vault runs two jobs simultaneously across every perpetual market on the exchange: it quotes passive liquidity, and it acts as the counterparty of last resort when a leveraged position gets liquidated and the order book can't absorb it cleanly.

Those two jobs sound similar — both involve holding inventory — but they have very different risk profiles. Market making is a strategy you choose. Liquidation absorption is a strategy that gets forced on you by whoever just got margin-called.

Job one: passive market making

HLP runs quoting strategies (there are actually several sub-strategies bundled under the HLP umbrella) that post resting bid and ask orders around the mid price on each market. It earns:

• Spread capture — buying at the bid, selling at the ask, pocketing the difference on round trips.
• Maker rebates — Hyperliquid, like most perp venues, pays makers a slice of taker fees.
• Funding — if the vault's net position across a market is long when funding is positive (longs pay shorts) or short when funding is negative, it collects funding on that skew.

The strategy adjusts quote width and skew based on inventory and realized volatility, same as any market-making bot you'd build yourself — the interesting part isn't the quoting logic, it's what happens when it's forced to take on a position it didn't choose.

Job two: liquidation backstop

When a trader's margin ratio breaches maintenance, Hyperliquid's liquidation engine tries to close the position against the book. If the book has enough depth, the position closes at close to the bankruptcy price and nobody outside the liquidated trader eats the loss. If the book is thin — which is common on low-cap perp markets — the unfilled remainder gets assigned to HLP at whatever price the engine could get, and HLP is now long or short a position it has to manage and eventually unwind, on its own schedule, into whatever liquidity exists.

This is the mechanism that makes HLP's P&L genuinely different from a market maker's. A pure market maker chooses its inventory limits. HLP's inventory limit, in the worst case, is set by the size of the single largest position anyone is willing to open on an illiquid market.

The on-chain accounting

HLP's books are fully transparent — every fill, every funding payment, and the vault's account value are queryable directly off Hyperliquid's L1 through the same APIs and WebSocket feeds any market maker uses to watch its own positions. Vault equity at any block is:

equity_t = equity_(t-1)
  + realized_pnl_from_fills
  + unrealized_pnl_change_on_open_inventory
  + funding_received - funding_paid
  + maker_fee_rebates
  - withdrawals

Depositor share price is just equity_t / total_shares, marked continuously rather than daily, so unlike a lot of DeFi vaults there's no NAV lag to arbitrage. The tradeoff is that depositors see drawdowns in real time, including the ugly ones — and withdrawals queue and settle over a multi-day lock rather than clearing instantly, which matters a lot if you're trying to exit during exactly the kind of volatility event that's causing the drawdown.

A worked example

Say a trader opens a $2M short on a thin-book altcoin perp at $1.00, 20x leverage, so roughly $100k margin. Price moves against them (up) to $1.045 and they hit maintenance margin. The liquidation engine tries to close the $2M short by buying it back:

• The book has $600k of ask-side depth within an acceptable slippage band. That portion fills around $1.05.
• The remaining $1.4M gets assigned to HLP at the bankruptcy price, roughly $1.047, meaning HLP is now short $1.4M of a coin trading at $1.05 — already about $4,200 underwater on entry, before it even starts unwinding.
• If HLP unwinds gradually and price drifts to $1.06 before it's flat, that's another ~$18,000 of loss on top.
• If instead price reverts to $1.02 while HLP is unwinding, HLP books a profit, because it absorbed the short at a worse price than where it eventually covers.

That asymmetry — sometimes backstop duty is profitable, sometimes it isn't — is the entire game. On liquid majors it nets out favorably most of the time because HLP is effectively getting paid (via the spread between bankruptcy price and mark) to take a position it can unwind quickly. On illiquid markets, size can overwhelm that edge completely.

The JELLYJELLY case

In March 2025 a trader opened an outsized short position on the JELLYJELLYJELLY perp, then bought up the thin spot market to pump the price and push their own short toward liquidation on purpose. Standard liquidation would have hit exactly the failure mode above at a much larger scale: HLP would have inherited a large short in a coin actively being squeezed higher, with essentially no book depth to unwind into. HLP's marked loss briefly approached eight figures. Hyperliquid's validator set intervened, delisted the market, and settled outstanding positions at a price that made the vault close to whole — a decision that drew real criticism, because a protocol that markets itself as decentralized reaching for a validator-level override is a governance admission, not just a risk-management one.

For engineering teams, the lesson isn't "avoid HLP," it's that any strategy sitting on top of a shared liquidation backstop inherits tail risk from every other market on that venue, not just the one you're trading. If you're running size on illiquid perps yourself, or building anything that depends on a vault like this staying solvent, you want position and funding data streamed continuously rather than checked on a dashboard once a day — the kind of real-time monitoring we build into every trading dashboard engagement, backed by the same low-latency infrastructure and data feeds we'd use for a validator client, which is a similar latency problem to what we cover in our breakdown of Jito vs. Firedancer validator performance. The choice between polling an API and subscribing to a stream is exactly the tradeoff we walk through in gRPC versus WebSocket RPC for Solana, and it applies just as directly to watching a perp vault's inventory in real time.

What it means for depositors and builders

HLP's expected return is the spread and funding it earns on quiet markets, minus the tail losses it eats on chaotic ones, and historically the former has outweighed the latter by a solid margin — but "historically" is doing real work in that sentence, because the vault's loss distribution is fat-tailed by construction. You're underwriting whoever opens the largest position on the thinnest market that week.

If you're building a strategy that reads liquidation events off-chain and needs a dispute or override mechanism of its own — say, contesting a mark price during a manipulation event — the design space looks a lot like what we cover in our explainer on UMA's optimistic oracle dispute process: someone has to be able to challenge a bad price before it becomes final. HLP currently solves that with validator discretion instead of a formal dispute window, which is faster but a lot less predictable for anyone depositing.

And if you already run automated strategies that depend on a vault, a bot, or a liquidation engine staying up and behaving correctly under stress, that's an ops problem as much as a strategy problem — it needs someone watching it and shipping fixes when the market does something the backtests didn't cover, which is the gap our ongoing support and maintenance work is built to close.

If your team is evaluating exposure to a vault like HLP or building comparable market-making infrastructure of your own, talk to us about the trading dashboard build that would let you see this risk before it shows up in your equity curve.