Implemented IMD-only stock purchases through Uniswap v3 with a fixed 0.5% fee and configurable burn/creator split.

forge build, forge test, and forge fmt --check pass, including clean offline verification.

Deployment settings and responsibilities are in README.md. Trading starts paused; the owner must configure verified addresses and confirm IMD supports burn(uint256).

Created launch.json for IMDStockDex with constructorArgs: ["$owner"]. Notes describe fees and the paused state pending owner configuration.

Manifest structure and constructor ABI checked. forge build succeeded; forge test passed all 65 tests. Only launch.json changed outside permitted scratch files.

Review complete. The findings file is at the repository root with 2 findings and 15 coverage rows, and no source or configuration file was changed.

Outcome of the Access Control, Trust Gap and Asymmetry audit of IMDStockDex

The permission model holds. Every configuration setter is owner-only and most also require the paused state. The purchase path writes no storage, pulls IMD only from the caller, delivers stock only to the caller, and delta-checks every leg. No unprivileged path can bump the configuration version, so nobody but the owner can invalidate pending purchases. Reentrancy from the router or token hooks into any admin or buy function is blocked. All nine Slither reentrancy and divide-before-multiply leads were traced and are false positives.

Findings recorded

• Low. setFeeDistribution accepts the configured router or quoter as creator. The function setIMD rejects the router, quoter and creator addresses, but the mirror check is missing on the creator side. With the real Uniswap v3 SwapRouter, the creator share lands on the router and anyone can take it with sweepToken. I executed the full sweep against the vendored SwapRouter bytecode. The attached proof test expects the revert and fails on current code, so it will pass once the fix lands.
• Info. Owner trust assumptions. The router, quoter, listings, creator and donation recovery are fully owner-controlled by design. A buyer's only defense against a malicious router is the minimum output it derives from the owner-chosen quoter. The entry documents the concrete scenario and recommends operational safeguards rather than a code change.

Coverage

All 13 entry points have rows. Twelve hold, setFeeDistribution points at finding 1, and two invariant rows record that only owner functions write the version counter and that no admin function is reachable mid-purchase. The existing suite of 65 tests passes unchanged. The only failing test is my scratch proof under test/scratch/, which is expected and is not kept.

The review is complete. The findings file is written at the repository root, all four snippets match the tree, and the scratch tests were removed so no source or test file changed.

Outcome: the fee arithmetic is sound; the defects are at the boundaries, not in the math. The fee is ceil(G/200), the burn share uses an exact quotient/remainder decomposition that cannot overflow for any uint256 input, and the split always conserves every base unit. I verified this by hand and against the repo's independent long-division fuzz. Balance-delta checks, allowance clearing, slippage, deadline and partial-fill handling were traced on the real vendored Uniswap v3 router bytecode and all fail safely.

Findings written to .imd-findings.json:

• Medium. The 0.5% fee and burn are opt-in. The DEX wraps a public Uniswap v3 pool it does not gate. A buyer submitting the listed path directly to the router got 996.0 stock for 1000 IMD against 991.0 through the DEX, with nothing burned and nothing paid to the creator. This is a design gap against the brief rather than a code bug, so no proof test is attached. Nothing inside the contract can close it.
• Low. Disabling one market invalidates every other market's pending orders. The global version counter bumps on disableMarket, so a quoted buy of a still-enabled market reverts with ConfigurationChanged. The NatSpec says disabling happens "without pausing other markets".
• Low. Minimum order size scales with the inverse of the burn share. At a 1 bps split, every order up to 1,999,800 base units reverts with AmountTooSmall. The fuzz and invariant tests start at 2,000,000, so this region is untested. With a low-decimal IMD this becomes a real availability limit.
• Info. The quoter returns a price for orders that exhaust pool liquidity. The buy then correctly reverts because the router spends only part of the input, so integrators relying on the quote submit a doomed transaction. No funds move.

Coverage has a row for all 13 entry points plus four invariants. Nothing was left unreached. The Slither reentrancy and divide-before-multiply leads were checked and do not hold: every state-changing and quote path is guarded, and both flagged divisions are exact decompositions.

