王侯将相宁有种乎

王侯将相宁有种乎 is a permissionless bonding-curve issuance protocol structured as an open-ended sequence of independent dynasties. Each dynasty is an independent ERC-20 token paired with its own exponential bonding curve and parameter pair (K, S_N), N >= 1. The Protocol's distinguishing mechanism is a time-decaying supply threshold: a dynasty admits new mints until cumulative fair-curve supply reaches threshold(N, t) of K, where threshold decays linearly from 99% at launch to 80% over 24 hours and locks at 80% thereafter. When this threshold is crossed, the dynasty sunsets and the next dynasty launches atomically within the same transaction. A 30% snapshot of the protocol fund is allocated to each sunset dynasty's distribution pool, redeemable by holders through a cross-generation burn function that emits both fresh-generation tokens and a fair-share dividend — because sells are closed once a dynasty sunsets, the only path that decreases totalMintedFair is the burn itself, so every fair-curve unit locks in D / s₀ ETH at the moment of sunset and burn order is irrelevant; tokens that are never burned leave their share permanently sequestered in the pool, never redistributed to other holders. The Protocol implements no admin role, no upgrade path, and no pause function. All economic constants are bound at deployment. The Protocol is deployed on Ethereum as a Uniswap V4 hook.

This Protocol replaces the conventional launchpad model of "one token, one curve" with "independent tokens, independent curves, and a single dynasty-succession rule." Every generation shares the same supply cap K = 21M (fixed) — equal token seats — while the curve scale S_N = S_BASE × 2^(N-1) doubles each generation, doubling both the trigger ETH cap and the entry price P(0) = S_N / K. The motto holds at the dynasty level as process-equality: every dynasty plays by the same K, the same 99→80% threshold schedule, the same 1% tax, the same burn mechanism — but late-arriving dynasties must commit more ETH to push past the trigger and open at a proportionally higher price. The cost of process-equality, framed as the rising-stakes story rather than treated as inequity.

There are three things you can do: (i) buy the live dynasty's token — the buy that crosses its current threshold automatically advances the dynasty and collects 5% of protocolFund as a trigger bonus; (ii) sell the live generation's token along the inverse curve (sells are closed once the generation sunsets); (iii) hold sunset tokens and call burnOldForLatest, redeeming them at curve-equivalent value into the live generation plus a fair-share dividend.

