Docs v0.1

How the shrew eats.

What the nest does, how it works, and how to check every number yourself.

Overview

SHREW is a meme token on Robinhood Chain with a twist: trading fees get pooled in a vault and paid out to holders every 12 hours. Small holders get a bigger slice per token than big ones. If you don't claim your cut in time, it gets used to buy and burn SHREW instead.

The whole thing is called Hypermetabolism, because a shrew has to eat constantly or it dies. Same idea here: rewards keep moving, or they get burned.

The token itself is just a standard ERC-20. Fixed supply, no minting, locked liquidity. The reward mechanism is a separate contract that anyone can read and verify. No admin keys, no backdoors.

Not financial advice. This is a meme coin with extra steps. Have fun, don't bet your rent.

Mechanism

Three steps, in order.

Eat

Every trade on the SHREW pool kicks back a creator fee (that's how Pons works). 70% of that fee goes straight into the vault. It shows up as ETH, in real time.

The vault has no withdrawal function. ETH can only leave through claims or burns. Anyone can check the balance anytime.

Metabolize

Every 12 hours, anyone can trigger a snapshot. This records who's holding what and stores a merkle root on-chain. The ETH sitting in the vault at that moment becomes the epoch pool.

The pool gets split between holders using a square root curve:

// per-wallet reward

reward = pool * sqrt(min(balance, cap)) / totalWeight

// cap = 100M (10% of supply)

// totalWeight = sum of sqrt(min(b, cap)) across all holders

In plain terms: someone holding 1M SHREW earns about 20x more per token than someone holding 400M. Whales still get a piece, just a smaller one relative to their bag size.

Burn

You've got 48 hours after a snapshot to claim your share. Just call claim(epochId) with a merkle proof of your balance.

Miss the window? Anyone can call starve(epochId) after that. The leftover ETH buys SHREW on the open market and burns it. Less supply, more buy pressure.

The shrew doesn't do leftovers.

How much more does a small bag earn?

Rough numbers at launch.

Bag size	% of supply	Weight per token	vs. whale
1M	0.1%	1.00x	20x more
10M	1%	0.32x	6.4x more
50M	5%	0.14x	2.8x more
100M	10%	0.10x	2x more
200M	20%	0.07x	1.4x more
400M	40%	0.05x	baseline

Weight = sqrt(min(balance, 100M)). Ratios shift as more people join, but the curve stays the same.

Architecture

Three layers, all verifiable on their own.

Layer 1

Token

A standard ERC-20 deployed through Pons. 1 billion supply, 18 decimals, no mint function. Liquidity is on Uniswap V3 paired with WETH, and the LP is locked permanently.

Layer 2

ShrewVault

The reward contract. It collects fees, manages snapshots, processes claims, and runs burns. No admin keys can redirect funds or change the formula. ETH only leaves through claim() or starve().

Key functions: snapshot(), claim(epochId, proof), starve(epochId), getEpoch(id), pendingClaim(wallet, epochId).

Layer 3

Frontend

This website. Static, no backend, reads everything from the chain. If it goes down, the token and vault still work fine. Anyone can build their own UI.

Tokenomics

Supply

Fixed. No minting, ever.

Decimals

Standard.

Liquidity

Locked

Permanently, via Pons.

Fee to vault

70%

The rest goes to Pons protocol.

Epoch

12h

Snapshots run twice a day.

Claim window

48h

Then leftovers get burned.

Fee flow

Trade happens on SHREW pool

→ Creator fee generated by Pons

→ 70% to ShrewVault (ETH, real-time)

→ 30% to Pons protocol

→ Vault fills up until next epoch

→ Every 12h: snapshot + merkle root posted

→ Holders claim with proof (48h)

→ Claimed: ETH to your wallet

→ Unclaimed after 48h: buy SHREW and burn it

Contracts

Addresses go live here at launch. Always verify on the explorer before swapping.

SHREW Token

ERC-20, 1B supply, 18 decimals

ShrewVault

Reward contract, no admin keys

TBA

Uniswap V3 Pool

SHREW / WETH, fee tier 10000

TBA

Pons Factory

Launchpad factory (existing)

TBA

How to check before you buy

Look up the token on the Robinhood Chain explorer.
Make sure supply is 1B and there's no mint function.
Check that the LP is locked in the Pons locker.
Read the ShrewVault code and confirm there's no admin withdrawal path.
Call getEpoch(currentId) to see the live vault balance.

Roadmap

Phase 1

Launch

Token deployed via Pons, liquidity locked
ShrewVault deployed and verified
Website live with live chain data
First epoch starts 12h after launch

Phase 2

Getting noticed

Dexscreener and GMGN listings
Social channels live (X, Telegram)
Claim dashboard with countdown timer
First burn executed

Phase 3

Growing up

Holder governance for parameter changes
Integrations with other Robinhood Chain projects
Claim notifications on mobile
Open-source indexer so anyone can build a frontend

Security

What's trustless

Supply is fixed and on-chain. Nobody can mint more.
Liquidity is locked. The LP can't be pulled.
The vault has no admin withdrawal. ETH only leaves via claim or burn.
The weighting formula is hardcoded. Can't be changed after deploy.
Snapshots use on-chain merkle roots. Anyone can verify.

What still needs trust

The snapshot indexer. It reads transfers and builds the merkle tree off-chain, then posts the root. If it's wrong, the root is wrong. But since the root is public, anyone can re-derive it and challenge it.
The burn swap. The vault buys SHREW via Uniswap, which means normal DEX slippage and MEV apply. We use tight slippage limits and a TWAP check to mitigate.

Audit

Source code will be published and verified before the first epoch. Independent audit coming after launch. Until then, treat this as experimental.

Glossary

Nest: The vault contract. Where fees pile up between epochs.
Epoch: A 12-hour cycle. Each one has a snapshot, a claim window, and maybe a burn.
Reverse weighting: Small bags earn more per token than big ones. Uses sqrt(min(balance, cap)).
Burn: Unclaimed rewards get spent buying SHREW on the market, then sent to a dead address.
Merkle root: A cryptographic fingerprint of everyone's balances at snapshot time. You prove your balance with a merkle proof.
Pons: The launchpad on Robinhood Chain. Handles token deploy, pool creation, and LP locking.
Cap: The max balance counted in the formula. Set at 100M (10% of supply). Bigger bags get capped.

Still hungry?

Read the contract at launch. Or just grab a shrew.

Buy $SHREW