Review complete. The findings file is in place at the repository root, no tracked files were changed, and the scratch tests sit in the git-ignored test/scratch/ directory as the assignment allows.

Outcome: no critical or high defects in IMDStockDex. The purchase path is sound end to end. Exact balance-delta checks cover the gross pull, the router spend, the stock delivery, the burn and the creator payment. A shared reentrancy guard spans every state-changing function, so even a router made owner cannot reconfigure mid-swap. The fee decomposition is exact and overflow-free across the full input range. The path validator's offsets match Uniswap v3 packed encoding. I confirmed all of this against the real SwapRouter and QuoterV2 bytecode fixtures as well as the mocks, and the existing 65 tests and two invariant campaigns pass.

Two substantiated findings, both reproduced with scratch tests:

• Low, address-guard asymmetry. setIMD refuses the creator, router and quoter, but setFeeDistribution accepts the router as creator. With the real SwapRouter fixture, a buy of 1000 IMD left the 2 IMD creator share inside the router, and an unrelated address took it with sweepToken. This needs an owner misconfiguration, so it is a half-enforced self-reference check rather than a bypass. The fix is to mirror the existing guard in setFeeDistribution, setRouter and setQuoter.
• Info, over-broad version bump. disableMarket increments the global configVersion, so disabling one listing reverts every in-flight purchase on every other market with ConfigurationChanged. This contradicts the function's own comment about not disturbing other markets, though the README documents the bump. No funds are at risk.

Coverage: all 13 listed entry points have a row, plus three invariant rows. Eleven hold, two point at the findings above. The static-analysis leads were all traced and none survived as defects. What I could not reach is behavior against the real IMD token's burn and against permissioned or rebasing Ondo assets on mainnet, since neither address was supplied. Those remain the documented deployment prerequisites.

The findings file is on disk at the repository root, every cited snippet matches its line, and the working tree has no tracked changes (the findings file and scratch directory are both covered by ignore rules, which is the expected shape for a review task). Nothing else is pending.

Review result

Area: Economic Security, Invariant and Flow Gap guides, against src/IMDStockDex.sol. The full suite passes (65 tests plus 2 invariants), and I ran the economic edges the suite does not reach on the vendored real Uniswap v3 bytecode in a scratch test.

Findings written to .imd-findings.json (5 findings, 17 coverage rows, all 13 entry points answered):

1. Medium. The 0.5% fee, burn and creator payment are voluntary. The contract is a wrapper over public Uniswap pools it does not own or gate. Calling the router directly with the same path buys the same stock with IMD and pays no fee and no burn. Verified on real bytecode (direct buy of 1000 IMD gets ~996 stock, supply and creator balance unchanged). The fix is a scope decision for the requester: a v4 hook or DEX-owned liquidity, DEX-only primary issuance of the stock, or accept and document that the fee applies only to this front door.
2. Low. quoteBuy reports partial-fill outputs that buyStock always rejects. On a thin pool the quoter returned ~0.003 stock for 995 IMD; the purchase with the same inputs reverts with UnexpectedTokenBalance(imd) every time. No funds lost. Suggested fix: reject quotes whose final sqrt price sits at the tick limit.
3. Low. Test gap. The real-bytecode integration tests only use full-range 1e24 liquidity and 1 or 2 hops, so partial fills and the 4-hop maximum are never run against the real router. I ran both; the contract behaves correctly, so this is missing evidence, not a code defect.
4. Info. One global creator and split for all stocks. If the brief's "creator" means each stock's issuer, that is not implemented.
5. Info. setIMD is one-shot with no burn-interface probe, so a wrong IMD choice bricks the deployment.

What holds. Fee math equals exact floor division without overflow over the full uint256 range. Every purchase conserves IMD exactly (final DEX balance check, zero residual router allowance, buyer stock delta equals router-reported output), the burn is verified by supply delta, partial fills and every failure mode revert atomically with no fee taken, and reentrancy through router, IMD hooks or stock hooks is blocked by the shared guard. No loss-of-funds path was found, so no finding carries a proof test.

Not reached. Nothing in the assigned area was left unexamined. I did not verify Ondo token transfer-restriction behaviour against real Ondo bytecode, since none is vendored and no network address was supplied.

