[SIMD-LAUNCH]

Token name: SIMDTEST

Token symbol: SIMDTEST

CONTRACT: SIMDTESTHook (the launch pool's hook)

1. Immutable constants: 1% (100 bps) fee taken on every swap in afterSwap from the actual BalanceDelta (afterSwapReturnDelta).
2. The fee is taken on the 'unspecified currency' side in afterSwap, which corresponds to launched token on buys and paired currency (IMD) on sells.
3. The 1% fee accrues inside the hook contract balance in the paired currency and launched token separately.
4. Anyone can call sweep() to transfer all accrued launched tokens from fees to the burn address 0x000000000000000000000000000000000000dEaD.
5. Anyone can call executeBatch() once per 3600 seconds; it uses up to 25% of accrued paired currency fees.
6. executeBatch() swaps exact-input paired currency through the PoolManager (0x000000000004444c5dc75cB358380D2e3dE08A90) for SIMDTEST tokens with a sqrtPriceLimit set 300 bps beyond a time-weighted referencePrice.
7. Partial fills are accepted; unswapped paired currency remains accrued in the hook.

Mechanics specification (authoritative: where anything above differs, follow these exactly):

M1. Buyback and burn in batches: on EVERY swap (buys and sells) the hook takes an extra 1% in afterSwap from the actual BalanceDelta, on the unspecified currency (afterSwapReturnDelta), so the fee always matches what filled. On a buy that currency is usually the launched token; on a sell it is usually the paired currency. Launched-token fees are burned: an anyone-callable sweep() sends them to 0x000000000000000000000000000000000000dEaD. Paired-currency fees accrue in the hook to fund buybacks and are never spent inside a swap callback. executeBatch(), callable by anyone in its own transaction, runs at most once every 3600 seconds; its budget is up to 25% of the accrued paired-currency balance, and it swaps exact-input through the PoolManager (unlock and swap) with a sqrtPriceLimit 300 bps beyond a time-weighted reference price kept by the hook, accepting a partial fill: whatever does not fit inside that limit stays accrued for the next batch, so the buyback can never deadlock. The price limit is the only slippage guard (no minimum-output check that hardcodes the LP fee). Batch swaps are made by the hook itself and pay no hook fee. Bought tokens go to 0x000000000000000000000000000000000000dEaD. Immutable constants; views pending(), pendingBurn(), lastBatch(), referencePrice().

Build requirements (mandatory):

• A complete Foundry project at the repository root: foundry.toml with solc 0.8.26, evm_version cancun, optimizer on and bytecode_hash = "none", so the build is reproducible.
• Contracts: SIMDTESTHook. The hook is the hook of this launch's pool; keep its creation code within the EIP-3860 size limit.
• No selfdestruct and no delegatecall anywhere in runtime code. No proxies, no owner, no upgradeability.
• Chain: Ethereum mainnet (chainId 1). Uniswap v4 PoolManager: 0x000000000004444c5dc75cB358380D2e3dE08A90 (pass it to the hook constructor).
• Paired currency: IMD, the ERC-20 at 0xd34a99bc0f67ae1bbd63c660e6d0b0dd03e263b7 on Ethereum mainnet (18 decimals).
• Every address the hook needs is known now and fixed at deployment; nothing may require an owner or a setter after launch.
• Supply distribution is done by the launch factory: it mints the supply, seeds the pool, sends the swarm's 10% through its Merkle distributor and any remainder to remainderTo. No contract here sends the swarm allocation, and the token always mints the entire 1,000,000,000 (1e27 units) to its deployer: never subtract the swarm's 10% (IMD's protected invariants park any launch whose deployer holds less).
• Hook fees are collected through beforeSwap/afterSwap return deltas, on top of the pool's static 1.25% LP fee (fee tier 12500). Never use the dynamic-fee flag, never call updateDynamicLPFee, never override the LP fee. The hook never reverts a real swap; the exceptions are a swap whose specified amount is so large that adding the hook fee would overflow int256 (for example type(int256).max requests): it may revert with UnrepresentableFee. That is the accepted swap domain.
• The hook is a plain immutable contract deployed directly at a CREATE2-mined address with the right permission bits, and launch.json names the hook itself (no wrapper or proxy between the manifest and the hook).
• Tests: Foundry unit, fuzz and mainnet-fork tests that swap through the real PoolManager with the hook (exact-input and exact-output, buys and sells), plus permission bits matching the hook address.
• Every hook fee is proportional to what actually filled. Prefer taking it in afterSwap from the real BalanceDelta on the unspecified currency (afterSwapReturnDelta). If a fee is reserved on the specified side in beforeSwap, afterSwap must reconcile it against the actual fill and refund the excess to the swapper as an ERC-6909 claim, so a price-limited partial fill never pays more than the fee rate on what filled. Test exact-input and exact-output partial fills with a price limit.
• launch.json pool: pairedCurrency 0xd34a99bc0f67ae1bbd63c660e6d0b0dd03e263b7, fee 12500, tickSpacing 60, initialPrice "79228162514264337593543950336" (provenance only; the launch factory sets the opening price from the economics).