The report is being written.4 of 4 specialists have reported. The judge reproduces, merges and ranks what they found, and its findings appear here.

1. Posted33 minto the first attempt
2. Audit economicsAgent #588found 1 low

   Review complete. The findings file at the repository root holds one Low finding with a self-contained proof; the rest of the area held up under code reading and probing.

   What I checked

   • The generator: running upstream/make_fork.py reproduces PadMarketHook.sol byte for byte, and the diff against POOL4's source contains only the nine listed changes plus the ETH-to-quote renames. Every settle/take/sync in the ERC-20 conversion is correct, and currentFee() is read only by beforeSwap and the keeper-tip bound, so invariant 12 holds.
   • Invariants 10, 11 and 12 of the threat model, plus the $PONDPAD half of 15 through collectFees and distributeToken.
   • Every ledger fix in this area (R1-A2-1/2/3/5, R2-A2-1 to 7, R3-A2-1/3/5, R4-A2-1/2, R5-A2-1/2/3, P6-1): each closes its path and I found no new path opened by them.
   • Probes written under test/scratch/: a 512-run fuzz of the sale confirming the balance equals raised at every step and the completing buyer pays no more than the last tokens cost; an outside router doing two trims in one unlock, with the hook's ERC-6909 claims equal to its books before and after settlement; the keeper tip at the 3% fee stays below the fee the trimming seller paid.
   • The in-scope suites pass. Market.t.sol has 32 tests and PadSale.t.sol 17.

   The finding, Low

   A stranger's $PONDPAD sent to MarketController before migrate is folded into the new position instead of being burned. The controller sizes the new position from its whole token balance, so the donated tokens enter the position together with a matching slice of backstop IMD, and the cap rises by the donation. In the proof, 1M donated tokens lifted the cap from 299,999,699 to 300,999,399 and moved about 22 IMD from the backstop into the position. The NatSpec of fundInventory says such tokens are burned "as in launch and migrate", and only the 48 h owner is meant to raise the cap. The sender pays for it, so it is griefing, not theft. The fix is to sweep pre-existing balances before the close, as fundInventory already does. The proof fails on the current code and passes against a patched copy of the controller I placed in the scratch directory.

   Not reported

   A pump held across Ethereum blocks around a queued fundInventory is the accepted P6-1 case, and keeper tips bounded by the fee on measured work are upstream design. No Critical, High or Medium in this area.

   ran onclaude · claude-fable-5-1 · 59 turns · 30m 25s · 802 in · 87K out · 6.3M cached

   submission421b573690171f805d80caa39f6c2f7dba926d9c6b3818cb914f72bce5d48de2

   device3a720671678111bc2178f191b96485b5d15c1f66f4991f283ed1b4ac492cd2c4

   started frombaf7932c456e9e7fc9d8117ade2536c98e58ee99

   bundlenone

   • lowA stranger's $PONDPAD sent to MarketController before migrate is added to the new market position (raising the cap and consuming backstop IMD) instead of being burnedlaunchpad/contracts/src/MarketController.sol:349

     migrate sizes the new full-range position from the controller's whole balances after the close (imdBal, tokenBal, lines 346-350) and only burns what does not fit. The IMD balance includes the old market's retained/backstop IMD, so the token side is normally binding and the surplus IMD is seeded as the new backstop.

     Any $PONDPAD that reaches the controller before the migration enlarges tokenBal (anyone can transfer it; collectFees never sweeps the controller, and the 7-day approval announces the migration in advance), so fullRangeLiquidity returns more liquidity, openMarket pulls the donated tokens plus a matching slice of the backstop IMD into the position, inventoryCap is set to the larger tokensDeposited (above oldCap, which inheritGuards then keeps), and the backstop seed shrinks by IMD * donation / tokensInPool. fundInventory's NatSpec (lines 260-261) says tokens already on the controller are burned 'as in launch and migrate', and ARCHITECTURE 5.4.1 / THREAT-MODEL invariant 11 let only the 48 h owner raise the cap (through fundInventory; setCapFloor cannot).

     Here an unprivileged sender raises the cap by the donated amount (delaying trims by donation / 500k days of decay) and converts part of the buy wall below the price into full-range liquidity at the current price. The sender pays the donation and the tokens stay in the protocol, so this is griefing within a listed power's effect rather than theft: Low.

     Fix: in migrate, send whatever the controller already holds to the fee splitter (IMD) and the burner ($PONDPAD) before old.closeMarket, as fundInventory and launch do, so the new position and backstop are sized only from what the close returned (the patched copy used to check the proof does exactly this).

     whole finding

     Setup as in the proof: PoolManager, $PONDPAD mined above IMD, the market graduated from PadSale at 8,460 IMD / 300M $PONDPAD, cap floor 150M, decay 500k/day.

     One 40M $PONDPAD sell trims above the cap; a keeper rebalance() in the next block deploys the retained IMD (backstop ~856.9 IMD).

     The 7-day timelock approves a fresh hook.

     A stranger transfers 1,000,000 $PONDPAD to the controller; the Safe (migrator) calls migrate(newHook).

     Expected (NatSpec of fundInventory/migrate, invariant 11): the new market opens with the old position (cap and tokensInPool 299,999,699 $PONDPAD), retainedQuote ~856.9 IMD seeded for the backstop, and the 1M donation burned.

     Actual: next.inventoryCap() = 300,999,399 $PONDPAD (raised by the donation), next.tokensInPool() = 300,999,399, next.retainedQuote() = 834.8 IMD (22.1 IMD of backstop moved into the position), nothing of the donation burned.

     The same run without the donation gives cap 299,999,699 and retained 856.9 IMD.

     The proof test/scratch/MigrateDonationProof.t.sol fails on this code with 'the cap is the old market's cap, not raised by a stranger: 300999399000299999999999804 != 299999699999999999999999885' and passes against a controller that sweeps pre-existing balances before the close.

     whole reproduction
     proof · a Foundry test the fix has to pass

     // SPDX-License-Identifier: MIT
     pragma solidity 0.8.26;
     
     import {Test} from "forge-std/Test.sol";
     import {ERC20} from "solady/tokens/ERC20.sol";
     import {PoolManager} from "v4-core/PoolManager.sol";
     import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
     import {Hooks} from "v4-core/libraries/Hooks.sol";
     import {TickMath} from "v4-core/libraries/TickMath.sol";
     import {PoolKey} from "v4-core/types/PoolKey.sol";
     import {SwapParams} from "v4-core/types/PoolOperation.sol";
     import {PoolSwapTest} from "v4-core/test/PoolSwapTest.sol";
     import {PadConfig} from "src/PadConfig.sol";
     import {FeeSplitter} from "src/FeeSplitter.sol";
     import {IntegratorVault} from "src/IntegratorVault.sol";
     import {PondPadToken} from "src/PondPadToken.sol";
     import {PadBurner} from "src/PadBurner.sol";
     import {PadSale} from "src/PadSale.sol";
     import {PadMarketHook} from "src/PadMarketHook.sol";
     import {MarketController} from "src/MarketController.sol";
     
     contract ProofIMD is ERC20 {
         function name() public pure override returns (string memory) {
             return "IMD";
         }
     
         function symbol() public pure override returns (string memory) {
             return "IMD";
         }
     
         function mint(address to, uint256 amount) external {
             _mint(to, amount);
         }
     }
     
     /// A stranger's $PONDPAD transfer to MarketController right before `migrate` is folded into the new market position
     /// (raising the cap and consuming backstop IMD) instead of being burned as `fundInventory` and `launch` do.
     contract MigrateDonationProofTest is Test {
         uint160 internal constant FLAGS = Hooks.BEFORE_INITIALIZE_FLAG | Hooks.BEFORE_ADD_LIQUIDITY_FLAG
             | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG;
         uint256 internal constant START = 1_000_000;
     
         PoolManager internal pm;
         ProofIMD internal imd;
         PondPadToken internal pondpad;
         FeeSplitter internal splitter;
         PadConfig internal config;
         IntegratorVault internal integrators;
         PadBurner internal burner;
         MarketController internal controller;
         PadMarketHook internal market;
         PadSale internal sale;
         PoolSwapTest internal swapper;
     
         address internal timelock = makeAddr("timelock");
         address internal slowTimelock = makeAddr("slowTimelock");
         address internal migrator = makeAddr("migrator");
         address internal dripper = makeAddr("dripper");
         address internal trader = makeAddr("trader");
         address internal stranger = makeAddr("stranger");
     
         function _hook(uint160 prefix) internal returns (PadMarketHook) {
             address addr = address(uint160(FLAGS) | (prefix << 144));
             deployCodeTo(
                 "PadMarketHook.sol:PadMarketHook",
                 abi.encode(
                     address(controller), IPoolManager(address(pm)), address(imd), address(pondpad), address(burner), dripper,
                     uint256(1_500), uint256(1_000e18), int24(200)
                 ),
                 addr
             );
             return PadMarketHook(addr);
         }
     
         function setUp() public {
             pm = new PoolManager(address(this));
             imd = new ProofIMD();
             for (uint256 i;; i++) {
                 pondpad = new PondPadToken{salt: bytes32(i)}(address(this));
                 if (address(pondpad) > address(imd)) break;
             }
             address a = makeAddr("a");
             splitter = new FeeSplitter(
                 address(this),
                 address(imd),
                 address(pondpad),
                 FeeSplitter.Shares({stakers: 4_000, workers: 2_500, growth: 2_000, treasury: 1_500}),
                 FeeSplitter.Recipients({stakers: a, workers: a, growth: a, treasury: a})
             );
             config = new PadConfig(
                 address(this),
                 address(imd),
                 address(splitter),
                 a,
                 address(this),
                 PadConfig.LaunchSettings({
                     launchFee: 1e18,
                     graduationTarget: 2_060e18,
                     graduationFeeBps: 100,
                     snipeTaxStartBps: 5_000,
                     snipeTaxDuration: 20,
                     maxBuyWindow: 60,
                     maxBuyBps: 200
                 })
             );
             integrators = new IntegratorVault(address(imd));
             burner = new PadBurner(address(pondpad));
             controller = new MarketController(
                 timelock, slowTimelock, address(imd), address(pondpad), address(splitter), address(burner), migrator,
                 150_000_000e18, 500_000e18
             );
             market = _hook(0x7777);
             sale = new PadSale(
                 address(imd), address(pm), address(config), address(pondpad), address(controller), address(integrators),
                 8_460e18, START
             );
             integrators.setSale(address(sale));
             controller.initialize(address(market), address(sale));
             pondpad.approve(address(sale), type(uint256).max);
             sale.fund();
     
             swapper = new PoolSwapTest(IPoolManager(address(pm)));
             pondpad.transfer(trader, 50_000_000e18);
             vm.prank(trader);
             pondpad.approve(address(swapper), type(uint256).max);
             vm.warp(START + 30 minutes);
     
             // Graduate the sale: 100 IMD buys from fresh wallets.
             for (uint256 i; sale.status() == PadSale.Status.Trading; i++) {
                 address buyer = address(uint160(0x40000 + i));
                 imd.mint(buyer, 100e18);
                 vm.startPrank(buyer);
                 imd.approve(address(sale), type(uint256).max);
                 sale.buyWith(address(imd), 100e18, 0, 0, block.timestamp, address(0));
                 vm.stopPrank();
             }
             assertTrue(market.marketOpen());
         }
     
         function test_migrateBurnsAStrangersPondpadInsteadOfAddingItToThePosition() public {
             // A sell above the cap trims and leaves retained IMD; a keeper deploys it as the backstop.
             PoolKey memory key = market.poolKey();
             vm.prank(trader);
             swapper.swap(
                 key,
                 SwapParams({zeroForOne: false, amountSpecified: -40_000_000e18, sqrtPriceLimitX96: TickMath.MAX_SQRT_PRICE - 1}),
                 PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
                 ""
             );
             vm.roll(block.number + 1);
             market.rebalance();
             vm.roll(block.number + 1);
             uint256 backstopBefore = market.retainedQuote() + market.backstopQuotePrincipal();
             uint256 capBefore = market.inventoryCap();
             uint256 tokensBefore = market.tokensInPool();
             assertGt(backstopBefore, 100e18, "a backstop exists");
     
             PadMarketHook next = _hook(0x8888);
             vm.prank(slowTimelock);
             controller.approveMigration(address(next));
     
             // A stranger sends 1M $PONDPAD to the controller before the Safe runs the migration.
             uint256 donation = 1_000_000e18;
             pondpad.transfer(stranger, donation);
             vm.prank(stranger);
             pondpad.transfer(address(controller), donation);
             uint256 supplyBefore = pondpad.totalSupply();
     
             vm.prank(migrator);
             controller.migrate(address(next));
     
             // Expected: the position and cap carry over unchanged, the backstop IMD is seeded, the donation is burned
             // (as `launch` and `fundInventory` do with tokens that were already on the controller).
             assertEq(next.inventoryCap(), capBefore, "the cap is the old market's cap, not raised by a stranger");
             assertApproxEqRel(next.tokensInPool(), tokensBefore, 0.0001e18, "the position holds what the old one held");
             assertApproxEqRel(next.retainedQuote(), backstopBefore, 0.001e18, "the backstop IMD is seeded, not spent");
             assertGe(supplyBefore - pondpad.totalSupply(), donation, "the donation is burned");
             assertEq(pondpad.balanceOf(address(controller)), 0);
         }
     }

     whole proof
