The review is complete and .imd-findings.json holds 8 entries, every snippet verified against its line in the tree. No source file was changed; the scratch tests were deleted after running.

Outcome. No critical or high defect. One medium, four low, three info. The vault's accounting, access control and randomness held up under adversarial tracing and the tree's own invariant suite.

Findings written to the report

• Medium, src/InkVault.sol:306. The admission loop inside every reveal is unbounded. Measured on this tree at 33.4k gas per pending deposit, so about 1,080 portraits deposited after the last revealed pull and before the next pull make that reveal, and every later one, exceed a 36M block forever. Every later puller's 400,000 INK is locked with no refund path. Heavy precondition (a whale holding over half the collection), which is why it is medium rather than high.
• Low, src/InkVault.sol:406. The vault accepts safeTransferFrom of a portrait but never uses that path, so the token is stranded, no INK is paid and it never joins the draw. Reproduced.
• Low, src/InkLiquidity.sol:100. setPool on a never-initialized pool records a zero floor tick permanently, and does not check the key's hook or counter-currency. Reproduced.
• Low, src/InkVault.sol:356. A pending trait reroll does not block transfers, and the new seed is public one block after the request, so a seller can pass a known-bad repaint to a buyer. Reproduced.
• Low, launch policy. Lists every post-deployment owner setter across the four configured contracts, with the reason most cannot move into constructors (INK and the pool do not exist yet, Portraits and Vault reference each other). All roles go to the owner_ argument, none to msg.sender or tx.origin; the treasury holds no role.
• Info. Permissionless addLiquidity lists at the spot tick (modelled as unprofitable to sandwich at the current fees), release() has no escape hatch if setPool was skipped, and a coverage entry.

Coverage. Read in full: TestSeats, InkPortraits, InkVault, InkLiquidity, InkRenderer, plus InkHook for the trust the vault places in it. Checks run: the existing suite (55 passed, 0 failed, 28 fork tests skipped cleanly without an RPC), forge build --sizes (all five under EIP-170), Slither medium and high on src/ (no High), and an opcode scan of the five runtimes (no DELEGATECALL, CALLCODE or SELFDESTRUCT). Not reached: the real Sepolia PoolManager/PositionManager minting path (no fork) and the renderer's JavaScript trait parity.

For the adapter. Constructor argument counts and order match the task for all five contracts, and no constructor calls another contract, so the tree deploys as ordered. The one thing to settle before the manifest step is the post-deployment setter list in the low finding, since the recipe's letter forbids it while the task's own deploy order relies on it.

Implemented four reproduced audit fixes and prepared the five-contract Sepolia deployment handoff, preserving constructors and ownership.

• forge build: passed.
• Seeded forge test: 71 passed, 0 failed, 28 skipped.
• Changes and audit dispositions: ADAPTATION.md.

No transactions were broadcast; deployment remains IMD’s subsequent step. Live Sepolia verification was unavailable because the public RPC returned HTTP 403.

Created launch.json with the required contract order, constructor arguments, $owner roles, treasury, and official Sepolia Uniswap addresses.

Verified manifest constraints and compiled constructor ABIs. forge build passed. Tests using the supplied fuzz seed: 71 passed, 0 failed, 28 skipped for unavailable fork/snapshot prerequisites.

Only launch.json is included in the deliverable.

The review is complete and the findings file is written and validated.

Outcome. The math across the five deployed contracts holds up. I found one low-severity boundary defect and no precision or numerical-gap defects. The file .imd-findings.json holds that finding plus 55 coverage rows, one for each of the 52 listed entry points and three for invariants and the static-analysis leads.

What I checked in depth (Math Precision, Boundary, Numerical Gap):

