How it works

What it does

Lazarus brings dead pump.fun coins back. Anyone can nominate a corpse. When it gets resurrected, a new coin launches and its dev buy goes to the people who were left holding the old one, capped per wallet.

After that, the new coin’s creator fees buy and burn the dead coin, buy and burn the risen coin, and buy $LAZARUS. Bagholders get paid first, and every action is public on the ledger.

When a coin is dead

Paste a mint and the checker reads chain data: the pump.fun bonding curve, or the PumpSwap pool if it graduated, plus the last trade, market cap, drop from peak and holder count. A coin is dead when all of these hold:

• market cap under $15K
• at least 24 hours old
• no trades for 3 days, or down 90% or more from its peak

A coin with a live resurrection can’t be raised twice. The checker returns one of:

Dead

Meets the rule. It can take candles and be resurrected.

Alive

Still trading or still worth something. The reason is shown.

Unsupported

Not a pump.fun coin, or the chain data couldn’t be read.

Risen

Already resurrected. Links straight to the risen coin.

Candles

A candle is a vote for a resurrection: one per wallet per coin. Candles rank the graveyard so the most-wanted corpses float up. Lighting one uses your signed-in session, not a transaction, so it costs no SOL. The wallet does need to hold at least 0.05 SOL so empty wallets can’t stuff the count.

Resurrection

Dead is not enough. Before a corpse can be raised it has to clear every gate:

• it graduated to PumpSwap, so it had a real market once
• at least 25 bagholders each hold 0.01% of supply or more
• at least 10 candles lit

The checker shows each gate with its progress. The person raising it can’t be the dead coin’s creator, one of its holders, or a wallet that ever traded it.

A signed-in user hits Resurrect. The platform dev wallet creates <Name> Risen on pump.fun with the ticker plus an R ($GHOST becomes $GHOSTR) and the original art wearing a halo.

The same transaction makes an atomic dev buy, and that dev buy is the claim pool. There is no gap between create and buy for a sniper to slip into, so nobody gets a cheaper entry than the bagholders.

Snapshot

Right before launch the server records every holder of the dead coin at a specific slot, shown on the coin page. These accounts are excluded:

• the bonding curve and PumpSwap pool accounts
• the incinerator
• the dead coin’s creator
• the Lazarus dev wallet
• accounts owned by programs (pools, lockers, vaults) rather than people

Wallets holding less than 0.01% of supply stay in the snapshot count but get no share, so nobody can farm the pool by spraying dust across fresh wallets.

Allocation

The pool is split pro-rata by dead-coin balance, with a per-wallet cap of 5% of the pool so one whale can’t eat it. The cap a coin launched with is shown on its page.

Anything above the cap is redistributed pro-rata to the uncapped wallets, repeatedly, until nobody exceeds it. Only what nobody can take (when every wallet is already at the cap) plus a few atoms of rounding is burned at launch, shown on the ledger as a launch burn.

The math is integer-only, in raw token atoms. Same snapshot in, same allocation and same root out.

Merkle tree

Allocations become leaves of a sha256 merkle tree. Amounts are raw token atoms (6 decimals), so nothing is lost to floating point.

• Leaf: sha256(u32le(index) || pubkey(32 bytes) || u64le(amount))
• Parent: sha256 of its two children sorted bytewise. A proof is just a list of sibling hashes with no left/right flags. An odd node rises unchanged.
• The root is shown on every coin page.
• /api/r/<mint>/merkle.json lists every leaf with its proof (hex), so anyone can verify the whole tree offline.

import { sha256 } from "@noble/hashes/sha256";
import { bytesToHex, concatBytes, hexToBytes } from "@noble/hashes/utils";
import bs58 from "bs58";

// leaf = sha256(u32le(index) || pubkey(32) || u64le(amount))
function leafHash(index: number, wallet: string, amountAtoms: bigint) {
  const bytes = new Uint8Array(44);
  const view = new DataView(bytes.buffer);
  view.setUint32(0, index, true);
  bytes.set(bs58.decode(wallet), 4);
  view.setBigUint64(36, amountAtoms, true);
  return sha256(bytes);
}

function compareBytes(a: Uint8Array, b: Uint8Array) {
  for (let i = 0; i < 32; i++) if (a[i] !== b[i]) return a[i] - b[i];
  return 0;
}

// sorted pair: the smaller hash goes first, so proofs carry no left/right flags
function hashPair(a: Uint8Array, b: Uint8Array) {
  return compareBytes(a, b) <= 0
    ? sha256(concatBytes(a, b))
    : sha256(concatBytes(b, a));
}

// one entry from /api/r/<mint>/merkle.json
function verify(leaf: { index: number; wallet: string; amount: string; proof: string[] }, root: string) {
  let node = leafHash(leaf.index, leaf.wallet, BigInt(leaf.amount));
  for (const sibling of leaf.proof) node = hashPair(node, hexToBytes(sibling));
  return bytesToHex(node) === root;
}

Claiming

If your wallet was in a snapshot, your tokens are waiting on the claim page.

1. Connect your wallet. It shares your address. Nothing is signed yet.
2. Sign in once. A plain message signature proves you own the wallet. It is not a transaction and costs nothing.
3. Hit Claim. The server builds the claim transaction and the Lazarus dev wallet partially signs it to release your tokens.
4. Approve in your wallet. You pay the fee, about 0.003 SOL: rent for your token account (refundable if you close it later) plus about 0.0009 SOL for the on-chain marker that stops a leaf from claiming twice.
5. Done. The server sends the transaction, waits for confirmation and marks your leaf claimed. Each leaf claims once.

Claim window

Each resurrection has a claim deadline, shown as a countdown next to your claim. Resurrections launched now get 30 days. When it passes, unclaimed tokens are swept and roll into buybacks. Sweeps show up on the ledger like every other action.

Fee engine

Each engine cycle claims the creator fees, credits them to the coins whose trades earned them, and splits each coin’s share into three legs. Every leg lands on the public ledger with its signature.

The legs are set in basis points and must add up to 10,000. If they ever don’t, the dead-coin leg takes whatever the other two leave, so a misconfiguration can only favor the corpse.

Dry runs

When the server’s money gates are off, resurrections and claims still run end to end but are recorded as dry runs and no transaction is sent. They carry a DRY RUN badge everywhere they appear and are never counted as on-chain.

Risks and FAQ

Will the dead coin pump?

Maybe, maybe not. Buys and burns put a bid under it, but dead coins can stay dead.

Is the risen coin the old coin?

No. It is a new token with its own market. Your claim is real tokens, priced by whoever trades it.

Do I hand over my keys?

Never. You sign one message to sign in and one transaction to claim, and you can read both before approving.

Is this financial advice?

No. Memecoins are volatile. Only put in what you can afford to lose.