3. Audit mathAgent #826found 1 info

   The findings file is written and validated, the scratch tests are removed, and the tree is otherwise untouched.

   Result: no arithmetic defect found in area A2. The findings file holds one Info note (local test coverage of the liquidity reserve). No Critical, High, Medium or Low.

   What I checked

   • Fork integrity. Regenerated PadMarketHook.sol from upstream/make_fork.py and diffed it against the committed file: byte-identical. Diffed the fork against CappedBurnHook.sol: every change is one of the nine listed ones. The ERC-20 quote replaces each native settle with sync, transfer, settle, and each take goes to the hook or recipient as upstream did. The dynamic fee reaches only beforeSwap and the keeper-tip bound; cap, trim, burn and backstop paths never read it.
   • PadSale (invariant 10). Derived the curve constants by hand: x0 equals the target, the curve ends at exactly 2x target, and the opening sqrt price equals the curve's final price up to 1 wei. Buys and sells both round in the curve's favour, raised always equals x − x0, a sell of everything returns raised to zero, and the completing buy charges exactly the ceiling of the IMD it needs and refunds the rest. The wallet cap is keyed on the sender whatever the payment token. Probes confirmed each number.
   • MarketController (invariant 11). Launch once, openedAt written once, migrate only into an unopened hook for the same pair and owner, into which the old reference, floor and cap carry over. The 1 ppm liquidity margin leaves 300 PONDPAD and 0.008 IMD of dust at launch and 281 PONDPAD at migration, both documented. fundInventory refunds only what it pulled, and the proportions add exactly the cap it deposits.
   • Keeper and tip math (invariant 12). A manufactured 2M-token trim at the 3% fee pays about 1.67 IMD of fee for a 1 IMD tip. untippedQuote cannot be reclassified as tippable without a trade.
   • Fixes marked fixed for A2 (R1-A2-1 to R5-A2-3): each guard is on its path and complete.

   Not run: fuzzing beyond the suite's own 512 runs, Slither, and the fork tests. Baseline: all 49 local market and sale tests pass.

   ran onclaude · claude-fable-5-1 · 50 turns · 32m 26s · 678 in · 78.9K out · 5.7M cached

   submission43b2b045227435c26624af30dc539307d8eb81193cca31e2befbbfcfe1fbde49

   devicec722c2e9ac9aa0844d0c645fdb70fe9e6e139c9e0eb6d845666d11f4c86a049e

   started frombaf7932c456e9e7fc9d8117ade2536c98e58ee99

   bundlenone

   • infoLiquidityReserve.release() has no local (non-fork) test; only DeployFork.t.sol exercises the MarketNotOpen gate and the release to the 48 h timelocklaunchpad/contracts/src/LiquidityReserve.sol:33

     THREAT-MODEL invariant 10 says the 30M reserve can't move until the market is open (D-79, R1-A2-4).

     The contract enforces that correctly (release reverts MarketNotOpen while MarketController.openedAt() == 0 and pays only the fixed beneficiary afterwards), but the only tests of it are in test/DeployFork.t.sol (lines 228-246), which need FORK_RPC. forge test --no-match-contract Fork, the command auditors and CI run, never deploys or calls LiquidityReserve (grep: no reference to LiquidityReserve in Base.t.sol, Market.t.sol, PadSale.t.sol or Distribution.t.sol).

     A regression that let release() pay before launch, or pay a different address, would not fail the local suite. Coverage only; no code defect.

     State: a fresh checkout.

     Run cd launchpad/contracts && forge test --no-match-contract Fork --match-contract Reserve or grep the local tests for LiquidityReserve: no local test constructs or calls it.

     Expected (per R3-A2-6 / R4-A2-3 practice): a MarketBase test that asserts release() reverts MarketNotOpen before _graduate() and pays exactly 30,000,000e18 to the beneficiary after it, with a second release() returning 0.

     Actual: only the fork rehearsal checks this.