Returns come from three sources: curve price appreciation (~100x for a rising dynasty, ~5x for a decaying one; see §5); cross-generation burn dividends (ETH paid from the sunset generation's pool at the moment of burn; see §7); and the 5% trigger bonus for advancing dynasty succession. Losses are equally explicit: buy price exceeds the current curve price, sells lose 1% to tax, and any sunset-token holding that is never burned has its share of the dividend pool locked in the contract indefinitely (protocol sediment, never claimed by other holders).

This document specifies the 王侯将相宁有种乎 protocol (the "Protocol"), an open-ended sequence of generations N >= 1. Generations 1–12 are named after Chinese historical dynasties (Xia -> Xiandai); from generation 13 onward each generation takes a 50-year future-year marker (1950, 2000, 2050, ...). Each generation is an autonomous market with deterministic pricing, governed by an exponential bonding curve and a single, time-aware trigger condition that determines when the generation ends.

Design contributions.

1.1 Time-decaying threshold. Decouples the trigger from any single fixed cap. The same generation produces qualitatively distinct equilibria depending on whether early demand pushes past the high cap before it decays, versus an incremental approach to the 80% floor (Section 5).

1.2 Cross-generation real-time dividend. The cross-generation burn function paired with a real-time dividend denominator gives sunset-token holders an explicit incentive to delay redemption, structurally suppressing peak sell-pressure at dynasty turnover (Section 7).

1.3 Full immutability. All economic constants are bound to bytecode at deployment, with no owner / pauser / proxy. Dynasty progression is a pure function of public market activity and elapsed time (Section 10).

Let N denote a generation index, N >= 1. Let K denote the supply cap, K := 21,000,000 (units: 10^18 wei of generation token), constant across all dynasties. Let S_N denote the curve scale of generation N, with S_N := S_BASE * 2^(N-1). Let t denote elapsed time since the launch timestamp of generation N. Let supply_N(τ) denote the cumulative fair-curve supply minted under generation N at protocol time τ, and cumulativeEth_N(τ) denote the cumulative quote token routed onto its curve.

Let protocolFund denote the global protocol reserve, and distributionPool_N the per-generation dividend snapshot allocated to sunset generation N. The constant S_BASE is fixed at 60 ETH at deployment. K is fixed at 21M at deployment and does not vary with N; the ratio P(0)_N = S_N / K = (S_BASE / K) * 2^(N-1) doubles each generation, so late-arriving dynasties open at a higher per-token price. This is the mathematical consequence of the K-fixed / S-doubling combination: K stays constant to keep the per-generation supply cap equal (process-equality), S doubles to keep the trigger ETH cap doubling (rising-stakes story), so P(0) = S/K must double in turn.

Within a single generation N, supply and marginal price are deterministic functions of cumulative quote token routed onto its curve:

mint(eth) = K * (1 - exp(-eth / S_N))
price(eth) = (S_N / K) * exp(eth / S_N)

The supply function is monotonically increasing and bounded above by K; the price function is monotonically increasing and unbounded. Inverting mint(·) yields the inverse curve used by the sell path. The implementation lives in Curve.sol and uses the prb-math UD60x18 fixed-point library.

By direct calculation, the cumulative quote required to reach a target supply ratio θ := supply / K and the corresponding marginal price are:

eth(θ) = -S_N * ln(1 - θ)
price(θ) / price(0) = 1 / (1 - θ)

The price multiple relative to entry is therefore 1 / (1 - θ), independent of N. This is the structural reason every generation behaves identically.

Worked example: Gen 1 (S_1 = 60 ETH, K_1 = 21,000,000 token)

• Entry price. S_1 / K_1 ~= 2.857 * 10^-6 ETH/token.
• 50% supply. eth(0.50) = 60 * ln(2) ~= 41.59 ETH cumulative; marginal = 2x entry.
• 80% supply (decaying-trigger floor). eth(0.80) = 60 * ln(5) ~= 96.57 ETH; marginal = 5x entry.
• 99% supply (rising-trigger ceiling). eth(0.99) = 60 * ln(100) ~= 276.31 ETH; marginal = 100x entry.
• Structural ratio. eth(0.99) / eth(0.80) ~= 2.86: pushing a dynasty to its rising apex costs ~2.86x as much cumulative ETH as parking it on the floor.

The trigger threshold for generation N at age t is defined as:

threshold(N, t) = 0.80 + 0.19 * max(0, 1 - t / 24h)

At t = 0 the threshold is 0.99; for t >= 24h the threshold is permanently 0.80. The function is continuous and monotonically non-increasing in t.

The Protocol checks the trigger condition supply_N >= threshold(N, t) * K on every operation that can increase supply: buy(), and burnOldForLatest() when the destination is the live generation. sell() never advances the trigger. A buy that crosses the live threshold sunsets generation N and launches generation N+1 atomically within the same transaction; the transaction caller receives 5% of protocolFund as a trigger bonus.

Any buy or cross-gen burn that crosses the threshold performs the dynasty transition atomically and pays its sender the 5% bonus. The protocol exposes no entrypoint that advances the dynasty without a buyer or burner.

Because the threshold decays while supply is monotonically non-decreasing, every generation terminates in exactly one of two states. Letting θ* denote the supply ratio at termination, the terminal market cap (at marginal price) and single-generation paper gain are:

marketCap*(N) = K * price(θ*) = S_N * θ* / (1 - θ*)
paperGain(θ*) = price(θ*) / price(0) = 1 / (1 - θ*)

• 5.1 · Rising dynasty · The trigger fires while threshold(N, t) is close to 99%; θ* ~= 0.99 -> terminal market cap ~= 99 * S_N, single-generation paper gain ~= 100x.
• 5.2 · Decaying dynasty · The trigger fires at or near the 80% floor, after the decay window has fully elapsed and incremental inflows have lifted supply onto the floor; θ* ~= 0.80 -> terminal market cap ~= 4 * S_N, single-generation paper gain ~= 5x.

The Protocol does not prefer either outcome. The exponential curve sets the multiplicative gap; market participants jointly determine which equilibrium any single generation realizes.

When the trigger fires for generation N, the contract performs the following operations within a single transaction:

1. Marks generation N as sunset; both subsequent buys and sells of this generation are rejected, holders' only exit being burnOldForLatest cross-generation burn.
2. Snapshots 30% of the live protocolFund into distributionPool_N.
3. Pays a 5% trigger bonus from protocolFund to the transaction caller (if the caller is a contract without a receive, the bonus escrows into bonusEscrowed[triggerer] with a TriggerBonusEscrowed event, never blocking the transition; the triggerer can later pull it via claimBonus(address payable to)).
4. Deploys the ERC-20 contract for generation N+1 and initializes its on-chain state; mints the EmperorBadge SBT (tokenId = N+1) to the triggerer.
5. (V4 deployment only) Defers PoolManager initialization for the new generation; any address may invoke initialize(poolKey) on the V4 PoolManager once the transition has finalized.

If a sunset generation's supply ever decays to zero, its residual distributionPool is swept into protocolFund at the next trigger. Anyone may also call sweepStaleDistributionPool on older sunset generations to perform the same reabsorption.

Sunset tokens remain transferable, but the inverse sell curve is closed for them (sells are gated on status == Active at the contract layer). Holders' sole exit is burnOldForLatest(N, amount):

1. The caller burns amount tokens of sunset generation N.
2. The contract mints fresh tokens of the live generation L at the equivalent quote-token cost nativeEq implied by the two curves.
3. The caller additionally receives a quote-token dividend computed as:

// Written once at sunset, immutable thereafter:
dividendPerFairUnit_N = distributionPool_N / totalMintedFair_N

// On burn:
dividend = fairBurn * dividendPerFairUnit_N

where fairBurn is the burn amount expressed in fair-curve units of generation N, and dividendPerFairUnit_N is the per-fair-unit ETH lock-in for generation N — computed once during the sunset trigger and stored as the uint128 storage field dividendPerFairUnitScaled (1e18-scaled). The hook exposes it as dividendPerToken(N), which returns wei locked per whole token; clients render "X ETH per token" with one RPC instead of two reads and a client-side division.

7.1 · Fair shares and dead-coin sediment

The denominator s₀ and the per-fair-unit lock-in dpfu = D / s₀ are written once into the storage field dividendPerFairUnitScaled (uint128, 1e18-scaled) during the sunset transaction, and become immutable thereafter (the contract exposes no setter and no path can rewrite it). Because sells are closed at the contract layer once a generation sunsets, any subsequent change to totalMintedFair_N originates from burnOldForLatest itself; but dpfu is already fixed, so every subsequent burn simply takes fairBurn × dpfu of its share — neither burn order nor other burners' amounts can affect any single dividend. Formalized below.

The Protocol enforces the following invariants on every user-facing entry point:

8.1 · Per-transaction cap.

A single buy is capped at 5 ETH. One-shot supply vacuuming is structurally impossible.

8.2 · Same-block sandwich resistance.

A sell against generation N reverts if the seller's most recent buy on generation N occurred in the current block. Atomic flash-loan sandwich extraction is therefore unavailable on the swap path.

8.3 · Hard supply cap (defense-in-depth).

Each generation's ERC-20 (GenToken) carries a hardcoded MAX_SUPPLY = 21_000_000e18. mint(to, amount) reverts SupplyCapExceeded when totalSupply() + amount > MAX_SUPPLY. Even if the hook were upgraded, bugged, or re-entered via EIP-7702, the ERC-20 itself reverts and cannot be bypassed. K is the same constant 21M for every generation (Parameters.K(N) returns K_BASE regardless of N); process-equality crystallizes here.

8.4 · EOA enforcement.

Every entry point requires msg.sender == tx.origin. The Protocol settles outbound quote token via a raw call with revert-on-failure; a smart-contract sender (including ERC-4337 wallets without a receive() function) would brick trigger / sell / burn for itself. The constraint is deliberately strict and uniform across all entry points.

A 1% tax is applied to the gross quote-token amount on every buy and every sell (cross-generation burns carry no tax). Sell tax always splits 50/50 between dev and protocolFund; only buy tax routes 10% to an inviter.

• 9.1 · Without an inviter: 50% to the dev wallet (claimable via withdrawDev(); implemented as a derived balance − nonDevReserved rather than an independent counter), 50% to protocolFund.
• 9.2 · With an inviter: 40% dev / 50% protocolFund / 10% inviter. Inviter accruals are claimable through claimReferral(address payable to) — symmetric with claimBonus(to); the to field lets contract-shaped inviters route the payout to a wallet that can accept ETH.

Permanent inviter binding (first-touch lock). The hook maintains mapping(address buyer => address inviter) public inviter. The very first buy that supplies a non-zero referrer through hookData (e.g. via a URL of the form ?ref=0x...) writes inviter[buyer] = referrer and emits InviterBound; every subsequent buy by that wallet routes 10% to the recorded inviter regardless of what hookData carries. A first buy with address(0) does not bind, so a buyer who skipped a referral link on day one can still attach an inviter on a later buy. Once recorded the binding is immutable — there is no setInviter / unbindInviter / multisig override. Both the router's buyWithReferrer entrypoint and the hook's bind path reject referrer == msg.sender; an already-bound wallet that nevertheless emits a self-referencing referrer is silently ignored rather than reverted, so a malformed router call cannot brick that address's buys.

protocolFund flows out via exactly two paths: the 5% trigger bonus paid at every sunset transition, and the 30% snapshot allocated to each sunset generation's distributionPool. There is no withdraw function for protocolFund. The dev wallet is bound at deployment and is immutable; whether the address resolves to an EOA or a multi-signature wallet is opaque to the Protocol.

10.1 · Trust assumptions

The Protocol exposes no administrative role on any user-facing contract:

• no owner, governor, or pauser;
• no upgrade proxy, beacon, or implementation pointer;
• all economic constants (curve formula, threshold schedule, decay duration, fee splits, anti-manipulation caps, dynasty names) are bound to bytecode at deployment.

The only privileged actions retained are: (i) the dev wallet's withdrawDev() on its accrued share; (ii) a one-shot setBadge() after deployment that binds the EmperorBadge contract (immutable thereafter). Neither can affect the curve, threshold, fee, or any existing holder's state.

10.2 · Protocol invariants

10.3 · Attack surface

• Reentrancy. OZ ReentrancyGuardTransient guards every external entry point (burnOld / sweep / withdraw / claim, etc.); the swap path is protected by PoolManager's own lock.
• Sandwich. Atomic sandwich is excluded by §8's same-block cooldown. Non-atomic (cross-block) sandwiches degrade into ordinary price risk and pose no threat to the Protocol itself.
• Trigger-bonus front-running. The buy or cross-gen burn that crosses the threshold collects the 5% bonus, creating a mempool incentive. This advances the Protocol, consistent with design goals; not classified as an attack.
• Oracle manipulation. The Protocol depends on no external price oracle; pricing is determined entirely by internal curve state.
• Flash loan. The 5 ETH per-transaction cap bounds maximum input within a single transaction; flash loans cannot exceed it. Sells via inverse curve are bounded above by per-generation cumulativeEth, eliminating cross-generation reserve drainage.
• Griefing. Two threat models are addressed: trigger-bonus send failures escrow into bonusEscrowed[triggerer] with a TriggerBonusEscrowed event (preventing a malicious triggerer from blocking transitions; the triggerer pulls via claimBonus(to) after the fact); cross-generation dividend send failures revert (preventing a malicious burner from absorbing protocol losses).

10.4 · External dependencies

• Uniswap V4 PoolManager. The Protocol relies on its lock-and-callback model for ETH and per-generation token settlement. PoolManager itself is audited and immutable.
• PRB Math UD60x18. Provides fixed-point ln / exp. Every state write rebinds totalMintedFair from the canonical cumulativeEth source-of-truth, so ln/exp rounding never drifts between two independent accumulators — the invariant stays closed by construction.
• OpenZeppelin Contracts 5.x. Provides ERC-20 / ERC-721 / Strings / Base64 / ReentrancyGuardTransient.

The Protocol occupies a specific position in the launchpad / bonding-curve design space. The following compares the key differences against representative designs:

11.1 · Classical Bancor curve (single pool, CW = 50%).

A single token, single curve, no termination condition. Price rises monotonically with supply but there is no built-in incentive to transition. The multi-dynasty structure here gives every generation a definite finite life with explicit exit paths.

11.2 · pump.fun (Solana meme launchpad).

Single token graduates to an external AMM; graduation is an irreversible binary event with no protocol-layer incentive afterward. In this Protocol, every generation remains sellable through its inverse curve after sunset, and its holders retain the cross-generation burn right, providing the soft-exit path pump.fun lacks.

11.3 · SatoHook (Uniswap V4 launchpad, the direct ancestor).

A single token, a single (K, S), fixed 80% trigger followed by a one-shot distribution and graduation. This Protocol extends it with: (i) multi-generation sequence (K fixed at 21M, S doubles per generation, entry price P(0) = S/K doubles in turn), (ii) time-decaying threshold (replacing fixed 80%), (iii) cross-generation burn with fair-share dividend (replacing one-shot distribution), (iv) the EmperorBadge SBT and fully on-chain chronicle.

Mechanisms surveyed but not adopted (a continuous jackpot pool, collateral / floor-price borrowing, dynamic doc burn, per-transaction sell caps relative to TVL) are documented in DESIGN.md §10.7; their marginal benefit relative to added complexity is not justified for the current mainline and remains available as optional future upgrades.

12.1 · Generation ceiling (natural EVM bound).

The contract sets no explicit MAX_GEN. Naming is open-ended: Gen 1–12 follow a fixed dynasty table, Gen 13+ follow the formula 1950 + (N-13) x 50 with no terminator. Plan B fixes K at 21M (constant across generations, never overflows); the ceiling now lives in S_N = S_BASE << (N-1), which overflows uint256 around Gen 246 with mainnet S_BASE = 60 ether. At that point the trigger transaction reverts and the generation stays permanently active but unbuyable; cross-generation burns still execute (sells are sunset-locked at the contract level). The horizon is far enough -- even at the fastest 24-hour-decay cadence, Gen 246 is 246+ days out -- that this matters only theoretically.

12.2 · Open price doubles each generation (P(0) drift).

P(0)_N = S_N / K = (S_BASE / 21M) × 2^(N-1) doubles every generation. This is the mathematical consequence of the K-fixed / S-doubling combination: K must stay constant to keep the per-generation supply cap equal (process-equality), S must double to keep the trigger ETH cap doubling (rising-stakes story), so P(0) = S/K must double in turn. Late-arriving dynasties open at a higher per-token price; the protocol accepts this as the cost of process-equality, framed by the "rising-stakes" narrative rather than treated as a defect.

12.3 · V4 PoolManager forks.

The V4 PoolManager is itself immutable. However if Uniswap deploys a fork at a different address, this hook will continue using the original; users will need to choose a router accordingly. The Protocol does not migrate.

12.4 · Strategic play in the threshold-decay window.

During [0, 24h], a strategic gap emerges between waiters (who let the threshold decay below current supply, then snipe the trigger with a tiny buy) and aggressors (who buy across the live threshold to claim the trigger bonus themselves). Both are protocol-legal and the design accepts that participants will weigh the trade-off.

12.5 · Dead-coin sediment.

Lemma 7.1 / Corollary 7.2 establish that fair-share dividends are independent of burn order. However, any address whose sunset-generation holdings are never burned — through lost wallets, ignored UIs, or deliberate abandonment — leaves its q × D / s₀ ETH share permanently locked in distributionPool_N and not redistributed to other burners. The residue is only reabsorbed into protocolFund when the generation's supply reaches zero (via sweepStaleDistributionPool). The Protocol accepts this sediment and exposes no "claim on someone else's behalf" entrypoint.

12.6 · Single dev-wallet fee custody.

40–50% of the 1% swap tax routes to a single dev wallet bound at deployment. Loss of that wallet's private key does not impair Protocol operation (dev share continues to accrue without being withdrawable), but the wallet cannot be redirected.

The Protocol's primary motto, 王侯将相宁有种乎, is attributed to Chen Sheng (陈胜) in 209 BCE during the first recorded peasant uprising against the Qin dynasty. The line is preserved in Sima Qian's Records of the Grand Historian, Hereditary House of Chen She (《史记·陈涉世家》). It interrogates whether kings, princes, generals, and ministers constitute a separate hereditary class. Chen Sheng's answer was negative.

The Protocol asserts the analogous claim at the dynasty level: every generation is bound by the same set of rules — the same supply cap (K = 21M, fixed), the same threshold schedule (99% → 80% over 24h), the same anti-manipulation rules, the same fee structure, the same burn mechanism. "宁有种乎" holds at "every dynasty plays by the same rules," not at "every dynasty starts at the same price": late-arriving dynasties must commit more ETH to push past the trigger (S_N doubles), and their open price doubles in turn (P(0) = S_N / K) — the cost of process-equality, framed as the rising-stakes story. Whether any individual dynasty terminates as a rising or decaying equilibrium is decided by participants in the open market, generation by generation.

The Protocol is deployed on Ethereum mainnet, with Sepolia available for staging and integration testing. The hook contract intercepts swap, addLiquidity, and initialize on the Uniswap V4 PoolManager via the BeforeSwapDelta interface. The hook address is mined to satisfy the V4 hook-permission bitmask 0x2888 (beforeInitialize | beforeAddLiquidity | beforeSwap | beforeSwapReturnDelta). User transactions enter through a companion router contract, which performs the unlock-callback pattern required by the V4 architecture; settlement of native ETH and per-generation ERC-20 tokens is delegated to the PoolManager.

Deployment Reference

Per-generation token addresses are deterministic from _launchGen; query getGen(N).token.

All Protocol state lives on-chain. Notable view functions:

• currentTriggerSupply(N): live trigger threshold for generation N, expressed in token units;
• currentThresholdBps(N): the same threshold expressed in basis points (8000–9900);
• getGen(N): full state struct of generation N;
• previewBuy / previewSell / previewBurn: view-only quoting for client-side simulation;
• getChronicle(N): generation N's chronicle (first patriot / patron / defector / last loyalist).

The contract bytecode is the canonical specification; this document is its informal explanation.