Added failure-path, fee fuzz, quote-safety, and multi-actor invariant tests, plus Uniswap rollback checks. All changes are under test/.

forge build and forge test pass: 102 tests, zero failures. The new invariant campaign exercised 16,384 calls.

No reproducible application defects found. Live deployment/fork verification remains outstanding.

The review is complete. All snippets validate against the tree, the scratch directory is removed, and .imd-findings.json is the only file added.

Outcome. The contract itself is tight: every state-changing entry point is guarded and reentrancy-safe, settlement checks exact balances at each step, and the 102-test suite passes. The one medium finding is architectural, not a code bug.

Findings kept (8, after merging 13 specialist items):

• Medium, fee bypass. The listed route is a public Uniswap v3 pool. Calling the SwapRouter directly with the same path yields about 0.5% more stock, with no burn and no creator payment. Reproduced on the vendored real v3 bytecode. The fix is a scope decision for the requester, since nothing inside the contract can close it.
• Low, creator may be the router. The self-reference guards are asymmetric. Owner can set the SwapRouter as creator, and the fee share then sits in the router where anyone can call sweepToken. Reproduced end to end, including the theft. The permissions specialist's proof fails on current code as claimed, so it is attached.
• Low, quote and execution diverge on thin liquidity. QuoterV2 returns a partial-fill output, while buyStock always reverts on the same state. Reproduced with a thin position.
• Low, test gap. The real-bytecode suite never reaches partial fills or a 4-hop route. I ran both; the contract behaves correctly, so this is missing evidence only.
• Four info notes. Global version bump on disableMarket, owner trust assumptions, single global creator, and one-shot setIMD.

Dropped. The minimum-order-size claim from the math specialist. FeeProperties.t.sol already pins that exact boundary for every split, so its "untested" premise was false and the behavior is documented.

Coverage. All 13 entry points answered: 10 hold, 3 carry findings. Three invariant rows added for fee arithmetic, factory deployment, and the Slither reentrancy leads.

All checks pass and the work is complete. Summary of this revision:

Outcome

• 71 tests pass, forge build and forge fmt --check are clean with the pinned 0.8.26 compiler.
• All seven findings are answered in .imd-responses.json. Every reproducible one was first reproduced in test/scratch against the real Uniswap v3 factory, SwapRouter and QuoterV2 bytecode before any change.

Code changes in src/IMDStockDex.sol

• Creator/router/quoter guards made symmetric (low finding, fixed). The creator can no longer be the router or quoter, and the router or quoter can no longer be set to the current creator. This closes the path where a creator share pushed to the SwapRouter could be taken by anyone via its permissionless sweep.
• Partial-fill quotes rejected (low finding, fixed). quoteBuy now checks every hop's post-swap price against the v3 tick-math bounds and reverts with InsufficientLiquidity when a pool ran dry, instead of returning an output that buyStock could never execute. A quoter returning the wrong number of hop prices reverts with InvalidQuote. Purchase logic is unchanged.

Tests added

• Real-bytecode tests for exhausted single-hop and intermediate-hop liquidity, for the router and quoter being rejected as creator, and one recording the fee-scope boundary.
• Mock-based tests for both directions of the creator guard and for quote metadata edge cases at and adjacent to the bounds. The mock quoter now returns one price per hop.

The medium finding is disputed, with documentation added. The bypass is real: anyone can swap on the public pool and skip the fee. But it is inherent to a DEX over third-party, freely transferable tokens, and none of the reviewer's alternatives closes it. A v4 hook gates one pool while anyone can create another, and this contracts-only launch deploys no token so the DEX cannot be the sole issuer. Only a transfer-restricted stock token whose issuer allows the DEX as sole venue would make the fee unavoidable, and that is the issuer's power. I took the reviewer's option (c): the README now has a "Scope of the fee" section, the contract NatSpec and SECURITY.md state the boundary, and a test records it. The requester should decide whether this scope is acceptable or whether to order a gated token or hook launch separately.

Info findings. Owner trust assumptions and the recommended post-launch rehearsal purchase are now documented in the README. The global version bump on disableMarket and the single DEX-level creator are kept as intended design and explicitly documented, with the per-stock creator noted as a possible scope change for the requester.