• InkLiquidity ladder and single-position math. I replayed the ladder split and the Uniswap v4 round-up for every possible release amount (1 to 2000 unclaimed seats) and a sweep of single-position ticks at the launch price. The mint never asks the position manager for more INK than the contract allows, intermediate products stay far below overflow, and the last band absorbs split rounding. The currency1 path (Sepolia, where ETH is currency0) is safe by construction.
• InkVault fees and backing. Every allowed fee rate divides the 400,000 INK portrait exactly, so there is no truncation at all. Pull, deposit, release and reveal keep the backing invariant, and the pull admission check runs before any multiplication that could overflow.
• InkHook fee. The specified-side convention matches the v4 Hooks library, negation only fails at an unreachable int128 minimum, and the minted claim nets the hook delta to zero.
• InkPortraits bitmap and swarm numbering, InkRenderer threshold arithmetic, and all window boundaries (claim ends exactly when release opens).

The one finding (low): InkVault.setup() checks only that the liquidity address is non-zero. If the owner passes an address with no code or a non-InkLiquidity contract, release() reverts forever, trading and pulls never open, and the 800,000,000 INK allocation is stuck, because setup and setInk are once-only. Reproduced in a scratch test. This is an owner-input error, so it is reported as a missing boundary check rather than an attack.

Static-analysis leads. All examined and dismissed with reasons in the coverage record: the divide-before-multiply lines are intentional tick flooring, the unsafe cast is bounded by INK supply, and the weak-PRNG lead is the documented next-block-hash design.

Tests run. The existing suite passes (71 tests, fork suite skipped). Scratch probes live under test/scratch/ and are not part of the submission.

Added failure-path, fuzz, and stateful vault/liquidity tests under test/, using local Uniswap v4 contracts.

Validation passed:

• forge build
• Required-seed forge test: 106 passed, 0 failed, 28 skipped

Live Sepolia deployment and fork verification remain unperformed.

The review is complete. .imd-findings.json holds 4 findings and 54 coverage rows, with every snippet verified against the tree. The only files I created are the findings file and the scratch test under test/scratch/, which the assignment allots to me.

Outcome: no unprivileged access-control break, trust-gap exploit or asymmetric fee path was found in the five Sepolia contracts. The existing suite passes, and the owner roles match the brief.

What I verified

• Every Ownable contract takes the owner from its constructor argument, the ERC-2981 receiver is that owner at 0 bps, the treasury is a role-less immutable EOA, and TestSeats has no owner.
• The Sepolia PoolManager address has code and the PositionManager reports it as its pool manager, checked over a live RPC. The adaptation notes had left this unverified.
• Full Foundry suite excluding fork-only files: 71 passed, 0 failed, 14 skipped.
• Traced every onlyOwner, onlyVault and onlyPoolManager guard, the vault's deposit, pull, reveal and reroll paths for ownership and fee-class asymmetries, and the liquidity contract's permissionless addLiquidity and collectFees for sandwichable or misdirected value. All hold.

Findings reported

1. Low. setInk, setPool and setup are three independent one-shot owner calls with no cross-check. A mismatched INK address or a non-contract liquidity address makes release() revert forever, locking the unclaimed seats' INK with no recovery. Owner-triggered, so demoted per the validation gates. Reproduced by two passing scratch tests in test/scratch/SetupConsistency.t.sol.
2. Low. InkHook.beforeInitialize binds the hook to the first pool that pairs IMD with anything. This is only exploitable if the hook is deployed in a different transaction from the pool initialization, which the later hook launch must confirm. Not part of this launch.
3. Info. Owner trust assumptions documented: setVault grants the minter role to any address, the renderer is swappable until locked, ownership is single-step and renounceable, and the royalty receiver is fixed to the constructor owner.
4. Info. TestSeats.mint is permissionless, so any Sepolia address can claim any seat's portrait. Intended for the testnet stand-in and must not carry to mainnet.

Not reached: no fork tests ran, since they need an RPC the suite skips without. Nothing else in my area was left unchecked.

Review complete. The findings file is written and validated, the scratch test is removed, and no repository file was changed.

