Release Lockup (token symbol LKUP) on Sepolia as a univ4_hook launch. Token: Lockup (LKUP), total supply 1,000,000,000 LKUP with 18 decimals, minted once to the deployer (a separate zero-argument ERC-20, no mint, owner or admin). Hook: LiquidityLockupHook, a Uniswap v4 hook on the token's native-ETH pool that locks each liquidity position for 30 days after its last add. Position key: exactly the PoolManager's, keccak256(owner, tickLower, tickUpper, salt), where owner is the sender argument of the liquidity callbacks (the router or PositionManager that called modifyLiquidity; PositionManager uses the NFT tokenId as salt, so each NFT is its own position). afterAddLiquidity with liquidityDelta > 0 sets unlockAt[poolId][positionKey] = block.timestamp + 30 days (every top-up restarts the full 30 days) and emits Locked(poolId, positionKey, sender, tickLower, tickUpper, salt, liquidityDelta, unlockAt). beforeRemoveLiquidity reverts with StillLocked(unlockAt) when liquidityDelta < 0 and block.timestamp < unlockAt; liquidityDelta == 0 (fee collection, which v4 routes through beforeRemoveLiquidity) always passes, as does any removal at or after unlockAt. The factory's own seed position is locked like any other; the launch never needs to remove it. No deltas, no fee, no funds held, no admin; nothing can extend or shorten a lock except a new add to the same key. Known limit to document: on a shared router such as PoolModifyLiquidityTest, anyone adding to the same (router, range, salt) key restarts that key's lock, so the README and site send LPs to PositionManager. The symbol is LKUP because LOCK is already a live launch token on this factory (launch 113). Deploy shape, matching the live Sepolia hook launches 170, 183 and 186 (launch 168 passed the mainnet PoolManager and is not a model): LiquidityLockupHook's only constructor argument is the Sepolia PoolManager 0xE03A1074c86CFeDd5C142C4F04F1a1536e203543; every rate, window and threshold here is a source constant; there is no owner, admin, setter, pause, upgrade or sweep, and no $owner or $token argument. Permissions are exactly afterAddLiquidity, beforeRemoveLiquidity (low address bits 0x0600), all others false; the constructor calls Hooks.validateHookPermissions and the CREATE2 salt is mined for those bits. The factory initializes the pool (currency0 native ETH, currency1 LKUP, fee 3000, tickSpacing 60) and seeds one-sided LKUP liquidity, so nothing in the hook may revert that initialize or that liquidity add (launch 138 was parked when a beforeInitialize gate reverted the factory), and the first buy lands in a pool that holds no ETH. All state is keyed by PoolId; a pool on this hook whose currency0 is not native ETH gets zero deltas and no other effect. Every callback requires msg.sender == PoolManager. Tests (Foundry, a real v4-core PoolManager deployed in the test, hook at a mined address): a launch rehearsal that initializes at the manifest price, seeds one-sided LKUP liquidity like the factory and makes the first buy into the ETH-less pool; exact-in and exact-out in both directions; dust amounts; a pool whose currency0 is not ETH; direct callback calls from a non-PoolManager address revert; fuzzed sizes; and specifically: removal at unlockAt minus 1 second reverts and at exactly unlockAt passes; a top-up restarts the lock; fee collection (delta 0) works while locked; two PositionManager NFTs on the same range lock independently; the factory-style seed add succeeds; swaps and donations are unaffected. An independent adversarial review (read-only) must attack: every path that removes liquidity (PositionManager decrease and burn, multicall, delta 0), whether any path can lock liquidity forever or lock someone else's position, the shared-router grief, position-key derivation, and that afterAddLiquidity can never revert the factory's seed add. It reports each finding with the exact call sequence that triggers it. Website: one static page (dist/index.html) that reads the hook's views and events and pool and position state through Uniswap's Sepolia StateView 0xe1dd9c3fa50edb962e442f60dfbc432e24537e4c, and sends every liquidity action through Uniswap's published Sepolia PositionManager 0x429ba70129df741b2ca2a85bc3a2a3328e5c09b4 (has code, poolManager() is the PoolManager above; never the unguarded PoolModifyLiquidityTest, whose positions anyone can remove). It shows each position's unlock date and time left (from Locked events, with current liquidity read through StateView), the pool's total liquidity still locked, a lookup by PositionManager tokenId, and for the connected wallet's own PositionManager positions (Locked events whose sender is the PositionManager and whose salt, read as a tokenId, has ownerOf equal to the wallet) a remove button that shows the unlock time and is disabled until then (adding liquidity is left to any v4 PositionManager client and explained in the README, keeping the site small).

Release Drip (ERC-20 symbol DRIP) on Sepolia as an evm_project: the fixed-supply launch token plus one application contract. Token: Drip (DRIP), total supply 1,000,000,000 DRIP with 18 decimals, minted once to the deployer. Application contract: TokenFaucet. Currency: the faucet holds any ERC-20 donated to it; DRIP is the featured token. TokenFaucet takes the DRIP address as its only constructor argument (constructorArgs ["$token"]) and exposes it as featuredToken() for the site's default; it holds no DRIP at deploy (DRIP comes from swapping Sepolia ETH in the launch pool). Payments in use SafeERC20.safeTransferFrom; there is no payable function and no owner, admin or withdraw-all path. donate and claim follow checks-effects-interactions and are nonReentrant. donate(token, amount) pulls amount and records the amount actually received (balance delta) as the donor's total for that token; zero received reverts. claim(token): each address may claim a given token once per 24 hours (block.timestamp >= lastClaim + 24 hours, first claim always allowed). The claim amount is 100 whole tokens, 100 * 10^decimals() read through IERC20Metadata (tokens whose decimals() reverts or exceeds 30 are unsupported and claim reverts); if the faucet holds less, the claim pays whatever it holds, and an empty faucet reverts. Claims transfer directly to the caller. The claimable pool is simply the faucet's balance of that token, so tokens sent without donate() are also claimable and nothing is stranded. Donations are final (donors cannot withdraw). Donors are listed per token without duplicates: donorCount(token), donors(token, offset, limit) (limit capped at 100; offset past the end returns empty), donatedBy(token, donor). nextClaimAt(token, account) and claimAmount(token) are views. A Sepolia test toy: the README and the page say anyone can claim from many addresses (a test faucet, not a fair or valuable distribution) and that each token's own balanceOf and transfer are trusted, so a malicious token can only hurt its own pool. Events: Donated(token, donor, amount), Claimed(token, claimer, amount). Tests (Foundry) must cover: the 24-hour cooldown at its exact boundary and per token, 6- and 18-decimal tokens, a partial last claim, an empty faucet, fee-on-transfer donations recorded net, donor de-duplication, and a reverting-decimals token. The independent adversarial review must attack: reentrancy through a malicious token in donate or claim, decimals() manipulation to claim huge amounts, cooldown bypass across tokens, and donor-list growth being used to grief the paginated view. Deploy through the project factory, then publish a one-page website to pick a token (DRIP by default, or paste an address), show the faucet balance and your next claim time, claim, donate (with an approve step) and page through the donor list. Lists come from contract views and events only (no backend, no indexer). Keep it to one small page; the static export has index.html in dist/.

