How a dead bonding curve gets brought back, and who gets what when it does.

What Necropolis is

Necropolis is two things: a register of every Pons V2 bonding curve on Robinhood Chain that stopped trading before it graduated, and an escrow that lets people pool the ETH needed to finish one.

It is not a launchpad. The protocol never mints a token and never starts a curve. Its entire inventory is produced, for free, by the launchpads it sits downstream of — and that inventory grows every day the chain runs.

The project has one token, $NECRO, launched on Pons like everything else it indexes. The protocol's contracts never touch it. See The token.

Dying on a curve

A Pons V2 launch mints a fixed supply of 1,000,000,000 tokens straight into its own bonding curve contract. Traders buy and sell against that curve — not against any AMM — until the curve has collected its graduation threshold of the quote asset. For native ETH-quoted launches that threshold is 4.2 ETH.

When the threshold is reached, the curve is swept: the collected ETH and the reserved token supply seed a Uniswap v4 pool whose liquidity position is permanently locked, behind the Pons hook. That is graduation, and it is the moment the token acquires a market.

Before that moment there is no pool at all. The only venue is the curve's own sell side. On a launch nobody is watching any more, that is not a market — it is a formality.

So a curve that stops trading at, say, 3.90 of its 4.2 ETH leaves behind three things:

• Locked ETH. The 3.90 ETH sits in the curve contract. It does not move until someone pushes the curve past the threshold.
• Trapped holders. Everyone who bought holds a token with nowhere to sell it. Not because they are down — because there is no venue.
• Unsold supply. The remaining slice of the curve, which nobody bought.

Across every Pons launch to 4 September 2026: 207,893 launched, 3,228 graduated. That is 1.55%. The other 204,665 are in the state described above.

The two sides

Two groups are stranded on opposite sides of the same dead contract, and neither can act alone.

The bounty is the part people find surprising, so it is worth stating plainly: a bounty poster buys an exit, not a position. They get no claim on the recovered tokens. What they get is that their existing bag acquires a market for the first time. Whether that is worth paying for is their judgement, and nothing in the contract makes it for them.

The curve

Everything Necropolis ranks and prices comes from one relation. A Pons curve books collected reserve R against tokens sold s as:

R(s) = k · s² / 2        with  R(CURVE_SUPPLY) = THRESHOLD

which inverts to

s(R) = CURVE_SUPPLY · √(R / THRESHOLD)

With CURVE_SUPPLY = 800,000,000, POOL_SUPPLY = 200,000,000 and THRESHOLD = 4.2 ETH. From this, three quantities follow.

Gap

What the curve still has to collect. Read straight off the contract, no assumptions:

gap = THRESHOLD − reserveCollected

Required in

What a reviver must actually send. The curve books reserve net of its 1% trade fee, so the input is grossed up:

requiredIn = ceil( gap × 10000 / (10000 − tradeFeeBps) )   // tradeFeeBps = 100

// the factory adds a small buffer on top when it opens a crypt,
// so a sell landing mid-flight does not strand it one wei short
targetIn   = requiredIn × (1 + bufferBps / 10000)        // bufferBps = 50

Any pledged ETH the buy does not consume is returned pro-rata at claim time, so over-padding costs nothing but gas.

Recovered tokens

Closing the gap buys the entire remaining curve supply:

revivalTokens = CURVE_SUPPLY − s(reserveCollected)

Worked examples

Note the direction: a wider gap buys tokens at a lower average price, because you are buying further down the curve — but it is more capital at risk on a token that already failed once. That tradeoff is the whole product, and Necropolis does not pick a side of it.

Lifecycle

Five stages. Every one of them is a call anyone can make — there is no privileged operator anywhere in the path.

function openCrypt(address ponsFactory, address curve, uint64 lastTradeAt)
    external returns (address crypt)

function postBounty() external payable

function pledge() external payable   // min 0.001 ETH

function exhume(uint256 minTokensOut) external

if (!curve.graduated()) revert GraduationDidNotFire();

function claim() external    // after a successful exhume
function collapse() external // mark a crypt dead after its deadline
function refund() external   // take your ETH back from a collapsed crypt

Settlement arithmetic

Exactly what claim() pays, in the order the contract computes it.

// at exhume, once graduation is confirmed
recovered     = tokens the curve actually sent
tokensNet     = recovered   − recovered   × protocolFeeBps / 10000
bountyNet     = totalBounty − totalBounty × protocolFeeBps / 10000
unspentPledge = totalPledged − amountSpent

// at claim, for a pledger p
tokenShare  = tokensNet     × pledgeOf[p] / totalPledged
bountyShare = bountyNet     × pledgeOf[p] / totalPledged
refundShare = unspentPledge × pledgeOf[p] / totalPledged

A full example

A curve sitting at 3.90 ETH. Gap 0.30, required in 0.3030. One holder posts a 0.40 ETH bounty. Alice pledges 0.20, Bob pledges 0.15 — 0.35 total, which covers it.