Outcome: no critical, high or medium economic defects. The vault's backing invariant holds exactly: vault INK equals 400,000 per portrait outside the vault plus per pending pull, through claim, release, pull, reveal, deposit and trait reroll, with no rounding slack needed. The pull capacity check and the strict deposit-block cutoff mean an unprivileged actor cannot steer or re-draw a known pick. The hook's fee sign, currency and claim accounting match Uniswap v4's afterSwap delta handling. InkLiquidity positions cannot be removed by anyone.

Findings written to .imd-findings.json:

• Low: the setInk, setup and setPool settings are each write-once with no correction path. If the vault's INK and InkLiquidity's INK differ, release reverts with NothingToAdd forever, the pool never unlocks, pulls never open, and the 800M INK is stranded. Owner misconfiguration is required, so it is a trust and operations finding, with a concrete state sequence.
• Info: on Sepolia, TestSeats lets anyone mint every seat, claim all 2,000 agent portraits, redeem each for 400,000 INK fee-free, and leave zero swarm slots so pull can never succeed in the rehearsal. This is the documented stand-in behaviour. The mitigation is a stats root limited to team seats.

Leads checked and dropped:

• Spot-following permissionless listing, previously disposed as a tradeoff. I measured it in the project's own harness: selling to the floor, relisting 400k fee INK, and buying back cost the attacker 23.8 IMD versus 3.58 IMD at market. Not profitable.
• Both Sepolia Uniswap addresses in the adaptation have code, and the PositionManager reports the listed PoolManager.
• Slither leads (weak PRNG, strict equality, reentrancy in deposit) traced to acknowledged next-block randomness, a correct ladder boundary, and a nonReentrant path with view-only callbacks.

Coverage: all 52 listed entry points have rows, plus three invariant rows. The existing suite passed 71 tests with 28 fork and fixture tests skipped.

Findings file is written and verified: both snippets match the tree exactly, the JSON parses, and the coverage record answers all 52 listed entry points plus two invariant rows.

Outcome: .imd-findings.json holds 2 substantiated findings and 54 coverage rows. The existing suite passed before review (71 passed, 0 failed, 14 skipped, the fork tests). The Sepolia Uniswap v4 addresses in the adaptation were checked live over three RPCs: the PoolManager has code and the PositionManager's poolManager() returns it.

Findings

1. Medium, src/InkVault.sol:288. Renewing the head pull admits deposits by the renewed block, so a pull queued behind it draws, with its original and already public hash, over portraits handed in after its own block. This breaks the contract's documented rule that nobody can change what a pull picks once its hash is public, and a depositor who knows the victim's random value can choose how many portraits to hand in to steer the pick. Precondition is an earlier pull left unrevealed past 256 blocks or hitting zero availability. The attached Foundry proof under test/scratch/RenewalWidensDraw.t.sol fails on the current code.

2. Low, src/InkVault.sol:147. The one-shot setInk takes any address with no funding check, while the funding check sits in the retryable setup. A wrong value can never be corrected and strands the vault's full 800 million INK allocation with no path out. Owner error is required, so this is a footgun rather than an attack. A scratch test walks the bricked state.

Coverage. Every vault, portraits, liquidity, renderer and TestSeats entry point was traced for checks, state changes and failure paths. Hook and fee router entry points are outside this launch; I traced their swap-delta, lock and payout paths anyway and found nothing to report. Static-analysis leads were checked and none rose to a finding: the weak PRNG is documented design, the strict equality and uninitialized locals are benign, and the ceil-of-ceil rounding in position minting cannot exceed the supplied maximum.

Not covered. Trait parity between the on-chain labels and the art script, and production-router authentication of the hook's holder waiver, belong to other specialists and were not examined.

Review complete. The findings file at .imd-findings.json holds 5 findings and 55 coverage rows, one for each of the 52 listed entry points plus three invariants.

What I kept, after reproducing each against the code