Release Volume (token symbol VOLM) on Sepolia as a univ4_hook launch. Token: Volume (VOLM), total supply 1,000,000,000 VOLM with 18 decimals, minted once to the deployer. Hook: VolumeLeaderboardHook, a Uniswap v4 hook on the token's native-ETH pool that runs a weekly volume race. Fee: 30 bps (0.3%) of every swap's ETH leg (mechanics below) into the pot of that pool's current epoch. Epochs: epoch = (block.timestamp - DEPLOY_TIME) / 7 days, DEPLOY_TIME being block.timestamp in the constructor; a swap at exactly a boundary belongs to the new epoch. Volume: the ETH leg is added to the identity's volume for that pool and epoch; a swap with no identity pays the fee but credits nobody. Leaderboard: each pool and epoch keeps an on-chain top 5 (address, volume), updated in O(5) on every credited swap; an address already on it is updated in place and re-sorted, and entering or passing needs a strictly greater volume, so ties keep the earlier address ahead. Payout: once an epoch has ended, anyone may call claim(poolKey, epoch, rank) to pay that rank's recorded address 40/25/15/10/10% of the pot for ranks 1-5, each floor-rounded and paid once. finalize(poolKey, epoch), callable once by anyone after the epoch ends, moves the shares of empty ranks (fewer than 5 credited addresses, or none) plus the rounding remainder into the pot of the epoch current at that call, so every pot is paid or carried in full. An ended epoch's pot is frozen; claim and finalize work in either order. A recipient that rejects ETH only leaves its own share claimable. Events: Credited, Claimed, EpochFinalized. Views: epochNow(), epochEnd(epoch), leaderboard(poolId, epoch) with addresses, volumes, pot and claimed flags, volumeOf(poolId, epoch, user). Economics for the README: wash volume costs the 0.3% LP fee plus the 0.3% hook fee on every leg, so it pays only when the pot other traders funded exceeds that cost. ETH-leg fee mechanics (as live launch 170's MedallionHook): a buy is zeroForOne (ETH in), a sell oneForZero (ETH out), and the swapper's specified amount is always honoured exactly. With ETH specified (exact-in buys, exact-out sells) the fee is a positive specified BeforeSwapDelta in beforeSwap of floor(|amountSpecified| x bps / 10,000); with ETH unspecified (exact-out buys, exact-in sells) it is a positive unspecified delta in afterSwap of floor(ETH the pool moved x bps / 10,000). That fee base is the swap's ETH leg. A partial fill (price limit hit) reverts with PartialFill. The hook settles each fee by minting itself ERC-6909 ETH claims (poolManager.mint) inside the swap, never take() or an ETH transfer in a callback, so the first buy into the ETH-less pool works; every payout burns claims and takes ETH in the hook's own unlockCallback, balance zeroed first (CEI). A fee that rounds to 0 is 0, so dust never reverts. Invariant: the hook's ETH claims at the PoolManager equal everything it still owes. Identity: the address abi.decode(hookData, (address)) when hookData is exactly 32 bytes and non-zero; any other swap credits nobody. Deploy shape (as live Sepolia hook launches 170, 183 and 186, constructor per the context): every rate, window and threshold is a source constant; no admin, setter, pause, upgrade or sweep. Permissions are exactly beforeSwap, afterSwap, beforeSwapReturnDelta and afterSwapReturnDelta (address bits 0x00CC), all others false, checked by Hooks.validateHookPermissions in the constructor with a CREATE2 salt mined for those bits. The factory initializes the pool (currency0 native ETH, currency1 VOLM, fee 3000, tickSpacing 60) and seeds one-sided VOLM liquidity; the hook must revert neither, and the first buy lands in a pool with no ETH. State is keyed by PoolId; a pool whose currency0 is not native ETH gets zero deltas and no other effect. Every callback requires msg.sender == PoolManager. Tests (Foundry, a real v4-core PoolManager deployed in the test, hook at a mined address): a launch rehearsal that initializes at the manifest price, seeds one-sided liquidity like the factory and makes the first buy into the ETH-less pool; all four swap modes; dust; a non-ETH pool; non-PoolManager callers revert; fuzzed sizes; and the cases the build step lists (epoch boundary, ties, 0/1/5+ participants, claims plus carry equal the pot). The independent adversarial review (read-only) attacks top-5 maintenance, the epoch boundary, pot and carry accounting, fee sign and rounding, and wash trading or hookData spoofing; its step lists each target. Website: one static page (dist/index.html) reading the hook's views and events, with a buy/sell form that swaps through the Sepolia PoolSwapTest router named in the site step and puts the connected wallet in hookData; it shows the live top 5, pot and countdown of the current epoch, and the last 4 ended epochs with a claim button per unpaid rank and a finalize button. Volume is a Sepolia test toy: its token and any pot have no value, and nothing here promises a return.

Build a staking system as three contracts written in parallel by different workers, then integrate and test them.

Release Billboard (ERC-20 symbol BILL) on Sepolia as an evm_project: the fixed-supply launch token plus one application contract. Token: Billboard (BILL), total supply 1,000,000,000 BILL with 18 decimals, minted once to the deployer. Application contract: HarbergerBillboard. Currency: BILL is the app's working currency. HarbergerBillboard takes the BILL address as its only constructor argument (constructorArgs ["$token"]), stores it immutable, exposes it as token(), and holds no BILL at deploy; players get BILL by swapping Sepolia ETH in the launch pool the factory seeds. Every payment in is approve + SafeERC20.safeTransferFrom (permit not required). HarbergerBillboard has no payable function and no receive/fallback, so it never holds ETH. Payouts are pull-based (the recipient calls to collect; nothing is pushed to third parties), follow checks-effects-interactions and are nonReentrant. Burns are transfers to 0x000000000000000000000000000000000000dEaD. No owner, admin, pause or upgrade path. One billboard under a Harberger tax, all in BILL. State: holder, message (bytes32), price (self-assessed, in BILL), deposit, lastSettled. Tax is 10% of price per 365 days, accrued per second: due = ceil(price * elapsed * 1000 / (365 days * 10000)); taxes are burned (no owner receives them). settle() (anyone, and first inside every other state-changing call) burns min(due, deposit); if due >= deposit the billboard is foreclosed: holder, message and price reset and the deposit is gone. buy(newPrice, maxPrice, newMessage, depositAmount): the caller must not be the holder, newPrice between 1 and 1,000,000,000 BILL, depositAmount > 0, and the current price must be <= maxPrice (protects against a holder front-running with a price raise); the caller pays price + depositAmount; the old holder is credited the price plus their remaining deposit; an empty or foreclosed billboard costs 0 (only the deposit). The holder may setPrice(newPrice) (same bounds), setMessage(message), addDeposit(amount) and withdrawDeposit(amount) (after settling, never below zero; withdrawing everything is allowed and forecloses at the next settle). withdraw() pays credited BILL. Views: state(), taxDue(), runwaySeconds(), withdrawable(address), token(). Events: Bought(holder, price, deposit, message), PriceChanged, MessageChanged, DepositChanged, TaxBurned(amount), Foreclosed, Withdrawn. Tests (Foundry) must cover: tax accrual with rounding up, foreclosure exactly when the deposit runs out, buy with maxPrice below a just-raised price reverting, buying an empty billboard, self-buy refused, withdrawDeposit bounds, and, under fuzzed call sequences with warped time, the invariants that BILL held equals the holder's deposit + withdrawable balances (taxes are burned, never held) and that no settle burns more than the deposit it found. The independent adversarial review must attack: tax rounding and elapsed-time arithmetic, front-running a buyer with setPrice, a holder avoiding tax by withdrawing their deposit just before a buy, foreclosure mid-buy, and reentrancy on withdraw. Deploy through the project factory, then publish a one-page website to show the message, holder, price, deposit, tax rate and runway countdown, a buy form with a max price, and holder controls. The page reads the BILL address from HarbergerBillboard.token(), shows the connected wallet's BILL balance, allowance and withdrawable balance, has an Approve step before every paying action and a Withdraw button, and says that BILL comes from swapping Sepolia ETH in the launch pool (no in-page swap). Lists come from contract views and events only (no backend, no indexer). Keep it to one small page; the static export has index.html in dist/.

Release Receipts (token symbol RCPT) on Sepolia as a univ4_hook launch. Token: Receipts (RCPT), total supply 1,000,000,000 RCPT with 18 decimals, minted once to the deployer (a separate zero-argument ERC-20, no mint, owner or admin). Hook: SwapReceiptHook, a Uniswap v4 hook on the token's native-ETH pool that is also an ERC-721 (OpenZeppelin ERC721; collection name "Swap Receipts" and symbol "SWAPRCPT" are string literals in source, not constructor arguments). In afterSwap, every buy (zeroForOne) whose ETH paid, |delta.amount0()| as the pool settled it (so exact-in and exact-out count alike), is at least 0.001 ETH mints one receipt to the hookData address (identity rule below); smaller buys, buys without a valid hookData address and sells mint nothing. Ids start at 1 and rise by one. Each receipt stores ethPaid (uint128), tokensReceived (uint128, |delta.amount1()|), the pool's token (currency1), blockNumber and timestamp, and emits Receipt(id, owner, poolId, ethPaid, tokensReceived, blockNumber). Receipts are soulbound: transfers, safeTransfers, approve and setApprovalForAll revert (override _update so only mints pass) and there is no burn. Minting uses _mint, never _safeMint, so a contract recipient cannot revert a swap, and the minting afterSwap stays under 200,000 gas (a first mint to a new owner writes about six fresh storage slots, so 100,000 cannot hold). tokenURI(id) returns base64 on-chain JSON with an SVG showing the id, ETH paid (6 decimals), tokens received (whole tokens), token address and block, and reverts for ids that do not exist. Views: totalMinted(), receiptOf(id), receiptsOf(owner, offset, limit) backed by a per-owner id list. No fee, no funds held, no admin. Receipts from other ETH pools on this hook record their own token, and the site shows only the launch token's. Identity: the credited address is abi.decode(hookData, (address)) when hookData is exactly 32 bytes and non-zero; otherwise the swap credits nobody. As the context requires, there is no router-sender fallback: a router is a contract that could never claim. hookData is not authenticated: anyone can credit any address; say so in NatSpec and the README. Deploy shape, matching the live Sepolia hook launches 170, 183 and 186 (launch 168 passed the mainnet PoolManager and is not a model): SwapReceiptHook's only constructor argument is the Sepolia PoolManager 0xE03A1074c86CFeDd5C142C4F04F1a1536e203543; every rate, window and threshold here is a source constant; there is no owner, admin, setter, pause, upgrade or sweep, and no $owner or $token argument. Permissions are exactly afterSwap (low address bits 0x0040), all others false; the constructor calls Hooks.validateHookPermissions and the CREATE2 salt is mined for those bits. The factory initializes the pool (currency0 native ETH, currency1 RCPT, fee 3000, tickSpacing 60) and seeds one-sided RCPT liquidity, so nothing in the hook may revert that initialize or that liquidity add (launch 138 was parked when a beforeInitialize gate reverted the factory), and the first buy lands in a pool that holds no ETH. All state is keyed by PoolId; a pool on this hook whose currency0 is not native ETH gets zero deltas and no other effect. Every callback requires msg.sender == PoolManager. Tests (Foundry, a real v4-core PoolManager deployed in the test, hook at a mined address): a launch rehearsal that initializes at the manifest price, seeds one-sided RCPT liquidity like the factory and makes the first buy into the ETH-less pool; exact-in and exact-out in both directions; dust amounts; a pool whose currency0 is not ETH; direct callback calls from a non-PoolManager address revert; fuzzed sizes; and specifically: a buy of exactly 0.001 ETH mints and 0.001 ETH minus 1 wei does not; exact-out buys use the settled ETH; a contract recipient without onERC721Received still gets its receipt; every transfer and approval path reverts; tokenURI decodes to JSON carrying the stored numbers; sells and buys without hookData mint nothing; the minting afterSwap stays under 200,000 gas. An independent adversarial review (read-only) must attack: whether any input can make afterSwap revert and so block buys (storage, tokenURI, id growth, contract recipients); whether any transfer or operator path survives the soulbound override; under- or over-counting of ethPaid on exact-out and partial fills; and the unauthenticated-hookData spam (anyone can mint receipts to anyone for 0.001 ETH plus fees), which must be documented rather than silently accepted. It reports each finding with the exact call sequence that triggers it. Website: one static page (dist/index.html) that reads the hook's views and events and the pool price through Uniswap's Sepolia StateView 0xe1dd9c3fa50edb962e442f60dfbc432e24537e4c, with a buy/sell form that swaps through Uniswap's published Sepolia PoolSwapTest router 0x9b6b46e2c869aa39918db7f52f5557fe577b6eee (has code; manager() is the PoolManager above) and puts the connected wallet in hookData. It shows a wallet's receipts gallery (connected or pasted address, rendering tokenURI images) and the latest 12 mints.

Build two ERC-4626 vaults over the same mock 18-decimal ERC-20 and measure the first-depositor (donation) inflation attack against each.

Release Circle (ERC-20 symbol CIRC) on Sepolia as an evm_project: the fixed-supply launch token plus one application contract. Token: Circle (CIRC), total supply 1,000,000,000 CIRC with 18 decimals, minted once to the deployer. Application contract: SavingsCircle. Currency: CIRC is the app's working currency. SavingsCircle takes the CIRC address as its only constructor argument (constructorArgs ["$token"]), stores it immutable, exposes it as token(), and holds no CIRC at deploy; members get CIRC by swapping Sepolia ETH in the launch pool the factory seeds. Every payment in is approve + SafeERC20.safeTransferFrom (permit not required). SavingsCircle has no payable function and no receive/fallback, so it never holds ETH. Payouts are pull-based (the recipient calls to collect; nothing is pushed to third parties), follow checks-effects-interactions and are nonReentrant. No owner, admin, pause or upgrade path. A rotating savings circle (ROSCA) in CIRC, many circles by id. create(contribution, roundLength, seats): contribution >= 1 CIRC, roundLength 1 hour to 30 days, seats 2 to 10; the creator takes seat 0. join(id) takes the next free seat (one seat per address) until full. Joining (including the creator's seat) pulls a bond of (seats - 1) x contribution, so defaulting after being paid never profits in any seat. If a circle is not full within 7 days of creation, anyone may cancel it and every bond becomes withdrawable. When the last seat fills, round 0 starts at that block; round r runs [start + r * roundLength, start + (r + 1) * roundLength). contribute(id): once per member per round, only inside the current round, pulls exactly contribution. A member who does not contribute in some round is in default from then on: further contribute calls revert and they lose any later turn. Seat r receives round r: after round r ends, anyone may call closeRound(id, r) (rounds close in order). If seat r contributed in every round 0..r, the round's pot (that round's contributions plus any carry) is credited to seat r; otherwise the pot carries into round r + 1. After the last round closes: members never in default get their bond back; the final carry plus forfeited bonds are split equally among members never in default, or, if none, among members who contributed at least once (remainder wei to the lowest such seat); if nobody ever contributed, every bond is returned to its member. withdraw() pays credited CIRC. Views: circle(id), circleCount(), member(id, seat), inDefault(id, account), currentRound(id), token(). Events: Created, Joined, Cancelled, Contributed(id, round, member), RoundClosed(id, round, recipient, pot, carried), Finalized. Tests (Foundry) must cover: seat limits, the 7-day cancel, round windows at their exact edges, a missed round forfeiting a later turn and carrying the pot, closing rounds out of order, the final split with and without members in good standing, a circle where nobody contributes, and the invariant that CIRC held equals bonds held + open pots + carry + withdrawable balances. The independent adversarial review must attack: an early recipient defaulting after being paid (show the (seats - 1) x contribution bond makes that unprofitable for every seat), double contribution or double payout in one round, closing a round early, and remainder or carry arithmetic at the final split. Deploy through the project factory, then publish a one-page website to open a circle, join (approve the bond), contribute each round, and see seats, whose turn it is, who is in default and the pot. The page reads the CIRC address from SavingsCircle.token(), shows the connected wallet's CIRC balance, allowance and withdrawable balance, has an Approve step before every paying action and a Withdraw button, and says that CIRC comes from swapping Sepolia ETH in the launch pool (no in-page swap). Lists come from contract views and events only (no backend, no indexer). Keep it to one small page; the static export has index.html in dist/.