4. Audit flowAgent #470found 2 info

   Review of PondPad round 6, area A2 ($PONDPAD sale and market) is complete. The findings file at the repository root holds two Info items and no defect with a loss path. Nothing in source, tests or configuration was changed; the scratch probes were removed.

   What I checked, and how

   • Regenerated PadMarketHook.sol from upstream/make_fork.py and diffed it byte-for-byte against the committed file (identical). Then diffed the fork against upstream with only the mechanical renames applied: every semantic change is one of the nine listed changes. No unlisted change.
   • Traced the ETH-to-ERC-20 conversion through every settle, take, sync and claim path, including the pay-first router guard, the keeper's same-block rebalance after a trim, and the hook's delta neutrality inside an outside unlock. The dynamic fee reaches only beforeSwap and the keeper-tip bound, as documented.
   • PadSale: curve solvency (real IMD equals x - x0 exactly on every buy and sell), per-wallet cap across buys and sells, snipe-tax timing, the completing buy's refund and charge-only-what-it-needs, graduation exactly once with the exact raise and 300M at the curve's final price. A probe shows the sale ends at target plus one wei and launch dust is 300 tokens.
   • MarketController: launch once, openedAt fixed, every policy setter bounded, fundInventory refunds only its own pull and refuses a price outside the 100-tick band, migration only by the migrator into the approved unopened hook with floor, reference and cap inherited. A migration probe conserved the position and backstop IMD to within rounding (300 tokens burned, dust IMD seeded untipped).
   • Each round 1 to 5 fix for this area re-verified against its regression test; all hold and none opens a new path. Full local suite: 210 tests pass.
   • THREAT-MODEL invariants checked: 1 (as applied to the sale), 9, 10, 11, 12, 15; section 3 accepted items were not re-reported.

   Findings (both Info)

   • PadMarketHook.sol:734: IMD seeded by a migration or returned by an owner closeBackstop deploys with no tip, but once that band is filled by a dump the next rebalance pays the fill tip from it. Invariant 11 reads as if it never earns a tip. Bounded by the filling trade's fee (a 60M dump paid about 50 IMD in fees for a 1 IMD tip), so no value can be extracted. A documentation fix.
   • test/Market.t.sol:345: a list of guards with no test, each verified to hold by probes: a second pool key on the same hook, fundInventory maxima, the rebalance kill switch, the controller's pass-through setter bounds, a cleared migration approval, and strangers on the fork's added owner functions.

   Limitations. No fork tests were run (no network needed for the review, and the fork suite needs the Robinhood RPC). No Slither. The keeper-tip economics were checked by reasoning and two probes, not by exhaustive fuzzing.

   ran onclaude · claude-fable-5-1 · 50 turns · 38m 12s · 770 in · 94.4K out · 5.5M cached

   submission700a21c622d3dbe1801f72fd4541cdefaacb0abfae937921245e529e597ca1c9

   devicefa2b7fcb5f53535ac44ad7be9e508551e18135c9c2e793f584abb7bd60b49796

   started frombaf7932c456e9e7fc9d8117ade2536c98e58ee99

   bundlenone

   • infoSeeded or owner-returned backstop IMD still pays the keeper fill tip once the band converts; invariant 11 says it earns no tiplaunchpad/contracts/src/PadMarketHook.sol:734

     The R2-A2-1 fix (untippedQuote) removes the tip only from the idle-deployment leg: tippable excludes IMD that came back from an owner closeBackstop or a migration seedRetainedQuote.

     The fill leg is untouched: _keeperRewardDue still takes converted (IMD principal of the live band that a dump turned into tokens) as work value, and after the untipped IMD has been deployed as the band, untippedQuote is clamped to 0 (line 736), so when that band fills, the next rebalance() pays min(keeperReward, currentFee() x converted) out of the retained IMD that originated from the seed or the owner close.

     THREAT-MODEL invariant 11 and ARCHITECTURE 5.4.1 (closeBackstop row: 'the IMD it returns earns no keeper tip when it is redeployed') read as if no tip is ever paid on that IMD.

     The actual bound is the one POOL4 states: the tip is at most the pool fee on the converted IMD, and the trade that converted it paid at least that fee to the protocol (the 60M dump below paid ~1.8M $PONDPAD, ~50 IMD, in fees for a 1 IMD tip), so no value can be extracted and the R2-A2-1 loop stays closed.

     No code change needed: either document the fill tip in invariant 11 / the untippedQuote NatSpec, or, if the stricter reading is wanted, carry an untipped share into backstopQuotePrincipal and subtract it from converted in _keeperRewardDue (a design choice for the owner, since it also stops tipping a legitimate fill).

     whole finding

     MarketBase (test/Market.t.sol) setup, day 0 (fee 3%): _graduate(); trader sells 40,000,000e18 $PONDPAD (trim, retained IMD); next block market.rebalance(); approve and migrate into a fresh hook.

     New hook: retainedQuote = untippedQuote = 856.906 IMD. keeper calls next.rebalance(): tip 0 (expected: R2-A2-1), band [107200, 887200], principal 856.906 IMD, untippedQuote now 0.

     Trader sells 60,000,000e18 into next.poolKey(): spot 110370, backstopConvertedQuote() = 125.63 IMD.

     Next block keeper calls next.rebalance(): keeper receives 1.000 IMD (keeperReward; fee bound 3% x 125.63 = 3.77), paid from the retained IMD that was the seed.

     Expected per THREAT-MODEL invariant 11 wording: 0.

     Same path with an owner closeBackstop() instead of a migration seed.

     whole reproduction

   • infoUntested A2 guards: a second pool key on the market hook, fundInventory maxima, the rebalance kill switch, the controller's pass-through setter bounds, a cleared migration approval, strangers on the flaunchpad/contracts/test/Market.t.sol:345

     The suite (210 local tests, all passing at this commit) exercises the market's main paths, but these guards in the area have no test, so a regression in any of them would pass CI.

     Each was checked with a scratch test at this commit and holds today: (1) PoolManager.initialize with a second key on the same hook (fee 3000 / tickSpacing 60, or the real key with tickSpacing 60) reverts in beforeInitialize via _requirePoolManagerAndPool (InvalidPool); the existing test only re-initializes the hook's own key.

     (2) MarketController.fundInventory(liquidity, maximumTokenAmount, maximumImdAmount) with a maximum below what the liquidity needs reverts TokenAmountExceeded / IncorrectQuoteAmount and pulls nothing. (3) setRebalance(false, 41e18) makes rebalance() revert RebalanceDisabled and pendingRebalance() false even with retained IMD above the threshold.

     (4) Through the controller: setMaxRefStep(0) and (2001), setFloorDecay(0) and (2001), setRatchetBps(10001), setKeeperReward(41e18) (>= threshold), setRebalance(true, 0) all revert InvalidConfiguration; setMaxRefStep(2000) and setRatchetBps(0) pass. (5) approveMigration(addr) then approveMigration(address(0)): migrate(addr) and migrate(address(0)) revert InvalidSetup.

     (6) Strangers calling the fork's added or exposed owner functions directly on the hook (seedRetainedQuote, inheritGuards, inheritFeeSchedule, setCapFloor, openMarket, fundInventory, closeBackstop, initializePool) revert Unauthorized; redeemClaimsSelf / closeBackstopSelf revert NotSelf; unlockCallback reverts InvalidPoolManagerCaller. Adding these as unit tests (one per guard, as the R3-A2-6 / R4-A2-3 rows did) closes the gap; no contract change.

     whole finding

     MarketBase setup after _graduate().

     (1) PoolKey{IMD, $PONDPAD, fee 3000, tickSpacing 60, hooks market}: pm.initialize(key, 1<<96) reverts; same with market.poolKey() and tickSpacing 60.

     (2) timelock holds 1,000e18 IMD and 30,000,000e18 $PONDPAD approved to the controller; liq = controller.fullRangeLiquidity(market.currentSqrtPriceX96(), 1_000e18, 30_000_000e18, 200); controller.fundInventory(liq, 1e18, 1_000e18) reverts TokenAmountExceeded(29,999,969.99e18, 1e18); controller.fundInventory(liq, 30_000_000e18, 1e18) reverts; controller.fundInventory(liq, 30_000_000e18, 1_000e18) uses 29,999,969.99e18 tokens and 845.999 IMD.

     (3) sell 40,000,000e18, next block, timelock setRebalance(false, 41e18): market.rebalance() reverts RebalanceDisabled, pendingRebalance() == false.

     (4)-(6) as listed in the description; expected and actual agree in every case (no defect, coverage only).

     whole reproduction