Figures are rounded for readability; the contract works in wei and integer division, and the only thing that can remain in a crypt after everyone has settled is a couple of wei of rounding dust. There is a fuzz test that asserts exactly that.

Fees

The protocol fee is hard-capped in the contract at MAX_PROTOCOL_FEE_BPS = 500 (5%). That ceiling is a constant, not a setting — no owner call can exceed it.

A crypt keeps the terms it opened on. Changing a parameter affects crypts opened after the change and nothing already live, so nobody's fee can be raised while their ETH is escrowed.

Parameters

Graduation threshold

4.2 ETH

Pons constant for native-quoted launches

Max gap

2.0 ETH

Wider than this is a launch, not a revival

Dormancy

7 days

Zero curve trades before a crypt may open

Crypt duration

14 days

Then it can be collapsed and refunded

Protocol fee

250 bps

Hard cap 500 bps

Minimum pledge

0.001 ETH

Contract constant, keeps the ledger clean

Safety model

• The buy is all-or-nothing. exhume() asserts curve.graduated() after the purchase. If graduation did not fire, the whole transaction reverts and nothing was spent. This is a revert, not a policy.
• Two ledgers, two refund paths, no overlap. A bounty poster can never take a pledger's tokens; a pledger can never take another pledger's refund.
• Settlement is pull-based and there is no loop over contributors anywhere. No number of pledgers can make a payout run out of gas or brick the contract.
• No admin key over user funds. The factory owner can recognise Pons factories and set parameters for future crypts. There is no function, anywhere, that lets anyone move escrowed ETH or claimed tokens.
• Reentrancy guarded on every function that moves value, with state written before any external call.
• The ABI seam is one file. Every read Necropolis performs on a foreign Pons contract goes through a single PonsAdapter library, so upstream ABI drift is a one-file patch rather than an audit-wide change.
• Crypt addresses are CREATE2-derived from the curve address, so you can compute and verify a crypt's address independently of any front end — including this one.

What can go wrong

Listed because they are real, not because the list is required.

• The holders you just freed. Graduation hands every trapped bag its first venue. Some of those holders have been waiting months to sell, and they can sell into the pool you created.
• Snipe tax. Pons applies a decaying tax on buys immediately after graduation. It does not touch the reviver's entry, which happened on the curve — but it does affect what trading around that moment costs.
• The gap can widen. A sell into the curve between your pledge and the exhume pushes the reserve back down. The contract handles this by reverting rather than half-spending, but it means a crypt can sit covered and then stop being covered.
• The token already failed once. Reviving a curve creates a market. It does not create demand, and nothing about graduation makes a dead project alive.
• Capital is locked until settlement. Pledged ETH cannot be withdrawn while a crypt is open — only after a successful exhume, or after the deadline and a collapse.
• Unaudited. See below.

Open unknowns

Things that are not settled yet, stated here rather than buried.

Architecture

Four layers. There is no custody anywhere in the path: the only component that ever holds funds is the crypt contract for a given curve, and the only way out of it is settlement.

If this site went offline, nothing would be lost: every grave, crypt and contribution is recoverable from the chain alone, and every contract call above can be made directly from a block explorer.

Contract reference

NecropolisFactory

NecropolisCrypt

Phases

The token

$NECRO is launched on Pons, on the same bonding curve as every token in the register: fixed supply of 1,000,000,000, graduating to a permanently locked Uniswap v4 pool at 4.2 ETH. If it never graduates, it becomes grave #1 — and the first crypt the protocol opens.

What holding it does and doesn't do

• It is not a claim on escrowed funds. ETH in a crypt belongs to that crypt's pledgers and bounty posters, and only claim() or refund() can move it. No token balance changes that.
• It is not a share of protocol fees. The 2.5% protocol fee goes to the treasury. Nothing in the contracts routes any of it to token holders.
• It is not required to use the protocol. Anyone can pledge, post a bounty or exhume without ever holding it.
• It is a token on an open curve, with every risk that implies. It can go to zero. Nothing on this site is a reason to buy it.

Planned

What the token is being built toward. None of it is live, and none of it is a promise of value — each piece ships in verified contracts before this page calls it live.

If any of this changes — a fee share, governance, anything — it will be in the contracts first, verified on Blockscout, and written here before it is announced anywhere else.

How to buy

Four steps. The only one that can go wrong in an expensive way is the last.

1. Add Robinhood Chain to your wallet. The button on the register page does it in one click. Manually:

   Network name	Robinhood Chain
   RPC URL	https://rpc.mainnet.chain.robinhood.com
   Chain ID	4663
   Currency	ETH
   Explorer	https://robinhoodchain.blockscout.com

2. Bridge ETH in. The canonical route is the Arbitrum bridge — about ten minutes in, about seven days out. Third-party bridges such as Relay and Across are faster in both directions.
3. Buy on Pons using the contract address from this site — not from a search result, a reply, or a DM.
4. Check the address matches, character by character, against the one on this page and pinned on @necropolisfund. Copycats with the same name and ticker appear within minutes of every launch.

Addresses

Glossary

FAQ