Squeeze Protocol

A collateralised borrow market for Pons tokens on Robinhood Chain, and the public short interest tape it produces.

Overview

Pons has launched more than 50,000 tokens on Robinhood Chain. Every one of those markets is long-only. There is no way to express a bearish view, no borrow market for memecoins, and consequently the single most powerful narrative primitive in retail trading — short interest — does not exist on this chain at all.

Squeeze is two products sharing one set of contracts:

The Desk earns the revenue. The Tape is the moat. Short interest, days to cover and borrow rates are numbers that people check daily and share compulsively, and they only exist once a real borrow market exists underneath them.

Why this doesn't exist yet

Shorting illiquid tokens fails for four specific reasons. Each one has a countermeasure, and those countermeasures are the entire design.

1. Nobody wants to lend

No holder lends you their bag so you can dump it. The fix is to change what they get paid in: borrow interest is paid in ETH, not in tokens. A holder sitting on a position they can't exit earns real yield, and at high utilization that is a triple-digit APR.

This inverts the relationship. Demand to short a token becomes income for the people holding it — the more bearish the market gets, the better it pays to be long. That is the flywheel.

2. Thin pools get manipulated

One whale pumps the pool and every short is liquidated. Handled in three layers, covered in detail under The oracle.

3. Losses are theoretically unbounded

Positions are overcollateralised with hard liquidation, and loss is capped at the collateral in the position. No cross-margin in v1.

4. What if the token goes to zero?

Vaults

Each listed token gets its own lending vault. Supply is isolated per token: a failure in one market cannot touch another.

deposit(token, amount)   // -> sTOKEN receipt
withdraw(sToken, amount) // -> TOKEN
claim()                  // -> accrued ETH interest

• Depositors receive sTOKEN, a transferable ERC-20 receipt.
• Interest accrues in ETH and is claimed separately from principal.
• Withdrawals are limited to the vault's free (un-lent) balance. At 100% utilization you wait for a short to close — which is exactly the condition that drives the rate up and pulls shorts out.

Interest rate model

A standard two-slope utilization curve, deliberately steep above the kink.

U = borrowed / totalSupplied

U <= 0.80:  APR = 20%  + U * (80% / 0.80)
U >  0.80:  APR = 100% + (U - 0.80) * (400% / 0.20)

The steepness above the kink is a safety mechanism, not a revenue decision: it forces positions to unwind before a vault runs dry and lenders find themselves unable to withdraw.

The Desk

openShort(token, borrowAmount, collateralETH) // -> positionId
closeShort(positionId)
addCollateral(positionId, amountETH)

Opening a short is a single transaction:

1. Trader posts ETH collateral — minimum 150% of notional.
2. Protocol borrows TOKEN from the vault.
3. Protocol sells that TOKEN into the token's Uniswap V3 pool via exactInputSingle.
4. The ETH proceeds stay inside the position as additional collateral.

position = { debt: X TOKEN, collateral: Y ETH, accrued: Z ETH }

healthFactor = collateral / (debt * twap * 1.20)
// liquidatable below 1.00, i.e. a 120% collateral ratio

Interest is charged in ETH against the position's collateral, block by block. If interest alone eats the collateral down to the threshold, the position liquidates like any other. Waiting is never free.

Liquidation

A position is liquidatable when HF < 1 and both oracle windows confirm it (see below). Any address can liquidate.

• The keeper buys TOKEN, repays the debt, and takes an 8% bonus from the collateral.
• Any remainder returns to the trader.
• Residual bad debt is absorbed by the Backstop Fund.

The oracle

Everything above depends on one question: does a manipulation-resistant price exist for a memecoin pool? It does, and the reason is a fortunate accident of which Uniswap version Pons happens to use.

V3 has an oracle. V4 doesn't.

Uniswap V4 removed built-in price oracles — observation tracking was moved out of the pool and into optional hooks. Had Pons graduated tokens into bare V4 pools, there would be no on-chain price history to read, and Squeeze would have had to build and incentivise its own checkpointing infrastructure before it could liquidate anything safely.

Pons runs on Uniswap V3. Every launch gets a dedicated TOKEN/WETH pool at the 1% fee tier, and V3 carries the TWAP oracle inside the pool itself. For this specific use case the older version is strictly better.

Reading the price

Every V3 pool maintains a ring buffer of observations — (blockTimestamp, tickCumulative, secondsPerLiquidityCumulative). You never read the array directly; you call observe():

uint32[] memory ago = new uint32[](3);
ago[0] = 1800;  // 30 minutes ago
ago[1] = 300;   // 5 minutes ago
ago[2] = 0;     // now

(int56[] memory tickCumulatives, ) = pool.observe(ago);

int24 twap30 = int24((tickCumulatives[2] - tickCumulatives[0]) / 1800);
int24 twap5  = int24((tickCumulatives[2] - tickCumulatives[1]) / 300);
// price = 1.0001 ^ tick

Two properties make this workable:

• Counterfactual observations. If your window boundary doesn't land on a block where an observation was written, the pool interpolates one for you. You never need an observation at exactly t−1800s.
• Geometric mean. Averaging the tick and then exponentiating yields a geometric mean price, which is far less sensitive to spikes than an arithmetic mean — exactly the property you want against a pumper.

Dual-bound liquidation

Both windows come out of the same call, which costs one extra array element and no additional infrastructure. A position only becomes liquidatable when the 30-minute and the 5-minute TWAP both breach the threshold.

A single-block pump therefore moves nothing except the attacker's balance — they pay full slippage into a 1% fee pool, arbitrage takes the other side, and no position closes. To actually trigger liquidations they would have to hold a false price for half an hour against every arbitrageur watching, which is a completely different and far more expensive problem.

Manipulation cost floor