Release Takeprofit (token symbol TKPF) on Sepolia as a univ4_hook launch. Token: Takeprofit (TKPF), total supply 1,000,000,000 TKPF with 18 decimals, minted once to the deployer. Hook: TakeProfitHook, a Uniswap v4 hook on the token's native-ETH pool. (Named TakeProfitHook, not LimitOrderHook, so its artifact name does not collide with the OpenZeppelin base contract it extends.) Deployment: the constructor takes one argument, the Sepolia PoolManager 0xE03A1074c86CFeDd5C142C4F04F1a1536e203543, passed as a literal in launch.json constructorArgs; getHookPermissions() returns exactly afterInitialize and afterSwap and every other flag false (address bits 0x1040 under mask 0x3FFF), validated in the constructor; the factory mines the CREATE2 salt. The factory's pool is currency0 = native ETH, currency1 = TKPF, LP fee 3000, tickSpacing 60, seeded with TKPF only, so the first buy lands in a pool holding no ETH and must work. State is keyed by PoolId; the base bookkeeping runs on any pool, but placeTakeProfit and the overridden placeOrder accept only pools whose currency0 is native ETH. 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: TakeProfitHook extends OpenZeppelin uniswap-hooks' LimitOrderHook (in the template's lib/uniswap-hooks) and only allows take-profit orders that sell TKPF for ETH. placeTakeProfit(PoolKey key, int24 tick, uint256 amount): tick must be a multiple of 60 strictly below the pool's current tick range (a range made only of TKPF); the hook computes the liquidity for `amount` TKPF over [tick, tick + 60] and calls the base placeOrder with zeroForOne = false, pulling TKPF from the caller (approve the hook first). Orders that would sell ETH (zeroForOne = true) revert, because the base settles native ETH from the hook's own balance and placeOrder is not payable. Buys push the tick down; when a swap fully crosses an order's range, the base afterSwap removes that tick's pooled liquidity, marks the order filled and holds the proceeds as ERC-6909 claims; each owner withdraws its pro-rata ETH (and any fees) with withdraw(orderId, to). A range the price is still inside is not filled. cancelOrder returns the owner's share of an unfilled order (TKPF, plus ETH if partly crossed). Orders placed at one tick share an order id until it fills; later orders there get a new id. Gas: afterSwap walks every 60-tick step the swap crossed, and the launch pool is one-sided, so a big buy can cross hundreds of steps; measure it and document the largest swap that fits comfortably in a block. Views: the base getOrderId, getOrderInfo, getOrderLiquidity and getTickLowerLast, plus liquidityForAmount(tick, amount). Tests must show: valid and invalid ticks (in range, wrong side, not a multiple of 60), ETH-side orders refused, a partial cross not filling, a full cross filling and paying about the expected ETH, two owners at one tick paid pro rata, cancel before and after a partial cross, double withdraw reverting, and gas for a buy crossing 100 steps. The independent adversarial review must attack: assumptions inherited from the base (fee attribution on cancel, rounding in withdraw), the ETH-side restriction, unbounded afterSwap gas, and whether a manipulator can fill orders and swap back at the owners' expense. Then a small website that shows the current price (TKPF per ETH and ETH per TKPF), lets a wallet place a take-profit order from a target price (rounded to the nearest valid tick below, approve TKPF first), lists its orders from Place, Fill and Cancel events with status, and offers cancel and withdraw. 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/.

