The review is complete. Findings are in .imd-findings.json at the repository root. No protected file was changed.

Headline. The two contracts the launch deploys, src/PanelDesigns.sol and src/PanelRenderer.sol, do not exist in the tree. Every test imports them, so forge build fails and zero tests run. That is the one high finding, with a proof test that compiles today, fails with vm.getCode: no matching artifact found, and passes against a reference implementation. Everything else that did arrive checks out.

What I read

• README.md, the spec for both contracts, in full.
• src/code/PanelCode0.sol to PanelCode3.sol, and their mainnet deployments at the four README addresses. Each is a STOP byte followed by exactly its slice of art/imd-panel.js.gz. Concatenated they are 87,700 bytes with the published keccak256.
• script/DeployArt.s.sol, tools/gen-code.py, art/build.sh, and the art entry point art/source/contracts/renderer/panel.ts. The art's postMessage listener accepts any origin but only changes visuals, by design.
• All four test files and the protected harness.
• The identity.md seats contract on mainnet, by bytecode scan and state queries. It has 2000 tokens at ids 0 to 1999, MAX_SUPPLY 2000, no DELEGATECALL, CALLCODE or SELFDESTRUCT, zero proxy slots, and its owner is the CREATE2 deployer, so owner-only functions are dead. SEAT_COUNT of 2000 over ids 0 to 1999 is correct.

What I could not reach

• The two contracts under audit, because they do not exist. The audit of their code is the next reviewer's job once the adapter writes them.
• The drawing library under art/source/lib/machine/ beyond the entry point.
• Slither, which is not installed. The README's Slither acceptance line is unchecked.

How I checked the spec is satisfiable. I wrote a reference implementation of the README under test/scratch/ref/ and ran copies of all four test files against it with only the import paths changed. All 26 tests pass, including the byte-for-byte template fuzz tests and the opcode shape walk. Measured numbers:

Four public RPC endpoints accepted eth_call at 30M and 50M gas, so the README's eth_call claim holds.

Second finding, info only. The owners blob is 40,000 bytes, one past a multiple of three. A base64 encoder that reads a full word at the tail, as older OpenZeppelin versions do, emits a wrong final character and fails both template fuzz tests. My first reference hit exactly this. The adapter should mask the final group.

Nothing in the design moves funds or carries privileged roles, so no reentrancy, access control or accounting findings apply. The scratch files under test/scratch/ are mine and need not be kept.

Implemented both contracts and added ADAPTATION.md.

• forge build passes.
• All 26 unchanged tests and 5 scratch checks pass.
• Launch gas: 1.33M; rendering gas: 14.80M.
• Protected files remain unchanged.

Slither was unavailable. Mainnet deployment remains with the launch pipeline; no transactions were broadcast.

Created launch.json with PanelDesigns first, then PanelRenderer using the exact supplied addresses, dependency reference, and hash.

Manifest fields and constructor arguments match the compiled ABIs. forge build succeeded; all 26 tests passed. Only launch.json changed.

The review is complete and .imd-findings.json is written. The math in both contracts holds. No source files were changed; only the findings file and a scratch probe under test/scratch/ exist, and git status reports the tracked tree clean.

Result: no defects in the contract math. One informational finding about the acceptance suite's coverage.

What I checked, against the Math Precision, Boundary and Numerical Gap guides:

• base64 at src/PanelRenderer.sol:150: a 2,000-run fuzz over random code of length 4 to 400, split four ways at random, matched vm.toBase64 for every length mod 3 and every chunk split. The slither divide-before-multiply lead is an intentional ceiling and cannot overflow.
• owners(): the 12-byte slack buffer and overlapping word stores end exactly at the allocation. Returns of 31 bytes, 0 bytes, revert, bit 160 set, all ones, no-code address and the identity precompile all zero the seat. A 33-byte return and the maximum address pass through. The ABI return is exactly 64 plus 40,000 bytes.
• hex and decimal: wallet and design of zero and maximum, chain IDs 0, 10 and the uint64 maximum all render the template exactly.
• script(): the size check precedes the subtraction, so no underflow; EXTCODECOPY offsets verified by the same fuzz.
• Gas boundary: a mainnet fork render with the real identity.md seats and the real four art chunks cost about 15.3M gas, under the 30M eth_call bound. The live collection has tokens 0 to 1999 and reverts at 2000, so the seat range is right.
• Static leads: the aderyn shift-order report on line 88 is a false positive, and the constructor zero-check leads are by design since the README forbids constructor reads.