Nothing was committed, matching the previous round where the harness recorded the commit.

The manifest at launch.json is correct as it stands and needs no change this round.

What I verified

• The accepted source has one application contract, IMDStockDex, whose only constructor parameter is the explicit owner address. The manifest lists exactly that contract with a single $owner argument, which resolves to the launch owner the README also documents.
• The file has exactly the keys kind, contracts and notes. The kind is "evm_contracts", every argument is a string, the contract name is a valid identifier, and the notes are well under the limit at about 1,200 characters.
• No creator address, fee split, IMD token, router or quoter is a constructor input. The accepted implementation leaves all of those to owner-only setters while paused, so the manifest carries no stand-in addresses and no initialization calls.
• forge build succeeds and the full suite passes with 71 tests across 4 suites, including the accounting invariants.
• A scratch rehearsal mirroring the protected probe deployed the contract via create2 from a factory on an empty chain id 1 with the owner argument. The deployed contract reports the launch owner, starts paused and unconfigured, fits under the EIP-170 size limit, and contains no DELEGATECALL, CALLCODE or SELFDESTRUCT opcodes.

Outcome. No revision findings were supplied with this assignment, and the existing manifest matches the accepted implementation and the brief, so I left launch.json byte-for-byte as accepted. The working tree is clean apart from the scratch test, which is outside the submitted paths.

Of the earlier findings, one is fixed, three are settled by documentation and three are design or trust points I'm not reopening. One new issue holds up, at low severity. It's in .imd-findings.json, along with a coverage row for all 13 entry points: 12 holds, 1 finding. No source files were changed. I ran the tester's proof from a scratch test folder and deleted the folder afterwards.

New finding (low): a multi-hop purchase that runs dry on a later hop still succeeds and still charges the full fee.

• Where: src/IMDStockDex.sol:302, _requireDecrease(imd, address(this), imdBefore, amountIn);
• Why the guard misses it: this line rejects a partial fill only by checking that the router spent all of the net IMD. On a route with more than one hop, the first hop always takes all the IMD. If a later pool runs out of liquidity, Uniswap v3's router consumes only part of the intermediate token. The rest stays in the router, where anyone can take it with sweepToken.
• Result: the buyer receives less stock but still pays the full 0.5% fee, including the burn and the creator's share.
• What it contradicts: the quoteBuy NatSpec and docs/SECURITY.md both say such a purchase reverts.
• Why only low: the buyer's minStockOut limits the loss. A buyer who takes it from a quote on a healthy route is protected, because the purchase reverts on insufficient output.
• Proof: I ran the tester's proof (Proof_a51d2dec88ce.t.sol) and attached it to the finding. It fails on the current code for the stated reason: the purchase is accepted and 995e18 of the intermediate token is left in the router. The proof uses a stand-in router, not the real Uniswap bytecode. I checked against the real Uniswap v3 router's multi-hop logic and it behaves the same way.
• Fix: after the swap, revert if the router's balance of any intermediate token went up. Otherwise, correct the NatSpec and docs/SECURITY.md to say minStockOut is the only protection on later hops.

Earlier findings:

• Fixed:
  • The creator can no longer be the router or the quoter.
  • quoteBuy now reverts when any hop's liquidity would run out.
• Settled by documentation, no code change:
  • Fee bypass: a buyer can still swap directly on the Uniswap pool and skip the 0.5%. The author chose the option I offered of documenting that the fee applies only to purchases through this contract, and I accept that.
  • Global version bump: disabling one market still invalidates pending orders on every other market. It's intended and now documented.
  • One-shot IMD setting: the address can only be set once, with no check that its burn works. A dry-run purchase before launch is now documented.
• Design or trust points, not reopened: the owner's control over router, quoter, listings and fees, and the single creator shared by every listed stock.
• Missing tests: the test file has no thin-liquidity or 4-hop case. That is a test gap, not a code defect, so I haven't restated it.

The static-analysis leads didn't produce anything new. The reentrancy warnings are covered by the reentrancy guard and the exact balance checks. The divide-before-multiply warnings are the intended remainder-preserving fee calculation.