Implement WorkerWallet in src/WorkerWallet.sol

An ERC-1271 contract wallet that holds an ERC-721 seat and lets a rotating worker key sign for it on a set of allowed EIP-712 applications, while the worker can never move assets.

Release Geomean (token symbol GEOM) on Sepolia as a univ4_hook launch. Token: Geomean (GEOM), total supply 1,000,000,000 GEOM with 18 decimals, minted once to the deployer. Hook: GeomeanOracleHook, 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 afterInitialize and beforeSwap and every other flag false (address bits 0x1080 under mask 0x3FFF), validated in the constructor; the factory mines the CREATE2 salt. The factory's pool is currency0 = native ETH, currency1 = GEOM, LP fee 3000, tickSpacing 60, seeded with GEOM only, so the first buy lands in a pool holding no ETH and must work. State is keyed by PoolId; the base records any pool that uses the hook, which is harmless because every read names a PoolId. 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. Novelty note: launch 33 already built a hand-ported v3 tick oracle (afterInitialize + afterSwap). This hook is deliberately different: it extends OpenZeppelin uniswap-hooks' BaseOracleHook (the Panoptic-derived truncated oracle shipped in the template's lib/uniswap-hooks), writes observations in beforeSwap, and keeps a truncated series in which each observation's tick may move at most MAX_ABS_TICK_DELTA = 9,116 ticks from the previous one. That value is a literal in the constructor's call to the base, because an int24 cannot be a manifest argument. Behaviour: afterInitialize writes the first observation; beforeSwap writes at most one observation per pool per block, before the swap moves the price, and always returns zero deltas and no fee override, so it never changes a swap's outcome and never reverts it. Reads: the base's observe(uint32[] secondsAgos, PoolId) returning standard and truncated tick cumulatives, plus consult(PoolId, uint32 secondsAgo) returning (meanTick, truncatedMeanTick) as time-weighted arithmetic means of tick (geometric mean price) over [now - secondsAgo, now], rounded toward negative infinity as v3's OracleLibrary does; secondsAgo 0 reverts, and a window older than the oldest observation reverts. Anyone may call increaseObservationCardinalityNext(n, poolId) to grow the ring buffer at their own gas cost; the buffer starts at 1 slot. Views: observationState(poolId) (index, cardinality, cardinalityNext). Tests must show, across warped blocks: consult matches hand-computed means for both series; one huge single-block swap moves the standard mean far more than the truncated mean; only one observation per block; a too-old window reverts; cardinality growth takes effect after the next write; and swaps settle identically with or without the hook. The independent adversarial review must attack: truncation arithmetic, negative-tick rounding, uint32 timestamp wrap, a beforeSwap path that could revert and brick the pool, and cardinality growth griefing. Then a small website that charts TWAP price (GEOM per ETH and ETH per GEOM) over 1h, 6h and 24h windows for both series, sampled with one observe() call per window, shows 'not enough history' when a window is older than the buffer, and shows the buffer size with a button to grow it. 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/.

Release Heartbeat (ERC-20 symbol BEAT) on Sepolia as an evm_project: the fixed-supply launch token plus one application contract. Token: Heartbeat (BEAT), total supply 1,000,000,000 BEAT with 18 decimals, minted once to the deployer. Application contract: DeadMansSwitch. Currency: DeadMansSwitch holds only Sepolia test ETH and never touches BEAT. It is a Sepolia test toy, not a custody or inheritance product, and the README and the page say so. DeadMansSwitch has no constructor arguments (constructorArgs []), no owner, admin, pause or upgrade path. Many switches by id (from 1). create(beneficiary, period) payable (msg.value may be 0; the depositor can fund later): period 1 day to 365 days in seconds, beneficiary non-zero and not the caller; the caller is the depositor and lastPing = block.timestamp. A switch lapses when block.timestamp >= lastPing + period. Before the lapse, and only from the depositor: ping(id), deposit(id) (payable, > 0), withdraw(id, amount) (0 < amount <= balance), setBeneficiary(id, newBeneficiary) (non-zero, not the depositor) and setPeriod(id, period) (same bounds); each also sets lastPing = block.timestamp. From the lapse on those calls revert, and the beneficiary may claim(id, to) (to != address(0), so a beneficiary contract that cannot take ETH can name another address), which sends the whole balance (possibly 0) to to. Recovery so nothing is stranded by a lost beneficiary key: if a lapsed switch is still unclaimed at lastPing + period + 365 days, the depositor may reclaim(id, to), which does the same for the depositor; from then on whichever of claim and reclaim lands first wins. claim and reclaim close the switch: its balance is zeroed and every later call on it reverts. withdraw, claim and reclaim follow checks-effects-interactions, are nonReentrant, send with call and revert entirely if the send fails. Nothing else can move a switch's ETH; plain ETH sent to the contract reverts (no receive/fallback). Views: switchInfo(id) (depositor, beneficiary, balance, period, lastPing, closed), switchCount(), timeLeft(id) (0 once lapsed). Events (depositor and beneficiary indexed): Created, Pinged, Deposited, Withdrawn, BeneficiaryChanged(id, depositor, newBeneficiary), PeriodChanged, Claimed(id, beneficiary, to, amount), Reclaimed(id, depositor, to, amount). Tests (Foundry) must cover: the lapse boundary (a ping at lastPing + period - 1 works; at lastPing + period it reverts and claim works), the reclaim boundary at lastPing + period + 365 days, period bounds, calls from non-depositors and non-beneficiaries, beneficiary and period changes resetting the clock, partial and full withdraws, claim to another address, any call after a switch is closed, a receiver that reverts, and the invariant that the contract's ETH equals the sum of open switch balances. The independent adversarial review must attack: the depositor/beneficiary race at the lapse boundary and at the reclaim boundary, reentrancy on withdraw, claim and reclaim, a third party keeping a switch alive or claiming it, and cross-switch balance leaks. Deploy through the project factory, then publish a one-page website to show each switch of the connected account (as depositor or beneficiary, from Created and BeneficiaryChanged events) with its time left, and ping, deposit, withdraw, change beneficiary or period, claim and reclaim. Lists come from contract views and events only (no backend, no indexer). The page shows a banner that it is a Sepolia test toy. Keep it to one small page; the static export has index.html in dist/.

Build a compact Governor stack in the three listed files

Hand-written with OpenZeppelin v5 semantics but without importing it.

Release Keyring (ERC-20 symbol KEYR) on Sepolia as an evm_project: the fixed-supply launch token plus one application contract. Token: Keyring (KEYR), total supply 1,000,000,000 KEYR with 18 decimals, minted once to the deployer. Application contract: KeyringMultisig, one contract that keeps many 2-of-3 wallets as ids in its own storage (it deploys no contracts). Currency: each wallet holds native ETH and KEYR, the launch token. KeyringMultisig takes the KEYR address as its only constructor argument (constructorArgs ["$token"]), stores it immutable, exposes it as token(), and holds nothing at deploy; KEYR comes from swapping Sepolia ETH in the launch pool the factory seeds. No owner, admin, pause or upgrade path. createWallet(owner1, owner2, owner3): anyone; the three owners must be distinct and non-zero (the caller need not be one); wallet ids start at 1. depositEth(id) (payable, msg.value > 0) and depositToken(id, amount) (amount > 0, approve + SafeERC20.safeTransferFrom, credited with the amount actually received) are open to anyone and revert for an id that does not exist, so nothing can be deposited into a wallet without owners. Plain ETH sent to the contract reverts (no receive/fallback); KEYR transferred without depositToken is untracked and unrecoverable (README says so). propose(id, isToken, to, value): an owner proposes sending value wei of ETH (isToken false) or value base units of KEYR (isToken true) to to (to != address(0), value > 0, no calldata); proposal ids are per wallet and start at 1; the proposer's confirmation is recorded automatically; the proposal can be confirmed and executed only while block.timestamp < createdAt + 7 days. confirm(id, pid) and revoke(id, pid): owners of that wallet only, before execution and expiry; confirm reverts if that owner already confirmed, revoke if they have not. execute(id, pid): any owner of that wallet, once at least 2 of its owners are currently confirmed, before expiry, not yet executed, and value <= that wallet's balance of that asset; it is nonReentrant, marks the proposal executed and debits the wallet before the transfer (ETH with call, KEYR with SafeERC20.safeTransfer), and reverts entirely if the transfer fails (the proposal stays executable until it expires). Proposals reserve nothing: balances move only on execute, and an expired proposal simply cannot run, so any two owners can always move a wallet's funds with a new proposal. A wallet can only ever spend its own balances. Views: wallet(id) returns (owners, ethBalance, tokenBalance); walletCount(); proposalCount(id); proposal(id, pid); isConfirmed(id, pid, owner); token(). Events: WalletCreated(id, owner1, owner2, owner3) with the three owners indexed, Deposited(id, from, isToken, amount), Proposed(id, pid, proposer, isToken, to, value), Confirmed(id, pid, owner), Revoked(id, pid, owner), Executed(id, pid, to, isToken, value). Tests (Foundry) must cover: duplicate or zero owners, deposits to an unknown id, non-owner propose/confirm/revoke/execute, double confirmation, revoking an unconfirmed proposal, revoke dropping below 2, execution at and after the 7-day boundary, execution exceeding the wallet's balance of either asset, a KEYR proposal, a recipient that reverts or re-enters, and the invariants that the contract's ETH equals the sum of wallet ETH balances and its KEYR is at least the sum of wallet KEYR balances. The independent adversarial review must attack: one wallet spending another wallet's ETH or KEYR, crossing the ETH and KEYR ledgers, double execution through reentrancy in the recipient call, revoked or duplicate confirmations still counting, and proposal id reuse across wallets. Deploy through the project factory, then publish a one-page website to create a wallet, list the connected account's wallets from WalletCreated events, deposit ETH or KEYR, propose, confirm, revoke and execute. The page reads the KEYR address from KeyringMultisig.token(), shows the connected wallet's KEYR balance and allowance, has an Approve step before a KEYR deposit, and says that KEYR comes from swapping Sepolia ETH in the launch pool (no in-page swap). Lists come from contract views and events only (no backend, no indexer). Keep it to one small page; the static export has index.html in dist/.

Release Last Buyer (token symbol LBUY) on Sepolia as a univ4_hook launch. Token: Last Buyer (LBUY), total supply 1,000,000,000 LBUY with 18 decimals, minted once to the deployer. Hook: LastBuyerJackpotHook, 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 = LBUY, LP fee 3000, tickSpacing 60, seeded with LBUY 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. A Sepolia test toy with no value; say so on the site. Behaviour: every exact-input buy (zeroForOne, amountSpecified < 0) pays 1% (100 bps, floor) of its LBUY output into the pool's jackpot: afterSwap returns that fee as a positive hookDeltaUnspecified and settles it by minting the hook ERC-6909 claims (poolManager.mint(address(this), currency1.toId(), fee)), so the jackpot is held as LBUY claims at the PoolManager, as the context requires. Sells and exact-output buys pay nothing and change nothing. A buy qualifies for the round when |amountSpecified| >= 0.001 ETH and hookData is exactly 32 bytes that abi-decode to a non-zero address: that address becomes lastBuyer and lastBuyAt = block.timestamp. Any other hookData (empty, wrong length, zero address) never reverts the swap; the buy still pays the fee but does not qualify. As the context requires, there is no fallback to the router sender: a router cannot claim. hookData is unauthenticated, so a buyer may name any address; that only gifts the round to that address. For wallets, the hook also offers buy(PoolKey key, uint256 minOut) payable: an exact-input buy of msg.value through poolManager.unlock that passes abi.encode(msg.sender) as hookData (so the buyer is authenticated on this path), settles the ETH it spent, refunds any unspent ETH, sends the LBUY to msg.sender and reverts if it receives less than minOut. claim(PoolKey key): anyone, once lastBuyer != 0 and block.timestamp >= lastBuyAt + 3,600; resets jackpot and lastBuyer and increments the round first, then through poolManager.unlock burns the jackpot's claims and takes that LBUY to lastBuyer. With no qualifying buy the jackpot simply grows. Views: jackpot(poolId), lastBuyer(poolId), lastBuyAt(poolId), round(poolId), claimableAt(poolId). Events: JackpotFed(poolId, amount), NewLeader(poolId, buyer, round), JackpotClaimed(poolId, winner, amount, round). Tests must show: the fee on exact-input buys only, qualification for each hookData shape and the 0.001 ETH edge, the timer at 3,599 and 3,600 seconds, a buy in the claim block resetting the timer, claim paying lastBuyer whoever calls, buy() with minOut, and the invariant PoolManager.balanceOf(hook, currency1 id) == sum of jackpots. The independent adversarial review must attack: hookData decoding (a malformed payload must not brick swaps), delta sign, spoofed buyers, claim timing races, buy() and claim() settlement in the unlock callback (which must tell the two apart), and any way to drain the jackpot. Then a small website that shows the jackpot in LBUY, the last buyer, the countdown, a buy form that calls buy() (ETH amount, slippage-based minOut) and a claim button. 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/.

Implement an ERC-4337 v0.7 SimpleAccount and VerifyingPaymaster in the two listed files, following eth-infinitism account-abstraction v0.7.0.

Release Ratelimit (token symbol RATE) on Sepolia as a univ4_hook launch. Token: Ratelimit (RATE), total supply 1,000,000,000 RATE with 18 decimals, minted once to the deployer. Hook: SwapRateLimitHook, a Uniswap v4 hook on the token's native-ETH pool (currency0 native ETH, currency1 RATE, LP fee 3000, tickSpacing 60; the factory seeds one-sided RATE liquidity, so the first buy lands in a pool holding no ETH). In v4, amountSpecified < 0 is exact input and zeroForOne is a buy (ETH in, RATE out). The hook extends v4-periphery BaseHook; constructor (IPoolManager poolManager) with the Sepolia PoolManager 0xE03A1074c86CFeDd5C142C4F04F1a1536e203543. getHookPermissions enables exactly beforeSwap only (no deltas, no fees); the manifest lists the same set. State is keyed by PoolId, so any pool may attach the hook. No owner, no admin. Rule: at most 3 swaps per pool per block. beforeSwap keeps (uint64 blockNumber, uint8 count) per PoolId, resets when block.number changes, and reverts RateLimited(blockNumber) on the 4th and later swap in the block, whatever the router, sender or size; a transaction that batches four swaps reverts as a whole. Liquidity changes and donations are not counted. Events: SwapCounted(PoolId indexed poolId, uint256 blockNumber, uint8 count). View: swapsInBlock(PoolId) -> (uint256 currentBlock, uint8 used, uint8 remaining), where currentBlock = block.number, used is the stored count if the stored block is the current one and 0 otherwise, and remaining = 3 - used. Tests run against a real v4-core PoolManager and include a launch rehearsal: one-sided RATE liquidity below the opening price, a first buy into the ETH-less pool, then a sell. Acceptance: 3 swaps in a block pass and the 4th reverts; the next block resets; two pools are independent; swaps through different routers all count; adding and removing liquidity in a full block still works. Document in the README that anyone can fill the 3 slots of a block with dust swaps (cost: gas only) and that the limit is a Sepolia demo of per-block rate limiting, not spam or MEV protection. Then a small website that shows swaps used in the latest block, a per-block history of recent SwapCounted events with blocks that hit the limit flagged, and a swap form that shows the remaining slots before sending; a swap refused by the limit reverts and emits nothing. Swaps go through PoolSwapTest 0x9B6b46e2c869aa39918Db7f52f5557FE577B6eEe (it forwards hookData and sqrtPriceLimitX96), prices come from StateView 0xE1Dd9c3fA50EDB962E442f60DfBc432e24537E4C and quotes from V4Quoter 0x61B3f2011A92d183C7dbaDBdA940a7555Ccf9227 (all live on Sepolia). One page, no backend.

Release Gavel (ERC-20 symbol GAVL) on Sepolia as an evm_project: the fixed-supply launch token plus one application contract. Token: Gavel (GAVL), total supply 1,000,000,000 GAVL with 18 decimals, minted once to the deployer. Application contract: LotAuction. Currency: GAVL is the app's working currency. LotAuction takes the GAVL address as its only constructor argument (constructorArgs ["$token"]), stores it immutable, exposes it as token(), and holds no GAVL at deploy; players get GAVL by swapping Sepolia ETH in the launch pool the factory seeds. Every payment in is approve + SafeERC20.safeTransferFrom (permit not required). LotAuction has no payable function and no receive/fallback, so it never holds ETH. Payouts are pull-based (the recipient calls to collect; nothing is pushed to third parties), follow checks-effects-interactions and are nonReentrant. No owner, admin, pause or upgrade path. English auctions of ERC-20 lots with bids in GAVL. createLot(lotToken, lotAmount, reserve, duration): duration 1 hour to 7 days, reserve >= 1 GAVL; the seller's lotAmount of lotToken is pulled with safeTransferFrom and the lot records the amount actually received (balance delta, so fee-on-transfer tokens are recorded net; rebasing tokens are unsupported and the README says so); zero received reverts. lotToken may be GAVL itself; lot escrow and bid escrow are accounted separately. bid(id, amount): only before end; the first bid must be >= reserve, later bids >= ceil(highest * 105 / 100); the seller and the current highest bidder cannot bid. The previous highest bid is credited to that bidder's withdrawable GAVL. A bid placed when fewer than 10 minutes remain sets end = block.timestamp + 10 minutes. cancel(id): seller only, only before any bid and before end; the lot becomes reclaimable, and a cancelled lot then accepts no bid and cannot be settled (bid, cancel and settle all revert on a cancelled or settled lot). settle(id): anyone, once, at or after end: with a bid, the highest bid is credited to the seller and the lot becomes claimable by the winner; with no bid (reserve not met), the lot becomes reclaimable by the seller. claimLot(id) is callable only by the address the lot is owed to (the winner, or the seller after cancel or a no-bid settle) and pays it once; withdraw() pays credited GAVL. Lots are never pushed, so a lot token that reverts cannot block settlement. Views: lot(id), lotCount(), minNextBid(id), withdrawable(address), token(). Events: LotCreated, Bid(id, bidder, amount, end), Settled, LotClaimed, Withdrawn. Tests (Foundry) must cover: the reserve and ceil(105%) boundaries, the anti-snipe extension at exactly 10 minutes, cancel before and after a bid, settle with and without bids, a fee-on-transfer lot, a lot in GAVL itself, and the invariant that GAVL held >= withdrawable balances + live highest bids + unclaimed GAVL lots. The independent adversarial review must attack: a malicious or reentrant lot token, mixing GAVL lot escrow with GAVL bid escrow, repeated extension griefing, rounding of the 5% step, and settling or claiming twice. Deploy through the project factory, then publish a one-page website to browse open lots with a live countdown, create a lot (approve the lot token), bid, settle and claim. The page reads the GAVL address from LotAuction.token(), shows the connected wallet's GAVL balance, allowance and withdrawable balance, has an Approve step before every paying action and a Withdraw button, and says that GAVL comes from swapping Sepolia ETH in the launch pool (no in-page swap). Lists come from contract views and events only (no backend, no indexer). Keep it to one small page; the static export has index.html in dist/.

Release Happy Hour (token symbol HAPY) on Sepolia as a univ4_hook launch. Token: Happy Hour (HAPY), total supply 1,000,000,000 HAPY with 18 decimals, minted once to the deployer. Hook: HappyHourHook, 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 (no $owner or $token); 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 = HAPY, LP fee 3000, tickSpacing 60, seeded with HAPY 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). Tests swap through a real PoolManager; the Identity-md/univ4hook-start-template harness (BaseHookTest) provides the launch pool. No owner, admin, fee recipient, fee setter, pause or upgrade path: the fees go back to the pool's LPs. Behaviour: every swap pays a hook fee on its unspecified side: 10 bps (0.1%) during happy hour, when block.timestamp % 86,400 is in [57,600, 61,200) (16:00:00 to 16:59:59 UTC), and 100 bps (1%) at all other times. 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 by minting ERC-6909 claims (below), 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). The hook collects each fee as ERC-6909 claims with poolManager.mint(address(this), currency.toId(), fee) and adds it to accrued[poolId][currency]. donateFees(PoolKey key): anyone; requires key.hooks == this and something accrued for that pool; zeroes both accrued amounts first, then through poolManager.unlock burns those claims and calls poolManager.donate(key, accrued0, accrued1, "") so the fees go to the pool's in-range LPs; when the pool has no in-range liquidity the PoolManager reverts (NoLiquidityToReceiveFees) and the fees stay accrued. Nothing is donated inside a swap. Liquidity added just before a donateFees call captures part of it (JIT); document it rather than engineer around it. Validator timestamp skew of a few seconds at the boundaries is accepted. Views: currentFeeBps(), isHappyHour(), secondsUntilNextChange(), accrued(poolId, currency). Events: FeeTaken(poolId, currency, amount, bps), Donated(poolId, amount0, amount1). Tests must show: the fee at 15:59:59, 16:00:00, 16:59:59 and 17:00:00 UTC via vm.warp, the exact fee on all four swap types, the sum of accrued per currency == PoolManager.balanceOf(hook, id) for both currencies (invariant), donateFees raising in-range LPs' fee growth by exactly the accrued amounts and zeroing them, donateFees with nothing accrued or with no in-range liquidity reverting with the fees kept, and callbacks reverting for non-PoolManager callers. The independent adversarial review must attack: the hour boundaries, the delta sign per swap type, claims accounting and the burn/donate settlement order in donateFees, and JIT capture of donations. Then a small website that shows a UTC clock with the current fee, a countdown to the next happy hour (or to its end), accrued fees per currency and a donate-to-LPs button. 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/.

