RATCHET Documentation

RATCHET is the first rebase token on Robinhood Chain — engineered to fix the canonical failure of elastic-supply tokens: print supply → dilute price → holders dump → chart to zero. RATCHET never prints. Supply only contracts, every green tick is paid for with real buyback ETH, and underneath sits a collateralized ETH floor that can only ratchet up and can be redeemed at any time.

The three mechanisms

RATCHET rests on three reinforcing mechanisms — each defined in code, and each one pays for the next.

• Deflationary rebase. Once a day supply contracts and the price ticks up the exact same ratio — market-cap-neutral, capped to what the buyback actually spent. No inflation, ever.
• Rising redeemable floor. A share of every trade fills an ETH vault. floor = vault ÷ circulating — both terms move one way, so the floor can only climb. Redeem into it any time.
• Automatic buyback. A permissionless, TWAP-guarded buy-and-burn fires on dips and near the floor. It prints green candles when selling is heaviest, and the ETH it spends becomes tomorrow's contraction.

Get familiar

New here? Start with Why a ratchet for the thesis, then Quickstart to buy. Builders should jump to Architecture and Contracts.

Why a ratchet

Every elastic-supply blow-up — Titano, Libero, SafuuGO — died from the same wound: emissions decoupled from income. The UI showed a huge APY while the token printed itself into oblivion. A positive "your balance grows 2%/day" rebase is either price-diluting or unbacked inflation. It always snaps.

RATCHET inverts it. The rebase is contraction-only — supply can only shrink. That single constraint removes the death spiral entirely: with no way to print, there is no dilution to outrun. The rebase doesn't create value; it presents the value that the buyback and floor already produced — as a rising price (a green chart) instead of a growing bag.

Quickstart

RATCHET trades on Uniswap V2 on Robinhood Chain. Three steps:

1. Add Robinhood Chain to your wallet — chainId 4663, RPC rpc.mainnet.chain.robinhood.com, gas paid in ETH.
2. Buy on Uniswap V2 with ETH. A 2% buy fee applies; a 24-hour launch window caps max wallet — both auto-expire.
3. Hold, or redeem at the floor. You can always burn your tokens back to the FloorVault for 99% of the current floor — no permission, no queue.

Deflationary rebase

RATCHET uses the Ampleforth gons / fragments model: internal gon balances are fixed, and a rebase only rescales a global gonsPerFragment. Balances move in O(1) and holder ratios never change. What makes RATCHET different is that the rebase is contraction-only.

How rebase() works

Once per 24-hour epoch, anyone can call rebase(). It:

1. reads how much ETH the buyback engine actually spent that epoch;
2. contracts total supply by min(0.5%, buybackETH ÷ pairETHReserve);
3. syncs the Uniswap pair in the same transaction.

Why it's market-cap-neutral

Because the pair is included in the rebase and sync()'d atomically, the contraction reprices nothing unfairly: every balance shrinks by the same ratio while spot price rises by the same ratio. No value is created or destroyed by the rebase itself. And because the contraction is capped to what the buyback truly spent, every basis point of chart-up was already bought with real ETH. No spend that epoch → no rebase → the token flatlines, rather than inflating into a spiral.

Rising redeemable floor

The FloorVault holds only ETH. The floor price is simply:

It can only ratchet up, because every path that touches it raises it:

• Fees in raise the numerator.
• Buyback burns shrink circulating (the denominator).
• Redemptions pay 99% of floor and burn the tokens — mathematically raising the floor for everyone who stays.
• A contraction rebase shrinks circulating, raising the floor.

The redeem guarantee

There is no owner and no withdraw function on the vault. The only ETH exits are redeem() — burn your tokens for 99% of the floor, always open — and defendFloor(), which buys below the floor and burns. That is the "never zero": worst case, each token is a claim on a pro-rata, monotonically growing pot of ETH. The invariant suite proves floorPrice() is non-decreasing across every possible sequence of actions.

Automatic buyback

The BuybackEngine holds the buyback share of fees. buyAndBurn() is permissionless — keepers and bots keep it firing — but it only executes when it's genuinely a good buy:

• on a dip: spot ≤ 97% of a manipulation-resistant 15-minute TWAP;
• near the floor: spot ≤ 110% of the floor;
• or on a sideways heartbeat — but never above the recent average.

Each buy is capped at 0.5% of the pair's ETH reserve, with minOut floored by the TWAP so a caller can't grief it. Output goes straight to the burn address. The ETH it spends is recorded as epochSpend, which the next rebase() pulls to size that day's contraction.

Fees & routing

2% on buys, 4% on sells, 0% wallet-to-wallet. The ceilings — 3% buy / 6% sell — are constant and can never be exceeded. Accrued fees are converted to ETH and split on-chain:

Fee conversion is isolated in a try/catch so it can never revert a user's sell — the anti-honeypot guarantee. Anyone can also call processFees() to convert accrued fees out-of-band.

Anti-rug guarantees

These aren't promises — they're properties of the contracts, verifiable on the explorer.

• No mint function. Supply can only contract. No code path creates tokens.
• LP tokens burned at launch — liquidity is protocol-owned and unpullable.
• Redeemable floor — a permanent, permissionless ETH exit at a published price. A honeypot cannot have that.
• Fee caps are constant — no setter can raise fees to rug levels.
• No blacklist, no pause. There is no reachable state where a holder cannot sell.
• Trading-enable is one-way; launch anti-snipe limits auto-expire after 24h with no lever to hold them on.
• No proxy, non-upgradeable, source verified on Blockscout.

Rebase pitfalls handled

Elastic-supply tokens have a specific list of sharp edges. RATCHET designs around each:

Honest risk

Architecture

Four small, immutable contracts. Fees flow in as tokens, convert to ETH, and route to three sinks:

Primary and only official liquidity is a Uniswap V2 ETH pair — a rebasing balance needs pair.sync() to keep reserves coherent, which V2 has and V3/V4 do not. Concentrated liquidity is supported via the non-rebasing wRATCHET wrapper.

Contracts

All are non-upgradeable. Owner powers are bounded (fee-setting within caps, one-time wiring, exemptions for protocol contracts only) and intended to sit behind a timelock + multisig post-launch.

Integrating — wRATCHET

A rebasing balance breaks anything that caches balances — bridges, lending markets, vaults, and concentrated-liquidity AMMs (Uniswap V3/V4). WrappedRatchet (wRATCHET) is the sanctioned fix.

• Each wRATCHET represents a constant number of RATCHET gons, so its balance never rebases.
• wrap(amount) deposits RATCHET and mints wRATCHET; unwrap(shares) reverses it at the current index — so as RATCHET contracts, one wRATCHET simply unwraps into fewer RATCHET.
• Integrators should never cache balanceOf on raw RATCHET. Use wRATCHET, or read gonBalanceOf / gonsPerFragment directly.

Invariants & tests

The contracts ship with a Foundry suite — unit tests plus handler-based invariants run over tens of thousands of randomized action sequences. The headline proofs:

• The floor never falls. floorPrice() is non-decreasing across any call sequence.
• Any holder can always sell everything. No reachable state blocks an exit.
• Gons are conserved and Σ balances ≤ totalSupply (rounding favors the protocol).
• The pair is never skimmable after a rebase, and a contraction never exceeds the buyback-funded cap.

Parameters

Networks & addresses

FAQ

Why does my balance keep going down?

By design — RATCHET is deflationary. Supply contracts each epoch, so your token count shrinks while each token is worth proportionally more. Your portfolio value tracks price × balance, and the price rises with the contraction.

Can the team rug the floor?

No. The FloorVault has no owner and no withdraw function — the only ETH exits are redemption (at floor) and defending the floor (buying below it). Both only raise the floor.

Is it on Ethereum?

No. RATCHET is deployed on Robinhood Chain (chainId 4663). ETH is only the gas and the quote/floor asset.

Why Uniswap V2 and not V3/V4?

A rebasing balance needs pair.sync() to stay coherent, which only V2 provides. Concentrated liquidity is supported via the non-rebasing wRATCHET wrapper.