• Medium, InkVault.reveal / revealNext. Renewing the head pull passes the renewed block to _admit, so deposits made after a queued pull's block, and after its block hash is public, join that pull's draw. The specialist's proof fails on the current code for exactly that reason, and it is attached. No INK is lost. The documented fairness rule is broken when the head pull idles past 256 blocks or hits zero availability.
• Low, merged from four specialists. The write-once setters setInk, setup, setPool and setVault validate nothing about each other. A wrong token, an EOA as liquidity, or an INK mismatch makes release revert forever and strands the 800 million INK allocation. Reproduced with three scratch tests in test/scratch/JudgeRepro.t.sol. Owner error only, so low.
• Low, InkHook.beforeInitialize. The first IMD-paired pool initialized with the hook binds it, whoever initializes it. Reproduced locally with a real PoolManager. The hook belongs to the later hook launch, so this is a note for that launch's atomicity.
• Info, TestSeats. Permissionless mint lets anyone claim any seat and redeem it for 400,000 INK on Sepolia. By design per the brief, merged from two specialists.
• Info, formatting. The formatter check fails on three over-long signatures in src/InkHook.sol. The other six source files pass.

What I dropped or folded

• The separate owner trust-surface note from audit_permissions is folded into the merged low finding, since its concrete items share that root cause.
• No slither or aderyn line reproduced as a defect beyond the weak-PRNG lead, which is the documented blockhash design and only matters through the admission bug above.

Checks run

• Existing suite: 106 passed, 0 failed, 28 skipped (fork and env-gated tests).
• Manifest: keys, names and constructor argument order match each constructor. The Sepolia PoolManager and PositionManager addresses have code and the PositionManager points at that PoolManager.
• Deployability: no constructor calls another contract. Largest runtime is InkRenderer at about 12.7 KB, well under the limit.

Nothing in the tree outside test/scratch/ and .imd-findings.json was changed.

The revision is complete. The reviewer's medium finding reproduced and is fixed, the held proof now passes, and every finding is answered in the responses file.

What reproduced and what changed

• Medium 4ca49345, fixed. The proof failed on the accepted tree exactly as reported. Renewing the head pull passed the renewed block to admission, so hand-ins made after a queued pull's block joined that pull's draw. In src/InkVault.sol a renewal now records the pull's original block before moving its entropy block, and admission always uses the original block. The new pullBlock view exposes it. Since the cutoff no longer moves, a pull that counted a hand-in from its own block could never have been revealed, so pull now counts only hand-ins from earlier blocks through the new waitingBefore view. The draw rule, entropy, selection, batching and fees are unchanged.
• Low 71ef9819, partly addressed and otherwise disputed. setup now rejects a liquidity address with no code while the owner can still correct it. The other suggested cross-checks would break the reviewer's own proof fixture, which only implements addLiquidity, and the wrong-token cases cannot be detected without a reference value the brief does not give.
• Low eb210c01 and info 9d091aab, disputed. The hook is not deployed by this launch, and permissionless TestSeats minting is what the brief orders for Sepolia. No code changed.
• Info 6b948270, fixed. The hook file was reformatted. The formatter check on src passes.

Tests and checks

• Three new regression tests cover the review scenario, repeated renewals with a pull queued behind, and the same-block rule with a full collection. A fourth covers the setup no-code check. The invariant handler and its queue-coverage invariant now use the stricter capacity rule.
• Three fixtures that passed the ecrecover precompile as a never-called liquidity stand-in now pass a contract.
• Full suite with the verifier's fuzz seed: 75 passed, 0 failed, 28 skipped (the skipped tests are the existing optional fork tests). The proof passes from a copy under test/scratch. Build and size check pass. The vault runtime grew to 11,120 bytes.

ADAPTATION.md and README.md document each change, and .imd-responses.json holds the five verdicts. The remaining formatter diffs are in test files I did not touch, so I left them alone.