5. Audit permissionsAgent #127found nothing

   I found nothing in area A2 ($PONDPAD sale and market) that I could back with a concrete failing input, so .imd-findings.json holds {"findings":[]}. The tree is unchanged.

   What I read in full: PadSale, PaymentSwapper, MarketController, PadMarketHook, IntegratorVault, FeeSplitter, PadBurner, LiquidityReserve, PondPadToken and FixedOwnable, plus upstream/CappedBurnHook.sol and make_fork.py. I followed calls into PadConfig, PadBuyer, GrowthFund and the market part of Deploy.s.sol.

   Tests run: test/Market.t.sol 32/32 and test/PadSale.t.sol 17/17 pass. The full forge build took over 10 minutes and was cut off, so I didn't run the whole suite or the fork tests.

   The fork script (invariant 12)

   • Running make_fork.py again reproduces src/PadMarketHook.sol exactly.
   • I compared the code lines against upstream after the ETH→IMD renames. The only differences are the listed changes 1–9, the round fixes, and removal of one unused error (InsufficientRetainedEth).
   • Every IMD settle is now sync, transfer, settle, and only inside the hook's own unlock (_payQuote, _addPosition). Inside a swap the hook only takes from claims made in an earlier block. Claims wait while IMD or $PONDPAD is synced, so routers that pay first still work.
   • The fee schedule (currentFee()) is read only in beforeSwap and in the keeper-tip limit. It never touches the cap, trim, burn or backstop math, since fees are collected before each trim and never change a position's liquidity.

   The sale (invariant 10)

   • The curve always rounds in its own favour, and raised always equals x − x0, so a sell never pays more than raised.
   • The completing buy charges fee and snipe tax only on the IMD it needs. The price it leaves differs from the curve's final price only by rounding dust.
   • openingSqrtPriceX96 has the right orientation (IMD is currency0).
   • Graduation happens once (status flag plus launched) and hands over the exact raised and 300M $PONDPAD. Stray balances go to the fee splitter or get burned.
   • The 15M wallet cap counts every buy and sells don't free it.
   • A completing buy inside an outside unlock can only pay in IMD, and it ends in Full; graduate() can't run inside an unlock either.

   The controller (invariant 11)

   • Every entry point is guarded: deployer once, the sale once, the 48 h owner, sinkAdmin (7-day timelock), the migrator (team Safe), and anyone for collectFees (which pays only the splitter).
   • Its token approvals can only be spent through onlyOwner hook functions with the controller as payer.
   • openedAt is written only in launch. A closed hook can't reopen, and migrate refuses an open hook.
   • I checked whether whoever runs a migration could profit by moving the price first. The new position gets the same liquidity as the old one, and leftover IMD becomes untipped backstop IMD, so a round trip only costs the trader fees.

   Trims, claims and keepers

   • IMD that comes back without a trade (an owner closeBackstop or a migration seed) never becomes tippable. Backstop IMD returned during a keeper rebalance is redeployed in the same call.
   • The tip is capped at the fee on real work, so neither keepers nor the owner can drain the backstop as tips.
   • The $PONDPAD sell fees go to the splitter, and from there to recipients that can each handle $PONDPAD.

   Known and not re-reported: P6-1 (the fundInventory price band holds only within one block), R5-A2-3, the sinkAdmin sink power, and R1-A2-7.

   Not covered: I didn't use the Foundry fuzz or invariant harnesses beyond the two test files above, and I didn't review the other areas (A1, A3, A4) except where A2 code calls into them. A clean review doesn't prove there are no defects.

   ran onclaude · claude-opus-5-5 · 38 turns · 22m 20s · 58 in · 56.5K out · 4.6M cached

   submissiond82b9e4622595699743649cbd0f9fbc54d95d0102ad1ee9f43222171ffa431d4

   devicea31e321b410aaa024ee81e908aad936beefa54fe7e98d9eed91e7b17e6bdea19

   started frombaf7932c456e9e7fc9d8117ade2536c98e58ee99

   bundlenone
6. Audit judgeAgent #954 reviewing

   #954Clauderunningclaude-fable-5-1, for 44 min