Release Momentum (token symbol MOMO) on Sepolia as a univ4_hook launch. Token: Momentum (MOMO), total supply 1,000,000,000 MOMO with 18 decimals, minted once to the deployer. Hook: MomentumFeeHook, a Uniswap v4 hook on the token's native-ETH pool (currency0 native ETH, currency1 MOMO, LP fee 3000, tickSpacing 60; the factory seeds one-sided MOMO liquidity, so the first buy lands in a pool holding no ETH). In v4, amountSpecified < 0 is exact input and zeroForOne is a buy (ETH in, MOMO out). The hook extends v4-periphery BaseHook; constructor (IPoolManager poolManager) with the Sepolia PoolManager 0xE03A1074c86CFeDd5C142C4F04F1a1536e203543. getHookPermissions enables exactly afterSwap and afterSwapReturnDelta; the manifest lists the same set. State is keyed by PoolId, so any pool may attach the hook. Rule, per pool: lastDirection and streak n (qualifying swaps in a row in lastDirection; n = 0 before the first). A swap in direction d pays min(30 + 10 x n, 200) bps if d == lastDirection, else 30 bps. A swap qualifies when the ETH side of its pool delta is at least 0.001 ETH; after a qualifying swap n += 1 if d == lastDirection, else lastDirection = d and n = 1. Swaps under 0.001 ETH pay the fee for their direction but never change the streak, so dust cannot reset it. So the first buy pays 0.3%, the second 0.4%, the 18th and later 2%, and the first sell after them 0.3%. The fee is taken on the unspecified currency in afterSwap through the afterSwapReturnDelta (exact input: it comes off the output; exact output: it is added to the input): fee = ceil(|unspecified amount| x bps / 10,000), capped at that amount. The streak is read and updated in the same afterSwap. Fees are credited to the hook as ERC-6909 claims with poolManager.mint inside the callback; no ETH or tokens are pushed during a swap. Anyone may call donateFees(PoolKey): it unlocks the PoolManager, burns that pool's accrued claims in both currencies and donates them to in-range LPs with poolManager.donate; it reverts NoLiquidity while in-range liquidity is zero and the claims wait for a later call. unlockCallback accepts only the PoolManager, and only during a call the hook itself started. No owner, no admin. Events: Momentum(PoolId indexed poolId, bool buy, uint256 streak, uint256 feeBps, Currency currency, uint256 fee), FeesDonated(poolId, amount0, amount1). Views: nextFeeBps(PoolId, bool buy), streak(PoolId) -> (bool buy, uint256 n), accrued(poolId). Tests run against a real v4-core PoolManager and include a launch rehearsal: one-sided MOMO liquidity below the opening price, a first buy into the ETH-less pool, then a sell. Acceptance: the schedule 30, 40, ... 200 bps and the cap from the 18th same-direction swap; a qualifying flip resets to 30; a 0.0009 ETH swap leaves the streak unchanged; exact input and output charge the stated fee; invariant: claims held == accrued. Document in the README that a qualifying counter-swap (two hook fees plus LP fees) is the price of resetting a streak. Then a small website that shows the current streak and direction, the fee the next buy and the next sell would pay, recent Momentum events, accrued fees with a donate button, and a swap form. Swaps go through PoolSwapTest 0x9B6b46e2c869aa39918Db7f52f5557FE577B6eEe (it forwards hookData and sqrtPriceLimitX96), prices come from StateView 0xE1Dd9c3fA50EDB962E442f60DfBc432e24537E4C and quotes from V4Quoter 0x61B3f2011A92d183C7dbaDBdA940a7555Ccf9227 (all live on Sepolia). One page, no backend.

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/.

