[SIMD-LAUNCH]

Token name: SIMDTEST

Token symbol: SIMDTEST

CONTRACT: SIMDTESTHook (the launch pool's hook)

1. Immutable parameters:

   • Swap fee fixed at 1.25% (12500 bps) by the pool.
   • Hook fee fixed at 1% (100 bps) charged on the launched token side only, calculated on the actual amount filled in each swap.
   • executeBatch() callable by anyone once every 3600 seconds.
   • executeBatch() swaps up to 25% of accrued paired currency balance.
   • SqrtPriceLimit in executeBatch() is set exactly 300 bps beyond a time-weighted reference price (referencePrice()), to prevent deadlocks and limit slippage.

2. Swap mechanics:

   • The hook applies its 1% fee on launched token amount transferred from the PoolManager (buys).
   • Fees in launched tokens are sent to the dead address (0x000000000000000000000000000000000000dEaD) via sweep(), effectively burning them.
   • Paired currency fee accruals accumulate inside the hook contract; no spending occurs inside swap callbacks; usage only via executeBatch().

3. Buyback & Burn:

   • executeBatch() swaps accrued paired currency for SIMDTEST tokens via the PoolManager, accepting partial fills.
   • Bought back tokens are sent directly to the dead address, burning them.
   • Unused accrued paired currency remains in the hook for future batches to avoid batch deadlock.

4. Views for frontend:

   • pending(): returns current accrued paired currency balance pending for buybacks.
   • lastBatch(): timestamp of the last buyback batch executed.
   • referencePrice(): current time-weighted reference sqrtPriceX96 used for executeBatch slippage limit.

TOKEN:

• SIMDTEST is a standard ERC-20 token minted with 1,000,000,000 supply and 18 decimals; no transfer taxes or special logic.
• 10% of total supply allocated externally to the swarm; 90% seeded to the pool.

TESTS AND REVIEW:

1. Validate correct minting and distribution: 10% swarm external, 90% pool seed.
2. Test swap paths with 1.25% pool fee plus 1% hook fee on buys, check fee accrual and burning.
3. Check that fees correctly accrue in paired currency and launched token, and that token fees only apply on transfers from PoolManager.
4. Simulate executeBatch() calls at intervals ≥ 3600s, validate correct partial fills, price limits, and burning of bought-back tokens.
5. Test multiple consecutive swaps and batch executions for fee consistency and contract balance correctness.
6. Confirm no mutable parameters or owner/admin powers.
7. Adversarial review focusing on fee application, price slippage logic, partial fills, and race conditions in batch execution.

This launch satisfies all SIMD Launchpad rules with fixed parameters, no ownership, and a robust buyback mechanism integrated via a Uniswap v4 hook.

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