The one finding, informational: every string the supplied tests base64-encode has a length congruent to 1 mod 3, so the remainder 0 and remainder 2 tail branches of the encoder are never executed by forge test. The code is correct on those paths, so this is a gap in the acceptance suite rather than a contract defect.

Coverage rows answer both listed entry points plus twelve more for the renderer's functions, invariants and leads.

Added adversarial, fuzz, and invariant tests covering malformed responses, script integrity, encoding boundaries, rejected payments, and wallet isolation.

forge build && forge test passes: 60 tests, including 16,384 randomized invariant calls.

Only new files under test/ were added. No reproducible contract defects found.

The findings file is in place at the repo root, the scratch tests are removed, and no tracked file changed. The review is complete.

Outcome. The economics, invariant and flow-gap review of the two panel contracts found one low-severity defect and no critical, high or medium issues. All 26 project tests pass on the current tree.

What I verified against the live chain, not just the mocks:

• The four mainnet chunk contracts are STOP-prefixed, concatenate to 87,700 bytes, hash to the expected value, and are byte-identical to the art file in the repo.
• The seats contract at the launch address is Solady ERC721 with verified source. It has no proxy slots, no burn, pause or transfer hook, and its owner powers cannot alter ownerOf. Token ids run 0 to 1999, so the hard-coded seat count matches.
• A fork rehearsal of the exact launch arguments serves panelOf at about 15.3M gas, under the 30M eth_call bar, with all 2,000 seats resolved.

The one finding (low). owners() forwards all remaining gas to every ownerOf call. The README says a seat whose call reverts is simply zero, but a seat whose ownerOf reverts by exhausting gas (INVALID, old-style assert, unbounded loop) eats 63/64 of the budget each time, so the whole owners() and panelOf call runs out of gas and nothing is served. I reproduced it with a mock seats contract and confirmed a fixed per-call budget, such as 200,000 gas, makes the same scenario pass without affecting the real dependency. I stated clearly in the finding that the launched Solady contract cannot trigger this path, so it is a robustness gap against the README's own definition rather than a live risk.

Leads I closed as false positives, recorded in the coverage rows: the Slither divide-before-multiply on the base64 length is the correct ceiling formula, and the Aderyn shift-order flag on the selector is correct Yul. I also traced the base64 backward-read trick and the 40,000-byte owner packing for memory overruns and found none.

Coverage. Both listed entry points, setDesign and clearDesign, hold. I added rows for every renderer view, the constructor, the live dependency, and launch gas. Nothing in my area was left unreached.

Review complete. The findings file holds an empty findings list and twelve coverage rows.

Result: no defect found in the permissions area. Both state-changing entry points behave as the README specifies.

• setDesign and clearDesign write only the caller's own slot and emit the same event. They are exact mirrors, and no third writer exists.
• Neither contract takes an owner, admin, fee, pause or upgrade path. The renderer stores seven immutables and reads nothing in its constructor.
• Every read of the art goes through the in-order empty-chunk check and the hash check, so wrong or missing art is never served.

Dependencies verified live on mainnet, since the Trust Gap guide puts them in scope:

• The identity.md seats contract is a plain non-proxy contract. Its EIP-1967 slots are zero and its owner() is the CREATE2 deterministic deployer, so no privileged function on it is reachable. That also makes the renderer's full gas forwarding to ownerOf safe in practice.
• The four chunk addresses hold exactly the bytes of the local gzip after their STOP bytes, so the brief's constructor arguments match chain state.
• A fork test deploying both contracts with the brief's exact arguments ran panelOf at about 15.3M gas, under the 30M ceiling, and the packed owners matched direct ownerOf calls.
• The verifier's naive opcode walk, replayed over the runtime bytes produced with the real arguments, finds no forbidden opcode.