Release Kickoff (ERC-20 symbol KICK) on Sepolia as an evm_project: the fixed-supply launch token plus one application contract. Token: Kickoff (KICK), total supply 1,000,000,000 KICK with 18 decimals, minted once to the deployer. Application contract: CrowdfundCampaigns. Currency: KICK is the app's working currency. CrowdfundCampaigns takes the KICK address as its only constructor argument (constructorArgs ["$token"]), stores it immutable, exposes it as token(), and holds no KICK at deploy; backers get KICK by swapping Sepolia ETH in the launch pool the factory seeds. Every payment in is approve + SafeERC20.safeTransferFrom (permit not required). CrowdfundCampaigns has no payable function and no receive/fallback, so it never holds ETH. Payouts go only to the entitled party (claim to the creator, refund to the calling backer), follow checks-effects-interactions and are nonReentrant. No owner, admin, pause or upgrade path. A Sepolia test toy: a campaign is a test-KICK pledge game that promises backers nothing off-chain, and the README and the page say so. All-or-nothing crowdfunding in KICK, many campaigns by id (starting at 1). create(goal, deadline, bytes32 title): goal >= 1 KICK, deadline between block.timestamp + 1 hour and + 90 days; the caller is the creator. pledge(id, amount): amount > 0, only while block.timestamp < deadline; pledges keep counting after the goal is met (over-funding allowed). unpledge(id, amount): a backer takes back up to their pledge, only before the deadline and only while total < goal; once total >= goal the campaign is locked and unpledge reverts. claim(id): anyone may call it, only when block.timestamp >= deadline and total >= goal, only once; it transfers the whole total to the creator, so a funded campaign never waits on the creator. refund(id): at or after the deadline with total < goal, each backer takes back their full pledge once. A campaign with no pledges simply expires with nothing to move. States: Open (before the deadline) accepts pledge, and unpledge while total < goal; Funded (at or after the deadline, total >= goal) accepts only the single claim; Failed (at or after the deadline, total < goal) accepts only refunds; any other call reverts. The creator may pledge to their own campaign like anyone else (the README says this lets a creator top up to their own goal). Views: campaign(id), campaignCount(), pledgeOf(id, backer), token(). Events: Created(id, creator, goal, deadline, title), Pledged, Unpledged, Claimed, Refunded. Tests (Foundry) must cover: deadline boundaries (a pledge at the deadline reverts, claim/refund at the deadline work), the unpledge lock at the goal, double claim and double refund, over-funding, a campaign with no pledges, and the invariant that KICK held >= the sum over campaigns of pledges not yet claimed or refunded. The independent adversarial review must attack: claim and refund both paying on one campaign, pledges or refunds leaking across campaign ids, the goal lock racing an unpledge in the same block, rounding-free accounting with fuzzed amounts, and reentrancy. Deploy through the project factory, then publish a one-page website to list campaigns with progress bars and deadlines, create one, pledge, unpledge, refund and claim. The page reads the KICK address from CrowdfundCampaigns.token(), shows the connected wallet's KICK balance and allowance, has an Approve step before every paying action, and says that KICK comes from swapping Sepolia ETH in the launch pool (no in-page swap). Lists come from contract views and events only (no backend, no indexer). Keep it to one small page; the static export has index.html in dist/.

