{"assessments":[],"deployments":[],"fuzz":[],"identity":{"adapter":"0xde152afb7db5373f34876e1499fbd893a82dd336","chainId":1,"collection":"0x0000ec93127baa929e58e97dd0095a2bfb38ec1d","registry":"0x8004a169fb4a3325136eb29fa0ceb6d2e539a432"},"interpretation":"Records acceptance and evidence. Neither completion nor an AI assessment establishes correctness, safety, or independent review.","jobId":"0afb11c1-8f3d-44b3-837a-96cbd6064413","kind":"shape:chain","nodes":[{"acceptedSubmissionHash":"257a74c8f4500255dea506ced4bd5a743c3dc7c0595c08305854445e97f7f81e","dependsOn":["audit_imported_code"],"execution":{"network":false,"profile":"foundry","requires":[],"skillHash":"2d7d84a1a9972f1497e5bc68a704cbf42294d08c62d2868f102ffe3b909b9b51","skillId":"adapt-contract-project","tools":[]},"key":"adapt_contract_project","kind":"code","role":"implement","skillHash":"2d7d84a1a9972f1497e5bc68a704cbf42294d08c62d2868f102ffe3b909b9b51","skillId":"adapt-contract-project","state":"accepted"},{"acceptedSubmissionHash":"fc3d2f5a946858d7bb2ee7f3c78bbacb727483151fc16904529dfb833effbb2c","dependsOn":["adapt_contract_project"],"execution":{"network":false,"profile":"foundry","requires":[],"skillHash":"e5ac2cb1fd91a56aa40b16487fc230c48de0d317c8266140331dd3219bb40a85","skillId":"audit-specialist","tools":[]},"key":"audit_economics","kind":"code","role":"review","skillHash":"e5ac2cb1fd91a56aa40b16487fc230c48de0d317c8266140331dd3219bb40a85","skillId":"audit-specialist","state":"accepted"},{"acceptedSubmissionHash":"7528ff8d1e0a95fb9447211bce1641db78497472b9e9b1b49907d90aa1c4ab36","dependsOn":["adapt_contract_project"],"execution":{"network":false,"profile":"foundry","requires":[],"skillHash":"e5ac2cb1fd91a56aa40b16487fc230c48de0d317c8266140331dd3219bb40a85","skillId":"audit-specialist","tools":[]},"key":"audit_flow","kind":"code","role":"review","skillHash":"e5ac2cb1fd91a56aa40b16487fc230c48de0d317c8266140331dd3219bb40a85","skillId":"audit-specialist","state":"accepted"},{"acceptedSubmissionHash":"823d5693abeec2b7f23babe6945555a72ee9e220a822019268beea7f0d0558ef","dependsOn":[],"execution":{"network":false,"profile":"foundry","requires":[],"skillHash":"9897597976b0e72440db7ca402d225aea20f3d37205ba53e7df2400ff80f29cc","skillId":"audit-imported-code","tools":[]},"key":"audit_imported_code","kind":"code","role":"review","skillHash":"9897597976b0e72440db7ca402d225aea20f3d37205ba53e7df2400ff80f29cc","skillId":"audit-imported-code","state":"accepted"},{"acceptedSubmissionHash":"6f46715267be48135cfab30af76634e9725ee9d7408a0d6366ad260662f1eab4","dependsOn":["adapt_contract_project","write_foundry_tests","manifest","audit_math","audit_permissions","audit_economics","audit_flow"],"execution":{"network":false,"profile":"foundry","requires":[],"skillHash":"af3aa01159bbf354f621cafa5c0006f6169e0938a8b015be508b7377dbf165bc","skillId":"audit-judge","tools":[]},"key":"audit_judge","kind":"code","role":"review","skillHash":"af3aa01159bbf354f621cafa5c0006f6169e0938a8b015be508b7377dbf165bc","skillId":"audit-judge","state":"accepted"},{"acceptedSubmissionHash":"5584fc687cc4492e53aee504829eb3064dbeb28f253f01c0015182509309ac3e","dependsOn":["adapt_contract_project"],"execution":{"network":false,"profile":"foundry","requires":[],"skillHash":"e5ac2cb1fd91a56aa40b16487fc230c48de0d317c8266140331dd3219bb40a85","skillId":"audit-specialist","tools":[]},"key":"audit_math","kind":"code","role":"review","skillHash":"e5ac2cb1fd91a56aa40b16487fc230c48de0d317c8266140331dd3219bb40a85","skillId":"audit-specialist","state":"accepted"},{"acceptedSubmissionHash":"d22c7490fdc898f5c6f33b3cae1112c97ab4541e1fb75b08659862a978330bb0","dependsOn":["adapt_contract_project"],"execution":{"network":false,"profile":"foundry","requires":[],"skillHash":"e5ac2cb1fd91a56aa40b16487fc230c48de0d317c8266140331dd3219bb40a85","skillId":"audit-specialist","tools":[]},"key":"audit_permissions","kind":"code","role":"review","skillHash":"e5ac2cb1fd91a56aa40b16487fc230c48de0d317c8266140331dd3219bb40a85","skillId":"audit-specialist","state":"accepted"},{"acceptedSubmissionHash":"73c81de342a5e84b3442a03733bba2dcde1806d7f81d9718c1b97f72bc42d177","dependsOn":["adapt_contract_project"],"execution":{"network":false,"profile":"foundry","requires":[],"tools":[]},"key":"manifest","kind":"code","role":"integrate","skillHash":null,"skillId":null,"state":"accepted"},{"acceptedSubmissionHash":"13828115a745caa68cf99a2b4cd629827dcb1edb5b05c8586ac8f9b3600169bf","dependsOn":["adapt_contract_project"],"execution":{"network":false,"profile":"foundry","requires":[],"skillHash":"4c76766b00591dfe982fe85d3de589fdb2f810e5137c301155d1c5e36a1d3b23","skillId":"write-foundry-tests","tools":[]},"key":"write_foundry_tests","kind":"code","role":"tests","skillHash":"4c76766b00591dfe982fe85d3de589fdb2f810e5137c301155d1c5e36a1d3b23","skillId":"write-foundry-tests","state":"accepted"}],"objective":"Deploy the NFT, vault, liquidity contract and renderer from this repository on Sepolia, in this order, with no changes to their logic: (1) TestSeats from src/testnet/TestSeats.sol with no constructor arguments; (2) InkPortraits with constructor ($owner); (3) InkVault with constructor ($contract:InkPortraits, $contract:TestSeats, $owner); (4) InkLiquidity with constructor (the official Uniswap v4 PoolManager on this chain, the official Uniswap v4 PositionManager on this chain, $owner, 0xbc10b3662231c830d2ee10bc6359db17bea4b3d4); (5) InkRenderer with constructor ($contract:InkPortraits, $owner). Run the existing Foundry tests before deploying. The treasury argument (0xbc10b3662231c830d2ee10bc6359db17bea4b3d4) only receives IMD fees and is not an owner. Owner roles and royalties must go to $owner, the address in the owner field, never to the deploying wallet or any swarm address. Do not add any other owner, admin or upgrade role.","parentJobId":null,"planHash":"a99a5e4538f090645966f4ff85b3bfc15a59f0b1bc525ace1b70bda2b2e98fa0","previousHash":"0000000000000000000000000000000000000000000000000000000000000000","projectId":"0afb11c1-8f3d-44b3-837a-96cbd6064413","publication":{"commit":null,"deliveredAt":null,"repoUrl":"https://github.com/identity-md-launches/launch-2258-deploy-nft-vault-liquidity"},"receiptIdentity":{"adapter":"0xde152afb7db5373f34876e1499fbd893a82dd336","chainId":1,"collection":"0x0000ec93127baa929e58e97dd0095a2bfb38ec1d","registry":"0x8004a169fb4a3325136eb29fa0ceb6d2e539a432"},"registry":"0xb6d0a187b050fa5bb0b87033a203f37becf4a775","research":[],"schema":"identitymd-work-v1","signals":[{"agentId":"51459","feedbackHash":"36ee8f0977d6b66c7cb714af0172cf189e50c0b3690ce48ce67a150377558e00","nodeKey":"adapt_contract_project","submissionHash":"18db3d4316a7383ff698a1335333d4aab9510ac46ff2561c6ae9050419f5ef9e","tag1":"verification:checks","tag2":"acceptance-v2","value":1},{"agentId":"51083","feedbackHash":"9a935136fae1c7076f651220c16f21da8987bc8c324a6ed0e21fb7b4f1b98462","nodeKey":"adapt_contract_project","submissionHash":"257a74c8f4500255dea506ced4bd5a743c3dc7c0595c08305854445e97f7f81e","tag1":"verification:checks","tag2":"acceptance-v2","value":1},{"agentId":"50959","feedbackHash":"0a41b2cddf011e9a1e84b081543e05654b02699c54ef3c6527fa97b12e501107","nodeKey":"audit_economics","submissionHash":"fc3d2f5a946858d7bb2ee7f3c78bbacb727483151fc16904529dfb833effbb2c","tag1":"review:submission","tag2":"acceptance-v2","value":1},{"agentId":"51291","feedbackHash":"cd2f8ffe810da74116804f312f528cc0af862540092e8cdd9f49ce3cc70e0a9a","nodeKey":"audit_flow","submissionHash":"7528ff8d1e0a95fb9447211bce1641db78497472b9e9b1b49907d90aa1c4ab36","tag1":"review:submission","tag2":"acceptance-v2","value":1},{"agentId":"51304","feedbackHash":"202d4c87427d8afb9112a052fdb2504243d946b53f66ee81f058d6dae202f84b","nodeKey":"audit_imported_code","submissionHash":"823d5693abeec2b7f23babe6945555a72ee9e220a822019268beea7f0d0558ef","tag1":"review:submission","tag2":"acceptance-v2","value":1},{"agentId":"52707","feedbackHash":"6826bed5361fbb881b01ccff96eeb6fcd4f41e6d3c2d05b6fe11824e41884d22","nodeKey":"audit_judge","submissionHash":"6f46715267be48135cfab30af76634e9725ee9d7408a0d6366ad260662f1eab4","tag1":"review:submission","tag2":"acceptance-v2","value":1},{"agentId":"52323","feedbackHash":"539d8d72381a739ee5635afdb0a4412fbc0e19d925fb7ad306b2e2a364bed32e","nodeKey":"audit_judge","submissionHash":"ea55121e8b01c85fca63e1bceb35360290c32363ee0cb3f72d58dc4e9bc9eaf4","tag1":"review:submission","tag2":"acceptance-v2","value":1},{"agentId":"51515","feedbackHash":"628329d6d977a698c1d924a103f841a99c391255bb58af1933c899359b05b5f1","nodeKey":"audit_math","submissionHash":"5584fc687cc4492e53aee504829eb3064dbeb28f253f01c0015182509309ac3e","tag1":"review:submission","tag2":"acceptance-v2","value":1},{"agentId":"52193","feedbackHash":"82ac8bb5103972e3e2859b218cd5c1edfd32d4673e1a628b1673835564de0fff","nodeKey":"audit_permissions","submissionHash":"d22c7490fdc898f5c6f33b3cae1112c97ab4541e1fb75b08659862a978330bb0","tag1":"review:submission","tag2":"acceptance-v2","value":1},{"agentId":"52567","feedbackHash":"8ed099870906081e0334a2c813f50851a332a05cb936bb6df3832082dd58763e","nodeKey":"manifest","submissionHash":"812a00fbb79e3b541a216679a351aa6fcd58e19b5f3be94bafb180168e4aa399","tag1":"verification:checks","tag2":"acceptance-v2","value":1},{"agentId":"54230","feedbackHash":"489d4a1b1dcb0ba33ac7f0ba3321352acebecc0d9dd7ad254318e22f15f0e253","nodeKey":"manifest","submissionHash":"73c81de342a5e84b3442a03733bba2dcde1806d7f81d9718c1b97f72bc42d177","tag1":"verification:checks","tag2":"acceptance-v2","value":1},{"agentId":"52583","feedbackHash":"667e8ae4c5031c04ae43ecc536607e61873ccac38d48a46dabe29cc1f7d61d1a","nodeKey":"write_foundry_tests","submissionHash":"c469c37b0faef2d14f844e70c7596fbc1f51bf8f573a9d0996219ff8248ca2a5","tag1":"verification:checks","tag2":"acceptance-v2","value":1},{"agentId":"52612","feedbackHash":"8b3b3af3f721ce11106f5bd3dff9c9ace77b81d0f3a0067f84c3c0a0ce82b194","nodeKey":"write_foundry_tests","submissionHash":"13828115a745caa68cf99a2b4cd629827dcb1edb5b05c8586ac8f9b3600169bf","tag1":"verification:checks","tag2":"acceptance-v2","value":1}],"site":null,"snapshotHash":"dcd3454abcfc0c7778c447ddd75aa3bcd5a39a031bbea6d982353004542bf2db","state":"completed","submissions":[{"artifacts":[],"attempt":1,"bundleHash":"dbcf12df40d81204d44743e35c4134992b78f134afceeefbd8aa2e751ad15388","device":"fbdcf3c80b280e3b","findings":[],"hash":"13828115a745caa68cf99a2b4cd629827dcb1edb5b05c8586ac8f9b3600169bf","nodeId":"1a6a9599-3116-4b77-8260-f67a3cab7ae4","outcome":"completed","summary":"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.\n\n**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:\n\n- **`test/VaultInvariants.t.sol`:**\n - The handler now records the block each pull was made in.\n - `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.\n - It passes over 256 runs of 120 calls.\n- **`test/PROPERTY_COVERAGE.md`:** one sentence describing the new invariant.\n\nI 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.","treeHash":"2d1ec4da07af64ff0ae8134f1327149b0158445e","usage":{"cachedInputTokens":382840,"inputTokens":20,"model":"claude-opus-5-5","outputTokens":4770,"runtime":"claude","turns":11,"wallClockMs":377002}},{"artifacts":[],"attempt":1,"bundleHash":"e7711780663ef806cb073b64aab5a4c2d98b901564324c067b729325f2dfd057","device":"b5370e603753d2ab","findings":[],"hash":"18db3d4316a7383ff698a1335333d4aab9510ac46ff2561c6ae9050419f5ef9e","nodeId":"cbcd45a9-0c30-4e3b-a1c4-28fa85c7b885","outcome":"completed","summary":"Implemented four reproduced audit fixes and prepared the five-contract Sepolia deployment handoff, preserving constructors and ownership.\n\n- `forge build`: passed.\n- Seeded `forge test`: **71 passed, 0 failed, 28 skipped**.\n- Changes and audit dispositions: [ADAPTATION.md](/home/imd/.identitymd/work/0afb11c1-8f3d-44b3-837a-96cbd6064413/cbcd45a9-0c30-4e3b-a1c4-28fa85c7b885/ADAPTATION.md).\n\nNo transactions were broadcast; deployment remains IMD’s subsequent step. Live Sepolia verification was unavailable because the public RPC returned HTTP 403.","treeHash":"5103c176237603d9484b166dd8100fbab40acd7f","usage":{"cachedInputTokens":2438016,"inputTokens":132507,"model":"gpt-6-astra","outputTokens":26358,"runtime":"codex","turns":6,"wallClockMs":628065}},{"artifacts":[],"attempt":1,"bundleHash":"36d2c07f7dc9fa934e550d2fe44ba77c7f0e42503717cc18916f82da1c60c755","device":"dc7103e773ea194a","findings":[],"hash":"257a74c8f4500255dea506ced4bd5a743c3dc7c0595c08305854445e97f7f81e","nodeId":"cbcd45a9-0c30-4e3b-a1c4-28fa85c7b885","outcome":"completed","summary":"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.\n\n**What reproduced and what changed**\n\n- **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.\n- **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.\n- **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.\n- **Info 6b948270, fixed.** The hook file was reformatted. The formatter check on src passes.\n\n**Tests and checks**\n\n- 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.\n- Three fixtures that passed the ecrecover precompile as a never-called liquidity stand-in now pass a contract.\n- 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.\n\nADAPTATION.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.","treeHash":"c8fd32b1b83f402d65939e685c884060044cef5a","usage":{"cachedInputTokens":2267879,"inputTokens":674,"model":"claude-fable-5-1","outputTokens":46345,"runtime":"claude","turns":49,"wallClockMs":779674}},{"artifacts":[],"attempt":1,"bundleHash":null,"device":"ea89e16822824c6f","findings":[{"citation":"resolved","description":"Boundary (external call to an address with no code). setup() validates only that liquidity_ is non-zero, then stores it once (a second setup() reverts AlreadySetUp, setInk() reverts InkAlreadySet). release() does ink.safeTransfer(liquidity, inkToPool) followed by IInkLiquidity(liquidity).addLiquidity(). If liquidity_ is an EOA or any contract that is not an InkLiquidity bound to the INK pool, the high-level call reverts (extcodesize check / missing function), so release() reverts every time. Nothing else can set released = true: the hook never opens trading, pull() stays closed (NotReleased), and the 2,000 x 400,000 INK allocation (800,000,000e18) stays in the vault with no recovery path. The same once-only shape applies to setInk(): a wrong token address makes setup() revert NotFunded forever. These are owner-input errors, so they are reported as a missing boundary check (low), not as an attack. Minimal fix that preserves the design: in setup(), require liquidity_.code.length > 0 (and optionally that IInkLiquidity(liquidity_).poolSet() is callable), and in setInk() require address(ink_).code.length > 0. The existing test test_releaseFailureRollsBackUntilLiquidityIsConfigured only covers the recoverable case where the address is a real InkLiquidity whose pool is not yet set.","line":157,"path":"src/InkVault.sol","reproduction":"State: InkPortraits with setVault(vault); vault holds 800,000,000e18 INK; owner calls setInk(ink). Call: owner -> vault.setup(bytes32(1), uint64(block.timestamp), 0x0000000000000000000000000000000000001234). Expected: revert BadSetup (not a liquidity contract). Actual: accepted, Setup event emitted. Then warp +24 hours and call vault.release() from any account. Expected: released == true and INK moved to the pool. Actual: reverts (call to address without code at IInkLiquidity(liquidity).addLiquidity()), released stays false, vault still holds 800,000,000e18 INK; owner -> vault.setup(...) again reverts AlreadySetUp and vault.setInk(...) reverts InkAlreadySet. Verified with test/scratch/SetupNoCode.t.sol (passes on current code, i.e. the mis-set address is accepted and release() reverts).","severity":"low","snippet":" root == bytes32(0) || liquidity_ == address(0) || start < block.timestamp","title":"InkVault.setup() accepts a liquidity address with no code; release() then reverts forever and the once-only setup cannot be corrected"}],"hash":"5584fc687cc4492e53aee504829eb3064dbeb28f253f01c0015182509309ac3e","nodeId":"a521662f-5510-42a5-9cf4-a834eef4e483","outcome":"completed","summary":"The review is complete and the findings file is written and validated.\n\n**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.\n\n**What I checked in depth (Math Precision, Boundary, Numerical Gap):**\n- 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.\n- 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.\n- 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.\n- InkPortraits bitmap and swarm numbering, InkRenderer threshold arithmetic, and all window boundaries (claim ends exactly when release opens).\n\n**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.\n\n**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.\n\n**Tests run.** The existing suite passes (71 tests, fork suite skipped). Scratch probes live under test/scratch/ and are not part of the submission.","treeHash":null,"usage":{"cachedInputTokens":1580418,"inputTokens":514,"model":"claude-fable-5-1","outputTokens":41587,"runtime":"claude","turns":29,"wallClockMs":671818}},{"artifacts":[],"attempt":1,"bundleHash":null,"device":"2293d6b19e81ef1a","findings":[{"citation":"resolved","description":"Settlement of my earlier low finding 71ef9819. Confirmed fixed: setup() now reverts BadSetup when liquidity_ has no code (src/InkVault.sol line 165: `root == bytes32(0) || liquidity_.code.length == 0 || start < block.timestamp`), so case 1 of the earlier reproduction (an EOA as liquidity) is rejected while still correctable; my scratch test test_setupRejectsEOA confirms the revert and that a contract address is then accepted. Not fixed, and still reproducible: (a) setInk() stores any address once (line 154) with no check that the vault holds SEATS*PORTRAIT of it, so a wrong token makes setup() revert NotFunded forever and release() revert InkNotSet forever while the real 800,000,000e18 INK stays in the vault with no exit; (b) setup() does not check that IInkLiquidity(liquidity_).ink() equals the vault's ink, and InkLiquidity.setPool() (src/InkLiquidity.sol line 98, PoolAlreadySet) is equally one-shot, so an INK mismatch makes release() revert NothingToAdd on every call; (c) InkPortraits.setVault (src/InkPortraits.sol line 84, VaultAlreadySet) does not check the target is the InkVault bound to this collection. The author disputes the remaining checks on the grounds that a poolSet()/ink() cross-check would break liquidity stand-ins such as the proof fixture, that setInk/setVault have no reference value to compare against, and that the brief says the logic is deployed as written; these are owner-input steps now documented in ADAPTATION.md and README.md. I accept that as a documented trust assumption for this launch: owner error only, no unprivileged path, so it stays low and advisory, not blocking. The impact when it happens remains permanent. If the author wants to close (a) without a reference value, allowing setInk() to be re-called until setup() succeeds is enough; (b) could be closed by comparing IInkLiquidity(liquidity_).ink() to ink only when that call succeeds.","line":154,"path":"src/InkVault.sol","reproduction":"Scratch test test/scratch/JudgeRound2.t.sol (not kept), both passing on the current code. test_wrongSetInkStillStrands: deploy TestSeats, InkPortraits(owner), InkVault(portraits, seats, owner), setVault(vault); mint 800,000,000e18 of the real INK to the vault; owner calls vault.setInk(WRONG) where WRONG is another ERC-20 -> accepted. Then: vault.setInk(INK) reverts InkAlreadySet; vault.setup(root, now, liquidityContract) reverts NotFunded; vault.release() reverts InkNotSet; INK.balanceOf(vault) == 800,000,000e18 and no function in the vault can move it. Expected: the wrong token is rejected or correctable before setup(). test_setupRejectsEOA (fix confirmed): after setInk(INK), vault.setup(root, now, 0x1234) reverts BadSetup and vault.setup(root, now, address(mockLiquidity)) is then accepted, liquidity() == mockLiquidity.","severity":"low","snippet":" if (address(ink) != address(0)) revert InkAlreadySet();","title":"Residual of 71ef9819 (partly fixed): setInk, setVault and setPool remain one-shot with no cross-check, so one wrong owner input before release() still permanently strands the 800,000,000 INK allocatio"},{"citation":"resolved","description":"Settlement of my earlier low finding eb210c01. The author disputes it for this launch because InkHook is not one of the five contracts launch.json deploys (TestSeats, InkPortraits, InkVault, InkLiquidity, InkRenderer) and the hook's constructor and pool initialization belong to the later univ4_hook launch. That is correct: the hook is absent from the manifest, and this round changed only the formatting of its three signatures (git diff of src/InkHook.sol between the accepted and revised trees shows signature rewraps only, no logic). The behaviour is unchanged: PoolManager.initialize is permissionless for any key, beforeInitialize only requires key.hooks == this and that one currency is imd, and it then records the other currency as ink and sets poolCreated, after which the real INK/IMD pool reverts PoolAlreadyCreated. There is no window if the hook is deployed and its pool initialized in one factory transaction. Downgraded to info for this launch and recorded (as ADAPTATION.md item 7 also does) so the hook launch's atomicity is checked rather than assumed. Nothing in the five contracts of this launch should change for it.","line":123,"path":"src/InkHook.sol","reproduction":"Deploy InkHook(manager, portraits, vault, imd=IMD, treasury, 25) at an address with the BEFORE_INITIALIZE|BEFORE_SWAP|AFTER_SWAP|AFTER_SWAP_RETURNS_DELTA flag bits, without initializing a pool in the same transaction. Attacker deploys token X and calls manager.initialize(PoolKey(sorted(X, IMD), 12500, 200, hook), sqrtPrice(0)). Expected: only the launch's INK/IMD pool can bind the hook. Actual: hook.poolCreated() == true, hook.ink() == X, and manager.initialize(PoolKey(sorted(INK, IMD), 12500, 200, hook), ...) reverts with PoolAlreadyCreated wrapped by the PoolManager. Reproduced last round in test/scratch/JudgeRepro.t.sol test_hookBindsToFirstInitializer; the hook code is unchanged this round apart from formatting.","severity":"info","snippet":" if (poolCreated) revert PoolAlreadyCreated();","title":"Unchanged, for the later hook launch: InkHook.beforeInitialize binds the hook to the first IMD-paired pool anyone initializes with it"},{"citation":"resolved","description":"Settlement of my earlier info finding 9d091aab, disputed by the author as intended. Agreed: the brief orders TestSeats from src/testnet/TestSeats.sol with no constructor arguments, the file's notice says anyone can mint any seat for rehearsal and it must never be deployed on mainnet, and InkVault.claim authenticates only seats.ownerOf(seat) == msg.sender plus a Merkle proof against statsRoot. Nothing in the contracts should change. Kept as an operational note for the rehearsal (publish a statsRoot covering only team-controlled seats, or mint them first) and for the mainnet manifest, which must pass the real identity.md collection since InkVault.seats is immutable; ADAPTATION.md item 8 records the same.","line":10,"path":"src/testnet/TestSeats.sol","reproduction":"Sepolia deployment after setup(root, start, liq) with a root covering all seats: attacker calls TestSeats.mint(7) (unminted) -> owns seat 7; during the window calls vault.claim(7, statsOf(7), proofOf(7)) from the published stats -> portraits.ownerOf(7) == attacker; attacker.setApprovalForAll(vault, true) then vault.deposit([7], 400_000e18) -> attacker receives 400,000 INK, fee 0 (isAgentPortrait). Repeating for every seat before claimEnd: release() emits Released(0, 0), swarmSlots() == 0, pull(1) reverts NoneAvailable. Expected on mainnet: only the real seat holder; on Sepolia: anyone, by design.","severity":"info","snippet":" function mint(uint256 seat) external {","title":"By design on Sepolia: TestSeats.mint is permissionless, so any address can claim any seat's agent portrait and redeem it for 400,000 INK during the rehearsal"}],"hash":"6f46715267be48135cfab30af76634e9725ee9d7408a0d6366ad260662f1eab4","nodeId":"af109a30-50a4-4f5f-a937-24682a929e24","outcome":"completed","summary":"The review is complete. The findings file is written and validated, with all 52 entry points answered.\n\n**Outcome: the one blocking finding is fixed, and nothing new blocks the launch.**\n\nSettlement of my earlier findings:\n\n- **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.\n- **Formatter check (info, 6b948270): fixed.** The check on the source directory exits 0 and the hook diff is signature rewraps only.\n- **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.\n- **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.\n- **TestSeats.mint permissionless (9d091aab): info, by design.** Unchanged, as the brief orders.\n\nChecks 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.","treeHash":null,"usage":{"cachedInputTokens":2184517,"inputTokens":706,"model":"claude-fable-5-1","outputTokens":30275,"runtime":"claude","turns":32,"wallClockMs":441023}},{"artifacts":[],"attempt":1,"bundleHash":"2ca6dfc447177cef9e928b9b000df87fdae840c560aa7c83f6b05a1d48a4d616","device":"aa333626543c4dee","findings":[],"hash":"73c81de342a5e84b3442a03733bba2dcde1806d7f81d9718c1b97f72bc42d177","nodeId":"3d9643ed-2233-4715-b24c-69223b2b4342","outcome":"completed","summary":"The accepted launch.json already satisfies the brief, and the revision prompt listed no findings to act on, so I left it unchanged.\n\n**What I verified**\n\n- The manifest has exactly the keys kind, contracts and notes, with five unique contracts in dependency order and notes under the length limit.\n- 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.\n- 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.\n- 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.\n- 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.\n\n**Checks run**\n\n```\nforge build --sizes # compiled, five contracts between 3.8 kB and 12.7 kB runtime\nFOUNDRY_FUZZ_SEED=0x30c0...c635 forge test --no-match-path test/MainnetFork.t.sol\n# 75 passed, 0 failed, 14 skipped\n```\n\nThe 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.","treeHash":"c5ca58c9af97c2e1c8ce62bb8d32e718370eb747","usage":{"cachedInputTokens":197785,"inputTokens":194,"model":"claude-fable-5-1","outputTokens":2675,"runtime":"claude","turns":7,"wallClockMs":320993}},{"artifacts":[],"attempt":1,"bundleHash":null,"device":"bd7adba3a8045853","findings":[{"citation":"resolved","description":"InkVault documents (lines 27-29) that 'a portrait handed in only joins the draw for pulls made in later blocks, so once a block hash is public nobody can change what it picks'. _revealNext() enforces this by calling _admit(p.blockNumber) for the pull at the head of the queue only. When that head pull is renewed (line 295, p.blockNumber = uint64(block.number), after its hash expired or avail == 0), the next _admit uses the RENEWED block, and everything deposited before that block is pushed into _inventory. Pulls queued behind the head keep their original blockNumber, their entropy blockhash(blockNumber + 1) may still be valid, and they then draw over an inventory containing portraits handed in after their own block, by someone who could already see their entropy. Because pick = r % avail and the admitted items occupy inventory indexes [0, held), a depositor who knows r for the victim's pull can choose how many portraits to hand in (k) so that r % (unminted + k) < k, steering the victim's pull onto one of the depositor's own (already paid-out) portraits instead of a fresh mint, or away from a valuable agent portrait sitting in inventory. Preconditions: an earlier pull stays unrevealed past its 256-block hash window (reveal is permissionless, so this needs keepers and the victim to be idle for about 51 minutes), or the head pull hits avail == 0 at reveal. The victim loses the documented fairness guarantee, not INK. Fix: keep the admission cutoff separate from the entropy block, e.g. store the original pull block (or the smallest original block among pending pulls) and pass that to _admit, so renewal changes only which block hash is used, never which deposits are eligible.","line":288,"path":"src/InkVault.sol","proof":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.26;\n\nimport {Test} from \"forge-std/Test.sol\";\nimport {ERC20} from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {InkPortraits} from \"src/InkPortraits.sol\";\nimport {InkVault} from \"src/InkVault.sol\";\nimport {TestSeats} from \"src/testnet/TestSeats.sol\";\n\ncontract MockInk is ERC20(\"INK\", \"INK\") {\n function mint(address to, uint256 amount) external {\n _mint(to, amount);\n }\n}\n\n/// Stands in for InkLiquidity: release() only needs addLiquidity() to succeed.\ncontract MockLiquidity {\n function addLiquidity() external pure returns (uint256) {\n return 1;\n }\n}\n\n/// A pull's draw is documented as fixed once its block hash is public: \"a portrait handed in only joins the\n/// draw for pulls made in later blocks, so once a block hash is public nobody can change what it picks\".\n/// When an earlier pull is renewed (hash expired), _admit runs with the renewed block, so a deposit made\n/// AFTER a later pull's block (and after that pull's hash is public) joins the later pull's candidate set.\ncontract RenewalWidensDrawTest is Test {\n uint256 constant PORTRAIT = 400_000e18;\n address owner = makeAddr(\"owner\");\n address attacker = makeAddr(\"attacker\");\n address victim = makeAddr(\"victim\");\n\n MockInk ink;\n TestSeats seats;\n InkPortraits portraits;\n InkVault vault;\n MockLiquidity liq;\n\n function setUp() public {\n vm.roll(100);\n ink = new MockInk();\n seats = new TestSeats();\n portraits = new InkPortraits(owner);\n vault = new InkVault(portraits, seats, owner);\n liq = new MockLiquidity();\n vm.prank(owner);\n portraits.setVault(address(vault));\n ink.mint(address(vault), 2000 * PORTRAIT);\n vm.startPrank(owner);\n vault.setInk(IERC20(address(ink)));\n vault.setup(keccak256(\"root\"), uint64(block.timestamp), address(liq));\n vm.stopPrank();\n vm.warp(block.timestamp + 24 hours);\n vault.release();\n ink.mint(attacker, 10 * PORTRAIT);\n ink.mint(victim, 10 * PORTRAIT);\n vm.prank(attacker);\n ink.approve(address(vault), type(uint256).max);\n vm.prank(victim);\n ink.approve(address(vault), type(uint256).max);\n vm.prank(attacker);\n portraits.setApprovalForAll(address(vault), true);\n }\n\n function test_depositAfterLaterPullsHashIsPublicJoinsItsDraw() public {\n // Attacker owns two swarm portraits (pulled and revealed earlier).\n vm.prank(attacker);\n vault.pull(2);\n vm.roll(block.number + 2);\n vault.reveal(1);\n uint256 junkA = 10_000;\n uint256 junkB = 10_001;\n assertEq(portraits.ownerOf(junkA), attacker);\n assertEq(vault.inventorySize(), 0);\n\n // Pull A (attacker) at block 1000, pull B (victim) at block 1003. Nobody reveals A.\n vm.roll(1000);\n vm.prank(attacker);\n uint256 pullA = vault.pull(1);\n vm.roll(1003);\n vm.prank(victim);\n uint256 pullB = vault.pull(1);\n assertEq(pullB, pullA + 1);\n\n // Block 1010: blockhash(1004), pull B's entropy, is public. The attacker hands in both junk portraits.\n // Per the documented rule they can only join draws of pulls made after block 1010.\n vm.roll(1010);\n assertTrue(blockhash(1004) != bytes32(0));\n uint256[] memory ids = new uint256[](2);\n ids[0] = junkA;\n ids[1] = junkB;\n vm.prank(attacker);\n vault.deposit(ids, 0);\n assertEq(vault.waitingCount(), 2);\n\n // Block 1258: pull A's hash (block 1001) has expired, pull B's (block 1004) has not. A is renewed.\n vm.roll(1258);\n assertEq(blockhash(1001), bytes32(0));\n assertTrue(blockhash(1004) != bytes32(0));\n assertFalse(vault.reveal(pullA));\n (, uint64 renewedBlock,) = vault.pulls(pullA);\n assertEq(renewedBlock, 1258);\n\n // Block 1260: both reveal. Admission runs with A's renewed block (1258), so the block-1010 deposits are\n // admitted into the inventory, and pull B (block 1003, original hash still valid) draws over them.\n vm.roll(1260);\n assertTrue(blockhash(1004) != bytes32(0));\n assertTrue(vault.reveal(pullB));\n (, uint64 bBlock, bool bDone) = vault.pulls(pullB);\n assertTrue(bDone);\n assertEq(bBlock, 1003, \"pull B drew with its original block hash\");\n // Expected: the two deposits are still waiting (they were handed in after pull B's block).\n // Actual: they were admitted and were candidates for pull B.\n assertEq(vault.waitingCount(), 2, \"deposits made after pull B's block joined pull B's draw\");\n }\n}","reproduction":"State: vault released; attacker holds swarm portraits 10000 and 10001 and has approved the vault. Block 1000: attacker pull(1) -> pull A. Block 1003: victim pull(1) -> pull B. Nobody reveals. Block 1010: blockhash(1004), B's entropy, is public; attacker calls deposit([10000,10001], 0) -> waitingCount()==2. Block 1258: reveal(A) returns false and emits PullRenewed(A, 1258) because blockhash(1001)==0; blockhash(1004) is still nonzero. Block 1260: reveal(B): _admit(1258) moves both block-1010 deposits into _inventory, A draws with blockhash(1259), then B draws with its ORIGINAL blockhash(1004) over an inventory that contains the two portraits handed in 7 blocks after B was made. Expected per the contract's own rule: waitingCount()==2 after B is revealed (deposits only eligible for pulls made after block 1010). Actual: waitingCount()==0 and pulls(B).blockNumber==1003. The scratch test test/scratch/RenewalWidensDraw.t.sol fails on the current code with 'deposits made after pull B's block joined pull B's draw: 0 != 2'.","severity":"medium","snippet":" if (!_admit(p.blockNumber)) {","title":"Renewing an earlier pull admits later deposits into a later pull's draw after that pull's hash is public"},{"citation":"resolved","description":"setInk() (lines 145-149) accepts any address once and can never be changed (InkAlreadySet). The only funding check, ink.balanceOf(address(this)) >= SEATS * PORTRAIT, lives in setup() (line 160) and is evaluated against whatever setInk() stored. If the owner passes a wrong address (the IMD token, a typo, the pool, the hook), setup() reverts NotFunded forever, setInk() cannot be redone, and no other function can move the real 800,000,000 INK (80% of supply) that the launch sent to the vault: claim() needs statsRoot, release() needs statsRoot, pull()/rerollTraits() need released, deposit() has nothing to deposit. The contracts have no sweep and no owner path to recover, so the mistake is a permanent loss of the whole allocation and of the claim/swarm distribution. This is an owner-error precondition, not an attacker path, but the irreversible setter is the one without the check while the recoverable step (setup can be retried) has it. Fix: validate in setInk() that ink_.balanceOf(address(this)) >= SEATS * PORTRAIT (the launch funds the vault before the owner can call it), or let setInk() be re-called until setup() has succeeded.","line":147,"path":"src/InkVault.sol","reproduction":"Deploy per the manifest; launch sends 800,000,000 real INK to the vault. Owner calls setInk(0xWrongToken) where 0xWrongToken is any ERC-20 that is not INK: succeeds, emits InkSet. Owner calls setInk(realInk): reverts InkAlreadySet. Owner calls setup(root, now, liquidity): reverts NotFunded (wrong token balance is 0). release(): reverts InkNotSet; pull(1): reverts NotReleased; claimOpen()==false forever. realInk.balanceOf(vault) stays 800,000,000e18 with no function able to transfer it. Expected: either setInk rejects a token the vault is not funded in, or it can be corrected before setup. test/scratch/SetInkBrick.t.sol walks this sequence and passes on the current code (it asserts the bricked state).","severity":"low","snippet":" ink = ink_;","title":"setInk() is irreversible but unvalidated: a wrong token address permanently strands the vault's entire INK allocation"}],"hash":"7528ff8d1e0a95fb9447211bce1641db78497472b9e9b1b49907d90aa1c4ab36","nodeId":"3f4575ef-1820-4ed3-b875-3890697aae73","outcome":"completed","summary":"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.\n\n**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.\n\n**Findings**\n\n1. **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.\n\n2. **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.\n\n**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.\n\n**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.","treeHash":null,"usage":{"cachedInputTokens":1280972,"inputTokens":322,"model":"claude-fable-5-1","outputTokens":54844,"runtime":"claude","turns":31,"wallClockMs":864519}},{"artifacts":[],"attempt":1,"bundleHash":"ba6d6babb73e21742a895f1e179881cd9c720afc11749bfcd207d09b1577e76c","device":"8a38929b31c716ff","findings":[],"hash":"812a00fbb79e3b541a216679a351aa6fcd58e19b5f3be94bafb180168e4aa399","nodeId":"3d9643ed-2233-4715-b24c-69223b2b4342","outcome":"completed","summary":"Created [launch.json](/home/imd3/.identitymd/work/0afb11c1-8f3d-44b3-837a-96cbd6064413/3d9643ed-2233-4715-b24c-69223b2b4342/launch.json) with the required contract order, constructor arguments, `$owner` roles, treasury, and [official Sepolia Uniswap addresses](https://developers.uniswap.org/docs/protocols/v4/deployments).\n\nVerified 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.\n\nOnly `launch.json` is included in the deliverable.","treeHash":"8817ccd55a4e26d7dc0fe19a17899ea750230306","usage":{"cachedInputTokens":447872,"inputTokens":40932,"model":"gpt-6-astra","outputTokens":3666,"runtime":"codex","turns":3,"wallClockMs":124306}},{"artifacts":[],"attempt":1,"bundleHash":null,"device":"4be5e039e1c77ce3","findings":[{"citation":"resolved","description":"Every reveal first admits, in one loop, every portrait handed in with deposit() since the last revealed pull's block (_admit). Each admitted entry costs about 33,400 gas (an _inventory.push of a fresh slot plus the delete of the two-slot Incoming). Measured with a scratch test on this tree: 500 pending entries make the next reveal() cost 16.79M gas, 1,000 cost 33.44M and 2,000 cost 66.73M, linear at ~33.4k per entry. A 36M block (Sepolia, Ethereum today) is exhausted at about 1,080 pending entries; a 60M block at about 1,800. Pulls are revealed strictly in order and the admission cannot be split across calls, so once one pull's reveal cannot fit in a block, that pull and every pull queued after it can never be revealed: their 400,000 INK each stays in the vault with no refund path, the deposited portraits stay in _incoming, and the pull/reveal mechanic is dead for good. The precondition is heavy (holding more than half of the 2,000 portraits at once, or ~430M INK to pull them) and the attacker only loses the 1% reroll fee on each deposit (4,000 INK each), so this is a griefing vector for a whale rather than a profit attack; severity set to medium for that reason. Fix: bound the work per reveal (admit at most N entries per call and let a renewed/early-returning reveal continue later), or admit at deposit time with a one-block delay keyed on blockNumber instead of a queue walked inside the reveal.","line":306,"path":"src/InkVault.sol","reproduction":"State: after release(). Attacker A holds n swarm portraits (pull(n) at block B, reveal at B+2). A calls deposit() with all n token ids (in batches of 100 per tx) at blocks later than the last revealed pull's block; A receives n*396,000 INK back. Victim V calls pull(1) at a later block P (passes: available() + waiting covers it). At block P+2 anyone calls reveal(V's pull id): _admit(P) walks all n entries. With n = 1,000 the call needs 33,436,245 gas (measured); with n >= ~1,080 it exceeds a 36M block gas limit and reverts out of gas. Expected: V's pull is revealed and a portrait is delivered. Actual: reveal() and revealNext() can never complete for that pull or any later one; V's 400,000 INK and every later puller's INK are locked permanently. Scratch test used: deploy TestSeats, InkPortraits(owner), InkVault(portraits, seats, owner), a plain ERC20 as INK minted 800M to the vault, a mock liquidity whose addLiquidity() is a no-op; owner: setVault, setInk, setup(root=0x01, start=now, liquidity); warp 24h; release(); then the sequence above, measuring gasleft() around reveal().","severity":"medium","snippet":" while (head < end && _incoming[head].blockNumber < beforeBlock) {","title":"Unbounded admission loop in _revealNext: a large pile of deposits before one pull makes every later reveal run out of gas, locking all later pullers' INK forever"},{"citation":"resolved","description":"The vault takes portraits only through deposit(), which uses transferFrom and pushes the token into _incoming. It never needs onERC721Received, yet it returns the magic value unconditionally, so a holder who calls portraits.safeTransferFrom(holder, vault, id) (the natural 'hand it to the vault' action for a wallet or marketplace UI) succeeds, gets no INK, and the token is not in _incoming or _inventory, so no pull can ever return it. The 400,000 INK that backed it stays in the vault with no path to pay it out: the holder's value is lost and the vault's INK balance is permanently above its obligations. Fix: revert in onERC721Received (the vault has no legitimate inbound safe-transfer), or route it into _incoming and pay the depositor like deposit() does.","line":406,"path":"src/InkVault.sol","reproduction":"State: after release(). Alice pulls one portrait (pull(1), reveal) and owns token 10000. Alice calls portraits.safeTransferFrom(alice, address(vault), 10000). Expected: revert (or treated as a deposit paying 396,000 INK). Actual: call succeeds, portraits.ownerOf(10000) == vault, alice's INK balance unchanged, vault.heldCount() == 0 and vault.inventorySize() == 0, ink.balanceOf(vault) still 400,000e18 for a portrait nobody can pull. Confirmed with a scratch test on this tree (same minimal setup as the medium finding).","severity":"low","snippet":" function onERC721Received(address, address, uint256, bytes calldata) external pure returns (bytes4) {","title":"Vault accepts safeTransferFrom of any portrait but never uses it: a portrait sent that way is stranded with no INK paid and never enters the draw"},{"citation":"resolved","description":"floorTick is the price floor every later listing is clamped to (releaseStartTick, _rangeFrom) and setPool can be called exactly once. StateLibrary.getSlot0 on a pool id that was never initialized returns sqrtPriceX96 = 0 and tick = 0 instead of reverting, so if the owner calls setPool before the swarm launch initializes the pool (the launch README orders setPool after the hook launch, but nothing enforces it), floorTick becomes 0 and cannot be corrected. With INK as currency0 and a real opening tick around 129,000 (the tree's own tests use that), every addLiquidity() would then clamp to tick 0, i.e. list released INK at about 1.0001^-129000 (~2.5e-6) of the opening price; with INK as currency1 the clamp is the other way and INK is listed at ~400,000x the opening price, so the released supply is never bought. The same function also does not check key.hooks or that the other currency is IMD/ETH, so any key containing INK is accepted. Fix: require sqrtPriceX96 != 0 from getSlot0 (and ideally key.hooks == the expected hook) in setPool.","line":100,"path":"src/InkLiquidity.sol","reproduction":"Deploy a fresh PoolManager and InkLiquidity(pm, posm, owner, treasury). Build key = (currency0 = 0x0 (ETH), currency1 = INK, fee 12500, tickSpacing 200, hooks 0x0) and do NOT initialize the pool. owner calls setPool(key, INK). Expected: revert (pool not initialized). Actual: succeeds; floorTick() == 0; poolSet() == true; a second setPool reverts PoolAlreadySet. Confirmed with a scratch test on this tree.","severity":"low","snippet":" (, floorTick,,) = poolManager.getSlot0(key.toId());","title":"setPool records floorTick from getSlot0 without checking the pool is initialized or the key is the INK/IMD hook pool: a call before initialization fixes floorTick = 0 forever"},{"citation":"resolved","description":"rerollTraits() only blocks deposit() while a reroll is pending; InkPortraits puts no restriction on transfers. From block b+1 the entropy blockhash(b+1) and therefore the exact new seed keccak256(abi.encode(entropy, tokenId, \"traits\")) and the new traits are computable off-chain by the holder. A holder who sees a worse result can list and sell the portrait before anyone calls revealTraits(); marketplaces display the current (better) traits, the buyer pays for them, and the permissionless reveal then repaints the token in the buyer's wallet. The seller never gains a better outcome (they cannot cancel), so this is information asymmetry rather than theft, but it breaks the 'what you see is what you buy' property for every swarm portrait with traitRerollBlock != 0. Fix: have InkPortraits._update revert while the vault reports a pending reroll for the token (or clear/apply the reroll on transfer), and surface traitRerollBlock in tokenJSON.","line":356,"path":"src/InkVault.sol","reproduction":"State: after release(). Alice owns swarm token 10000 and 4,000 INK for the fee. Block b: alice calls rerollTraits(10000, 4000e18). Block b+2: blockhash(b+1) is known; alice computes the new seed, dislikes it, and calls portraits.transferFrom(alice, buyer, 10000). Expected: transfer refused while a reroll is pending (or the reroll voided). Actual: transfer succeeds; afterwards anyone calls vault.revealTraits(10000) and portraits.swarmSeed(10000) changes while portraits.ownerOf(10000) == buyer. Confirmed with a scratch test on this tree.","severity":"low","snippet":" traitRerollBlock[tokenId] = uint64(block.number);","title":"A pending trait reroll does not block transfers: the new seed is public one block after the request, so a seller can pass a known-bad repaint to a buyer"},{"citation":"resolved","description":"The evm_contracts recipe wants applications fully configured in nonpayable constructors and lists post-deployment initialization among the things the adapter removes. As the tree arrived: InkPortraits.setVault (once), setRenderer/lockRenderer, setContractURI; InkVault.setInk (once), setup (once: statsRoot, claimStart, liquidity), setFees; InkLiquidity.setPool (once), setWidth, setPremium; InkRenderer.addChunk, setPreviewBase, lock. All are onlyOwner, none is a proxy, initializer, delegatecall or upgrade path, and none of the five runtime bytecodes contains DELEGATECALL, CALLCODE or SELFDESTRUCT (scanned on this tree). Most of these cannot be moved into constructors without changing the design: INK and the pool do not exist until the later hook launch (setInk, setPool, setup), Portraits and Vault reference each other (setVault), and the renderer script is uploaded in chunks after deployment. The task text ('no changes to their logic') and the launch README both anticipate these owner calls. Reported at low so the adapter and the final review see the full list and decide deliberately rather than treating it as a defect to strip; what matters for the launch is that every such role is $owner (it is: every constructor takes owner_ and passes it to Ownable; none uses msg.sender or tx.origin) and that nothing is callable by anyone else (it is not). Until the owner completes them: pull/rerollTraits revert NotReleased, release reverts, claim reverts ClaimClosed, tokenURI reverts (no renderer), addLiquidity reverts PoolNotSet.","line":140,"path":"src/InkVault.sol","reproduction":"Deploy the five contracts with the task's constructor arguments and call nothing else. portraits.tokenURI(x) for any minted x reverts (renderer == address(0), confirmed in a scratch test); vault.pull(1) reverts NotReleased; vault.release() reverts InkNotSet (statsRoot == 0); liquidity.addLiquidity() reverts PoolNotSet; renderer.tokenJSON(..) returns an animation_url whose