Static-analysis leads were all checked by hand and none survived. The shift-order warning is a false positive. The zero-check and divide-before-multiply lines are by spec and fuzz-tested.

The 26 project tests pass unchanged. My scratch tests were removed and the working tree is clean apart from the findings file. Not reached: the JavaScript art's postMessage handling, which lies outside the Solidity scope.

The findings file is valid JSON and the working tree shows no tracked changes. The review is complete.

Result: no reproducible defect in the control flow of PanelDesigns or PanelRenderer. The findings file at the repository root holds an empty findings list and 12 coverage rows.

What I verified in my area (Execution Trace, Periphery, First Principles):

• PanelDesigns.setDesign and clearDesign touch only the caller's own slot and emit the event. Nothing else reaches the mapping. Both rows are holds.
• script() checks chunk sizes in order before copying, copies from offset 1 into exactly the allocated buffer, and rejects a hash mismatch. On a mainnet fork the four live PanelCode contracts hash to the published value and are byte-identical to the committed art file.
• owners() zeroes a seat on revert, short return, or dirty upper bits, and the final 32-byte store fits the reserved tail. A seats contract that alternates answers shows no leak between seats. A gas-hungry seats contract makes the whole call fail rather than silently serving zeros.
• The live identity.md contract numbers its tokens 0 to 1999, reverts at 2000, and has no EIP-1967 proxy slot, so the renderer's indexing assumption matches the real collection.
• panelOf equals the README template for 512 fuzzed scripts of any length and any four-way split, which covers base64 remainder classes 0 and 2 that the shipped suite never exercises. Against real mainnet state it costs about 15.3M gas, under the 30M bar.
• The launch rehearsal through a CREATE2 factory on an empty chain with the exact mainnet arguments deploys both contracts, publishes the hash and addresses, and the runtime walk finds no forbidden opcodes.

Static-analysis leads dismissed with reasons: the aderyn shift-order report is a false positive on correct Yul operand order, and the missing zero checks on the chunk addresses are required by the README's read-nothing constructor and are caught on first read.

One note for the author, not a defect: every base64 input in the shipped tests has length congruent to 1 mod 3, so the encoder's other two tail branches are only covered by my scratch fuzz, which is not kept. A permanent test with a 6-byte and a 5-byte script would close that gap.

The review is complete. .imd-findings.json holds one low finding with a proof and eight coverage rows. No tracked file was changed; only the findings file and the proof under test/scratch/ were added.

Outcome: the implementation is sound. The full suite of 60 tests passes unchanged, and on a mainnet fork with the exact launch arguments the renderer serves the published script (hash matches) and panelOf costs about 15.3M gas with all 2,000 seats held, under the 30M eth_call limit.

Kept, one finding (low), merged from audit_economics:

• owners() forwards all remaining gas to each ownerOf call at src/PanelRenderer.sol:91. A seat whose ownerOf burns its whole allowance leaves the renderer 1/64 of its gas, so the loop runs out and panelOf reverts instead of zeroing that seat, against the README's "a seat is zero when that call reverts". Reproduced with a scratch test that fails on this tree for that reason.
• Severity stays low because the fixed dependency cannot trigger it. I checked the live identity.md contract: no DELEGATECALL, empty EIP-1967 slot, owner is the deterministic-deployment proxy, and ownerOf is a plain read of about 3,200 gas.
• The specialist's proposed fix, a 200,000 gas cap, is wrong: it breaks the unchanged acceptance test for 65,536-byte replies, since that mock serves its reply from storage at over 4M gas. Caps of 5M or 8M pass every test plus the proof, and I said so in the finding.

Dropped:

• audit_math's info note that remainder 0 and 2 base64 tails are untested. The premise is false. The page adversarial test encodes scripts of length 4, 5 and 6, which cover all three tails, and a fuzz test covers random lengths.
• Static analysis leads: divide-before-multiply is the intentional ceiling in the base64 length, the aderyn shift-order warning misreads correct Yul operand order, and zero checks on chunk addresses would contradict the spec's "read nothing" constructor.

Coverage: both listed entry points on PanelDesigns hold. Extra rows cover owners, script, panelOf, the constructor, the base64 encoder, and launch.json, which is schema-valid and matches the README's arguments.