On top of that, a token only lists if moving its price 50% costs more than the total collateral at risk in that market. Computed from pool reserves and re-checked before any borrow cap increase. If the attack is profitable in principle, the market simply doesn't open.

Observation cardinality

This is the part that actually bites, and it is the reason listing is not instantaneous.

A pool left at the Uniswap V3 default stores one observation and overwrites it every block. Anyone may raise that, permissionlessly, up to 65535:

pool.increaseObservationCardinalityNext(2048);

What actually happens on Pons pools is more interesting than the textbook case. Measured live against Robinhood Chain — the first three are the markets Squeeze covers, the rest are there for contrast:

Cardinality tracks traction. The liquid markets already carry deep buffers — nobody has to provision them, it has happened organically — while dormant micro-caps sit at the default of 1. So the listing step is real and still necessary, but for exactly the tokens that clear the other criteria, it is usually already done.

Where provisioning is needed, sizing depends on how many blocks-containing-a-swap must be spanned to cover 1800 seconds. Robinhood Chain produces ~100ms blocks — up to 18,000 per window — but an observation is only written in blocks where a swap occurs. Each slot costs a cold SSTORE (~20k gas) at call time, so a large increase must be split across several transactions; on an L2 the constraint is the chunking, not the price.

What 100ms blocks change

Fast blocks are the single biggest reason a memecoin lending market is viable on Robinhood Chain and was never viable on Ethereum L1.

Bad debt is created in the gap between "health factor breaks" and "keeper has closed the position". On L1 that gap is twelve seconds plus a gas auction. Here it is a few hundred milliseconds.

The sequencer also orders transactions first-come-first-served with no priority fees. There is no gas auction around liquidations: keepers compete on latency rather than on bribes, so the 8% bonus mostly reaches the keeper instead of being competed away to a block builder.

Nothing here is new

This is the real answer to "how is this even possible": nothing has to be invented.

No new cryptography, no new AMM primitive, no hook, no custom pool. Squeeze touches the Pons pools in exactly two ways: observe() to read, and a swap to execute.

Two consequences follow, and both matter:

• No integration is required and nobody can revoke access. Squeeze needs no cooperation from the Pons team or from any token's developer. For a product that some token teams would rather did not exist, that is not a detail — it is the whole reason it can ship.
• It is auditable against known patterns. The novelty is in the application — pointing a lending market at launchpad tokens and publishing the resulting short interest — not in the machinery. That makes it a matter of weeks, not quarters.

Verify it yourself

Nothing on this page has to be taken on trust. Two scripts in the repo read Robinhood Chain directly, with no API key, no indexer service and no dependencies beyond Node 18+.

# prove a real TWAP exists on a live Pons pool
node indexer/verify-oracle.mjs

# rebuild the tape from live chain state
node indexer/build-tape.mjs

verify-oracle.mjs resolves the token's pool through the Pons V3 factory, reads slot0, pulls both TWAP windows from observe(), and prints a pass/fail line per claim. Point it at any token:

node indexer/verify-oracle.mjs 0x<token>

build-tape.mjs writes data/tape.json, which is what the tape on the website renders. Every row carries its own inputs — pool depth, holder count, observation cardinality, TWAP divergence — so any score can be recomputed by hand from the same file.

Listing criteria

A token opens a market only when it satisfies every condition:

Borrow caps

cap = min( 20% of circulatingSupply,
          k * sqrt(poolLiquidityETH) )

The square-root term makes the cap grow sublinearly with liquidity. A token with a high market cap but a thin pool gets a small market, which is the correct outcome — depth, not valuation, determines whether shorts can be closed.

The Tape

Computed live per token, free and public, no wallet required.

Because Squeeze borrows and sells the actual token, real supply leaves the float. That is why the short interest number means something. A synthetic perp market would produce a figure nobody could verify.

Squeeze Score

score = 40 * norm(shortInterestPct, 0, 25)
      + 25 * norm(daysToCover,     0, 10)
      + 20 * norm(utilization,     0, 1)
      + 15 * norm(borrowAPR,       0, 300)

norm(x, lo, hi) = clamp((x - lo) / (hi - lo), 0, 1)

Above 80, a token is flagged SQUEEZE WATCH: pinned at the top of the site and auto-posted.

One shareable number with a threshold that generates its own events. The data produces the announcements, which means the protocol does not depend on someone writing marketing copy every week.

The Feed

Every liquidation is published: $XYZ short liquidated — 4.21 ETH · HF 0.97. Cascades are the most-shared content in crypto, and Squeeze owns the feed they come out of.

$SQUEEZE

Fixed supply, launched on Pons itself. No presale, no VC allocation.

Fees: 10% of all borrow interest accrues to the protocol.

Staking reduces your borrow rate in tiers (5 / 10 / 15%) and grants early access to new listings. No governance theatre — two benefits that can be priced in ETH.

Risk disclosures

The first row is the one that matters. Every parameter in this document exists to survive it, and it remains the most likely way the protocol fails.

Roadmap

v0 — The Tape, before the Desk shipped

Short interest cannot exist before a borrow market does. So v0 publishes a Setup Score built from proxies that are computable today, straight from chain state:

v1 — The Desk

Five curated markets, ETH collateral, real short interest replacing the proxies.

v2 — Permissionless listings

Automatic caps derived from the manipulation cost floor.

v3 — Perps, or not

The borrow desk is more defensible and less crowded than perps. Perps are an option, not an obligation.

Contracts

None deployed. Planned surface:

Squeeze is an independent protocol on Robinhood Chain. Not affiliated with, endorsed by, or connected to Robinhood Markets, Inc., Pons, or Uniswap Labs. Nothing in this document is financial advice. Shorting leveraged positions in illiquid markets can result in total loss of collateral. No contracts are deployed and no code has been audited.