Approved workflow

Release Ember (token symbol EMBR) on Sepolia as a univ4_hook launch. Token: Ember (EMBR), total supply 1,000,000,000 EMBR with 18 decimals, minted once to the deployer. Hook: BuybackBurnHook, a Uniswap v4 hook on the token's native-ETH pool. Deployment: the constructor takes one argument, the Sepolia PoolManager 0xE03A1074c86CFeDd5C142C4F04F1a1536e203543, passed as a literal in launch.json constructorArgs; getHookPermissions() returns exactly afterSwap and afterSwapReturnDelta and every other flag false (address bits 0x0044 under mask 0x3FFF), validated in the constructor; the factory mines the CREATE2 salt. The factory's pool is currency0 = native ETH, currency1 = EMBR, LP fee 3000, tickSpacing 60, seeded with EMBR only, so the first buy lands in a pool holding no ETH and must work. State is keyed by PoolId; pools whose currency0 is not native ETH get zero deltas and no state. Callbacks are PoolManager-only (override BaseHook's internal _before/_after functions). No owner, admin, pause or upgrade path. Tests swap through a real PoolManager; the Identity-md/univ4hook-start-template harness (BaseHookTest) provides the launch pool. Behaviour: every swap pays a 1% hook fee (100 bps) on its unspecified side. Fee maths: in afterSwap the unspecified currency is currency1 when (amountSpecified < 0) == zeroForOne, else currency0; unspecifiedAmount = |that currency's amount in the swap's BalanceDelta|; fee = unspecifiedAmount x bps / 10,000 (floor, so dust swaps pay 0), returned as a positive int128 hookDeltaUnspecified: exact-input swappers receive fee less output, exact-output swappers pay fee more input. The hook settles that credit inside the same callback (take or ERC-6909 mint), never sends ETH to anyone from a swap callback, and never relies on a dynamic-fee pool key (the pool's 0.3% LP fee is separate). When the fee currency is EMBR (exact-input buys, exact-output sells) the hook burns it at once with poolManager.take(currency1, 0x000000000000000000000000000000000000dEaD, fee) and adds it to burnedTotal. When it is ETH (exact-input sells, exact-output buys) the hook mints itself ERC-6909 claims with poolManager.mint(address(this), currency0.toId(), fee) and adds it to accruedEth[poolId]. buyback(PoolKey key): anyone; requires key.hooks == this, currency0 native, accruedEth >= 0.001 ETH and no earlier buyback for that pool in this block; spends min(accruedEth, 0.05 ETH) through poolManager.unlock: an exact-input ETH->EMBR swap on the same pool (sqrtPriceLimitX96 = MIN_SQRT_PRICE + 1), settles the ETH it actually spent by burning that many claims (poolManager.burn), takes the EMBR output straight to the dead address, and reduces accruedEth by the ETH spent. The hook's own buyback swap pays no hook fee (sender == address(this) in afterSwap). unlockCallback is PoolManager-only and only reachable from buyback(); buyback cannot run inside another swap because the PoolManager is already unlocked there. The per-call 0.05 ETH cap and one-per-block rule bound what a sandwich around a buyback can extract; document the residual MEV. Views: accruedEth(poolId), burnedTotal(poolId), lastBuybackBlock(poolId). Events: FeeBurned(poolId, amount), FeeAccrued(poolId, amount), Buyback(poolId, ethSpent, tokensBurned). Tests must show: the exact 1% on all four swap types, EMBR fees landing at the dead address, PoolManager.balanceOf(hook, 0) == sum of accruedEth (invariant), buyback reducing accruedEth and burning EMBR, a second buyback in the same block reverting, the buyback swap itself paying no fee, and callbacks reverting for non-PoolManager callers. The independent adversarial review must attack: the sign of the returned delta for each swap type, fee-exemption abuse (can an outside swapper appear as the hook?), claims accounting in buyback, re-entrancy into buyback, and sandwiching the buyback. Then a small website that shows the burned total, the pending buyback ETH, whether a buyback is allowed now, a buyback button anyone can press, and the last 20 Buyback events. Read state from hook views and events via a public Sepolia RPC with no backend; keep it to one small page; the static export has index.html in dist/.

Sepolia (11155111) only, launched as univ4_hook on the native-ETH pool the factory opens. GitHub publication and IPFS hosting are approved. Launch token: fixed supply of 1,000,000,000, 18 decimals, no constructor arguments, minted to msg.sender, no mint or admin. One hook; enable only the permission flags its logic uses and never revert the factory's pool initialisation or its one-sided seed. Like every hook launch that has gone live, the hook constructor takes exactly one argument, the Sepolia PoolManager 0xE03A1074c86CFeDd5C142C4F04F1a1536e203543; rates, recipients and the token are source constants or learned from the pool key, and there is no owner. Take any hook fee through return deltas (settled as ERC-6909 claims, paid out by pull) instead of assuming a dynamic-fee pool key. Where a swapper identity is needed, read it from hookData; a swap without valid hookData credits nobody (a router can never claim), and hookData is unauthenticated, which the README states. No external oracles or VRF, no proxies, delegatecall or selfdestruct. foundry.toml sets bytecode_hash = "none". Any website is a static export with index.html in dist/. Site label lab-buyback-burn-hook.

Build EMBR and BuybackBurnHook (afterSwap + afterSwapReturnDelta, 1% fee: EMBR side burned, ETH side bought back and burned via unlock) with tests against a real PoolManager and an independent review, deploy them, then build the website against the live pool.

Burned total, pending ETH, buyback button with can-run state, last 20 buybacks from events.