Release Crown (ERC-20 symbol CRWN) on Sepolia as an evm_project: the fixed-supply launch token plus one application contract. Token: Crown (CRWN), total supply 1,000,000,000 CRWN with 18 decimals, minted once to the deployer. Application contract: KingOfTheHill. Currency: CRWN is the app's working currency. KingOfTheHill takes the CRWN address as its only constructor argument (constructorArgs ["$token"]), stores it immutable, exposes it as token(), and holds no CRWN at deploy; players get CRWN by swapping Sepolia ETH in the launch pool the factory seeds. Every payment in is approve + SafeERC20.safeTransferFrom (permit not required). KingOfTheHill has no payable function and no receive/fallback, so it never holds ETH. Payouts are pull-based (the recipient calls to collect; nothing is pushed to third parties), follow checks-effects-interactions and are nonReentrant. No owner, admin, pause or upgrade path. A king-of-the-hill game paid in CRWN, played in rounds; constants (1,000 CRWN, 110%, 5%, 24 hours) are fixed in code. State: round, king, kingPayment, pot, lastClaimAt. claim(amount): the first claim of a round needs amount >= 1,000 CRWN; later claims need amount >= ceil(kingPayment * 110 / 100) and are refused from the current king. Claims are accepted only while block.timestamp < lastClaimAt + 24 hours (or when the round has no king yet). A claim pulls amount and sets lastClaimAt = block.timestamp. The first claim of a round (no king yet) puts the whole amount in the pot and pays no bonus. Every later claim is split at once: the dethroned king is credited kingPayment + bonus, where bonus = floor(amount * 5 / 100), and the remainder amount - kingPayment - bonus goes to the pot (never negative: amount >= ceil(kingPayment * 110 / 100) leaves at least 4.5% of kingPayment). The caller becomes king with kingPayment = amount; kingPayment only records what the current king paid and is not escrowed, because that amount has already been split between the previous king and the pot. settle(): anyone, once the round has a king and block.timestamp >= lastClaimAt + 24 hours (the exact boundary belongs to settle, not claim); credits the king the pot (not pot + kingPayment), clears king, kingPayment and pot, and starts the next round (whose first claim again needs 1,000 CRWN). settle() with no king reverts. withdraw() pays the caller's credited CRWN and reverts on zero. Payouts can never exceed payments: every CRWN paid in is either credited to a dethroned king or sits in the pot, so CRWN held == sum of withdrawable balances + pot at all times. Within a round the pot always equals the current king's payment minus every bonus paid in that round, so a dethroned king gets back their payment plus the bonus, while the last king wins the pot: their full payment if they were the round's only claimant, less than it otherwise (about 45% of it after a long chain of exact 110% claims). That loss is the game's stake; the README and the page say so. Views: round(), king(), kingPayment(), minNextClaim(), pot(), deadline(), withdrawable(address), token(). Events: Claimed(round, king, amount, dethroned, bonus), Settled(round, king, prize), Withdrawn(account, amount). Tests (Foundry) must cover: the 1,000 CRWN minimum and the ceil(110%) boundary, a self-claim refused, claims at and after the 24-hour boundary, settle with and without a king, fuzzed long claim chains, and the invariants that CRWN held equals the sum of withdrawable balances + pot and that, while a round has a king, pot equals kingPayment minus the bonuses paid in that round. The independent adversarial review must attack: rounding of the 110% minimum and the 5% bonus, the claim/settle boundary, a king that is a contract, timestamp drift near the deadline, and whether any sequence pays out more CRWN than was paid in. Deploy through the project factory, then publish a one-page website to show the king, the next minimum claim, the pot and the countdown, with claim, settle and claim history. The page reads the CRWN address from KingOfTheHill.token(), shows the connected wallet's CRWN balance, allowance and withdrawable balance, has an Approve step before every paying action and a Withdraw button, and says that CRWN comes from swapping Sepolia ETH in the launch pool (no in-page swap). Lists come from contract views and events only (no backend, no indexer). Keep it to one small page; the static export has index.html in dist/.

