COMPLETE SELF-CONTAINED SPEC - this objective supersedes the project's stored brief in full (the stored copy is truncated); build from this text alone.

CROWN MODEL 2 (the Throne) - one immortal token per ticker, and a registry that decides who controls it. Build the full system for Robinhood Chain (chainId 4663) per this specification and deliver a working end-to-end demo.

CONCEPT: A registry binds a ticker to exactly ONE token contract, forever - one Dexscreener page, one chart, one pool, history never resets. What changes hands is the throne: the controller/beneficiary who receives the token's hook fee stream. A Uniswap v4 hook on the token's pool skims a cut of every swap and accrues it to the registry's current beneficiary for that ticker. Anyone can challenge for the throne with a bonded ETH stake-vote naming a candidate beneficiary wallet; if the challenger out-stakes the reigning side within the window and quorum is met, the registry flips the beneficiary after a timelock and every subsequent swap accrues to the new controller. The token, its supply, and its pool NEVER change - a dethrone moves control only.

CONTRACT 1 - ThroneRegistry:

• ticker is bytes32 = keccak256 of the uppercase symbol string.
• registerTicker(ticker, token, beneficiary): callable once per ticker; the token address is immutable afterward - no setter may exist, by construction.
• openChallenge(ticker, candidateBeneficiary) payable: bond 0.01 ETH; one live challenge per ticker; challengeable only after MIN_REIGN (a constructor parameter, production default 7 days); 3-day cooldown per ticker after a failed challenge. A challenge names a candidate beneficiary wallet - there is no challenger token in this model.
• stake(challengeId, side) payable in ETH during a 72-hour window (side = reigning or challenger).
• finalize(challengeId) after the window plus a 24-hour timelock: the challenger wins iff challenger stake > reigning stake AND total staked >= 0.05 ETH quorum. On a win, the registry beneficiary (and controller) flips to the candidate and a Reign record is appended (controller, from, to, how the reign ended). Losing side: 80% refundable to its stakers (pull pattern), 20% slashed - half of the slash pro-rata to winning-side stakers (pull), half to treasury 0xf19F11Dee16a341671E6Ed3e209b704C1Bbc3E57. Winning side stake is fully refundable (pull).
• Public reign history per ticker (the dynasty log) and per-ticker stake totals. Events: TickerRegistered, ChallengeOpened, Staked, Dethroned, ChallengeFailed.
• No admin functions after deployment beyond the constructor parameter init; resolution is purely rule-based.

CONTRACT 2 - CrownHook (Uniswap v4; afterSwap and afterSwapReturnsDelta permissions), ACCRUE-AND-PULL fee design:

• afterInitialize records poolId -> ticker; the deployer registers each pool ticker explicitly.
• On every swap: compute the cut (per-pool bps set at init, default 100, range 0-500) from the swap amount, read registry.beneficiary(ticker) via staticcall, take the cut as the hook's own delta and settle it inside the same unlock by calling PoolManager.mint(address(this), currency.toId(), cut), so the hook holds an ERC-6909 claim on the PoolManager backing the accrual; credit crownOwed[beneficiary][currency] += cut. Maintain a public counter crownPaid[ticker][currency] (cumulative accrued).
• During settlement the hook may call ONLY the PoolManager (mint/settle/take) and the registry staticcall read - never any contract whose target or code is beneficiary-controlled, and never a transfer to the beneficiary mid-swap: a contract beneficiary could otherwise leave transient PoolManager debt inside receive() and revert the enclosing unlock with CurrencyNotSettled. Swap liveness is unconditional - if the registry read fails, the swap proceeds without the cut.
• claim() on the hook, callable outside any swap, runs in its own unlock: it redeems the hook's ERC-6909 claim for that currency (burn the claim, take the currency) and transfers the caller's full crownOwed balance to the caller, zeroing the balance first (checks-effects-interactions). Claiming must work at any time, including while a challenge is live.

DEMO LAUNCH (this launch token): name "Throne Demo", symbol THRONE, paired with native ETH on Robinhood Chain, its pool wearing CrownHook, registered as the genesis entry for ticker THRONE with beneficiary = the launch payer wallet. The demo registry instance uses MIN_REIGN = 0 (the production default of 7 days stays in the code and README) so a full challenge -> stake -> finalize -> beneficiary flip can be executed end-to-end immediately after launch; name the second beneficiary wallet used in the demo flip in the delivery notes.

SITE: the ticker single canonical page - the token and its pool links, the current throne holder (controller and beneficiary), accrued and claimed fee totals, the reign history timeline (the dynasty log), live challenge state (window, both stakes, time remaining), stake, challenge and claim actions wired to the contracts, and a plain-English how-it-works section.

TESTS (Foundry, in the repo): registry and challenge math unit tests (bond, quorum, slash split exact to the wei); a malicious-contract-beneficiary test whose receive() attempts to leave PoolManager debt, proving swaps still settle and the fee still accrues; claim() correctness exact to the wei; an integration test that executes buy -> challenge -> stake -> finalize -> buy and asserts (a) accrual now goes to the new beneficiary, (b) crownPaid matches accruals and claims, and (c) the token address stored in the registry is byte-identical before and after the dethrone. Contracts must compile with the repo pinned settings and be Sourcify-verifiable; record the compiler settings in the README.