No findings were listed for this round, so I left the accepted work alone. forge build succeeds, and forge test with the verifier's seed passes all 110 tests and fails none. The 28 skipped tests are the fork and snapshot suites that only run when an RPC URL is configured.

What I added: the last source change gave each pull in InkVault a fixed admission cutoff (pullBlock, waitingBefore). The other contributor's unit tests cover it, but the random-sequence vault suite didn't check it. I added one invariant there:

• test/VaultInvariants.t.sol:
  • The handler now records the block each pull was made in.
  • invariant_pullCutoffFixed checks that the vault keeps every pull. For the oldest unrevealed pulls (up to 64, plus the last revealed one), it checks that renewal never moves the cutoff and that the block whose hash picks the portrait is never earlier than it.
  • It passes over 256 runs of 120 calls.
• test/PROPERTY_COVERAGE.md: one sentence describing the new invariant.

I found no defects, so there is no .imd-findings.json. Checks against the live Sepolia contracts still need to be done; they can't run offline. The changes are uncommitted.

The accepted launch.json already satisfies the brief, and the revision prompt listed no findings to act on, so I left it unchanged.

What I verified

• The manifest has exactly the keys kind, contracts and notes, with five unique contracts in dependency order and notes under the length limit.
• Each constructorArgs list matches the accepted source one entry per parameter: TestSeats takes none, InkPortraits takes the owner, InkVault takes the portraits, seats and owner, InkLiquidity takes PoolManager, PositionManager, owner and treasury, and InkRenderer takes the portraits and owner.
• The Uniswap v4 addresses in the manifest are the official Sepolia PoolManager and PositionManager, and they match the constants the repo's own Sepolia launch test uses.
• Every owner argument is $owner. The royalty recipient in InkPortraits is also the owner argument, at a zero rate. The treasury address only receives IMD fees and holds no role.
• No constructor calls another contract, so the empty-chain rehearsal in the protected test will not revert. All five runtimes are well under the EIP-170 limit.

Checks run

forge build --sizes                     # compiled, five contracts between 3.8 kB and 12.7 kB runtime
FOUNDRY_FUZZ_SEED=0x30c0...c635 forge test --no-match-path test/MainnetFork.t.sol
# 75 passed, 0 failed, 14 skipped

The mainnet fork suite was skipped because it needs an RPC. The working tree is clean, so no file other than the manifest from the previous round is in the submission.

The review is complete. The findings file is written and validated, with all 52 entry points answered.

Outcome: the one blocking finding is fixed, and nothing new blocks the launch.

Settlement of my earlier findings:

• Renewal widened queued draws (medium, 4ca49345): fixed. The vault now records a renewed pull's original block in _madeBlock and admits hand-ins against that block, so a renewal moves only the entropy block. My attached proof and the audit_flow proof both pass on the revised code. My own scratch test with two consecutive renewals of the head pull, hand-ins between them and a pull queued behind confirms the queued pull keeps its cutoff and the hand-ins wait for a later pull. The companion change, counting only hand-ins from earlier blocks in pull(), is correct: a same-block hand-in is refused and counted from the next block, and I found no path to a pull with zero candidates.
• Formatter check (info, 6b948270): fixed. The check on the source directory exits 0 and the hook diff is signature rewraps only.
• One-shot setters (low, 71ef9819): partly fixed, remainder kept at low as advisory. setup() now rejects a liquidity address with no code, which I confirmed. A wrong setInk() still strands the allocation, and I re-reproduced that. The author's reasons for not adding the other checks are documented and acceptable as a trust assumption. It does not block.
• Hook binds to the first pool (eb210c01): downgraded to info. The hook is not in this manifest and its code is unchanged apart from formatting. Recorded for the later hook launch.
• TestSeats.mint permissionless (9d091aab): info, by design. Unchanged, as the brief orders.

Checks run this round: the full suite passed with 111 tests and 28 skipped fork tests, plus four scratch tests I wrote under test/scratch, which is not kept.