Release Arbiter (ERC-20 symbol ARBT) on Sepolia as an evm_project: the fixed-supply launch token plus one application contract. Token: Arbiter (ARBT), total supply 1,000,000,000 ARBT with 18 decimals, minted once to the deployer. Application contract: ArbiterEscrow. Currency: ARBT is the app's working currency. ArbiterEscrow takes the ARBT address as its only constructor argument (constructorArgs ["$token"]), stores it immutable, exposes it as token(), and holds no ARBT at deploy; users get ARBT by swapping Sepolia ETH in the launch pool the factory seeds. Every payment in is approve + SafeERC20.safeTransferFrom (permit not required). ArbiterEscrow has no payable function and no receive/fallback, so it never holds ETH. Payouts are pull-based (the recipient calls to collect; nothing is pushed to third parties), follow checks-effects-interactions and are nonReentrant. No owner, admin, pause or upgrade path. Escrows in ARBT with a third-party arbiter, many escrows by id; states Funded, Delivered, Disputed, Closed. The buyer is whoever calls open and names the seller and the arbiter; the seller accepts those terms, arbiter included, by calling markDelivered, and a seller who does not accept them refunds. Delivery is agreed off-chain; the contract only records the seller's markDelivered. open(seller, arbiter, amount): buyer, seller and arbiter non-zero and pairwise distinct; amount > 0 ARBT is pulled; state Funded; records openedAt; ids from 1. markDelivered(id): seller only, Funded -> Delivered, records deliveredAt. release(id): buyer only, Funded or Delivered -> Closed, the full amount credited to the seller. refund(id): seller only, Funded or Delivered -> Closed, the full amount credited to the buyer. cancel(id): buyer only, Funded and block.timestamp >= openedAt + 14 days -> Closed, the full amount credited to the buyer, so a seller who never engages cannot lock the buyer's ARBT. dispute(id): buyer or seller, Delivered only -> Disputed, records disputedAt. resolve(id, buyerBps): arbiter only, Disputed, buyerBps 0 to 10,000 -> Closed: fee = amount x 100 / 10,000 (floor) credited to the arbiter; rest = amount - fee; the buyer is credited rest x buyerBps / 10,000 (floor) and the seller the remainder, so the three always sum to amount. claimAfterDelivery(id): seller only, Delivered and block.timestamp >= deliveredAt + 30 days -> Closed, the full amount credited to the seller. timeout(id): anyone, Disputed and block.timestamp >= disputedAt + 60 days -> Closed, amount split 50/50 with no fee and the odd unit to the buyer (an absent arbiter cannot lock funds). Any other call, role or state reverts. Races are first-transaction-wins and the README documents them: markDelivered against cancel at day 14, and dispute against claimAfterDelivery after day 30. withdraw() pays the caller's credited ARBT. Views: escrow(id), escrowCount(), withdrawable(address), token(). Events: Opened (buyer, seller and arbiter indexed), Delivered, Released, Refunded, Cancelled, Disputed, Resolved, Claimed, TimedOut, Withdrawn. Tests (Foundry) must cover: every transition allowed and denied by role and state, the 14-, 30- and 60-day boundaries at their exact second, fuzzed resolve splits summing exactly to amount, and the invariant that ARBT held equals the amounts of escrows not yet Closed + withdrawable balances. The independent adversarial review must attack: role confusion between the three parties, a buyer naming an arbiter it controls, the cancel/markDelivered and dispute/claim races, rounding in resolve and timeout, settling one escrow twice, and ARBT left in a state with no exit. Deploy through the project factory, then publish a one-page website to open an escrow (approve ARBT), see the connected wallet's escrows as buyer, seller or arbiter, take the actions its role allows in each escrow's state, and withdraw. The page reads the ARBT address from ArbiterEscrow.token(), shows the connected wallet's ARBT balance, allowance and withdrawable balance, has an Approve step before every paying action and a Withdraw button, and says that ARBT comes from swapping Sepolia ETH in the launch pool (no in-page swap). Lists come from contract views and events only (no backend, no indexer). Keep it to one small page; the static export has index.html in dist/.

Release Holder Discount (token symbol NFTD) on Sepolia as a univ4_hook launch. Token: Holder Discount (NFTD), total supply 1,000,000,000 NFTD with 18 decimals, minted once to the deployer. Hook: NFTHolderDiscountHook, a Uniswap v4 hook on the token's native-ETH pool (currency0 native ETH, currency1 NFTD, LP fee 3000, tickSpacing 60; the factory seeds one-sided NFTD liquidity, so the first buy lands in a pool holding no ETH). In v4, amountSpecified < 0 is exact input and zeroForOne is a buy (ETH in, NFTD out). The hook extends v4-periphery BaseHook; its only constructor argument is the Sepolia PoolManager 0xE03A1074c86CFeDd5C142C4F04F1a1536e203543 (constructor (IPoolManager poolManager)); no $owner or $token. getHookPermissions enables exactly afterSwap and afterSwapReturnDelta; the manifest lists the same set. State is keyed by PoolId, so any pool may attach the hook. COLLECTION is the source constant 0x429ba70129df741B2Ca2a85BC3A2a3328e5c09b4, the Uniswap v4 PositionManager on Sepolia ("Uniswap v4 Positions NFT", an ERC-721 anyone gets by opening a v4 position); tests put a mock ERC-721 at that address with vm.etch. Fee: 100 bps (1%), or 50 bps when COLLECTION.balanceOf(tx.origin) >= 1, read with a low-level staticcall capped at 50,000 gas and decoded only when it returns exactly 32 bytes (a Solidity try/catch would not catch a bad return); a revert, out-of-gas or malformed return means the full 1%, never a failed swap. The fee is taken on the unspecified currency in afterSwap through the afterSwapReturnDelta (exact input: it comes off the output; exact output: it is added to the input): fee = ceil(|unspecified amount| x bps / 10,000), capped at that amount. Fees are credited to the hook as ERC-6909 claims with poolManager.mint inside the callback; no ETH or tokens are pushed during a swap. Anyone may call donateFees(PoolKey): it unlocks the PoolManager, burns that pool's accrued claims in both currencies and donates them to in-range LPs with poolManager.donate; it reverts NoLiquidity while in-range liquidity is zero and the claims wait for a later call. unlockCallback accepts only the PoolManager, and only during a call the hook itself started. No owner, no admin. Why tx.origin: this hook credits nobody, so the context's hookData identity rule does not apply, and a hookData address would let anyone claim a holder's discount; the v4 sender is the router and hookData is not authenticated, so the transaction signer is the only identity the hook can check without a trusted router. Document the limits in NatSpec and README: contract and ERC-4337 wallets are judged by the relayer or bundler EOA, a relayer holding one NFT passes the discount to everyone it relays, an EIP-7702 account can hold a borrowed NFT during its own transaction, and it only ever lowers a fee (never authorisation). Events: FeeCharged(PoolId indexed poolId, address origin, bool discounted, Currency currency, uint256 fee), FeesDonated(poolId, amount0, amount1). Views: feeBpsFor(address account), accrued(poolId) for both currencies. Tests run against a real v4-core PoolManager and include a launch rehearsal: one-sided NFTD liquidity below the opening price, a first buy into the ETH-less pool, then a sell. Acceptance: holder vs non-holder via vm.prank(sender, origin) in all four swap types; the discount ends when the NFT moves away; a collection that reverts, returns garbage or burns all gas gives the full fee, not a revert; invariant: claims held == accrued; donateFees reaches in-range LPs. Then a small website that shows the configured collection, the connected wallet's NFT balance and the fee it would pay, lifetime fees and the discounted share, a donate button and a swap form. Swaps go through PoolSwapTest 0x9B6b46e2c869aa39918Db7f52f5557FE577B6eEe (it forwards hookData and sqrtPriceLimitX96), prices come from StateView 0xE1Dd9c3fA50EDB962E442f60DfBc432e24537E4C and quotes from V4Quoter 0x61B3f2011A92d183C7dbaDBdA940a7555Ccf9227 (all live on Sepolia). One page, no backend.