{"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":"7e353f41-1fc4-4390-8e61-58d1c845db1c","kind":"shape:chain","nodes":[{"acceptedSubmissionHash":"d33a8ae4d619f939da0907ddd57a1268108af025780646ce18e081318a6e8967","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":"cd837d959a06551de1aacd206abd02b8a696405f76771d9b655fe5de7ac9e055","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":"b814e045e0443a315e49d35f7b5b71f1f592a838c9e57302f152779dbb55a2c2","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":"bf124a7b1327a4dd1a1e17fd50bee9b96428a3499e486273c17b399f21c8736a","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":"275a020a783703255154e5837ad61bf12ef0f06d083cd8e53fdfd41968658ce7","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":"7cccdfd7865dce0554824275f1d80fe235cc73d39d2dcb3d6022ba7b4b404dd1","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":"b2cc38cd12b924b4cca9caa9785a0c22a6532cfd0fe4d2139bf0994eebe93a4c","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":"74d418e80ef41f6df31fb67ef6a97407725f8418c813cc9a1c3ae587d2077367","dependsOn":["adapt_contract_project"],"execution":{"network":false,"profile":"foundry","requires":[],"tools":[]},"key":"manifest","kind":"code","role":"integrate","skillHash":null,"skillId":null,"state":"accepted"},{"acceptedSubmissionHash":"126792b82b8dc2cd45a2f768bee53acbeca639b5fcaecf70aec7c82c8202b527","dependsOn":["adapt_contract_project"],"execution":{"network":false,"profile":"foundry","requires":[],"skillHash":"73431852439ad3a343f3d2b7db1c43cd363b9f48f9bb51497374a0cf6d50b223","skillId":"write-foundry-tests","tools":[]},"key":"write_foundry_tests","kind":"code","role":"tests","skillHash":"73431852439ad3a343f3d2b7db1c43cd363b9f48f9bb51497374a0cf6d50b223","skillId":"write-foundry-tests","state":"accepted"}],"objective":"Deploy LARP (Linked Avatar Registry Protocol) on Ethereum exactly as in the repository: two contracts in this order, (1) PlaceLARP() with no constructor arguments, (2) PlaceLinks($contract:PlaceLARP). Their constructors create the four LARP contracts (LARPBurner, LARP, IMDNames, LARPLinks) through CreateX's CREATE3 at the 0x6900 addresses in src/place/LARPPlan.sol, with the arguments fixed there (README v2). Pass no other constructor argument: no IMD protocol address may be a launch argument (launch #1395 parked on IMD's launcher). Don't change LARPPlan's salts or addresses, interfaces or constructor arguments. Keep: no owner or upgrade; prices and the IMD6900 share (6.9% to start, 0-100%) change only by the swarm's verdict within the guardrails; $IMD not spent on IMD6900 goes to IMD's BurnExecutor (IMD_BURN, a constant), never 0xdEaD; a planned address someone used first is never taken; out-of-gas swaps revert. Tests hold the launch: test/Placement.t.sol (plan, landing, squatted salt, fresh chain, one transaction, admission scan) and test/Launch.t.sol; 290 tests, fuzz seed fixed. AUDIT.md's fixes are tested: check, don't re-raise. Coverage: each audit must answer all 148 entry points: the 6 constructors; PlaceLARP: burner, larp, names; PlaceLinks: links; LARPBurner: receive, BACKUP_FEE, BACKUP_SPACING, IMD, IMD6900, IMD_BURN, MAX_BURN, MAX_SHARE_BPS, NAMES, PAIR_FEE, PAIR_HOOK, PAIR_SPACING, POOL4_FEE, POOL4_HOOK, POOL4_SPACING, POOL_MANAGER, POOL_SHARE_BPS, burn, burnImd, quoteImd, shareBps, unlockCallback; LARP: DOMAIN_SEPARATOR, IDENTITY, SLOTS, agentOf, avatarOf, canAct, clearFace, equip, faceOf, faceURI, identityOfAgent, itemOf, itemURI, nonces, resignAgent, setAgent, setAgentBySig, setFace, supportsInterface, unequip, wearerOf; IMDNames: ACTION, BURNER, COOLDOWN, EXECUTE_WINDOW, IDENTITY, INTAKE, LARP, MAX_PRICE, MAX_SHARE, MIN_PANEL, MIN_PRICE, MIN_QUORUM, ORACLE_SIGNER, ROYALTY_BPS, TLD, approve, artist, balanceOf, crewPrice, epoch, execute, getApproved, identityOf, imd6900ShareBps, isApprovedForAll, lastChange, link, linkWithImd, lockRenderer, name, nameOf, nameOfToken, onNoVerdict, onVerdict, ownerOf, priceOf, prices, primaryOf, proposal, proposalCount, propose, register, registerWithImd, renderer, rendererLocked, resolve, resolveName, royaltyInfo, both safeTransferFrom, setApprovalForAll, setArtist, setPrimary, setRenderer, setText, supportsInterface, symbol, text, tokenURI, tollOf, transferFrom, unlink; LARPLinks: BURNER, IDENTITY, LARP, LAUNCHER, NAMES, allocOf, asked, cardOf, crew, crewByName, crewCount, crewOf, disband, foundCrew, foundCrewWithImd, fren, frenCount, invite, invited, isFren, jeetOf, jeetOfRange, join, kick, launchCount, launchJeet, leave, passCaptain, proveAlloc, rankOf, setOpen, tierOf, titleOf, unfren. A coverage ratio below 1 is not a whole number: the launch blocks.","parentJobId":null,"planHash":"ffb4ff45585deb0e569534a70e76f26e0e4fd9afdc2a90387fcfd648aa3eb521","previousHash":"0000000000000000000000000000000000000000000000000000000000000000","projectId":"7e353f41-1fc4-4390-8e61-58d1c845db1c","publication":{"commit":null,"deliveredAt":null,"repoUrl":"https://github.com/identity-md-launches/launch-1436-placelarp-placelinks"},"receiptIdentity":{"adapter":"0xde152afb7db5373f34876e1499fbd893a82dd336","chainId":1,"collection":"0x0000ec93127baa929e58e97dd0095a2bfb38ec1d","registry":"0x8004a169fb4a3325136eb29fa0ceb6d2e539a432"},"registry":"0xb6d0a187b050fa5bb0b87033a203f37becf4a775","research":[],"schema":"identitymd-work-v1","signals":[{"agentId":"50990","feedbackHash":"15021f02957f54b934402ccbe783d09069a1ac6c097b7298509eb369fc45daa4","nodeKey":"adapt_contract_project","submissionHash":"b1b03f91ffc1bc9ad169f60fc3af7c7a69a6cec69811519059d6c26655a825a0","tag1":"verification:checks","tag2":"acceptance-v2","value":1},{"agentId":"52191","feedbackHash":"7c1cf52f9e3f6c990f729d49617feaa0788d97362a53afba823e534616538239","nodeKey":"adapt_contract_project","submissionHash":"d33a8ae4d619f939da0907ddd57a1268108af025780646ce18e081318a6e8967","tag1":"verification:checks","tag2":"acceptance-v2","value":1},{"agentId":"52681","feedbackHash":"7db90cbc2516afc9f06ad43def90707465fd28c6692c86d23cc7a8a725ad2c7e","nodeKey":"audit_economics","submissionHash":"cd837d959a06551de1aacd206abd02b8a696405f76771d9b655fe5de7ac9e055","tag1":"review:submission","tag2":"acceptance-v2","value":1},{"agentId":"51452","feedbackHash":"1cad47bcf1f339422a04f943b29b8a5db59bef09f8cf5f618b7bdce61630e4d2","nodeKey":"audit_flow","submissionHash":"b814e045e0443a315e49d35f7b5b71f1f592a838c9e57302f152779dbb55a2c2","tag1":"review:submission","tag2":"acceptance-v2","value":1},{"agentId":"51347","feedbackHash":"68f4ce0bbb669b337199cbb7c2815a2e7980ec206f91f56baaf53b049a55a074","nodeKey":"audit_imported_code","submissionHash":"bf124a7b1327a4dd1a1e17fd50bee9b96428a3499e486273c17b399f21c8736a","tag1":"review:submission","tag2":"acceptance-v2","value":1},{"agentId":"52584","feedbackHash":"96b92c8704337d5c008bd56c9eed79543c7f29d1bcddac3c39c8cc5464942bcf","nodeKey":"audit_judge","submissionHash":"42886dc8174dd6e495dcf82cf2f1cc349b3f7798d302c7ac3c712c7183fa56a6","tag1":"review:submission","tag2":"acceptance-v2","value":1},{"agentId":"52127","feedbackHash":"a114afc2fa2897779d0b11397da5e2bcfbaf69ad0f86513876a9ade5b0468900","nodeKey":"audit_judge","submissionHash":"275a020a783703255154e5837ad61bf12ef0f06d083cd8e53fdfd41968658ce7","tag1":"review:submission","tag2":"acceptance-v2","value":1},{"agentId":"51534","feedbackHash":"4021a7ddfd211a07cf5938ca54ae7a67adc344e61f13a5f2bef772ddb017f13f","nodeKey":"audit_math","submissionHash":"7cccdfd7865dce0554824275f1d80fe235cc73d39d2dcb3d6022ba7b4b404dd1","tag1":"review:submission","tag2":"acceptance-v2","value":1},{"agentId":"52287","feedbackHash":"7569679203cd2a699feec16cf7e392ecd75aee68f6f2eeb3f4966cd39f072754","nodeKey":"audit_permissions","submissionHash":"b2cc38cd12b924b4cca9caa9785a0c22a6532cfd0fe4d2139bf0994eebe93a4c","tag1":"review:submission","tag2":"acceptance-v2","value":1},{"agentId":"51096","feedbackHash":"b66858e2e8865c909cf1a2d97a5eb02767ba444db9ecac982558b5cc7c16a7ca","nodeKey":"manifest","submissionHash":"b19ddcfcf896af2a5bbe3aa5c4c8a7f6be5e0599831700bdb6c2c61b78db86c3","tag1":"verification:checks","tag2":"acceptance-v2","value":1},{"agentId":"50994","feedbackHash":"67bace16737bf4eca871bf8bb25bf6575a4f8dbf481defe4e013e6b6475490ec","nodeKey":"manifest","submissionHash":"74d418e80ef41f6df31fb67ef6a97407725f8418c813cc9a1c3ae587d2077367","tag1":"verification:checks","tag2":"acceptance-v2","value":1},{"agentId":"52163","feedbackHash":"4c042426ad551a758e54a000f2ad802116fc52979ee0aeb5a7a5ba96ddf7d0fe","nodeKey":"write_foundry_tests","submissionHash":"126792b82b8dc2cd45a2f768bee53acbeca639b5fcaecf70aec7c82c8202b527","tag1":"verification:checks","tag2":"acceptance-v2","value":1},{"agentId":"50991","feedbackHash":"a2aaf84ddb32d345caf03e27ad6b61f695b379e7da8ca8d6f1cc1443b17688c1","nodeKey":"write_foundry_tests","submissionHash":"67dbec99b3baa471d606fc861f1dcf29771f6c009f3cd4c7ea8e1037ce8757bb","tag1":"verification:checks","tag2":"acceptance-v2","value":1}],"site":null,"snapshotHash":"b5e89cf7eea38d84715d7b252e345ec5d6900db4dd16b4a2b50ba872bd1f0947","state":"completed","submissions":[{"artifacts":[],"attempt":1,"bundleHash":"d03323be4fd8d5808a398af48a714d57499ed9d906b3b9071d6e38706fe7f047","device":"52c98c0dc01791cd","findings":[],"hash":"126792b82b8dc2cd45a2f768bee53acbeca639b5fcaecf70aec7c82c8202b527","nodeId":"696488ee-5191-4aaf-81b3-3e71555dd5bb","outcome":"completed","summary":"All offline tests pass and the build is clean. The work is complete.\n\n**What was wrong.** The implementation changed after my previous round: the other contributor's L-16 fix now caps the IMD6900 leg at 2% of the pair pool's $IMD depth, and L-17 floors `minImd` on the payer's own part of the sale. Three of my tests still expected the uncapped leg and failed on this tree.\n\n**What I changed, all under `test/`:**\n- `test/LARPBurnerShareEdges.t.sol`: the share-split fuzz now reads the pool's room independently from the PoolManager and expects the leg to be the voted share clipped to that room, with the clipped part at IMD's burn. Added a pinned test that a 100% share on a 1,000 $IMD burn sells exactly the room and sends the rest to IMD_BURN, never 0xdEaD.\n- `test/SwarmShareSettlement.invariant.t.sol`: the handler takes the pair key, computes the room itself with StateLibrary, and asserts every burn sells at most the room and that the clipped remainder reaches the canonical burn. The step-through test now also checks that exactly the three shares above the room were clipped.\n- `test/LARPBurnerFloorEdges.t.sol` (new, 5 tests): a 256-run fuzz over any fee beside any waiting ETH proving the waiting ETH never meets a floor above the payer's own spot while a floor a little under it is met, the exact pro-rata boundary to the wei via a snapshot replay, dust fees, a fee above MAX_BURN, and an empty burn.\n- `test/ENTRYPOINT-COVERAGE.md`: L-16 and L-17 rows, updated burn and share entries, and the current counts.\n\n**Result.** 29 suites, 321 passed, 0 failed, 2 fork-only placement tests skipped without an RPC, fuzz seed fixed at 0x6900. No defect surfaced in the L-16/L-17 code under these properties, so no `.imd-findings.json` was written. Nothing outside `test/` was touched and nothing is committed.","treeHash":"960068fc370e0b350dff4a3d6aee4b0997c02165","usage":{"cachedInputTokens":1199667,"inputTokens":578,"model":"claude-fable-5-1","outputTokens":18951,"runtime":"claude","turns":22,"wallClockMs":1153872}},{"artifacts":[],"attempt":1,"bundleHash":null,"device":"fd5402086dce252e","findings":[],"hash":"275a020a783703255154e5837ad61bf12ef0f06d083cd8e53fdfd41968658ce7","nodeId":"32c385ba-78a8-4706-a520-1f7811a27296","outcome":"completed","summary":"Every suite passes and the tree is clean apart from the findings file. The review is complete.\n\n**Outcome: both findings from the last round are fixed. No new findings.** The findings file at `.imd-findings.json` holds an empty list, the two settled items, and a coverage record answering all 42 entry points as `holds`.\n\n**The pair-leg sandwich (medium, L-16) is fixed.**\n- The attached proof now passes on the revised code. The 100% share sandwich loses and the 6.9% control still passes.\n- `_burnImd` clips the leg to 2% of the pair pool's virtual $IMD reserve, read from the PoolManager, and sends what the share makes above that to IMD_BURN.\n- I replayed the burner's storage slot arithmetic against the live PoolManager. It returns the real pool's price and liquidity. The reserve is about 127.6 $IMD and the room about 2.55 $IMD, above the launch share of a full burn, so the launch design is unchanged.\n- I checked the one way around a depth-relative cap, just-in-time liquidity. The live pair hook refuses `beforeAddLiquidity` from any sender but itself, so nobody can inflate the room.\n- The swarm question now carries a sixth guideline for a rising share, judged against the pool's depth.\n\n**The minImd floor (low, L-17) is fixed.** The attached proof passes. The floor is checked against the payer's pro-rata part of the sale, and a keeper calling with no value still floors the whole sale. The author's two new tests cover both cases.\n\n**Tests.** Every offline suite passes, with the 13 fork tests skipping without an RPC. One note on the environment: this worker has a 1.5 GB memory cap and a single `forge test` run gets its solc killed, so I ran each test file separately. That is a worker limit, not a defect in the project.\n\n**Static-analysis leads** (strict equality, reentrancy in `burn`, unused returns, locked ether) were checked against the code and do not reproduce. The burn lock, the exact-value checks and the forwarding of all ETH to the burner cover them.","treeHash":null,"usage":{"cachedInputTokens":1714147,"inputTokens":644,"model":"claude-fable-5-1","outputTokens":23856,"runtime":"claude","turns":25,"wallClockMs":2350222}},{"artifacts":[],"attempt":1,"bundleHash":null,"device":"6f41bd9b44d3e708","findings":[{"citation":"resolved","description":"Merged from audit_math (pair leg uncapped, no min-out) and audit_economics (the share's guideline is a tautology). _burnImd sells `held * shareBps() / 10_000` $IMD into the IMD6900/$IMD pair in one exact-input swap to the extreme price limit. unlockCallback route 2 only checks `outDelta <= 0` (line 265), so there is no minimum out and no size bound against the pair's depth. On the $IMD path (registerWithImd/linkWithImd/foundCrewWithImd -> burnImd) not even MAX_BURN applies. AUDIT I-11 rests on the leg being 6.9% of at most 0.1 ETH. v2 lets the share reach MAX_SHARE_BPS = 10_000, and that path is cheap to reach. The question SwarmPrices._body asks the swarm (line 295) only checks 'the IMD6900 share is between 0% and 100%', which _checkBounds already enforces. A proposal that keeps the current prices and moves the share one _checkShareStep is therefore always approvable: 690 -> 1380 -> 2760 -> 5520 -> 10000 is four proposals, 2 IMD of oracle fees and four weekly cooldowns (test_UpToAllOfIt executes exactly this). At that share burn() is permissionless, so anyone wraps their own burn(0) over ETH already waiting in the burner (royalties, parked fees, fee remainders; up to MAX_BURN a block) between a buy and a sell on the pair, or sandwiches any payer. The pair's 6.9% fee each way does not cover the leg's price impact. Who loses: the value meant for the IMD6900 burn goes to the searcher. No payer principal is at risk, so this is medium, not high. Fix that keeps the 0-100% design: bound the $IMD the pair leg sells per block (or per call) by a constant sized like MAX_BURN was for 6.9%, and send the excess to IMD_BURN as the failure path already does. A min-out against the pair's own spot does not help, because the attacker moves that spot first. Also give the share a real criterion in the swarm's question (or require a counter-proposal window), so a single proposer cannot set it.","line":293,"path":"src/LARPBurner.sol","proof":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.26;\n\nimport {Test} from \"forge-std/Test.sol\";\nimport {MockERC20} from \"forge-std/mocks/MockERC20.sol\";\nimport {PoolManager} from \"@uniswap/v4-core/src/PoolManager.sol\";\nimport {IPoolManager} from \"@uniswap/v4-core/src/interfaces/IPoolManager.sol\";\nimport {IHooks} from \"@uniswap/v4-core/src/interfaces/IHooks.sol\";\nimport {PoolKey as V4PoolKey} from \"@uniswap/v4-core/src/types/PoolKey.sol\";\nimport {Currency} from \"@uniswap/v4-core/src/types/Currency.sol\";\nimport {ModifyLiquidityParams, SwapParams as V4SwapParams} from \"@uniswap/v4-core/src/types/PoolOperation.sol\";\nimport {BalanceDelta} from \"@uniswap/v4-core/src/types/BalanceDelta.sol\";\nimport {TickMath} from \"@uniswap/v4-core/src/libraries/TickMath.sol\";\n\nimport {LARPBurner} from \"src/LARPBurner.sol\";\n\ncontract Tok is MockERC20 {\n    constructor(string memory n) {\n        initialize(n, n, 18);\n    }\n\n    function mint(address to, uint256 amount) external {\n        _mint(to, amount);\n    }\n\n    function burn(uint256 amount) external {\n        _burn(msg.sender, amount);\n    }\n}\n\n/// @dev IMD Names as the burner reads it, after four approved share proposals (690 -> 1380 -> 2760 -> 5520 -> 10000).\ncontract Share {\n    uint256 public imd6900ShareBps;\n\n    function set(uint256 s) external {\n        imd6900ShareBps = s;\n    }\n}\n\n/// @dev Full-range liquidity and exact-input swaps on a v4 pool, paid by the caller.\ncontract Router {\n    IPoolManager immutable pm;\n\n    constructor(IPoolManager pm_) {\n        pm = pm_;\n    }\n\n    function add(V4PoolKey memory key, int256 liquidity) external payable {\n        pm.unlock(abi.encode(uint8(0), abi.encode(key, liquidity, msg.sender)));\n    }\n\n    function swap(V4PoolKey memory key, bool zeroForOne, uint256 amountIn) external returns (uint256 out) {\n        out = abi.decode(pm.unlock(abi.encode(uint8(1), abi.encode(key, zeroForOne, amountIn, msg.sender))), (uint256));\n    }\n\n    function unlockCallback(bytes calldata raw) external returns (bytes memory) {\n        (uint8 op, bytes memory data) = abi.decode(raw, (uint8, bytes));\n        if (op == 0) {\n            (V4PoolKey memory key, int256 liquidity, address payer) = abi.decode(data, (V4PoolKey, int256, address));\n            (BalanceDelta d,) = pm.modifyLiquidity(\n                key,\n                ModifyLiquidityParams(\n                    TickMath.minUsableTick(key.tickSpacing), TickMath.maxUsableTick(key.tickSpacing), liquidity, 0\n                ),\n                \"\"\n            );\n            _pay(key.currency0, uint256(uint128(-d.amount0())), payer);\n            _pay(key.currency1, uint256(uint128(-d.amount1())), payer);\n            if (address(this).balance > 0) payable(payer).transfer(address(this).balance);\n            return \"\";\n        }\n        (V4PoolKey memory k, bool zf1, uint256 amountIn, address who) =\n            abi.decode(data, (V4PoolKey, bool, uint256, address));\n        BalanceDelta s = pm.swap(\n            k,\n            V4SwapParams(zf1, -int256(amountIn), zf1 ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),\n            \"\"\n        );\n        (Currency cin, Currency cout) = zf1 ? (k.currency0, k.currency1) : (k.currency1, k.currency0);\n        uint256 got = uint256(uint128(zf1 ? s.amount1() : s.amount0()));\n        _pay(cin, amountIn, who);\n        pm.take(cout, who, got);\n        return abi.encode(got);\n    }\n\n    function _pay(Currency c, uint256 amount, address payer) internal {\n        if (Currency.unwrap(c) == address(0)) {\n            pm.settle{value: amount}();\n        } else {\n            pm.sync(c);\n            Tok(Currency.unwrap(c)).transferFrom(payer, address(pm), amount);\n            pm.settle();\n        }\n    }\n\n    receive() external payable {}\n}\n\n/// The IMD6900 leg sells its whole share of the burn's $IMD into the pair pool at any price (no size bound, no\n/// minimum out). At the swarm-allowed share of 100% the leg is no longer \"too small to sandwich\" (AUDIT I-11): anyone\n/// wraps their own permissionless burn(0) over ETH waiting in the burner and keeps part of the value meant for the\n/// IMD6900 burn, even through the pair's 6.9% fee each way.\ncontract PairLegSandwichTest is Test {\n    PoolManager pm;\n    Router router;\n    Tok imd;\n    Tok imd6900;\n    Share share;\n    LARPBurner burner;\n    V4PoolKey pool4;\n    V4PoolKey pair;\n    bool imdIs0;\n    address attacker = makeAddr(\"attacker\");\n\n    function setUp() public {\n        pm = new PoolManager(address(this));\n        router = new Router(IPoolManager(address(pm)));\n        imd = new Tok(\"IMD\");\n        imd6900 = new Tok(\"IMD6900\");\n        share = new Share();\n        share.set(10_000);\n        // ETH/$IMD 1% at ~2,000 IMD per ETH, as test/Base.sol\n        pool4 = V4PoolKey(Currency.wrap(address(0)), Currency.wrap(address(imd)), 10_000, 60, IHooks(address(0)));\n        pm.initialize(pool4, TickMath.getSqrtPriceAtTick(76_020));\n        // IMD6900/$IMD at 10,000 IMD6900 per IMD, charging 6.9% each way like the real pair hook\n        imdIs0 = address(imd) < address(imd6900);\n        pair = imdIs0\n            ? V4PoolKey(Currency.wrap(address(imd)), Currency.wrap(address(imd6900)), 69_000, 60, IHooks(address(0)))\n            : V4PoolKey(Currency.wrap(address(imd6900)), Currency.wrap(address(imd)), 69_000, 60, IHooks(address(0)));\n        pm.initialize(pair, TickMath.getSqrtPriceAtTick(imdIs0 ? int24(92_100) : int24(-92_100)));\n        burner = new LARPBurner(\n            address(pm), address(imd), 10_000, 60, address(0), 10_000, 200, address(imd6900), 69_000, 60, address(0),\n            address(share)\n        );\n        imd.mint(address(this), 1e30);\n        imd6900.mint(address(this), 1e33);\n        imd.approve(address(router), type(uint256).max);\n        imd6900.approve(address(router), type(uint256).max);\n        vm.deal(address(this), 10_000 ether);\n        router.add{value: 1_000 ether}(pool4, 1e21);\n        router.add(pair, 1e23); // ~1,000 $IMD of virtual reserve, as test/Base.sol's _fillPair\n    }\n\n    function _sandwich(uint256 frontImd) internal returns (int256 profit, uint256 burned6900) {\n        vm.deal(address(burner), 0.1 ether); // royalties waiting in the burner\n        imd.mint(attacker, frontImd);\n        vm.startPrank(attacker);\n        imd.approve(address(router), type(uint256).max);\n        imd6900.approve(address(router), type(uint256).max);\n        uint256 supply = imd6900.totalSupply();\n        uint256 got6900 = router.swap(pair, imdIs0, frontImd); // buy IMD6900 with $IMD\n        burner.burn{gas: 8_000_000}(0); // anyone's burn: 0.1 ETH -> $IMD -> 100% sold into the pair\n        uint256 back = router.swap(pair, !imdIs0, got6900); // sell the IMD6900 back\n        vm.stopPrank();\n        profit = int256(back) - int256(frontImd);\n        burned6900 = supply - imd6900.totalSupply() - 0; // what the burn destroyed (attacker's IMD6900 sold back)\n    }\n\n    /// Fails on this code: the attacker ends with more $IMD than it started with.\n    function test_TheIMD6900LegIsNotWorthSandwichingAtAnyAllowedShare() public {\n        (int256 profit,) = _sandwich(500 ether);\n        emit log_named_int(\"attacker profit, $IMD (wei)\", profit);\n        assertLe(profit, 0, \"a sandwich of the IMD6900 leg pays at the swarm-allowed 100% share\");\n    }\n\n    /// Control: at the launch share (6.9%) the same sandwich loses, as AUDIT I-11 says.\n    function test_AtLaunchShareItLoses() public {\n        share.set(690);\n        (int256 profit,) = _sandwich(30 ether);\n        assertLe(profit, 0);\n    }\n\n    receive() external payable {}\n}","reproduction":"Local, test/scratch/PairLegSandwich.t.sol (attached): v4 PoolManager; POOL4 ETH/$IMD 1% at tick 76020 with full-range liquidity 1e21 (as test/Base.sol); a hookless pair with a 6.9% LP fee (standing in for the pair hook's 6.9% each way) at 10,000 IMD6900 per IMD with full-range liquidity 1e23 (Base._fillPair, ~1,000 $IMD virtual reserve). The burner reads imd6900ShareBps() = 10000, the state four approved proposals reach. 0.1 ETH is waiting in the burner. In one transaction the attacker (1) swaps 500 $IMD for IMD6900 on the pair, (2) calls burner.burn(0) (0.1 ETH buys ~198 $IMD, all of it sold into the pair), (3) sells the IMD6900 back. Expected (I-11): the sandwich loses. Actual: the attacker ends +40.60 $IMD (~0.02 ETH, ~20% of the burn), and the test fails with 'a sandwich of the IMD6900 leg pays at the swarm-allowed 100% share: 40597672566689785997 > 0'. Control test_AtLaunchShareItLoses: at 690 bps the same sandwich loses (passes). audit_math measured the same on a mainnet fork at block 26177700 with the real hooks: +6.46 $IMD per 0.1 ETH burn at 10000 bps (24.8% of the fee), break-even near 5520 bps, losses at 690/1380/2760. Python constant-product model at the fork's depth (125 $IMD reserve, a 26 $IMD leg, 6.9% fee): +5.8 $IMD.","severity":"medium","snippet":"        uint256 share = held * shareBps() / 10_000;","title":"Once the share is high, the IMD6900 leg sells its whole share into the pair pool at any price, so it can be sandwiched at a profit; any proposer can raise the share to 100% in four weeks"},{"citation":"resolved","description":"From audit_permissions; reproduced. IIMDNames.register promises the price 'buys at least `minImd` $IMD to burn', and AUDIT L-04 relies on callers passing a quote as minImd. burn() sells eth = own + waiting (up to MAX_BURN in total) in one swap and compares minImd with what the whole amount bought. When ETH is already waiting, a floor sized for the payer's fee is met by the waiting ETH's $IMD even if the fee itself sold at a manipulated price. The protection is void exactly when a sandwich pays most. The loss falls on the burn, not the payer, and is bounded by MAX_BURN per call and per block (L-10), hence low. Fix: check minImd against the fee's pro-rata part, `imd * own / eth`, or sell `own` in its own unlock first and check minImd there.","line":230,"path":"src/LARPBurner.sol","proof":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.26;\n\nimport {Test} from \"forge-std/Test.sol\";\nimport {MockERC20} from \"forge-std/mocks/MockERC20.sol\";\nimport {PoolManager} from \"@uniswap/v4-core/src/PoolManager.sol\";\nimport {IPoolManager} from \"@uniswap/v4-core/src/interfaces/IPoolManager.sol\";\nimport {IHooks} from \"@uniswap/v4-core/src/interfaces/IHooks.sol\";\nimport {PoolKey as V4PoolKey} from \"@uniswap/v4-core/src/types/PoolKey.sol\";\nimport {Currency} from \"@uniswap/v4-core/src/types/Currency.sol\";\nimport {ModifyLiquidityParams} from \"@uniswap/v4-core/src/types/PoolOperation.sol\";\nimport {BalanceDelta} from \"@uniswap/v4-core/src/types/BalanceDelta.sol\";\nimport {TickMath} from \"@uniswap/v4-core/src/libraries/TickMath.sol\";\n\nimport {LARP} from \"src/LARP.sol\";\nimport {IMDNames} from \"src/IMDNames.sol\";\nimport {LARPBurner} from \"src/LARPBurner.sol\";\n\ncontract Token is MockERC20 {\n    constructor(string memory n) {\n        initialize(n, n, 18);\n    }\n\n    function mint(address to, uint256 amount) external {\n        _mint(to, amount);\n    }\n\n    function burn(uint256 amount) external {\n        _burn(msg.sender, amount);\n    }\n}\n\ncontract IdentityNFT {\n    mapping(uint256 => address) public ownerOf;\n}\n\n/// @dev Adds full-range liquidity to a v4 pool, paid by the caller.\ncontract LiquidityAdder {\n    IPoolManager immutable pm;\n\n    constructor(IPoolManager pm_) {\n        pm = pm_;\n    }\n\n    function add(V4PoolKey memory key, int256 liquidity) external payable {\n        pm.unlock(abi.encode(key, liquidity, msg.sender));\n    }\n\n    function unlockCallback(bytes calldata data) external returns (bytes memory) {\n        (V4PoolKey memory key, int256 liquidity, address payer) = abi.decode(data, (V4PoolKey, int256, address));\n        (BalanceDelta delta,) = pm.modifyLiquidity(\n            key,\n            ModifyLiquidityParams(\n                TickMath.minUsableTick(key.tickSpacing), TickMath.maxUsableTick(key.tickSpacing), liquidity, 0\n            ),\n            \"\"\n        );\n        _pay(key.currency0, uint256(uint128(-delta.amount0())), payer);\n        _pay(key.currency1, uint256(uint128(-delta.amount1())), payer);\n        if (address(this).balance > 0) payable(payer).transfer(address(this).balance);\n        return \"\";\n    }\n\n    function _pay(Currency currency, uint256 amount, address payer) internal {\n        if (Currency.unwrap(currency) == address(0)) {\n            pm.settle{value: amount}();\n        } else {\n            pm.sync(currency);\n            Token(Currency.unwrap(currency)).transferFrom(payer, address(pm), amount);\n            pm.settle();\n        }\n    }\n\n    receive() external payable {}\n}\n\n/// `burn(minImd)` compares `minImd` with the $IMD bought for own + waiting ETH, so a payer's floor for its own fee\n/// does not bound the fee's sale while ETH is waiting in the burner: a floor five times the fair quote for a\n/// 0.00069 ETH fee passes, because 0.0993 ETH of someone else's royalties were sold in the same call.\ncontract MinImdWaitingTest is Test {\n    Token imd;\n    Token imd6900;\n    PoolManager pm;\n    LARPBurner burner;\n    IMDNames names;\n    address alice = makeAddr(\"alice\");\n\n    function setUp() public {\n        IdentityNFT identity = new IdentityNFT();\n        imd = new Token(\"IMD\");\n        imd6900 = new Token(\"IMD6900\");\n        pm = new PoolManager(address(this));\n        LiquidityAdder adder = new LiquidityAdder(IPoolManager(address(pm)));\n        V4PoolKey memory pool4 =\n            V4PoolKey(Currency.wrap(address(0)), Currency.wrap(address(imd)), 10_000, 60, IHooks(address(0)));\n        V4PoolKey memory backup =\n            V4PoolKey(Currency.wrap(address(0)), Currency.wrap(address(imd)), 10_000, 200, IHooks(address(0)));\n        pm.initialize(pool4, TickMath.getSqrtPriceAtTick(76_020)); // ~2,000 IMD per ETH\n        pm.initialize(backup, TickMath.getSqrtPriceAtTick(76_000));\n        bool imdIs0 = address(imd) < address(imd6900);\n        V4PoolKey memory pair = imdIs0\n            ? V4PoolKey(Currency.wrap(address(imd)), Currency.wrap(address(imd6900)), 0, 60, IHooks(address(0)))\n            : V4PoolKey(Currency.wrap(address(imd6900)), Currency.wrap(address(imd)), 0, 60, IHooks(address(0)));\n        pm.initialize(pair, TickMath.getSqrtPriceAtTick(imdIs0 ? int24(92_100) : int24(-92_100)));\n\n        // the burner knows IMD Names before it exists (two creations later: LARP, IMDNames)\n        address namesAt = vm.computeCreateAddress(address(this), vm.getNonce(address(this)) + 2);\n        burner = new LARPBurner(\n            address(pm), address(imd), 10_000, 60, address(0), 10_000, 200, address(imd6900), 0, 60, address(0), namesAt\n        );\n        LARP larp = new LARP(address(identity));\n        names = new IMDNames(\n            address(identity), larp, address(burner), makeAddr(\"artist\"), makeAddr(\"intake\"), makeAddr(\"signer\")\n        );\n        assertEq(address(names), namesAt);\n\n        imd.mint(address(this), 1e30);\n        imd.approve(address(adder), type(uint256).max);\n        imd6900.mint(address(this), 1e33);\n        imd6900.approve(address(adder), type(uint256).max);\n        vm.deal(address(this), 10_000 ether);\n        adder.add{value: 1_000 ether}(pool4, 1e21);\n        adder.add{value: 1_000 ether}(backup, 1e21);\n        adder.add(pair, 1e23);\n    }\n\n    function test_AFloorForTheFeeBindsTheFee() public {\n        (bool ok,) = address(burner).call{value: 0.0993 ether}(\"\"); // royalties waiting\n        assertTrue(ok);\n        bytes32 l = bytes32(\"alice\");\n        uint256 price = names.priceOf(l); // 0.00069 ETH\n        uint256 floor = burner.quoteImd(price) * 5; // unreachable for the fee alone\n        vm.deal(alice, price);\n        vm.prank(alice);\n        vm.expectRevert(LARPBurner.TooLittleIMD.selector);\n        names.register{value: price}(l, alice, floor);\n    }\n\n    receive() external payable {}\n}","reproduction":"test/scratch/MinImd.t.sol (attached; the specialist's proof, run here). Pools as in test/Base.sol, all filled. 0.0993 ETH is sent to the burner (royalties). alice calls IMDNames.register{value: 0.00069 ether}('alice', alice, minImd = 5 * burner.quoteImd(0.00069 ether)), a floor the fee alone cannot buy. Expected: revert TooLittleIMD. Actual: the call succeeds, because burn sold 0.1 ETH (fee + waiting) for ~198 $IMD, above the floor. The test fails with 'next call did not revert as expected'.","severity":"low","snippet":"        if (imd < minImd) revert TooLittleIMD();","title":"burn checks the payer's minImd against own fee + waiting ETH, so register/link/foundCrew's floor does not bound the payer's own fee"}],"hash":"42886dc8174dd6e495dcf82cf2f1cc349b3f7798d302c7ac3c712c7183fa56a6","nodeId":"32c385ba-78a8-4706-a520-1f7811a27296","outcome":"completed","summary":"I kept two of the five specialist findings, one medium and one low; the other three I merged or dropped. Both kept findings are in `.imd-findings.json` with a test that fails on the current code. The coverage record has 149 rows, all `holds` or `finding`, none `unreached`: the 42 state-changing entry points from the ABI, plus the constructors and view functions from the brief's list of 148.\n\n**Kept**\n\n1. **Medium: the IMD6900 leg can be sandwiched once the share is high** (`src/LARPBurner.sol:293`). This merges the math and economics findings.\n   - **What's wrong:** the burner sells its whole share of the $IMD into the IMD6900 pool in one swap, with no size limit and no minimum output (the only check is at line 265). On the $IMD payment paths not even `MAX_BURN` applies.\n   - **Why it's reachable:** the swarm's question at `SwarmPrices.sol:295` only asks whether the share is between 0% and 100%, which the contract already enforces. So a proposal that leaves prices alone and moves only the share is always approvable. Any proposer can take it from 6.9% to 100% in four weekly steps for 2 IMD.\n   - **Reproduction:** I wrote a local test with a 6.9% pool fee standing in for the pair hook. At a 100% share, an attacker who wraps their own `burn(0)` around 0.1 ETH waiting in the burner ends up +40.6 $IMD (about 20% of the burn). At 6.9% the same sandwich loses, as the audit's I-11 says. The specialist's mainnet-fork figure (+24.8% of the fee) agrees.\n   - **Suggested fix:** cap how much $IMD the IMD6900 leg can sell per block and send the rest to `IMD_BURN`. The swarm's question also needs a real test for the share.\n\n2. **Low: the payer's `minImd` floor doesn't apply to their own fee** (`src/LARPBurner.sol:230`). `register`, `link` and `foundCrew` promise that the price \"buys at least `minImd`\". In fact the floor is checked against the payer's fee plus any ETH already waiting in the burner. The specialist's test fails here as described: a floor five times what the fee could buy passes because 0.0993 ETH was waiting. The loss falls on the burn, not the payer, and it's limited by `MAX_BURN`, so it's low.\n\n**Dropped**\n- **Agent passing a crew's captaincy:** it reproduces, but AUDIT.md's I-01 already accepts that an agent can run or disband the owner's crews.\n- **`quoteImd` uses spot price, about 1% above the ETH route:** AUDIT.md's L-07 already documents this, and nobody gains from it.\n\n**My own pass:** I found nothing further. CreateX placement, the occupied-address fallback, size limits, `launch.json`, the gas budgets, label validation, two-way name links, agent signatures and Merkle proofs all hold. The full suite gives 309 passed and 13 skipped (fork tests that need an RPC), which is 322 tests. The brief and AUDIT.md both say 290, so those documents are out of date; I didn't count that as a defect.\n\nI removed the scratch tests afterwards; their source is embedded as proofs in the findings file.","treeHash":null,"usage":{"cachedInputTokens":2538845,"inputTokens":44,"model":"claude-opus-5-5","outputTokens":38712,"runtime":"claude","turns":25,"wallClockMs":760628}},{"artifacts":[],"attempt":1,"bundleHash":null,"device":"4dd67dae195771b6","findings":[],"hash":"540868eb79737632c737d0fcb0d60cac72367d9c7805b089ba856468007eb74f","nodeId":"7147f916-1884-4292-bb4f-57a563ccae22","outcome":"failed","summary":"the task produced no changes; the agent's last message was: The manifest is already correct and nothing in this round's brief asks for a change. Summary:\n\n**Result:** launch.json stays as accepted. No file was modified and the working tree is clean.\n\n**What I verified**\n- The manifest has exactly the keys kind, contracts and notes, with kind \"evm_contracts\".\n- It names PlaceLARP with no constructor arguments, then PlaceLinks with the single argument `$contract:PlaceLARP`. That matches the constructors in src/place/PlaceLARP.sol, which pass only LARPPlan's fixed constants and the sibling addresses to the four CREATE3 placements. No IMD protocol address is a launch argument.\n- Notes are one string of 524 characters describing the placement, the 0x6900 plan addresses, the squatted-salt fallback and the getters that report actual addresses.\n- The protected check only rehearses deployment through the factory probe and scans runtime for forbidden opcodes. Neither placer contract uses DELEGATECALL, CALLCODE or SELFDESTRUCT, and the proxy they CREATE2 is the standard CREATE3 proxy.\n\n**Checks run**\n\n| Check | Outcome |\n|---|---|\n| forge build | compiled, lint warnings only |\n| forge test | 283 passed, 0 failed, 13 skipped |\n\nThe skipped tests are the mainnet fork suite, which needs an RPC this offline machine does not have. The fuzz seed is fixed in foundry.toml, which I did not touch.\n\nNo findings were attached to this revision round, so there was nothing to repair. The accepted launch.json is the deliverable.","treeHash":null,"usage":{"cachedInputTokens":155188,"inputTokens":130,"model":"claude-fable-5-1","outputTokens":1809,"runtime":"claude","turns":5,"wallClockMs":430462}},{"artifacts":[],"attempt":1,"bundleHash":"5e642bad22a36e03715d472ff19f48a077db8953a0c333087e4994844a78cf98","device":"8d210756eb9ac4d7","findings":[],"hash":"67dbec99b3baa471d606fc861f1dcf29771f6c009f3cd4c7ea8e1037ce8757bb","nodeId":"696488ee-5191-4aaf-81b3-3e71555dd5bb","outcome":"completed","summary":"Added failure-path tests and three invariant campaigns, entirely under `test/`. Coverage maps all 149 listed ABI entries.\n\nValidation passed:\n\n- `forge build --offline`\n- `forge test --offline`: **309 passed, 0 failed, 13 RPC-dependent skips**\n- Each new invariant campaign completed **16,384 calls** with no unexpected reverts.","treeHash":"6299a08e5285c5cfe040fa75cfaa313b393159c2","usage":{"cachedInputTokens":6234368,"inputTokens":196115,"model":"gpt-6-astra","outputTokens":50906,"runtime":"codex","turns":10,"wallClockMs":1458600}},{"artifacts":[],"attempt":2,"bundleHash":"82a10871956bc905878114a4b05068aa552f9a326e50df8ce32aa8626704d70b","device":"60ffae3cc413a0c6","findings":[],"hash":"74d418e80ef41f6df31fb67ef6a97407725f8418c813cc9a1c3ae587d2077367","nodeId":"7147f916-1884-4292-bb4f-57a563ccae22","outcome":"completed","summary":"Done. The revised launch.json is the only change in the tree, and it was rejected last round only because the attempt submitted no diff.\n\n**What changed**\n- The two contract entries are unchanged and still match the source: PlaceLARP with no arguments, then PlaceLinks with the single argument `$contract:PlaceLARP`.\n- The notes were rewritten to carry what the brief asks reviewers to confirm: every address, fee, spacing and salt the four constructors receive is a constant of LARPPlan, so no IMD protocol address is a launch argument. They list the four planned 0x6900 addresses, the squatted-salt fallback that never claims a planned address, the absence of any owner or upgrade path, the swarm-only price and IMD6900 share changes, and the $IMD burn destination as the IMD_BURN constant rather than 0xdEaD. Notes are 1,689 characters, under the limit.\n\n**Checks**\n\n| Check | Outcome |\n|---|---|\n| Manifest shape (keys, kind, unique names, string args, notes length) | ok |\n| forge build | compiled, lint warnings only |\n| forge test | 283 passed, 0 failed, 13 skipped |\n| Protected rehearsal in test/scratch (factory CREATE2 of both entries on an empty chain, opcode scan, EIP-170, init code under 48 KiB) | 2 passed |\n\nThe 13 skipped tests are the mainnet fork suite, which needs an RPC this offline machine does not have. The rehearsal copies the protected harness logic with the manifest's arguments resolved, because the original reads its inputs from service environment variables that are not set here. It confirms both placers deploy through the factory on a chain without CreateX, fall back to their own CREATE3 without claiming a planned address, and contain no DELEGATECALL, CALLCODE or SELFDESTRUCT. The scratch directory is not part of the submission.","treeHash":"eb3024262d461bb3af2bd7d4194b0f486fe46192","usage":{"cachedInputTokens":496691,"inputTokens":386,"model":"claude-fable-5-1","outputTokens":6905,"runtime":"claude","turns":13,"wallClockMs":391062}},{"artifacts":[],"attempt":1,"bundleHash":null,"device":"739094f0e08668ee","findings":[{"citation":"resolved","description":"Seam: boundary x precision x invariant (Numerical Gap guide), plus Boundary step 2 (an external swap with no output bound). The burner's only sandwich defence is size: MAX_BURN (0.1 ETH) was sized so that the IMD6900 leg, 6.9% of it, is too small to be worth attacking (AUDIT.md I-11: '6.9% of at most 0.1 ETH of $IMD per burn ... so it isn't worth sandwiching'). v2 made the multiplier swarm-voted up to MAX_SHARE_BPS = 10_000, but the leg kept its v1 shape: `share = held * shareBps() / 10_000` is sold in one exact-input swap to the price limit (MIN/MAX_PRICE_LIMIT) and unlockCallback accepts any output (`outDelta <= 0` is the only check, LARPBurner.sol:265). Nothing scales the leg to the pair pool, and on the $IMD-paid path (registerWithImd / linkWithImd / foundCrewWithImd -> burnImd) not even MAX_BURN applies: `held` is the whole fee. The live IMD6900/$IMD pool is shallow: at block 26177700 its in-range liquidity is 0x9f71e652756bc7fc62f at sqrtPriceX96 0xad9438eaad43daaa72f997, i.e. about 124.6 $IMD of virtual reserve (~0.47 ETH at 265 $IMD/ETH). One 0.1 ETH burn buys 26.03 $IMD, so the leg is 1.4% of that reserve at 690 bps but 21% at 10_000 bps. Measured on a fork of that block with the real hooks: the sandwich loses money at 690, 1380 and 2760 bps (I-11 holds there), turns profitable at 5520 bps (+0.95 $IMD per burn) and at 10_000 bps pays +6.46 $IMD (about 0.024 ETH, 24.8% of the fee) per 0.1 ETH, while the IMD6900 burned falls from 2,858,011 to 1,249,631 (-56%). It needs no mempool: burn() is permissionless, so the attacker wraps its own burn(0) over ETH already waiting in the burner (royalties, WETH, parked fees, the part of a fee above MAX_BURN) in one transaction, once per block (L-10's cap), or wraps any payer's transaction. The swarm's question only asks that the share be 'between 0% and 100%', and _checkShareStep allows 690 -> 1380 -> 2760 -> 5520 -> 10000 in four weekly steps, so this state is inside the guardrails the brief keeps. Without any attacker the leg already overpays at the edge: 265 $IMD (a 1 ETH fee, MAX_PRICE, paid in $IMD) at 10_000 bps burned 11.25M IMD6900 against about 37.8M at spot, a 70% loss to price impact, with nothing sent to IMD_BURN. Impact: fee value meant for the burn is paid to a third party / to arbitrage instead (medium: loss under a condition the guardrails allow; no user principal is at risk). Fix that keeps the design (share 0-100%, no owner, the remainder to IMD_BURN): bound the $IMD the pair leg may sell per block by a constant sized like MAX_BURN was for 6.9% (about 0.0069 ETH worth, e.g. a fixed $IMD amount or a fraction of the pair pool's in-range liquidity read with extsload), sending what exceeds it to IMD_BURN as the code already does when the leg fails; a min-out against the pair's own spot does not help, since the atomic attacker moves that spot first. Capping MAX_SHARE instead would change the agreed 0-100% range and needs a scope decision.","line":293,"path":"src/LARPBurner.sol","reproduction":"Fork Ethereum at block 26177700. Deploy LARPBurner(0x000000000004444c5dc75cB358380D2e3dE08A90, 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7, 10000, 60, 0xc6C965Bd164c483e87d0B550671798e9A3602840, 10000, 200, 0x0000198C940D8cD70Cb9ACeC5E3af8216ac57d2F, 0, 60, 0x667f4621030aCfAfb1bD0B64d33610A8567f2A44, names) with `names` a contract whose imd6900ShareBps() returns 10000 (the state IMDNames reaches after four approved proposals 690->1380->2760->5520->10000). Send the burner 0.1 ETH (a waiting royalty). In one transaction the attacker (a) swaps 70 $IMD -> IMD6900 exact-in on PoolKey(IMD6900, IMD, fee 0, spacing 60, hook 0x667f...2A44), zeroForOne=false; (b) calls burner.burn(0) with no value; (c) swaps all the IMD6900 from (a) back to $IMD. Expected: the burn is not worth sandwiching (AUDIT I-11) and burns about 2,858,011 IMD6900 for its 26.033 $IMD. Actual: the attacker ends with +6.4618 $IMD (76.46 back for 70 in), and the burn's 26.033 $IMD burns only 1,249,631 IMD6900. With 60 $IMD in step (a) and a burn{value: 0.1 ether}(0) victim: +6.3615 $IMD, 1,379,837 IMD6900 burned. Same steps at 5520 bps with 30 $IMD: +0.9548 $IMD. At 690/1380/2760 bps every size tried (3 to 100 $IMD) loses (-0.32/-0.25/-0.10 $IMD at best), so the defect appears only once the share leaves the range MAX_BURN was sized for. Uncapped $IMD path, no attacker: at 10000 bps give the burner 265 $IMD (what registerWithImd transfers for a 1 ETH name) and call burnImd(): 11,250,243 IMD6900 burned (spot would give ~37.8M), 0 $IMD to IMD_BURN.","severity":"medium","snippet":"        uint256 share = held * shareBps() / 10_000;","title":"The IMD6900 leg has no size cap and no minimum out, so at a swarm-voted share above ~50% every 0.1 ETH burn is profitably sandwiched (measured: 24.8% of the fee at 100%)"}],"hash":"7cccdfd7865dce0554824275f1d80fe235cc73d39d2dcb3d6022ba7b4b404dd1","nodeId":"f51829d0-c90a-45f5-8f29-0296d607e4f0","outcome":"completed","summary":"The review is written to `.imd-findings.json`: one medium finding and 152 coverage rows (all 42 state-changing entry points, the views and constructors, and two invariants). No repository files were changed.\n\n**Finding (medium): the IMD6900 leg has no size cap and no minimum out.** `LARPBurner.sol:293` sells `held * shareBps() / 10_000` in one swap to the price limit, and `unlockCallback` accepts any positive output. `MAX_BURN` was sized for a 6.9% share. With the share now votable up to 100%, the leg can be far larger than the pair pool tolerates, and on the `$IMD`-paid path `MAX_BURN` does not apply at all.\n\nI measured this on a fork of mainnet block 26177700 against the real pools and hooks; the pair pool holds only about 124.6 $IMD of in-range virtual reserve (≈0.47 ETH).\n\n| Share (bps) | Best attacker result per 0.1 ETH burn | IMD6900 burned, clean → sandwiched |\n|---|---|---|\n| 690 | −0.32 $IMD (unprofitable) | 235,004 → 224,162 |\n| 1380 | −0.25 $IMD | 463,424 → 442,188 |\n| 2760 | −0.10 $IMD | 901,590 → 860,811 |\n| 5520 | +0.95 $IMD | 1,709,980 → 1,133,611 |\n| 10000 | +6.46 $IMD (≈0.024 ETH, 24.8% of the fee) | 2,858,011 → 1,249,631 |\n\n- **No mempool needed:** the attacker wraps their own `burn(0)` over ETH already waiting in the burner, once per block.\n- **Reachable inside the guardrails:** 690 → 1380 → 2760 → 5520 → 10000 is four weekly approved steps, and the swarm's question only asks that the share be between 0% and 100%.\n- **Loss even without an attacker:** 265 $IMD (a 1 ETH fee paid in $IMD) at 100% burned 11.25M IMD6900 against about 37.8M at spot.\n- **AUDIT.md I-11 is stale, not re-raised:** its \"6.9% of at most 0.1 ETH\" premise holds at 690–2760 bps and fails from about 5520 bps.\n- **Suggested fix:** cap the $IMD the pair leg may sell per block and send the excess to `IMD_BURN`, as the code already does when the leg fails. Capping `MAX_SHARE` instead would change the agreed 0–100% range and needs your decision.\n\nThe finding carries no Foundry proof file: it is medium, and the reproduction depends on live pool depth, so it is given as a fork recipe with exact addresses, block and amounts.\n\n**Everything else in the math area held when traced by reading the code:**\n- the burner's per-block cap arithmetic and gas-budget checks;\n- the `BalanceDelta` splits for both token orders;\n- `quoteImd`'s slot and `mulDiv` math, which I also checked against live pool state;\n- the price and share step and bounds checks, and the verdict quorum arithmetic;\n- the slot packing in `LARP`;\n- the crew and fren counters;\n- the jeet board's sums, clamps and paging.\n\nI ran the existing suite once as a baseline (277 passed, 13 fork tests skipped, 290 total). I wrote no new edge-case tests for the `holds` rows.\n\n**Not covered:** I did not reproduce the acknowledged items L-03 to L-13; I only checked that their stated bounds match the code. Access-control and placement logic outside the numeric paths got a light read only.","treeHash":null,"usage":{"cachedInputTokens":1758037,"inputTokens":32,"model":"claude-opus-5-5","outputTokens":46893,"runtime":"claude","turns":19,"wallClockMs":733603}},{"artifacts":[],"attempt":1,"bundleHash":"43927aea1af02ace3fa8b2b056d51951461e6d43ea42b69fbdb37f8e87e0d4e8","device":"1d142f9c9d30c62a","findings":[],"hash":"b19ddcfcf896af2a5bbe3aa5c4c8a7f6be5e0599831700bdb6c2c61b78db86c3","nodeId":"7147f916-1884-4292-bb4f-57a563ccae22","outcome":"completed","summary":"Created [launch.json](/home/imd/.identitymd/work/7e353f41-1fc4-4390-8e61-58d1c845db1c/7147f916-1884-4292-bb4f-57a563ccae22/launch.json) with exactly `PlaceLARP()` followed by `PlaceLinks($contract:PlaceLARP)`.\n\nManifest structure and compiled constructor ABIs checked. `forge build` passed. `forge test --offline`: 277 passed, 0 failed, 13 RPC-dependent tests skipped.\n\nOnly `launch.json` changed for submission.","treeHash":"afd32f87faf019c8aa100128502b6983e1e1f77b","usage":{"cachedInputTokens":593152,"inputTokens":53625,"model":"gpt-6-astra","outputTokens":4156,"runtime":"codex","turns":4,"wallClockMs":198393}},{"artifacts":[],"attempt":1,"bundleHash":"e111312e889ae7321df96b15df0a04eebe5377223f41d936faff0bbf32254aa1","device":"1f805d33d69c340e","findings":[],"hash":"b1b03f91ffc1bc9ad169f60fc3af7c7a69a6cec69811519059d6c26655a825a0","nodeId":"0fcc7809-54f6-40c8-87a1-b5a12f34c0c4","outcome":"completed","summary":"Implemented both reproduced audit fixes, added 11 regression tests, and documented all entry points in [ADAPTATION.md](/root/.identitymd/work/7e353f41-1fc4-4390-8e61-58d1c845db1c/0fcc7809-54f6-40c8-87a1-b5a12f34c0c4/ADAPTATION.md).\n\nValidation passed:\n\n- `forge build`\n- `forge test`: 277 passed, 0 failed, 13 fork tests skipped without RPC\n- Protected deployment rehearsal\n\nLaunch arguments, salts, addresses, interfaces, and dependencies remain unchanged. No on-chain deployment was performed.","treeHash":"0e8b822afa19f9777545560fae69661c54b4715a","usage":{"cachedInputTokens":8898176,"inputTokens":238942,"model":"gpt-6-astra","outputTokens":48943,"runtime":"codex","turns":14,"wallClockMs":1865553}},{"artifacts":[],"attempt":1,"bundleHash":null,"device":"99c6d0bcc495ad61","findings":[{"citation":"resolved","description":"Agent authority is designed to be revocable: README and I-01 say the owner revokes it at any time and a sale ends it, and every other action an agent can take on the owner's behalf is reversible by the owner afterwards (unequip, unlink, overwrite setText, unfren, kick/rejoin, refound a disbanded crew). passCaptain is the exception: _captain(crewId) accepts the captain identity's live agent (LARP.canAct), and the function moves the crew's captaincy to any member identity, including one the agent's own wallet holds. Captaincy is bound to the identity, not to the agent key, so revoking the agent (LARP.setAgent(imdId, 0)) does not undo it: the owner, who paid the crew price (NAMES.crewPrice(), 0.00069 ETH at launch, burned), permanently loses the crew, its members and its unique name (crewByName stays taken, so the owner cannot refound it). Impact is bounded to a crew and its name (no funds), hence low; it is an escalation from a revocable delegated role to an irrevocable transfer, which the acknowledged I-01 (\"run or disband the owner's crews\") does not cover. Minimal fix preserving the design: in passCaptain, require the identity's owner rather than canAct (e.g. `if (IDENTITY.ownerOf(c.captain, gasleft()) != msg.sender) revert NotCaptain();`), or let the identity's owner reclaim a crew whose captaincy was passed by its agent.","line":288,"path":"src/LARPLinks.sol","proof":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.26;\n\nimport {Test} from \"forge-std/Test.sol\";\nimport {LARP} from \"src/LARP.sol\";\nimport {LARPLinks} from \"src/LARPLinks.sol\";\nimport {IIMDNames} from \"src/IIMDNames.sol\";\nimport {ILARP} from \"src/ILARP.sol\";\n\n/// @dev identity.md, as far as LARP reads it.\ncontract IdentityNFT {\n    mapping(uint256 => address) public ownerOf;\n\n    function mint(address to, uint256 id) external {\n        ownerOf[id] = to;\n    }\n}\n\n/// @dev IMD Names, as far as LARPLinks reads it: a crew price of zero, so no burner is needed.\ncontract FreeNames {\n    function crewPrice() external pure returns (uint256) {\n        return 0;\n    }\n\n    function nameOf(uint256) external pure returns (string memory) {\n        return \"\";\n    }\n}\n\n/// @dev Accepts the (empty) crew fee.\ncontract SinkBurner {\n    function burn(uint256) external payable returns (uint256) {\n        return 0;\n    }\n}\n\n/// An agent's authority is meant to lapse when the owner revokes it (README: \"The owner can replace or remove it\n/// at any time\"). Every other agent action is reversible by the owner, but `passCaptain` lets the agent hand the\n/// owner's crew to the agent's own identity for good: after revocation the owner can no longer disband it.\ncontract AgentKeepsCrewTest is Test {\n    IdentityNFT identity;\n    LARP larp;\n    LARPLinks links;\n    address alice = makeAddr(\"alice\");\n    address agent = makeAddr(\"agent\");\n\n    function setUp() public {\n        identity = new IdentityNFT();\n        larp = new LARP(address(identity));\n        FreeNames names = new FreeNames();\n        SinkBurner burner = new SinkBurner();\n        links = new LARPLinks(\n            address(identity), makeAddr(\"launcher\"), ILARP(address(larp)), IIMDNames(address(names)), address(burner)\n        );\n        identity.mint(alice, 1); // the owner's identity\n        identity.mint(agent, 2); // the agent's own identity\n    }\n\n    function test_ARevokedAgentDoesNotKeepTheOwnersCrew() public {\n        vm.prank(alice);\n        larp.setAgent(1, agent);\n        vm.prank(alice);\n        uint256 crewId = links.foundCrew(1, bytes32(\"frens\"), true, 0);\n\n        // the agent joins with its own identity and passes the owner's captaincy to it\n        vm.startPrank(agent);\n        links.join(2, crewId);\n        links.passCaptain(crewId, 2);\n        vm.stopPrank();\n\n        // the owner revokes the agent\n        vm.prank(alice);\n        larp.setAgent(1, address(0));\n        (bool live,) = larp.canAct(1, agent);\n        assertFalse(live, \"the agent is revoked\");\n\n        // ...but the owner's crew (and its unique name) is now the agent's: the owner cannot disband or reclaim it,\n        // and cannot found another crew with that name\n        (uint256 captain,,,,) = links.crew(crewId);\n        assertEq(captain, 1, \"the owner's identity should still captain the crew it paid for\");\n        vm.prank(alice);\n        links.disband(crewId);\n    }\n}","reproduction":"State: alice owns identity 1, agent wallet owns identity 2. 1) alice: LARP.setAgent(1, agent). 2) alice: LARPLinks.foundCrew{value: crewPrice}(1, \"frens\", true, 0) -> crewId. 3) agent: LARPLinks.join(2, crewId); agent: LARPLinks.passCaptain(crewId, 2) (passes: _captain(crewId) accepts the live agent of identity 1). 4) alice: LARP.setAgent(1, address(0)); LARP.canAct(1, agent) is now false. Expected: the owner's crew remains hers, or is recoverable, once the agent is revoked. Actual: LARPLinks.crew(crewId).captain == 2; alice's disband(crewId)/kick/setOpen/invite revert NotCaptain, crewByName[\"frens\"] == crewId stays taken, and alice's identity 1 is a plain member the new captain can kick. Test: test/scratch/AgentKeepsCrew.t.sol fails on this code with 'the owner's identity should still captain the crew it paid for: 2 != 1'.","severity":"low","snippet":"        _crews[crewId].captain = imdId;","title":"LARPLinks.passCaptain lets a revoked agent keep the owner's crew for good (access x asymmetry)"},{"citation":"resolved","description":"burn(minImd) sells eth = own + waiting (the caller's fee plus up to MAX_BURN - own of ETH already waiting from royalties, parked fees or fee remainders) in one swap and compares minImd with the $IMD bought for the whole amount (imd = abi.decode(result) for `eth`). README/AUDIT tell the site to pass a quote for the fee as minImd (L-04: \"Callers can set minImd; the site should pass a quote\"), and IMDNames.register, link and LARPLinks.foundCrew forward that floor. Whenever ETH is waiting, the floor is compared against a sale up to ~145x larger than a 5+ letter fee (0.1 ETH vs 0.00069 ETH), so it is satisfied even when the payer's own fee is executed at a heavily manipulated price: the slippage protection the payer believes it set is void in exactly the state (ETH waiting) where a sandwich is attractive. Who loses: the protocol (less $IMD burned), not the payer, and the loss stays bounded by the per-call/per-block MAX_BURN cap and POOL4's fee break-even (L-04, L-10), and an attacker already has burn(0) for waiting ETH; hence low. Fix options that keep the design: check minImd against the pro-rata share of `imd` for `own` (imd * own / eth), or sell `own` and the waiting ETH as two unlocks and check minImd on the first; and document the actual semantics.","line":230,"path":"src/LARPBurner.sol","proof":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.26;\n\nimport {Test} from \"forge-std/Test.sol\";\nimport {MockERC20} from \"forge-std/mocks/MockERC20.sol\";\nimport {PoolManager} from \"@uniswap/v4-core/src/PoolManager.sol\";\nimport {IPoolManager} from \"@uniswap/v4-core/src/interfaces/IPoolManager.sol\";\nimport {IHooks} from \"@uniswap/v4-core/src/interfaces/IHooks.sol\";\nimport {PoolKey as V4PoolKey} from \"@uniswap/v4-core/src/types/PoolKey.sol\";\nimport {Currency} from \"@uniswap/v4-core/src/types/Currency.sol\";\nimport {ModifyLiquidityParams} from \"@uniswap/v4-core/src/types/PoolOperation.sol\";\nimport {BalanceDelta} from \"@uniswap/v4-core/src/types/BalanceDelta.sol\";\nimport {TickMath} from \"@uniswap/v4-core/src/libraries/TickMath.sol\";\n\nimport {LARP} from \"src/LARP.sol\";\nimport {IMDNames} from \"src/IMDNames.sol\";\nimport {LARPBurner} from \"src/LARPBurner.sol\";\n\ncontract Token is MockERC20 {\n    constructor(string memory n) {\n        initialize(n, n, 18);\n    }\n\n    function mint(address to, uint256 amount) external {\n        _mint(to, amount);\n    }\n\n    function burn(uint256 amount) external {\n        _burn(msg.sender, amount);\n    }\n}\n\ncontract IdentityNFT {\n    mapping(uint256 => address) public ownerOf;\n}\n\n/// @dev Adds full-range liquidity to a v4 pool, paid by the caller.\ncontract LiquidityAdder {\n    IPoolManager immutable pm;\n\n    constructor(IPoolManager pm_) {\n        pm = pm_;\n    }\n\n    function add(V4PoolKey memory key, int256 liquidity) external payable {\n        pm.unlock(abi.encode(key, liquidity, msg.sender));\n    }\n\n    function unlockCallback(bytes calldata data) external returns (bytes memory) {\n        (V4PoolKey memory key, int256 liquidity, address payer) = abi.decode(data, (V4PoolKey, int256, address));\n        (BalanceDelta delta,) = pm.modifyLiquidity(\n            key,\n            ModifyLiquidityParams(\n                TickMath.minUsableTick(key.tickSpacing), TickMath.maxUsableTick(key.tickSpacing), liquidity, 0\n            ),\n            \"\"\n        );\n        _pay(key.currency0, uint256(uint128(-delta.amount0())), payer);\n        _pay(key.currency1, uint256(uint128(-delta.amount1())), payer);\n        if (address(this).balance > 0) payable(payer).transfer(address(this).balance);\n        return \"\";\n    }\n\n    function _pay(Currency currency, uint256 amount, address payer) internal {\n        if (Currency.unwrap(currency) == address(0)) {\n            pm.settle{value: amount}();\n        } else {\n            pm.sync(currency);\n            Token(Currency.unwrap(currency)).transferFrom(payer, address(pm), amount);\n            pm.settle();\n        }\n    }\n\n    receive() external payable {}\n}\n\n/// `burn(minImd)` compares `minImd` with the $IMD bought for own + waiting ETH, so a payer's floor for its own fee\n/// does not bound the fee's sale while ETH is waiting in the burner: a floor five times the fair quote for a\n/// 0.00069 ETH fee passes, because 0.0993 ETH of someone else's royalties were sold in the same call.\ncontract MinImdWaitingTest is Test {\n    Token imd;\n    Token imd6900;\n    PoolManager pm;\n    LARPBurner burner;\n    IMDNames names;\n    address alice = makeAddr(\"alice\");\n\n    function setUp() public {\n        IdentityNFT identity = new IdentityNFT();\n        imd = new Token(\"IMD\");\n        imd6900 = new Token(\"IMD6900\");\n        pm = new PoolManager(address(this));\n        LiquidityAdder adder = new LiquidityAdder(IPoolManager(address(pm)));\n        V4PoolKey memory pool4 =\n            V4PoolKey(Currency.wrap(address(0)), Currency.wrap(address(imd)), 10_000, 60, IHooks(address(0)));\n        V4PoolKey memory backup =\n            V4PoolKey(Currency.wrap(address(0)), Currency.wrap(address(imd)), 10_000, 200, IHooks(address(0)));\n        pm.initialize(pool4, TickMath.getSqrtPriceAtTick(76_020)); // ~2,000 IMD per ETH\n        pm.initialize(backup, TickMath.getSqrtPriceAtTick(76_000));\n        bool imdIs0 = address(imd) < address(imd6900);\n        V4PoolKey memory pair = imdIs0\n            ? V4PoolKey(Currency.wrap(address(imd)), Currency.wrap(address(imd6900)), 0, 60, IHooks(address(0)))\n            : V4PoolKey(Currency.wrap(address(imd6900)), Currency.wrap(address(imd)), 0, 60, IHooks(address(0)));\n        pm.initialize(pair, TickMath.getSqrtPriceAtTick(imdIs0 ? int24(92_100) : int24(-92_100)));\n\n        // the burner knows IMD Names before it exists (two creations later: LARP, IMDNames)\n        address namesAt = vm.computeCreateAddress(address(this), vm.getNonce(address(this)) + 2);\n        burner = new LARPBurner(\n            address(pm), address(imd), 10_000, 60, address(0), 10_000, 200, address(imd6900), 0, 60, address(0), namesAt\n        );\n        LARP larp = new LARP(address(identity));\n        names = new IMDNames(\n            address(identity), larp, address(burner), makeAddr(\"artist\"), makeAddr(\"intake\"), makeAddr(\"signer\")\n        );\n        assertEq(address(names), namesAt);\n\n        imd.mint(address(this), 1e30);\n        imd.approve(address(adder), type(uint256).max);\n        imd6900.mint(address(this), 1e33);\n        imd6900.approve(address(adder), type(uint256).max);\n        vm.deal(address(this), 10_000 ether);\n        adder.add{value: 1_000 ether}(pool4, 1e21);\n        adder.add{value: 1_000 ether}(backup, 1e21);\n        adder.add(pair, 1e23);\n    }\n\n    function test_AFloorForTheFeeBindsTheFee() public {\n        (bool ok,) = address(burner).call{value: 0.0993 ether}(\"\"); // royalties waiting\n        assertTrue(ok);\n        bytes32 l = bytes32(\"alice\");\n        uint256 price = names.priceOf(l); // 0.00069 ETH\n        uint256 floor = burner.quoteImd(price) * 5; // unreachable for the fee alone\n        vm.deal(alice, price);\n        vm.prank(alice);\n        vm.expectRevert(LARPBurner.TooLittleIMD.selector);\n        names.register{value: price}(l, alice, floor);\n    }\n\n    receive() external payable {}\n}","reproduction":"Setup as test/Base.sol (POOL4, backup and pair pools filled). 1) Anyone sends 0.0993 ETH to the burner (royalties). 2) alice: IMDNames.register{value: 0.00069 ether}(\"alice\", alice, minImd = 5 * quoteImd(0.00069 ether)) (quote ~1.381e18 IMD, so floor ~6.9e18 IMD, unreachable for 0.00069 ETH on these pools). Expected: revert TooLittleIMD, since 0.00069 ETH cannot buy the floor. Actual: the call succeeds; burn sold 0.1 ETH (own + 0.0993 waiting) for ~200e18 IMD, which exceeds the floor, and the name is minted; the burner's balance is 0. Test: test/scratch/MinImdWaiting.t.sol fails on this code with 'next call did not revert as expected'.","severity":"low","snippet":"        if (imd < minImd) revert TooLittleIMD();","title":"LARPBurner.burn checks minImd against own + waiting ETH, so a payer's floor does not bound its own fee's sale"}],"hash":"b2cc38cd12b924b4cca9caa9785a0c22a6532cfd0fe4d2139bf0994eebe93a4c","nodeId":"21326937-2c79-498e-8894-1576baf48565","outcome":"completed","summary":"The review is complete and `.imd-findings.json` holds the result. No source, config or library file was touched; only `.imd-findings.json` and `test/scratch/` were written.\n\n**Outcome:** the permission model holds across the four contracts and the two placements. No owner or upgrade path exists, the artist role reaches only `tokenURI`'s renderer, every state change in IMDNames and LARPLinks routes through `LARP.canAct` (owner or live agent) or the ERC-721 owner, `unlockCallback` is reachable only through the burner's own unlock, oracle callbacks need the Intake plus the signer's request-bound signature, and the CREATE3 placement wires each contract to the address actually obtained, never to a squatted plan address. Two defects survived verification, both low, each with a failing Foundry proof under `test/scratch/`:\n\n1. **Revoked agent keeps the owner's crew** at `src/LARPLinks.sol:288`. Every other agent action is reversible by the owner, but `passCaptain` accepts the live agent and binds captaincy to the identity the agent itself holds. After `setAgent(imdId, 0)` the owner can no longer disband, kick or refound under that name. Proof fails with `2 != 1` on current code.\n\n2. **`minImd` is checked against own plus waiting ETH** at `src/LARPBurner.sol:230`. With 0.0993 ETH of royalties waiting, a registration passing a floor five times the fair quote for its 0.00069 ETH fee still succeeds, because the 0.1 ETH total sale clears it. The protocol, not the payer, bears any sandwich loss, and the per-block cap and pool fee economics already bound it, so this is low rather than medium.\n\n**Coverage record:** 149 rows, one for each of the 42 verifier-listed state-changing entry points by exact signature plus every other entry point in the brief's 148. Verdicts: 146 holds, 3 finding (two rows point at finding 2 since `register` forwards the floor to `burn`), 0 unreached.\n\n**Leads checked and dropped:** the cold `shareBps` read costs about 12k of its 30k budget, so the swarm's share is honoured; toll bypass attempts through agents, gifting via `register(to)`, or operator transfers all fail; the Slither and Aderyn lines (strict equality, reentrancy, encodePacked, locked ether) are either guarded by the transient lock and exact `msg.value` forwarding or are fixed-width encodings with no collision. Live dependency behaviour (identity.md burnability, the real Intake's synchronous-callback handling, IMD6900's upgrade) could not be verified offline and is recorded as trust assumptions, not findings.","treeHash":null,"usage":{"cachedInputTokens":3361377,"inputTokens":674,"model":"claude-fable-5-1","outputTokens":67267,"runtime":"claude","turns":35,"wallClockMs":1367258}},{"artifacts":[],"attempt":1,"bundleHash":null,"device":"d63ea36a2b809080","findings":[],"hash":"b814e045e0443a315e49d35f7b5b71f1f592a838c9e57302f152779dbb55a2c2","nodeId":"bcd236d0-0855-47f4-b357-cdb784c2abcd","outcome":"completed","summary":"The review is complete. The findings file is in place, the tree is otherwise untouched, and the suite still passes 277 with 13 fork skips.\n\n**Outcome: no reproducible defect in the assigned area.** `.imd-findings.json` holds an empty findings list and 45 coverage rows: one `holds` row for each of the 42 listed entry points, plus three invariant rows for the placement flow, the $IMD destination rule and the no-owner rule. No row is `unreached`.\n\n**What I traced, by guide**\n\n- **Execution Trace.** Every fee path end to end: `register`, `link`, `foundCrew` and their $IMD twins into `LARPBurner.burn` and `burnImd`, through both ETH routes, the pair leg and the send to the burn executor. Value and gas accounting hold: own fee first, waiting ETH capped per call and per block and charged only after a sale, exact-fill or revert, native sync reset before settle, callbacks only from the PoolManager for the burner's own unlock. The toll, link and agent state machines keep their two-way maps consistent across sales, relinks and unlinks.\n- **Periphery.** `SafeReads` scratch-space reads, `Labels` validation and parsing, the hardcoded selectors and the PoolManager pool-state slot were checked against the vendored sources and `cast sig`. All match.\n- **First Principles.** The one assumption the local suite never exercises is the pair-leg delta decoding on mainnet's token ordering, where IMD6900 sorts below IMD. I forced both orderings in a scratch test and the share buys and burns IMD6900 in each. I also squatted the burner and registry salts, all four salts, and a used proxy with an empty planned address. The fallback placement and cross-wiring held every time.\n\n**What I did not reach.** Live Ethereum state: the real POOL4 and pair hooks, the Intake, and the launcher's ABI. Those rely on the historical fork observations in AUDIT.md and the skipped fork tests.\n\n**Static-analysis leads.** Each line was checked. None survives: the strict equality and reentrancy flags in `burn` are the block counter and the transient lock, the unused returns and uninitialised locals are intentional, and the missing zero checks cover hooks and a names address that are allowed to be zero by design.\n\nScratch tests under `test/scratch/` were removed after use.","treeHash":null,"usage":{"cachedInputTokens":2415906,"inputTokens":418,"model":"claude-fable-5-1","outputTokens":68913,"runtime":"claude","turns":48,"wallClockMs":1141087}},{"artifacts":[],"attempt":1,"bundleHash":null,"device":"af9a875696459139","findings":[{"citation":"resolved","description":"Uniswap v4's PoolManager.sync(currency) is permissionless (no unlock needed) and records the synced currency in transient storage for the rest of the transaction. LARPBurner.unlockCallback settles the ETH legs (routes 0 and 1) with settle{value: amount}() without calling sync(address(0)) first, and the PoolManager's _settle refuses native value while an ERC-20 is synced (NonzeroNativeValue; v4-core's own comment on _settle: \"if settling native, integrators should still call `sync` first to avoid DoS attack vectors\"). So any account that runs POOL_MANAGER.sync(IMD) and then burn / register / link / foundCrew in the same transaction (a contract, or an EOA with an EIP-7702 batch) makes POOL4 and the hookless pool both fail with a genuine revert, the burner emits Parked and keeps the ETH, and the call still succeeds when minImd is 0: the name or crew is granted with its fee unsold. This contradicts the burner's own rule (the _tryUnlock comment and AUDIT.md L-01: a caller can't pick a route, park a fee or skip the IMD6900 buy). Second effect, same root: burn() writes _burnBlock/_burnedInBlock (lines 213-214) before the routes run, so a parked attempt still consumes the block's MAX_BURN allowance of waiting ETH; one such call per block (about 120k gas) keeps royalties and parked fees from ever leaving while it lasts, and honest burn(0) calls in that block sell nothing. No funds are stolen (the ETH stays in the burner and is sold once the griefing stops), but the fee's POOL4 volume and the IMD6900 buy are skipped at the payer's choice, which the design forbids. Fix: in the ETH routes call POOL_MANAGER.sync(address(0)) before settle{value: amount}() (resets the synced currency; the pre-sync then has no effect), and consider charging _burnedInBlock only after a route succeeded.","line":280,"path":"src/LARPBurner.sol","proof":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.26;\n\nimport {Test} from \"forge-std/Test.sol\";\nimport {PoolManager} from \"@uniswap/v4-core/src/PoolManager.sol\";\nimport {IPoolManager} from \"@uniswap/v4-core/src/interfaces/IPoolManager.sol\";\nimport {IHooks} from \"@uniswap/v4-core/src/interfaces/IHooks.sol\";\nimport {PoolKey as V4PoolKey} from \"@uniswap/v4-core/src/types/PoolKey.sol\";\nimport {Currency} from \"@uniswap/v4-core/src/types/Currency.sol\";\nimport {ModifyLiquidityParams} from \"@uniswap/v4-core/src/types/PoolOperation.sol\";\nimport {BalanceDelta} from \"@uniswap/v4-core/src/types/BalanceDelta.sol\";\nimport {TickMath} from \"@uniswap/v4-core/src/libraries/TickMath.sol\";\nimport {LARPBurner} from \"src/LARPBurner.sol\";\nimport {IMDNames} from \"src/IMDNames.sol\";\nimport {ILARP} from \"src/ILARP.sol\";\n\n/// @dev A plain ERC-20 ($IMD / IMD6900 stand-ins).\ncontract Token {\n    string public name = \"T\";\n    string public symbol = \"T\";\n    uint8 public decimals = 18;\n    uint256 public totalSupply;\n    mapping(address => uint256) public balanceOf;\n    mapping(address => mapping(address => uint256)) public allowance;\n\n    function mint(address to, uint256 a) external {\n        balanceOf[to] += a;\n        totalSupply += a;\n    }\n\n    function approve(address s, uint256 a) external returns (bool) {\n        allowance[msg.sender][s] = a;\n        return true;\n    }\n\n    function transfer(address to, uint256 a) external returns (bool) {\n        balanceOf[msg.sender] -= a;\n        balanceOf[to] += a;\n        return true;\n    }\n\n    function transferFrom(address f, address to, uint256 a) external returns (bool) {\n        if (allowance[f][msg.sender] != type(uint256).max) allowance[f][msg.sender] -= a;\n        balanceOf[f] -= a;\n        balanceOf[to] += a;\n        return true;\n    }\n}\n\n/// @dev Adds full-range liquidity to a v4 pool, paid by the caller.\ncontract LiquidityAdder {\n    IPoolManager immutable pm;\n\n    constructor(IPoolManager pm_) {\n        pm = pm_;\n    }\n\n    function add(V4PoolKey memory key, int256 liquidity) external payable {\n        pm.unlock(abi.encode(key, liquidity, msg.sender));\n    }\n\n    function unlockCallback(bytes calldata data) external returns (bytes memory) {\n        (V4PoolKey memory key, int256 liquidity, address payer) = abi.decode(data, (V4PoolKey, int256, address));\n        (BalanceDelta delta,) = pm.modifyLiquidity(\n            key,\n            ModifyLiquidityParams(\n                TickMath.minUsableTick(key.tickSpacing), TickMath.maxUsableTick(key.tickSpacing), liquidity, 0\n            ),\n            \"\"\n        );\n        _pay(key.currency0, uint256(uint128(-delta.amount0())), payer);\n        _pay(key.currency1, uint256(uint128(-delta.amount1())), payer);\n        if (address(this).balance > 0) payable(payer).transfer(address(this).balance);\n        return \"\";\n    }\n\n    function _pay(Currency currency, uint256 amount, address payer) internal {\n        if (Currency.unwrap(currency) == address(0)) {\n            pm.settle{value: amount}();\n        } else {\n            pm.sync(currency);\n            Token(Currency.unwrap(currency)).transferFrom(payer, address(pm), amount);\n            pm.settle();\n        }\n    }\n\n    receive() external payable {}\n}\n\n/// @dev What any account can do in one transaction (a contract, or an EOA with an EIP-7702 batch): sync an ERC-20 on\n/// the PoolManager, then call the burner (or a paid entry point) in the same transaction.\ncontract SyncThenBurn {\n    PoolManager immutable pm;\n    Currency immutable token;\n\n    constructor(PoolManager pm_, address token_) {\n        pm = pm_;\n        token = Currency.wrap(token_);\n    }\n\n    function burn(LARPBurner burner) external returns (uint256) {\n        pm.sync(token);\n        return burner.burn{gas: 10_000_000}(0);\n    }\n\n    function register(IMDNames names, bytes32 label) external payable returns (uint256) {\n        pm.sync(token);\n        return names.register{value: msg.value, gas: 10_000_000}(label, address(this), 0);\n    }\n}\n\n/// @title Anyone can make both ETH routes of the burner fail in their own transaction, parking the ETH\n/// @notice PoolManager.sync(currency) is permissionless and its effect lives in transient storage for the whole\n/// transaction. LARPBurner.unlockCallback settles the ETH leg with settle{value: amount}() without resetting the\n/// synced currency first, and the PoolManager refuses native value while an ERC-20 is synced (NonzeroNativeValue).\n/// So a caller that runs pm.sync(<any ERC-20>) before burn / register / link / foundCrew makes POOL4 and the hookless\n/// pool both \"fail\", the ETH is parked instead of sold, and the block's allowance for waiting ETH is still charged.\n/// Fails on the code as it is (the ETH stays in the burner); passes once the ETH leg resets the synced currency\n/// (POOL_MANAGER.sync(address(0)) before settle{value}) or otherwise settles native ETH regardless of a prior sync.\ncontract Proof_PreSyncParksEth is Test {\n    Token imd;\n    Token imd6900;\n    PoolManager pm;\n    LiquidityAdder adder;\n    LARPBurner burner;\n    IMDNames names;\n\n    function setUp() public {\n        imd = new Token();\n        imd6900 = new Token();\n        pm = new PoolManager(address(this));\n        adder = new LiquidityAdder(IPoolManager(address(pm)));\n        V4PoolKey memory pool4 =\n            V4PoolKey(Currency.wrap(address(0)), Currency.wrap(address(imd)), 10_000, 60, IHooks(address(0)));\n        V4PoolKey memory backup =\n            V4PoolKey(Currency.wrap(address(0)), Currency.wrap(address(imd)), 10_000, 200, IHooks(address(0)));\n        pm.initialize(pool4, TickMath.getSqrtPriceAtTick(76_020));\n        pm.initialize(backup, TickMath.getSqrtPriceAtTick(76_000));\n        imd.mint(address(this), 1e30);\n        imd.approve(address(adder), type(uint256).max);\n        vm.deal(address(this), 10_000 ether);\n        adder.add{value: 1_000 ether}(pool4, 1e21);\n        adder.add{value: 1_000 ether}(backup, 1e21);\n        // the burner as launched (no hooks here; the pair pool is not initialized, so the IMD6900 share just burns)\n        burner = new LARPBurner(\n            address(pm), address(imd), 10_000, 60, address(0), 10_000, 200, address(imd6900), 0, 60, address(0), address(0)\n        );\n        names = new IMDNames(address(1), ILARP(address(2)), address(burner), address(0), address(3), address(4));\n    }\n\n    /// @dev Waiting ETH (royalties, parked fees) is meant to leave MAX_BURN a block through anyone's burn(0). A caller\n    /// who syncs an ERC-20 on the PoolManager first makes both routes revert and the ETH stays.\n    function test_ASyncedPoolManagerParksTheWaitingEth() public {\n        vm.deal(address(burner), 1 ether);\n        SyncThenBurn anyone = new SyncThenBurn(pm, address(imd));\n        uint256 held = address(burner).balance;\n        uint256 bought = anyone.burn(burner); // pm.sync($IMD) then burner.burn(0), one transaction\n        assertEq(address(burner).balance, held - 0.1 ether, \"MAX_BURN of the waiting ETH should have been sold\");\n        assertGt(bought, 0, \"should have bought $IMD\");\n    }\n\n    /// @dev The same from a paid entry point: the payer parks its own fee instead of buying $IMD on POOL4.\n    function test_APayerParksItsOwnFee() public {\n        bytes32 label = bytes32(\"frens\");\n        uint256 price = names.priceOf(label);\n        SyncThenBurn payer = new SyncThenBurn(pm, address(imd));\n        vm.deal(address(payer), 1 ether);\n        uint256 id = payer.register{value: price}(names, label); // pm.sync($IMD) then register, one transaction\n        assertEq(names.ownerOf(id), address(payer), \"the name was registered\");\n        assertEq(address(burner).balance, 0, \"the fee should have been sold for $IMD, not parked\");\n        assertGt(imd.balanceOf(burner.IMD_BURN()), 0, \"the fee's $IMD should have reached IMD's burn\");\n    }\n\n    receive() external payable {}\n}","reproduction":"State: PoolManager with POOL4 (ETH/$IMD 1%, spacing 60) and the hookless pool (1%, spacing 200) both with liquidity; the burner holds 1 ETH of waiting ETH (royalties). Input: a contract calls POOL_MANAGER.sync(IMD) then burner.burn{gas: 10_000_000}(0) in one transaction. Expected: Bought(0.1 ether, >0, 0) and the burner's balance drops to 0.9 ETH. Actual: both routes revert NonzeroNativeValue inside settle{value}, Parked(0.1 ether) is emitted, the balance stays 1 ETH, and _burnedInBlock is set to 0.1 ether so a following honest burn(0) in the same block sells nothing. Same with a paid entry point: a contract calls POOL_MANAGER.sync(IMD) then names.register{value: 0.00069 ether}(\"frens\", self, 0): expected the fee bought on POOL4 and its $IMD at IMD_BURN; actual the name is minted, Parked(0.00069 ether), the burner's balance is 0.00069 ETH and IMD_BURN received nothing. test/scratch/Proof_PreSyncParksEth.t.sol (both tests fail on this code). Note for the verifier: the two steps must run inside one call frame (the proof uses a helper contract); forge resets transient storage between a test's top-level calls, which does not model one mainnet transaction.","severity":"medium","snippet":"        POOL_MANAGER.settle{value: amount}();","title":"Any caller can park its fee or the waiting ETH: the ETH legs settle native value without resetting the PoolManager's synced currency"},{"citation":"resolved","description":"onVerdict(requestId, a, signature) looks the proposal up by its requestId parameter and verifies the oracle's EIP-712 signature over the Attestation, but never checks a.requestId == requestId (nor records a.panelJobId or the signature as used). The oracle signs a.requestId, so the binding is free, yet the contract leaves it to the Intake. Consequences: an attestation that approved proposal A also approves proposal B, C, ... when delivered under their ids, and a single signature can be replayed for every pending proposal of this contract; the swarm's judgement of one proposal's numbers is applied to another's. The trigger needs msg.sender == INTAKE, so today it is IMD's writer (AUDIT.md L-08 acknowledges it can \"pair it with the wrong one\"), and the guardrails bound the damage to one in-bounds change a week; but the repository's own tests rely on the gap (test/SwarmPrices.t.sol's _yes() signs a fixed requestId \"oracle uuid\" that never matches any proposal, and test_AProposalForOldPricesGoesStale approves two proposals with the same signed verdict). If the real Intake lets anyone relay a signed attestation for a request id of their choosing, the trigger is unprivileged. Fix: revert unless a.requestId == requestId (one line, no design change); optionally also refuse a.chainId != block.chainid outright instead of folding it into \"rejected\".","line":186,"path":"src/SwarmPrices.sol","proof":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.26;\n\nimport {Test} from \"forge-std/Test.sol\";\nimport {LARPBurner} from \"src/LARPBurner.sol\";\nimport {IMDNames} from \"src/IMDNames.sol\";\nimport {ILARP} from \"src/ILARP.sol\";\nimport {SwarmPrices, Attestation, IIntake} from \"src/SwarmPrices.sol\";\n\n/// @dev A plain ERC-20 ($IMD stand-in).\ncontract Token {\n    uint256 public totalSupply;\n    mapping(address => uint256) public balanceOf;\n    mapping(address => mapping(address => uint256)) public allowance;\n\n    function mint(address to, uint256 a) external {\n        balanceOf[to] += a;\n        totalSupply += a;\n    }\n\n    function approve(address s, uint256 a) external returns (bool) {\n        allowance[msg.sender][s] = a;\n        return true;\n    }\n\n    function transfer(address to, uint256 a) external returns (bool) {\n        balanceOf[msg.sender] -= a;\n        balanceOf[to] += a;\n        return true;\n    }\n\n    function transferFrom(address f, address to, uint256 a) external returns (bool) {\n        if (allowance[f][msg.sender] != type(uint256).max) allowance[f][msg.sender] -= a;\n        balanceOf[f] -= a;\n        balanceOf[to] += a;\n        return true;\n    }\n}\n\n/// @dev IMD's Intake as far as propose() uses it: takes the fee and hands back a request id.\ncontract Intake {\n    uint256 public count;\n\n    function requestWithFailure(bytes32, bytes calldata, IIntake.Callback calldata, bytes4, address asset, uint256 amount)\n        external\n        returns (bytes32 id)\n    {\n        Token(asset).transferFrom(msg.sender, address(this), amount);\n        id = keccak256(abi.encode(\"request\", ++count));\n    }\n}\n\n/// @title A signed verdict is not bound to the proposal it is delivered for\n/// @notice onVerdict(requestId, a, signature) looks the proposal up by its `requestId` parameter but never checks\n/// `a.requestId == requestId`, although the oracle signs `a.requestId`. One signature made for proposal A therefore\n/// approves proposal A and, delivered again under B's id, proposal B (and every other pending proposal of this\n/// contract). Fails on the code as it is (the second delivery is accepted); passes once onVerdict refuses an\n/// attestation whose requestId is not the one it is delivered for.\ncontract Proof_VerdictNotBoundToRequest is Test {\n    Token imd;\n    Intake intake;\n    IMDNames names;\n    uint256 oracleKey = 0x0A11CE0;\n    address oracleSigner;\n\n    function setUp() public {\n        imd = new Token();\n        intake = new Intake();\n        oracleSigner = vm.addr(oracleKey);\n        LARPBurner burner = new LARPBurner(\n            address(0xB0B), address(imd), 10_000, 60, address(0), 10_000, 200, address(0x6900), 0, 60, address(0), address(0)\n        );\n        names = new IMDNames(address(1), ILARP(address(2)), address(burner), address(0), address(intake), oracleSigner);\n        imd.mint(address(this), 10 ether);\n        imd.approve(address(names), type(uint256).max);\n    }\n\n    function _p(uint64 short, uint64 four, uint64 long_, uint64 crew) internal pure returns (SwarmPrices.Prices memory) {\n        return SwarmPrices.Prices(short, four, long_, crew, 690);\n    }\n\n    /// @dev An attestation as IMD's oracle signs it (EIP-712 \"IdentityMD Oracle\" v2, for `names`), for `requestId`.\n    function _yes(bytes32 requestId) internal view returns (Attestation memory a, bytes memory sig) {\n        a = Attestation({\n            requestId: requestId,\n            chainId: block.chainid,\n            questionHash: keccak256(\"the question\"),\n            answerType: 0,\n            answer: abi.encode(true),\n            figure: 0,\n            fromBlock: 0,\n            toBlock: uint64(block.number),\n            blockHash: bytes32(0),\n            panelJobId: bytes32(bytes16(keccak256(\"panel job\"))),\n            panelSize: 9,\n            quorum: 7,\n            agreed: 9,\n            issuedAt: uint64(vm.getBlockTimestamp()),\n            expiresAt: uint64(vm.getBlockTimestamp() + 1 days)\n        });\n        bytes32 structHash = keccak256(\n            bytes.concat(\n                abi.encode(\n                    keccak256(\n                        \"OracleAttestation(bytes32 requestId,uint256 chainId,bytes32 questionHash,uint8 answerType,bytes answer,uint256 figure,uint64 fromBlock,uint64 toBlock,bytes32 blockHash,bytes32 panelJobId,uint16 panelSize,uint16 quorum,uint16 agreed,uint64 issuedAt,uint64 expiresAt)\"\n                    ),\n                    a.requestId,\n                    a.chainId,\n                    a.questionHash,\n                    a.answerType,\n                    keccak256(a.answer),\n                    a.figure,\n                    a.fromBlock,\n                    a.toBlock\n                ),\n                abi.encode(a.blockHash, a.panelJobId, a.panelSize, a.quorum, a.agreed, a.issuedAt, a.expiresAt)\n            )\n        );\n        bytes32 domain = keccak256(\n            abi.encode(\n                keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n                keccak256(\"IdentityMD Oracle\"),\n                keccak256(\"2\"),\n                block.chainid,\n                address(names)\n            )\n        );\n        (uint8 v, bytes32 r, bytes32 s) = vm.sign(oracleKey, keccak256(abi.encodePacked(\"\\x19\\x01\", domain, structHash)));\n        sig = abi.encodePacked(r, s, v);\n    }\n\n    function test_AVerdictSignedForOneProposalIsRefusedForAnother() public {\n        bytes32 idA = names.propose(_p(0.005 ether, 0.0012 ether, 0.0005 ether, 0.0005 ether), 0.5 ether);\n        bytes32 idB = names.propose(_p(0.008 ether, 0.002 ether, 0.0008 ether, 0.0008 ether), 0.5 ether);\n        assertTrue(idA != idB);\n        (Attestation memory a, bytes memory sig) = _yes(idA); // the oracle answered A\n\n        vm.prank(address(intake));\n        names.onVerdict(idA, a, sig); // delivered for A: fine\n        assertEq(uint8(names.proposal(idA).status), uint8(SwarmPrices.Status.Approved));\n\n        // the same signed answer, delivered for B: must not count as B's verdict\n        vm.prank(address(intake));\n        vm.expectRevert();\n        names.onVerdict(idB, a, sig);\n        assertEq(uint8(names.proposal(idB).status), uint8(SwarmPrices.Status.Pending), \"B is still undecided\");\n    }\n}","reproduction":"State: two pending proposals, A = propose((0.005, 0.0012, 0.0005, 0.0005 ETH, 690), 0.5 IMD) and B = propose((0.008, 0.002, 0.0008, 0.0008 ETH, 690), 0.5 IMD), ids idA != idB from the Intake. Input: an attestation with requestId = idA, answer true, panel 9 / quorum 7 / agreed 9, unexpired, signed by ORACLE_SIGNER for this contract; the Intake calls onVerdict(idA, a, sig) then onVerdict(idB, a, sig). Expected: the second call reverts (the verdict is A's). Actual: both proposals become Approved; execute(idB) then applies B's prices on A's verdict. test/scratch/Proof_VerdictNotBoundToRequest.t.sol fails on this code (\"next call did not revert as expected\").","severity":"low","snippet":"        if (!_signedByOracle(a, signature)) revert BadVerdictSignature();","title":"A signed verdict is not bound to the proposal it is delivered for: one oracle signature approves every pending proposal"},{"citation":"resolved","description":"Checked, not re-raised: AUDIT.md L-09's fix holds (a leg that eats its LEG_GAS budget is skipped, test_AGasEatingIMD6900IsSkippedNotFatal and test_AGasEatingPool4HookFallsToTheHooklessPool pass). The residual that the trust table's rows for POOL4's hook and IMD6900 omit: a leg that loops (an IMD6900 upgrade whose burn never returns, or a hook that does the same) makes every register, registerWithImd, link, linkWithImd, foundCrew and foundCrewWithImd spend the full 3,000,000 gas of that leg on top of its own cost, for as long as the condition lasts; with both legs hostile about 6.4M gas per call. At today's prices that is a gas cost well above a 5+ letter name's fee (0.00069 ETH), and a wallet that reuses the documented 3.4M limit reverts with TooLittleGas on the IMD6900 leg's check. The share can be voted to 0 (then the IMD6900 leg is not tried), but by the step rule that takes four weekly changes from 6.9% (345, 173, 87, 0 bps); nothing can disable route 0. Nothing to fix in code unless the requester wants a cheaper budget or a per-leg circuit breaker; the adapter should put the number in the trust table.","line":325,"path":"src/LARPBurner.sol","reproduction":"State: IMD6900's burn(uint256) loops until out of gas (the repository's own test mock). Input: names.register{value: 0.00069 ether, gas: 3_400_000}(\"frens\", alice, 0). Expected per README: a 3.4M limit suffices. Actual: the IMD6900 leg spends its whole 3M budget and is skipped; the call is only accepted with a limit of about 6.4M and spends more than 3M gas extra; at 3.4M it reverts TooLittleGas before the leg. Same per call for link, foundCrew and the $IMD twins while the upgrade stands.","severity":"info","snippet":"        try POOL_MANAGER.unlock{gas: LEG_GAS}(data) returns (bytes memory r) {","title":"A hostile budgeted leg is skipped but still costs every paid call its 3M budget; the trust table does not say so"},{"citation":"resolved","description":"Checked and holding: Placer._where takes CreateX's CREATE3 address only while its proxy and the address itself have no code, and otherwise falls back to the placement's own CREATE3 (test_ASaltUsedFirstIsNeverTaken), so nothing at a planned address is ever taken as LARP's. The residual is publication, not code: the salts, LARPPlan's *_AT constants and README's address table are public before the launch transaction, and CreateX.deployCreate3(salt, anyInitCode) is open to anyone. Whoever uses a salt first decides what sits at 0x6900…; a look-alike IMDNames there (same ABI, a different beneficiary or no burn) would be the contract README and LARPPlan point at, while the launch's genuine IMDNames lands at an address that only the deployment handoff knows. Integrations, the site and the manifest notes must take addresses from the handoff (PlaceLARP.burner/larp/names, PlaceLinks.links) and verify code, never from LARPPlan or README; the README's table should say the addresses hold only if the salts were unused at launch.","line":31,"path":"src/place/LARPPlan.sol","reproduction":"State: Ethereum before the launch transaction. Input: anyone calls CreateX(0xba5E…ba5Ed).deployCreate3(LARPPlan.NAMES_SALT, <initcode of a contract with IMDNames' ABI>). Then IMD deploys PlaceLARP. Expected by a reader of README: IMDNames at 0x690084D1331F7a6509EeD32e7d34ffAcB377d807. Actual: that address holds the squatter's code; PlaceLARP places IMDNames at _create3(address(PlaceLARP), NAMES_SALT) (p.names() != NAMES_AT), the burner and the links correctly wire to that one, and only PlaceLARP.names() tells the truth.","severity":"info","snippet":"    address internal constant BURNER_AT = 0x69006faEc2D2094e375cAFA5e3C87C5cB2847bef;","title":"The plan's 0x6900 addresses and README's table are not guaranteed: a squatter can put arbitrary code there before the launch, and the real contracts then land elsewhere"},{"citation":"resolved","description":"Documentation only. The count the brief and AUDIT.md give for this tree does not match what forge reports, which matters because the launch 'holds' by test count. Not a code defect; the adapter should fix the number (or add the missing tests) so the claim is checkable.","line":232,"path":"AUDIT.md","reproduction":"Input: `env -i PATH=$PATH HOME=$HOME forge test --offline` at commit daa6496. Expected per AUDIT.md and the brief: 290 tests. Actual: 'Ran 20 test suites: 268 tests passed, 0 failed, 11 skipped (279 total tests)'; the 11 skipped are test/MainnetFork.t.sol (no MAINNET_RPC_URL), and PlacementForkTest's 2 count as passed because they return early.","severity":"info","snippet":"- **Tests:** 290, all pass (with MAINNET_RPC_URL: the fork's, including the launch landing at 0x6900… through the real","title":"The tree runs 279 tests offline (268 pass, 11 fork tests skipped), not the 290 the documentation and the brief state"},{"citation":"resolved","description":"Read in full, every external and public function traced for who may call it, what it moves and what it trusts (Pashov SOP: Feynman, Socratic, inversion; then the math, access-control, economic, execution-trace, invariant, periphery, first-principles, asymmetry and boundary passes as one reviewer's passes, not twelve agents): src/place/LARPPlan.sol, src/place/PlaceLARP.sol (Placer, PlaceLARP, PlaceLinks: 6 constructors, burner, larp, names, links), src/LARPBurner.sol (all 22 listed entry points), src/LARP.sol with src/ILARP.sol (all 21), src/IMDNames.sol with src/IIMDNames.sol and src/SwarmPrices.sol (all 62, both safeTransferFrom overloads), src/LARPLinks.sol (all 34), src/Labels.sol, src/SafeReads.sol; coverage ratio 1 of the 148 listed. Vendored code read where the contracts lean on it: solady ERC721 (_mint refuses an existing token and address(0), _ownerOf returns 0), v4-core PoolManager (unlock, sync, _settle, swap deltas, the pools slot 6 layout _spot reads), FullMath. Checked and holding against their tests: AUDIT.md L-01/L-09 budgets, L-10 per-block cap, L-11 WETH unwrap, L-02 paging, the CREATE3 squat fallback, the fresh-chain and admission-scan launch tests, the 30k-gas share read at 1380/10000/0 bps, the 16 hard-coded selectors (cast sig), the EIP-712 digests, the toll and two-way link bookkeeping, the per-holder agent nonce, the Merkle double-hash leaf. Not reachable: the live Ethereum contracts (CreateX, PoolManager state, POOL4's hook 0xc6C9…, the pair hook 0x667f…, IMD6900's proxy implementation, IMD's Intake and its delivery permissions, the BurnExecutor, the launcher and distributors, identity.md) and therefore the 11 fork tests (no MAINNET_RPC_URL); the real Intake's behaviour on delivery and on fees above its price is assumed from the repository's mock. No DELEGATECALL, CALLCODE, SELFDESTRUCT, proxy, initializer, owner, pause, blacklist or post-launch mint exists in src/.","line":1,"path":"README.md","reproduction":"Not a defect: the coverage statement the brief asks for. Commands run: forge build --offline; env -i forge test --offline (268 passed, 11 skipped); forge test --offline --match-path test/scratch/Proof_PreSyncParksEth.t.sol (2 failed, as the finding states); forge test --offline --match-path test/scratch/Proof_VerdictNotBoundToRequest.t.sol (1 failed, as the finding states).","severity":"info","snippet":"# LARP: Linked Avatar Registry Protocol, by the IMD6900 frens","title":"Coverage: all 11 source files and all listed entry points were read; the live Ethereum dependencies could not be reached"}],"hash":"bf124a7b1327a4dd1a1e17fd50bee9b96428a3499e486273c17b399f21c8736a","nodeId":"fc23134b-270e-472b-b0b5-dd5287085614","outcome":"completed","summary":"The review is complete. `.imd-findings.json` holds six entries, and no file outside it and `test/scratch/` was touched.\n\n**What I found**\n\n- **Medium, with proof.** Any account can park its own fee or the burner's waiting ETH. Uniswap v4's `PoolManager.sync` is permissionless and lives in transient storage for the whole transaction, and the burner's ETH legs call `settle{value}` without resetting the synced currency, which v4 refuses with `NonzeroNativeValue`. A contract that syncs $IMD and then calls `burn`, `register`, `link` or `foundCrew` in one transaction makes both routes fail, the ETH is parked, the name or crew is still granted, and the block's allowance for waiting ETH is charged anyway. That breaks the burner's own rule that a caller cannot park a fee. The one-line fix (sync `address(0)` before settling) was checked against a scratch copy and makes the proof pass.\n- **Low, with proof.** `onVerdict` never checks that the signed attestation's request id is the one it is delivered for, so one oracle signature approves every pending proposal. Today only IMD's Intake can trigger it, and the guardrails bound the damage, but the repository's own tests rely on the gap.\n- **Info.** Three documentation and trust notes: a hostile hook or IMD6900 upgrade still costs every paid call its 3M gas budget; the published 0x6900 addresses are not guaranteed if a salt is squatted first, so integrations must use the deployment handoff; the tree runs 279 tests offline, not the documented 290.\n\n**Coverage.** All 11 source files and every listed entry point were read, with the relevant vendored code (solady ERC721, v4 PoolManager, FullMath) checked where the contracts lean on it. The acknowledged and fixed items in AUDIT.md were checked against their tests and hold. Not reachable: the live Ethereum dependencies and the 11 fork tests, since no RPC was available.\n\n**For the adapter.** Both proofs fail on the current code as the findings state and were run from `test/scratch/`. Nothing in the launch shape needs to change: no owner, upgrade, forbidden opcode, proxy, initializer or post-launch mint exists in the source.","treeHash":null,"usage":{"cachedInputTokens":5336124,"inputTokens":834,"model":"claude-fable-5-1","outputTokens":104809,"runtime":"claude","turns":54,"wallClockMs":2091703}},{"artifacts":[],"attempt":1,"bundleHash":null,"device":"1a7606be97f168d4","findings":[{"citation":"resolved","description":"SwarmPrices.propose writes the whole question the swarm judges. Its fifth guideline is 'the IMD6900 share is between 0% and 100%', and _checkBounds (line 234, p.share > MAX_SHARE) already refuses any proposal outside that range on chain. A proposal that keeps all four prices identical to the current ones (which the swarm has by definition already found within the guidelines, since they are the current terms) and changes only the share therefore meets all five guidelines by construction: the panel is asked a question whose answer is always 'true', and the verdict is not a judgement of the share. The README and the task describe the share as 'swarm-voted' and the keep-condition is that it 'changes only by the swarm's verdict within the guardrails'. In practice the only limits on the share are _checkShareStep (2x or one percentage point per change) and the 7-day COOLDOWN, so whoever pays 0.5 IMD per proposal sets it: 690 -> 1380 -> 2760 -> 5520 -> 10000 in four weeks (2 IMD), after which nothing reaches IMD_BURN and every fee buys IMD6900; or 690 -> 345 -> 173 -> 87 -> 0 in four weeks, after which nothing buys IMD6900. No funds are lost (everything is still burned one way or the other), which is why this is low, but the governance guarantee the design relies on does not exist for the share, and the existing tests (test_UpToAllOfIt, test_AndDownToNothing) show the swarm answering yes at every step. A proposer who holds IMD6900 profits from the buy pressure of 100%; IMD's burn loses the 93.1% it receives today. Fix options: give the share a real guideline in the question (for example a band the swarm must judge, or 'does this share serve the burn better than the current one'), or require a price change to accompany a share change, or tighten the step (one point only) so the drift to either extreme takes long enough for a counter-proposal.","line":295,"path":"src/SwarmPrices.sol","reproduction":"State: fresh deployment (prices 0.0069/0.00169/0.00069/0.00069 ETH, share 690). Four times, one week apart: (1) propose(Prices(0.0069e18, 0.00169e18, 0.00069e18, 0.00069e18, S), 0.5e18) with S = 1380, 2760, 5520, 10000 (each within _checkShareStep); (2) the Intake delivers a true verdict (panel 9, quorum 7, agreed 9), which the question guarantees since prices are unchanged and S is between 0 and 10000; (3) execute(requestId). Result: burner.shareBps() == 10000; minting 1000 IMD to the burner and calling burnImd() sends 0 IMD to IMD_BURN (verified: test/scratch/Probe.t.sol::test_ShareSteering, 2 IMD paid, 4 weeks). Expected per README: the share is 'swarm-voted'; actual: the swarm's question cannot say no to any in-range share.","severity":"low","snippet":"            \". At the median Coinbase, Kraken and Binance ETH/USD price over the last 24 hours, do the proposed terms meet all of LARP's guidelines: a 5+ letter name costs between 1 and 5 US dollars, a crew costs between 1 and 5 US dollars, a 1-3 letter name costs at least 10 times a 5+ letter name, a 4 letter name costs at least 2 times a 5+ letter name, and the IMD6900 share is between 0% and 100%? Answer true if all five hold, false otherwise.\\\",\",","title":"The IMD6900 share's guideline in the oracle question is a tautology, so any proposer steers the share to 0% or 100% at 0.5 IMD a week"},{"citation":"resolved","description":"quoteImd returns eth * sqrtPrice^2 / 2^192 of the higher-priced pool (its spot price, no swap fee, no price impact). The ETH route sells the same fee on POOL4 with its 1% LP fee and impact, so it buys less $IMD than the quote. registerWithImd, linkWithImd and foundCrewWithImd therefore burn ~1% more value than register, link and foundCrew for the same name or crew. The view promises 'what eth is worth in $IMD now' and the write path (the ETH route) realises a different amount: a view/write divergence, in the protocol's favour. Nobody gains (the difference is burned), the payer can always pay in ETH, and AUDIT.md L-07 documents that the quote is spot, so this is informational: the site should show that the $IMD price is the spot quote, about 1% above the ETH route's realised amount, or the quote could apply the pool's fee so both paths burn the same.","line":243,"path":"src/LARPBurner.sol","reproduction":"On the test pools (POOL4 at tick 76020, backup at 76000, both 1% fee, full-range liquidity 1e21): price = names.priceOf('frens') = 690000000000000 wei; burner.quoteImd(price) = 1380990458065909056 (1.3810 IMD); burner.burn{value: price}(0) buys 1367138773557999221 (1.3671 IMD) on POOL4. Overpay = 101 bps (test/scratch/Probe.t.sol::test_QuoteVsExecution). Expected: the same fee burns the same value whichever currency it is paid in; actual: the $IMD payer burns 1.01% more.","severity":"info","snippet":"    function quoteImd(uint256 eth) external view returns (uint256) {\n        uint256 a = _spot(PoolKey(address(0), IMD, POOL4_FEE, POOL4_SPACING, POOL4_HOOK), eth);\n        uint256 b = _spot(PoolKey(address(0), IMD, BACKUP_FEE, BACKUP_SPACING, address(0)), eth);\n        if (a == 0 || b == 0) revert NoPrice();\n        return a > b ? a : b;\n    }","title":"quoteImd charges the fee-free spot price, so $IMD payers pay about 1% more than the ETH route burns for the same fee"}],"hash":"cd837d959a06551de1aacd206abd02b8a696405f76771d9b655fe5de7ac9e055","nodeId":"4875c91e-8761-4bcc-a3d2-2e5d46237bf7","outcome":"completed","summary":"The review is complete. `.imd-findings.json` is in the repository root with 2 findings and 154 coverage rows (all 42 verifier-listed state-changing entry points by exact signature, the remaining 107 listed names, and 5 invariants). No source file was changed; my probes live only under `test/scratch/`.\n\n**What I checked.** The Economic Security, Invariant and Flow Gap guides against the burner, the swarm-priced names, the links, the placement contracts and the launch keep-conditions. The baseline suite passes offline (277 pass, 13 fork tests skip). Launch gas is 10.99M under the 16.7M cap, PlaceLARP init code is 39,120 bytes under EIP-3860, and AUDIT.md's fixes L-01, L-09, L-10, L-11, L-14 and L-15 are present in code and tested, so I did not re-raise them. The burner's ETH leaves only as an exact-fill swap, $IMD leaves only to the IMD6900 swap or the constant IMD_BURN, caps hold per call and per block, out-of-gas on the hookless route reverts, budgeted legs are skipped only on their own failure, and the placement never takes a used salt.\n\n**Findings.**\n\n- **Low, `src/SwarmPrices.sol:295`.** The question the contract writes for the swarm says the share guideline is \"between 0% and 100%\", which `_checkBounds` already enforces on chain. A proposal that keeps the four prices unchanged and moves only the share therefore satisfies all five guidelines by construction, so the swarm's verdict cannot refuse it. Anyone paying 0.5 IMD a week steers the share 690→1380→2760→5520→10000 in four weeks (2 IMD total), after which nothing reaches IMD's burn, or down to 0 in four weeks. Reproduced in `test/scratch/Probe.t.sol::test_ShareSteering`. No funds are lost, but the \"swarm-voted share\" guarantee does not exist in practice.\n- **Info, `src/LARPBurner.sol:243`.** `quoteImd` is the fee-free spot price, so the $IMD payment paths burn about 1% more than the ETH route realises for the same fee. On the test pools a 0.00069 ETH name quotes 1.3810 IMD while the ETH route buys 1.3671 IMD (101 bps). Burned either way and documented as spot in AUDIT L-07, so informational.\n\n**Not substantiated, left out.** The POOL4 and pair pool keys (fee 10000/spacing 60 with hook, fee 0/spacing 60 with hook) cannot be verified without an RPC; a mismatch would silently route every ETH fee to the backup pool and send the whole share to IMD_BURN. The fork tests cover this and should be run before launch. I also considered a frozen POOL4 price after its hook closes the market acting as a floor for $IMD payers; it only over-charges and the payer can use ETH, so I did not report it.","treeHash":null,"usage":{"cachedInputTokens":2234056,"inputTokens":450,"model":"claude-fable-5-1","outputTokens":65574,"runtime":"claude","turns":36,"wallClockMs":1129166}},{"artifacts":[],"attempt":2,"bundleHash":"54e9e91608479567c8138d7cfb06010dffd532d8f860715e47a08d25cc956a7d","device":"1f9cb1750ebf47ed","findings":[],"hash":"d33a8ae4d619f939da0907ddd57a1268108af025780646ce18e081318a6e8967","nodeId":"0fcc7809-54f6-40c8-87a1-b5a12f34c0c4","outcome":"completed","summary":"The responses file is excluded by the harness's own git exclude list, which is expected: it is read from the repository root, not committed. Everything is in place, so the work is done.\n\nBoth reopened findings reproduced and are fixed. The reviewer's proof fails on the starting tree and passes on the result. The suite runs 296 tests offline with 283 passing and 13 fork skips, and all 13 fork tests pass against a public Ethereum RPC.\n\n**Finding 22bc735e (medium, pair leg uncapped): fixed.**\n- The proof reproduced exactly: an attacker ended +40.6 $IMD sandwiching a 0.1 ETH burn at the 100% share.\n- `_burnImd` in src/LARPBurner.sol now sells the pair pool at most 2% of its own $IMD depth per call. The depth is the pool's virtual $IMD reserve from the liquidity and price the PoolManager holds, read with the same storage read `quoteImd` already uses. Anything the share makes above that goes to IMD_BURN, as a failed leg's share already did.\n- I chose a bound relative to the pool rather than a constant in $IMD. The real pool holds about 125 $IMD and 0.1 ETH buys about 25, so the launch's 6.9% leg of a full burn fits under the cap and the launch design is unchanged. A constant would either clip the launch share or stop binding as prices move.\n- The swarm's question gains a sixth guideline for a rising share: the proposed share of what 0.1 ETH buys must be at most 2% of the pair pool's $IMD depth, with the depth defined in the body. Lowering the share and price-only proposals are unaffected.\n- New test/LARPBurnerPairLeg.t.sol covers the sandwich losing at 100%, at 6.9% and with a small front on a 6.9%-fee pair, the exact room sold at 100%, the launch share not being clipped, and the room following the depth. The `test_UpToAllOfIt` test encoded the uncapped behaviour and now asserts the capped one. The fuzz and invariant models expect the smaller of share and room.\n\n**Finding 83d29e62 (low, minImd met by waiting ETH): fixed.**\n- Reproduced with the reviewer's scenario. `burn` now checks the floor against the sender's pro-rata part of the sale. A call that sends nothing still floors the whole sale, so a keeper's floor keeps its meaning. Two tests cover it, and both failed on the old check.\n\n**Also found while verifying.** The real-Intake fork test signed its attestation for a fixed request id, which the previous round's request binding correctly refuses. It now signs the proposal's own id. The previous round could not run the fork suite, which is why this slipped.\n\n**Documentation.** AUDIT.md gained L-16 and L-17 and updated I-11, L-04, the trust row for the pair pool and the counts. README, AUDIT-COVERAGE.md and ADAPTATION.md record the changes, the fork results and the re-run protected probe. The cap constant is internal, so the ABI and the 148-entry list are unchanged. Answers to both findings are in .imd-responses.json.\n\nOne point worth the requester's attention: the cap is sized against the pair hook's 6.9% fee. If the hook's owner ever dropped that fee below about 1%, a leg at the cap would become worth sandwiching again, and the swarm should vote the share down. AUDIT.md's trust table says so.","treeHash":"b00356c1a3d3813e53d6cfe5e4655764aa137392","usage":{"cachedInputTokens":4443772,"inputTokens":930,"model":"claude-fable-5-1","outputTokens":74576,"runtime":"claude","turns":110,"wallClockMs":2107808}},{"artifacts":[],"attempt":1,"bundleHash":null,"device":"0da932e4a0b9bd4a","findings":[],"hash":"e37edf0b7ee1ef62c78ac8a8b99f1126ebbb4e6c54a52b8c355dcafd27128a1e","nodeId":"0fcc7809-54f6-40c8-87a1-b5a12f34c0c4","outcome":"failed","summary":"This content was flagged for possible cybersecurity risk. If this seems wrong, try rephrasing your request. If you’re doing authorized security work that requires more cyber permissive safeguards, apply for Daybreak access via https://platform.openai.com/settings/organization/status-and-access before retrying.","treeHash":null,"usage":{"cachedInputTokens":0,"inputTokens":0,"model":"gpt-6-astra","outputTokens":0,"runtime":"codex","turns":4,"wallClockMs":365651}}],"verification":[{"checks":[{"durationMs":294338,"exitCode":0,"name":"build","output":"Compiling 112 files with Solc 0.8.26\nSolc 0.8.26 finished in 293.96s\nCompiler run successful!\nwarning[boolean-cst]: misuse of a boolean constant\n   ╭▸ src/place/PlaceLARP.sol:49:98\n   │\n49 │             if (_proxy(LARPPlan.CREATEX, g).code.length == 0 && at.code.length == 0) return (at, true);\n   │                                                                                                  ━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:333:25\n    │\n333 │                 return (true, r);\n    │                         ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[unsafe-typecast]: typecast can truncate values\n   ╭▸ src/SwarmPrices.sol:87:38\n   │\n87 │     bytes32 public constant ACTION = bytes32(\"oracle.request@oracle-1\");\n   │                                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ├ note: consider disabling this lint if you're certain the cast is safe\n   │       \n   │       // casting to 'bytes32' is safe because [explain why]\n   │       // forge-lint: disable-next-line(unsafe-typecast)\n   │       \n   │       \n   ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:336:25\n    │\n336 │                 return (false, \"\");\n    │                         ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:342:21\n    │\n342 │             return (true, r);\n    │                     ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:344:21\n    │\n344 │             return (false, \"\");\n    │                     ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/SwarmPrices.sol:137:17\n    │\n137 │     constructor(address intake, address oracleSigner, Prices memory start) {\n    │                 ━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/SwarmPrices.sol:137:33\n    │\n137 │     constructor(address intake, address oracleSigner, Prices memory start) {\n    │                                 ━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[boolean-cst]: misuse of a boolean constant\n   ╭▸ src/place/PlaceLARP.sol:51:48\n   │\n51 │         return (_create3(address(this), salt), false);\n   │                                                ━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[uninitialized-local]: local variable is read before being initialized\n   ╭▸ src/Labels.sol:23:16\n   │\n23 │         while (n < 32 && label[n] != 0) ++n;\n   │                ━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unsafe-typecast]: typecast can truncate values\n   ╭▸ src/SafeReads.sol:21:46\n   │\n21 │         return ok && w >> 160 == 0 ? address(uint160(w)) : address(0);\n   │                                              ━━━━━━━━━━\n   │\n   ├ note: consider disabling this lint if you're certain the cast is safe\n   │       \n   │       // casting to 'uint160' is safe because [explain why]\n   │       // forge-lint: disable-next-line(unsafe-typecast)\n   │       \n   │       \n   ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n   ╭▸ src/SafeReads.sol:47:40\n   │\n47 │         (bool ok, bytes memory data) = target.staticcall{gas: gasCap}(call);\n   │                                        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:146:9\n    │\n146 │         address pairHook,\n    │         ━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:140:9\n    │\n140 │         address pool4Hook,\n    │         ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:147:9\n    │\n147 │         address names\n    │         ━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n    ╭▸ src/LARPBurner.sol:172:13\n    │\n172 │             n.staticcall{gas: SHARE_GAS}(abi.encodeWithSelector(IShareSource.imd6900ShareBps.selector));\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:182:16\n    │\n182 │         return int24(s);\n    │                ━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int24' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/SwarmPrices.sol:176:9\n    │\n176 │         emit Proposed(requestId, number, msg.sender, next);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:88:13\n    │\n 88 │ ┏             abi.encodePacked(\n 89 │ ┃                 type(LARPBurner).creationCode,\n 90 │ ┃                 abi.encode(\n 91 │ ┃                     LARPPlan.POOL_MANAGER,\n    ‡ ┃\n104 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:108:36\n    │\n108 │         _place(LARPPlan.LARP_SALT, abi.encodePacked(type(LARP).creationCode, abi.encode(LARPPlan.IDENTITY)), l, lx);\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:111:13\n    │\n111 │ ┏             abi.encodePacked(\n112 │ ┃                 type(IMDNames).creationCode,\n113 │ ┃                 abi.encode(LARPPlan.IDENTITY, l, b, LARPPlan.ARTIST, LARPPlan.INTAKE, LARPPlan.ORACLE_SIGNER)\n114 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:133:13\n    │\n133 │ ┏             abi.encodePacked(\n134 │ ┃                 type(LARPLinks).creationCode,\n135 │ ┃                 abi.encode(\n136 │ ┃                     LARPPlan.IDENTITY,\n    ‡ ┃\n142 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:111:33\n    │\n111 │         if (at == 0) return (0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:120:64\n    │\n120 │         if (holder == address(0) || who == address(0)) return (false, holder);\n    │                                                                ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:121:36\n    │\n121 │         if (who == holder) return (true, holder);\n    │                                    ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:265:36\n    │\n265 │         if (at == 0) return (0, 0, false);\n    │                                    ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n   ╭▸ src/LARP.sol:78:13\n   │\n78 │         if (block.timestamp > deadline) revert Expired();\n   │             ━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARP.sol:138:9\n    │\n138 │         emit AgentSet(imdId, holder, agent);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:159:45\n    │\n159 │         return ok && answer.length >= 32 && bytes4(abi.decode(answer, (bytes32))) == 0x1626ba7e;\n    │                                             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes4' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/LARPBurner.sol:332:17\n    │\n332 │             try POOL_MANAGER.unlock(data) returns (bytes memory r) {\n    │                 ━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/LARPBurner.sol:341:13\n    │\n341 │         try POOL_MANAGER.unlock{gas: LEG_GAS}(data) returns (bytes memory r) {\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:236:21\n    │\n236 │                     emit Bought(eth, imd, route);\n    │                     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:240:27\n    │\n240 │             if (imd == 0) emit Parked(eth);\n    │                           ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:315:9\n    │\n315 │         emit Burned(rest, share, burned6900);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[require-revert-in-loop]: `require` or `revert` inside a loop\n    ╭▸ src/LARPBurner.sol:335:49\n    │\n335 │                 if (gasleft() <= gasBefore / 4) revert TooLittleGas();\n    │                                                 ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/require-revert-in-loop\n\nwarning[require-revert-in-loop]: `require` or `revert` inside a loop\n    ╭▸ src/LARPBurner.sol:340:61\n    │\n340 │         if (gasleft() < LEG_GAS + LEG_GAS / 63 + AFTER_GAS) revert TooLittleGas();\n    │                                                             ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/require-revert-in-loop\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:219:39\n    │\n219 │         uint256 spent = _burnBlock == uint64(block.number) ? _burnedInBlock : 0;\n    │                                       ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:233:38\n    │\n233 │                         _burnBlock = uint64(block.number);\n    │                                      ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:234:42\n    │\n234 │                         _burnedInBlock = uint192(spent + waiting);\n    │                                          ━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint192' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:189:16\n    │\n189 │             && block.timestamp <= a.expiresAt && a.answer.length == 32 && uint256(bytes32(a.answer)) == 1;\n    │                ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/SwarmPrices.sol:192:9\n    │\n192 │         emit Verdict(requestId, approved, a.agreed, a.panelSize);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/LARP.sol:310:15\n    │\n310 │             ++digits;\n    │               ━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:189:83\n    │\n189 │             && block.timestamp <= a.expiresAt && a.answer.length == 32 && uint256(bytes32(a.answer)) == 1;\n    │                                                                                   ━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes32' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:191:23\n    │\n191 │         p.decidedAt = uint64(block.timestamp);\n    │                       ━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:314:36\n    │\n314 │             out[--digits] = bytes1(uint8(48 + value % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:325:22\n    │\n325 │             out[i] = bytes16(\"0123456789abcdef\")[v & 15];\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes16' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:220:33\n    │\n220 │         if (at == 0) return (0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:228:42\n    │\n228 │         if (owner == address(0)) return (false, address(0), 0, false);\n    │                                          ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:228:64\n    │\n228 │         if (owner == address(0)) return (false, address(0), 0, false);\n    │                                                                ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:240:33\n    │\n240 │         if (label == 0) return (false, address(0), 0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:240:55\n    │\n240 │         if (label == 0) return (false, address(0), 0, false);\n    │                                                       ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:247:37\n    │\n247 │         if (at == 0) return (0, \"\", false);\n    │                                     ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n   ╭▸ src/IMDNames.sol:67:63\n   │\n67 │     constructor(address identity, ILARP larp, address burner, address artist_, address intake, address oracleSigner)\n   │                                                               ━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:109:9\n    │\n109 │         LARPBurner(payable(BURNER)).burn{value: price}(minImd);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:123:24\n    │\n123 │         if (toll != 0) LARPBurner(payable(BURNER)).burn{value: toll}(minImd);\n    │                        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:137:9\n    │\n137 │         emit NameRegistered(tokenId, label, to, price);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:153:13\n    │\n153 │             emit NameUnlinked(old, imdId);\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:158:13\n    │\n158 │             emit NameUnlinked(tokenId, was - 1);\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:162:9\n    │\n162 │         emit NameLinked(tokenId, imdId, holder, toll);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:185:9\n    │\n185 │         emit NameUnlinked(tokenId, imdId);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:181:22\n    │\n181 │         (bool ok,) = LARP.canAct(imdId, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:272:43\n    │\n272 │                 pair, SwapParams(imdIs0, -int256(amount), imdIs0 ? MIN_PRICE_LIMIT : MAX_PRICE_LIMIT), \"\"\n    │                                           ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:275:27\n    │\n275 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                           ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:275:49\n    │\n275 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                 ━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:275:67\n    │\n275 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                                   ━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:275:82\n    │\n275 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                                                  ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:276:30\n    │\n276 │             if (imdDelta != -int128(int256(amount)) || outDelta <= 0) revert Unfilled();\n    │                              ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:276:37\n    │\n276 │             if (imdDelta != -int128(int256(amount)) || outDelta <= 0) revert Unfilled();\n    │                                     ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPBurner.sol:279:13\n    │\n279 │             POOL_MANAGER.settle();\n    │             ━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:280:27\n    │\n280 │             uint256 out = uint128(outDelta);\n    │                           ━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:288:61\n    │\n288 │         int256 d = POOL_MANAGER.swap(key, SwapParams(true, -int256(amount), MIN_PRICE_LIMIT), \"\");\n    │                                                             ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:289:27\n    │\n289 │         int128 ethDelta = int128(d >> 128);\n    │                           ━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:290:25\n    │\n290 │         int128 bought = int128(d);\n    │                         ━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:291:26\n    │\n291 │         if (ethDelta != -int128(int256(amount)) || bought <= 0) revert Unfilled();\n    │                          ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:291:33\n    │\n291 │         if (ethDelta != -int128(int256(amount)) || bought <= 0) revert Unfilled();\n    │                                 ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPBurner.sol:294:9\n    │\n294 │         POOL_MANAGER.settle{value: amount}();\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:295:47\n    │\n295 │         POOL_MANAGER.take(IMD, address(this), uint128(bought));\n    │                                               ━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:296:27\n    │\n296 │         return abi.encode(uint256(uint128(bought)));\n    │                           ━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:296:35\n    │\n296 │         return abi.encode(uint256(uint128(bought)));\n    │                                   ━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:209:44\n    │\n209 │         if (p.status != Status.Approved || block.timestamp > p.decidedAt + EXECUTE_WINDOW) revert NotApproved();\n    │                                            ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/LARPBurner.sol:315:34\n    │\n315 │         emit Burned(rest, share, burned6900);\n    │                                  ━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:211:32\n    │\n211 │         if (lastChange != 0 && block.timestamp < lastChange + COOLDOWN) revert Cooling();\n    │                                ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:215:22\n    │\n215 │         lastChange = uint64(block.timestamp);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/IMDNames.sol:306:26\n    │\n306 │     function setRenderer(address renderer_) external {\n    │                          ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:341:36\n    │\n341 │             digits[i - 1] = bytes1(uint8(48 + frac % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/SwarmPrices.sol:357:15\n    │\n357 │             ++digits;\n    │               ━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:361:36\n    │\n361 │             out[--digits] = bytes1(uint8(48 + value % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/IMDNames.sol:314:24\n    │\n314 │     function setArtist(address artist_) external {\n    │                        ━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:208:9\n    │\n208 │         LARPBurner(payable(BURNER)).burn{value: msg.value}(minImd);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n    ╭▸ src/LARPBurner.sol:341:13\n    │\n341 │         try POOL_MANAGER.unlock{gas: LEG_GAS}(data) returns (bytes memory r) {\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:327:22\n    │\n327 │         (bool ok,) = LARP.canAct(c.captain, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPLinks.sol:342:39\n    │\n342 │         address distributor = address(uint160(w));\n    │                                       ━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint160' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPLinks.sol:380:31\n    │\n380 │             j.token = address(uint160(t));\n    │                               ━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint160' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:443:9\n    │\n443 │         (, c.faceCollection, c.faceTokenId, c.faceLive) = LARP.faceOf(imdId);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:454:22\n    │\n454 │         (bool ok,) = LARP.canAct(imdId, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/LARPAgents.t.sol:139:28\n    │\n139 │         uint256 deadline = block.timestamp + 1 hours;\n    │                            ━━━━━━━━━━━━━━━\n140 │         bytes memory sig = _sign(ownerKey, 7, agent, owner, 0, deadline);\n141 │         vm.warp(deadline + 1);\n    │         ───────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.number` may be reused across `vm.roll`\n   ╭▸ test/LARPBurnerFloorEdges.t.sol:60:21\n   │\n60 │             vm.roll(block.number + 1);\n   │             ────────━━━━━━━━━━━━───── `vm.roll` changes this environment here\n   │\n   ├ help: capture it with `vm.getBlockNumber()` instead\n   ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.number` may be reused across `vm.roll`\n   ╭▸ test/LARPBurnerPairLeg.t.sol:94:17\n   │\n94 │         vm.roll(block.number + 1);\n   │         ────────━━━━━━━━━━━━───── `vm.roll` changes this environment here\n   │\n   ├ help: capture it with `vm.getBlockNumber()` instead\n   ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:203:60\n    │\n203 │             _attest(id, true, 0, \"\", block.chainid, uint64(block.timestamp + 1 days));\n    │                                                            ━━━━━━━━━━━━━━━\n    ‡\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:54:30\n    │\n 54 │             issuedAt: uint64(block.timestamp),\n    │                              ━━━━━━━━━━━━━━━\n    ‡\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:209:17\n    │\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────━━━━━━━━━━━━━━━─────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:203:60\n    │\n203 │             _attest(id, true, 0, \"\", block.chainid, uint64(block.timestamp + 1 days));\n    │                                                            ━━━━━━━━━━━━━━━\n    ‡\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ───────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:54:30\n    │\n 54 │             issuedAt: uint64(block.timestamp),\n    │                              ━━━━━━━━━━━━━━━\n    ‡\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ───────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:236:17\n    │\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ────────━━━━━━━━━━━━━━━────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\n","passed":true},{"durationMs":37900,"exitCode":0,"name":"test","output":"No files changed, compilation skipped\n\nRan 2 tests for test/Placement.t.sol:PlacementForkTest\n[SKIP] test_fork_ANameBurnsTheCanonicalWay() (gas: 0)\n[SKIP] test_fork_LandsAt6900ThroughTheRealCreateX() (gas: 0)\nSuite result: ok. 0 passed; 0 failed; 2 skipped; finished in 409.11µs (74.78µs CPU time)\n\nRan 11 tests for test/MainnetFork.t.sol:MainnetForkTest\n[SKIP] test_ACrewBuysAndBurnsRealIMD() (gas: 0)\n[SKIP] test_ANameBuysRealIMDOnPool4AndBurnsIt() (gas: 0)\n[SKIP] test_ANameChangesHandsAndBurns() (gas: 0)\n[SKIP] test_ANamePaidInRealImd() (gas: 0)\n[SKIP] test_APriceProposalThroughIMDsRealIntake() (gas: 0)\n[SKIP] test_AnAgentRunsTheTreasurysIdentity() (gas: 0)\n[SKIP] test_AnIdentityWearsAWorkerFren() (gas: 0)\n[SKIP] test_RealProofsRefuseTampering() (gas: 0)\n[SKIP] test_TheHooklessPoolTakesWhatPool4Cant() (gas: 0)\n[SKIP] test_TheRealJeetBoard() (gas: 0)\n[SKIP] test_TheTreasurysCard() (gas: 0)\nSuite result: ok. 0 passed; 0 failed; 11 skipped; finished in 636.45µs (156.07µs CPU time)\n\nRan 24 tests for test/LARPLinks.t.sol:LARPLinksTest\n[PASS] test_AGasHungryTokenCantSinkTheBoard() (gas: 1737463)\n[PASS] test_AnInnerNodeIsNotALeaf() (gas: 1448373)\n[PASS] test_AnUnreadableTokenCountsAsHeld() (gas: 1784660)\n[PASS] test_BadAllocations() (gas: 1754999)\n[PASS] test_CaptainsRun() (gas: 592442)\n[PASS] test_Card() (gas: 903636)\n[PASS] test_CrewFoundingRules() (gas: 546171)\n[PASS] test_Disband() (gas: 810487)\n[PASS] test_FoundACrewWithImd() (gas: 1184629)\n[PASS] test_FoundingACrewBurnsIMD() (gas: 378689)\n[PASS] test_FrenRules() (gas: 383139)\n[PASS] test_FrensPassWithTheIdentity() (gas: 302573)\n[PASS] test_FrensTakeTwo() (gas: 266329)\n[PASS] test_JeetsAreReadLive() (gas: 2364129)\n[PASS] test_JeetsInPages() (gas: 8424463)\n[PASS] test_OpenAndClosedCrews() (gas: 955439)\n[PASS] test_PassTheCaptaincy() (gas: 577520)\n[PASS] test_ProveAnAllocation() (gas: 1534389)\n[PASS] test_RanksAcrossLaunches() (gas: 5184173)\n[PASS] test_TheCaptaincyPassesWithTheIdentity() (gas: 397438)\n[PASS] test_TheRankIsTheHoldersNow() (gas: 1748137)\n[PASS] test_Tiers() (gas: 80885)\n[PASS] test_Unfren() (gas: 271974)\n[PASS] test_WithdrawAndDeclineAsks() (gas: 244060)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 12.41ms (9.62ms CPU time)\n\nRan 14 tests for test/LARPAgents.t.sol:LARPAgentsTest\n[PASS] test_AContractWalletSignsWithERC1271() (gas: 431060)\n[PASS] test_ASignatureWorksOnce() (gas: 230440)\n[PASS] test_AnAgentCantNameAgentsOrTheWallet() (gas: 195893)\n[PASS] test_AnAgentDressesTheIdentityWithTheOwnersNFTs() (gas: 396334)\n[PASS] test_AnAgentLapsesOnASale() (gas: 317701)\n[PASS] test_AnAgentLinksTheOwnersNameAndSetsTexts() (gas: 615060)\n[PASS] test_AnAgentResigns() (gas: 193582)\n[PASS] test_AnAgentRunsFrensAndCrews() (gas: 860110)\n[PASS] test_AnyAgentChangeVoidsOutstandingSignatures() (gas: 188002)\n[PASS] test_BadSignatures() (gas: 364692)\n[PASS] test_OnlyTheOwnerSetsTheAgent() (gas: 40977)\n[PASS] test_SignaturesExpire() (gas: 49228)\n[PASS] test_TheOwnerConnectsAnAgentInOneCall() (gas: 188975)\n[PASS] test_TheOwnerSignsTheAgentSends() (gas: 176447)\nSuite result: ok. 14 passed; 0 failed; 0 skipped; finished in 11.20ms (8.37ms CPU time)\n\nRan 7 tests for test/ConstructorMatrix.t.sol:ConstructorMatrixTest\n[PASS] test_AllSixConstructorsAreNonpayable() (gas: 10519828)\n[PASS] test_AllThreeSpacingFieldsRejectValuesAboveV4sMaximum() (gas: 1967664)\n[PASS] test_EachRequiredBurnerAddressRejectsZeroIndependently() (gas: 645722)\n[PASS] test_EachRequiredLinksAddressRejectsZeroIndependently() (gas: 1335136)\n[PASS] test_EachRequiredNamesAddressRejectsZeroIndependently() (gas: 1572887)\n[PASS] test_RegistryRejectsZeroIdentityAndStoresThePlanIdentity() (gas: 1782307)\n[PASS] test_V4MinimumAndMaximumSpacingsSurviveTheUnsignedArguments() (gas: 1726608)\nSuite result: ok. 7 passed; 0 failed; 0 skipped; finished in 14.43ms (15.53ms CPU time)\n\nRan 6 tests for test/PaymentAtomicity.t.sol:PaymentAtomicityTest\n[PASS] test_AllSixPaymentsRejectCallerGasStarvationAtomically() (gas: 4879290)\n[PASS] test_AllSixPaymentsRollBackWhenCanonicalTransferFails() (gas: 5681810)\n[PASS] test_ForwardingInTheCallbackLeavesTheNextHolderOwingItsOwnToll() (gas: 1418909)\n[PASS] test_ImdTransferFailureDoesNotMintOrFoundOrPayAToll() (gas: 659659)\n[PASS] test_ReceiverCanPayItsTollInsideEitherSafeTransferCallback() (gas: 2249089)\n[PASS] test_RejectingReceiverRollsBackItsNestedPaymentRecordsAndSwap() (gas: 1267363)\nSuite result: ok. 6 passed; 0 failed; 0 skipped; finished in 16.50ms (23.06ms CPU time)\n\nRan 6 tests for test/LARPBurnerPairLeg.t.sol:LARPBurnerPairLegTest\n[PASS] test_AtAHundredPercentOnlyThePoolsRoomBuysIMD6900() (gas: 318615)\n[PASS] test_BurnFloorsTheSendersPartOrTheWholeSaleWhenItSendsNothing() (gas: 756118)\n[PASS] test_MinImdIsCheckedAgainstThePayersOwnFee() (gas: 630527)\n[PASS] test_TheIMD6900LegIsNotWorthSandwichingAtAnyShare() (gas: 1901512)\nLogs:\n  attacker's $IMD profit at 100%, 500 $IMD front (wei): -42829697176817851510\n\n[PASS] test_TheLaunchShareOfAFullBurnIsNotClipped() (gas: 280495)\n[PASS] test_TheRoomFollowsThePoolsDepth() (gas: 615537)\nSuite result: ok. 6 passed; 0 failed; 0 skipped; finished in 18.36ms (6.47ms CPU time)\n\nRan 14 tests for test/LARPItems.t.sol:LARPItemsTest\n[PASS] test_AFaceBecomesAnItem() (gas: 321185)\n[PASS] test_AnItemBecomesAnotherIdentitysFace() (gas: 306295)\n[PASS] test_EquipAnERC1155Copy() (gas: 195226)\n[PASS] test_EquipAnERC721() (gas: 228623)\n[PASS] test_OneCopyOnePlacement() (gas: 372050)\n[PASS] test_ReequippingTheSameCopyInTheSameSlot() (gas: 213412)\n[PASS] test_RefusedItems() (gas: 220243)\n[PASS] test_ReplacingAnItemFreesTheOldOne() (gas: 291522)\n[PASS] test_SellingACopyDarkensItsPlacementsUntilOneComesOff() (gas: 456264)\n[PASS] test_SellingTheIdentityDarkensItsItems() (gas: 360711)\n[PASS] test_SlotsAreOneToEight() (gas: 224747)\n[PASS] test_StrangersCantTakeItemsOff() (gas: 174966)\n[PASS] test_TheNewOwnerClearsTheOldItems() (gas: 343634)\n[PASS] test_ThePlacerTakesItsCopyBackAfterSellingTheIdentity() (gas: 399525)\nSuite result: ok. 14 passed; 0 failed; 0 skipped; finished in 19.64ms (2.47ms CPU time)\n\nRan 23 tests for test/IMDNamesEdges.t.sol:IMDNamesEdgesTest\n[PASS] test_APrimaryWithoutANameIsLiveAndNameless() (gas: 182236)\n[PASS] test_ARendererThatAnswersNothingFallsBack() (gas: 383627)\n[PASS] test_ASaleDarkensTheLinkAndTheTextStays() (gas: 286579)\n[PASS] test_AStrangerCannotUnlink() (gas: 160730)\n[PASS] test_AnAgentLinksUnlinksAndWrites() (gas: 486024)\n[PASS] test_ApprovalsAndOperatorTransfers() (gas: 452506)\n[PASS] test_Constants() (gas: 191514)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 15761)\n[PASS] test_LockingIsIdempotentAndKeepsTheRenderer() (gas: 292103)\n[PASS] test_PrimaryAndTextRefusals() (gas: 147701)\n[PASS] test_ReadingNames() (gas: 64773)\n[PASS] test_RegisterRefusesLessThanThePrice() (gas: 216901)\n[PASS] test_RegisterWithAFloorTheBurnCannotMeet() (gas: 224412)\n[PASS] test_RegisterWithImdNeedsAnAllowance() (gas: 622695)\n[PASS] test_ResolveNameSpellings() (gas: 150173)\n[PASS] test_RoyaltyRounding() (gas: 35079)\n[PASS] test_SafeTransfersCheckTheReceiver() (gas: 603375)\n[PASS] test_TheArtistRenouncesAndTheArtIsFinal() (gas: 154258)\n[PASS] test_TheCardOfAnUnlinkedName() (gas: 2382338)\n[PASS] test_TheLongestAndShortestNames() (gas: 503735)\n[PASS] test_TheTollInImdRespectsMaxImd() (gas: 1139620)\n[PASS] test_TransferRules() (gas: 144769)\n[PASS] test_UnlinkingNothingDoesNothing() (gas: 37821)\nSuite result: ok. 23 passed; 0 failed; 0 skipped; finished in 20.95ms (17.91ms CPU time)\n\nRan 24 tests for test/LARP.t.sol:LARPFaceTest\n[PASS] testFuzz_OnlyTheHolderOfBothSetsAFace(address,uint256,uint256) (runs: 256, μ: 55799, ~: 56425)\nLogs:\n  Bound result 0\n  Bound result 9\n\n[PASS] test_AFaceComesBackWithBothTokens() (gas: 220934)\n[PASS] test_AMaskMovesToTheIdentityThatPutsItOn() (gas: 323750)\n[PASS] test_AvatarFormat() (gas: 249931)\n[PASS] test_ChangingMasksFreesTheOldOne() (gas: 274960)\n[PASS] test_ClearFace() (gas: 200738)\n[PASS] test_ClearingNoFaceDoesNothing() (gas: 36612)\n[PASS] test_FaceURIFallsBackOnABrokenTokenURI() (gas: 2152591)\n[PASS] test_OnlyTheIdentitysOwnerClears() (gas: 173845)\n[PASS] test_PuttingTheSameMaskOnAgain() (gas: 240094)\n[PASS] test_RefusesAMaskThatIsNotYours() (gas: 49187)\n[PASS] test_RefusesAnIdentityAsAMask() (gas: 41585)\n[PASS] test_RefusesAnIdentityThatDoesNotExist() (gas: 41653)\n[PASS] test_RefusesAnIdentityThatIsNotYours() (gas: 43653)\n[PASS] test_RefusesWhatIsNotAnNFT() (gas: 510494)\n[PASS] test_SellingTheIdentityTakesTheFaceDown() (gas: 252506)\n[PASS] test_SellingTheMaskTakesTheFaceDown() (gas: 223250)\n[PASS] test_SetFace() (gas: 266231)\n[PASS] test_SupportsInterface() (gas: 27637)\n[PASS] test_TheIdentitysNewOwnerClearsTheOldFace() (gas: 225470)\n[PASS] test_TheNewHolderOfAMaskTakesItOff() (gas: 321718)\n[PASS] test_TheNewOwnerMustChooseAgain() (gas: 327564)\n[PASS] test_WearerOfAnUnwornMask() (gas: 14020)\n[PASS] test_ZeroIdentityRefused() (gas: 4446)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 36.38ms (38.57ms CPU time)\n\nRan 15 tests for test/LARPEdges.t.sol:LARPEdgesTest\n[PASS] testFuzz_WearerOfRoundTripsForAnyIdentityId(uint256,uint8) (runs: 256, μ: 220260, ~: 220684)\nLogs:\n  Bound result 32491682452882424984932\n  Bound result 8\n\n[PASS] test_ACopyPlacedTwiceIsCountedTwice() (gas: 341053)\n[PASS] test_ASignatureFromAnotherChainIsRefused() (gas: 83326)\n[PASS] test_AgentsOfNothing() (gas: 146135)\n[PASS] test_AnAgentTakesOffThePreviousOwnersItems() (gas: 350579)\n[PASS] test_ConstantsAndDomain() (gas: 57230)\n[PASS] test_ContractWalletsThatRefuseOrMumble() (gas: 462979)\n[PASS] test_EmptySpots() (gas: 141020)\n[PASS] test_OddSignatureBytes() (gas: 342349)\n[PASS] test_OneAgentForTwoIdentities() (gas: 326950)\n[PASS] test_RemovingAnAgentBumpsTheNonce() (gas: 371695)\n[PASS] test_ResigningDoesNotBumpTheNonce() (gas: 288556)\n[PASS] test_SupportsInterfaceIsPure() (gas: 15273)\n[PASS] test_TakingOffAnEmptySlotIsSilent() (gas: 61582)\n[PASS] test_ThePlacerTakesOffWhatItPlacedAfterSellingTheIdentity() (gas: 426342)\nSuite result: ok. 15 passed; 0 failed; 0 skipped; finished in 41.61ms (39.59ms CPU time)\n\nRan 4 tests for test/Launch.t.sol:LaunchTest\n[PASS] test_DeploysOnAFreshChain() (gas: 193241)\n[PASS] test_FitsOneTransaction() (gas: 25789)\nLogs:\n  launch gas, four creations: 8303\n\n[PASS] test_PassesTheAdmissionScan() (gas: 18079964)\n[PASS] test_UnderTheCodeSizeLimit() (gas: 11134)\nSuite result: ok. 4 passed; 0 failed; 0 skipped; finished in 85.85ms (85.89ms CPU time)\n\nRan 8 tests for test/PlacementEdges.t.sol:PlacementEdgesTest\n[PASS] testFuzz_MixedSquattersNeverChangeTheWiring(uint8,uint8) (runs: 64, μ: 10430779, ~: 10429596)\n[PASS] test_AllSixteenDestinationOccupancyCombinations() (gas: 167290353)\n[PASS] test_AllSixteenProxyOnlyOccupancyCombinations() (gas: 167352150)\n[PASS] test_CreateXReturningTheRightAddressWithoutCodeIsRefused() (gas: 413982)\n[PASS] test_EveryCreateXFailureRollsBackTheEntireLaunchAndCanRetry() (gas: 54092771)\n[PASS] test_PlaceLinksRequiresTheEarlierPlacement() (gas: 10617921)\n[PASS] test_PlacementAndApplicationsExposeNoOwnerOrUpgradeCalls() (gas: 11176768)\n[PASS] test_SecondLaunchCreatesItsOwnFourContracts() (gas: 20646674)\nSuite result: ok. 8 passed; 0 failed; 0 skipped; finished in 110.84ms (221.97ms CPU time)\n\nRan 18 tests for test/SwarmPricesEdges.t.sol:SwarmPricesEdgesTest\n[PASS] testFuzz_TheGuardrailsAreExactlyTheDocumentedRule(uint64,uint64,uint64,uint64) (runs: 512, μ: 478654, ~: 60870)\nLogs:\n  Bound result 6676411726391504\n  Bound result 2800121725734695\n  Bound result 1255642554590168\n  Bound result 5319433\n\n[PASS] test_AFailureAfterAVerdictIsRefused() (gas: 3536518)\n[PASS] test_AVerdictExpiringThisSecondStillCounts() (gas: 3485815)\n[PASS] test_AnUnknownProposalIsNone() (gas: 18765)\n[PASS] test_ExactlyTwiceAndExactlyHalfAreAllowed() (gas: 9955402)\n[PASS] test_ExecutingNothingOrAPendingProposalIsRefused() (gas: 3448188)\n[PASS] test_OverpayingTheOracleIsTheProposersChoice() (gas: 3419807)\n[PASS] test_PricesAfterTwoChangesStayWithinTheRailsOfEach() (gas: 5666539)\n[PASS] test_ProposingNeedsTheProposersImd() (gas: 384718)\n[PASS] test_TheAnswerMustBeABoolTrueAboutThisChain() (gas: 9661881)\n[PASS] test_TheCallbackSelectorsAreTheProtocolsLayout() (gas: 3565259)\n[PASS] test_TheFirstChangeHasNoCooldown() (gas: 3524896)\n[PASS] test_TheLastSecondOfTheCooldown() (gas: 5829304)\n[PASS] test_TheLastSecondOfTheExecuteWindow() (gas: 3521482)\n[PASS] test_TheProtocolsOwnSignatureVerifies() (gas: 3709734)\n[PASS] test_TheProtocolsSignatureOnATamperedVectorIsRefused() (gas: 3749904)\n[PASS] test_TheVectorsSignerApprovesWithABoolAnswer() (gas: 3712925)\n[PASS] test_TwoProposalsOneVerdictEach() (gas: 5635427)\nSuite result: ok. 18 passed; 0 failed; 0 skipped; finished in 103.96ms (117.13ms CPU time)\n\nRan 4 tests for test/LARPBurnerShareEdges.t.sol:LARPBurnerShareEdgesTest\n[PASS] testFuzz_ValidShareSplitsEveryWeiAndBurnsActualSupply(uint16,uint256) (runs: 256, μ: 383174, ~: 396410)\nLogs:\n  Bound result 4\n  Bound result 962641359231113882193\n\n[PASS] test_DustOnBothSidesOfTheFirstNonzeroShare() (gas: 1316066)\n[PASS] test_OnlyOneAbiWordIsAnAcceptableShareAnswer() (gas: 476838)\n[PASS] test_TheClippedShareGoesToTheCanonicalBurn() (gas: 331570)\nSuite result: ok. 4 passed; 0 failed; 0 skipped; finished in 115.50ms (114.37ms CPU time)\n\nRan 9 tests for test/Placement.t.sol:PlacementTest\n[PASS] test_ASaltUsedFirstIsNeverTaken() (gas: 10748250)\n[PASS] test_ArgumentsAsTheReadmeSays() (gas: 6240)\n[PASS] test_DeploysOnAFreshChain() (gas: 10281074)\n[PASS] test_FitsOneTransaction() (gas: 31706733)\nLogs:\n  the launch: gas, all in: 11261259\n  PlaceLARP initcode bytes: 40310\n  PlaceLinks initcode bytes: 12010\n\n[PASS] test_FreshChainFitsOneTransaction() (gas: 31425881)\nLogs:\n  the launch: gas, all in: 11203616\n  PlaceLARP initcode bytes: 40310\n  PlaceLinks initcode bytes: 12010\n\n[PASS] test_LandsWhereThePlanSays() (gas: 10563501)\n[PASS] test_PassesTheAdmissionScan() (gas: 43505634)\n[PASS] test_PlanFollowsFromTheSalts() (gas: 162797)\n[PASS] test_SameAddressesWhoeverRunsIt() (gas: 20402429)\nSuite result: ok. 9 passed; 0 failed; 0 skipped; finished in 130.58ms (275.98ms CPU time)\n\nRan 7 tests for test/SwarmPrices.t.sol:SwarmShareTest\n[PASS] test_AndDownToNothing() (gas: 10341468)\n[PASS] test_ShareGuardrails() (gas: 7682664)\n[PASS] test_StartsAt6Point9AndTheBurnerReadsItFromIMDNames() (gas: 264776)\n[PASS] test_TheBurnerFallsBackTo6Point9() (gas: 429031)\n[PASS] test_TheQuestionNamesTheShare() (gas: 6758711)\n[PASS] test_TheSwarmMovesTheShareAndTheBurnerFollows() (gas: 3760618)\n[PASS] test_UpToAllOfIt() (gas: 10694969)\nSuite result: ok. 7 passed; 0 failed; 0 skipped; finished in 112.43ms (84.78ms CPU time)\n\nRan 5 tests for test/LARPBurnerFloorEdges.t.sol:LARPBurnerFloorEdgesTest\n[PASS] testFuzz_TheWaitingEthNeverMeetsThePayersFloor(uint256,uint256) (runs: 256, μ: 461648, ~: 463155)\nLogs:\n  Bound result 99999999999995320\n  Bound result 87\n\n[PASS] test_ADustFeeIsFlooredOnItsOwnPart() (gas: 1122234)\n[PASS] test_AFeeAboveTheCapIsFlooredOnTheFirstTenthOfAnEther() (gas: 392735)\n[PASS] test_AnEmptyBurnMeetsOnlyAZeroFloor() (gas: 70156)\n[PASS] test_TheFloorBoundaryIsThePayersProRataPartToTheWei() (gas: 655052)\nSuite result: ok. 5 passed; 0 failed; 0 skipped; finished in 140.80ms (140.90ms CPU time)\n\nRan 24 tests for test/LARPLinksEdges.t.sol:LARPLinksEdgesTest\n[PASS] testFuzz_JeetBpsIsTheSoldShareOfTheAllocation(uint128,uint256,bool) (runs: 256, μ: 1665676, ~: 1535742)\nLogs:\n  Bound result 3582\n  Bound result 2671\n\n[PASS] testFuzz_TiersAreMonotoneInJeetPoints(uint256,uint256,uint256) (runs: 256, μ: 33076, ~: 33214)\nLogs:\n  Bound result 1000\n  Bound result 4319\n  Bound result 9996027\n\n[PASS] test_ACardWithALiveFace() (gas: 694335)\n[PASS] test_ADisbandedCrewIsGone() (gas: 624526)\n[PASS] test_ADistributorWithoutARootIsUnknown() (gas: 1411930)\n[PASS] test_ADistributorWithoutATokenCountsAsHeld() (gas: 1673522)\n[PASS] test_ALauncherAnsweringGarbageIsUnknown() (gas: 1533984)\n[PASS] test_AllocationBounds() (gas: 2897946)\n[PASS] test_AnAskSurvivesASaleOfEitherIdentity() (gas: 241341)\n[PASS] test_AnEmptyProofForASoloRound() (gas: 1509668)\n[PASS] test_AnIdentityNobodyHolds() (gas: 54774)\n[PASS] test_CaptainRules() (gas: 588036)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 13620)\n[PASS] test_CrewNamesAtTheEdges() (gas: 689374)\n[PASS] test_Defaults() (gas: 177309)\n[PASS] test_FoundCrewWithImdRefusals() (gas: 1002976)\n[PASS] test_FoundCrewWithTheWrongValue() (gas: 364406)\n[PASS] test_InviteRules() (gas: 567999)\n[PASS] test_JoinLeaveRules() (gas: 743979)\n[PASS] test_LaunchJeetPastTheEndReverts() (gas: 14394)\n[PASS] test_MembersCountFollowsEveryMove() (gas: 725282)\n[PASS] test_TwoRoundsOfOneLaunchAreOneLevel() (gas: 1866769)\n[PASS] test_UnfrenClearsBothAsksAtOnce() (gas: 388582)\n[PASS] test_UnfrenWithNothingDoesNothing() (gas: 86806)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 144.37ms (224.12ms CPU time)\n\nRan 28 tests for test/IMDNames.t.sol:IMDNamesTest\n[PASS] test_ABrokenRendererFallsBackToTheCard() (gas: 10710970)\n[PASS] test_AFeeParksWhenNoPoolCanTakeIt() (gas: 8894773)\n[PASS] test_ANewOwnerPaysTheTollToLink() (gas: 659541)\n[PASS] test_ARoyaltyPaymentIsBurned() (gas: 197078)\n[PASS] test_AnyoneRegistersAnyFreeName() (gas: 251418)\n[PASS] test_BadNames() (gas: 76271)\n[PASS] test_LinkRules() (gas: 227703)\n[PASS] test_LinkTheNameToAnIdentity() (gas: 188953)\n[PASS] test_NoImdPaymentWithoutBothPools() (gas: 233712)\n[PASS] test_OneNamePerIdentityOneIdentityPerName() (gas: 566947)\n[PASS] test_Prices() (gas: 63806)\n[PASS] test_Primary() (gas: 249738)\n[PASS] test_RegisterForSomeoneElse() (gas: 242327)\n[PASS] test_RegisterWithImd() (gas: 962888)\n[PASS] test_RegisterWithImdRespectsMaxImd() (gas: 785222)\n[PASS] test_RegisteringMintsTheNameAndBurnsTheFee() (gas: 287226)\n[PASS] test_RegistrationRules() (gas: 228053)\n[PASS] test_RoyaltiesGoToTheBurner() (gas: 40939)\n[PASS] test_SellingTheIdentityTakesItDown() (gas: 170626)\n[PASS] test_SellingTheNameTakesItDown() (gas: 207985)\n[PASS] test_ShortNamesHaveShortNameTolls() (gas: 290386)\n[PASS] test_TextRecordsStartOverWithANewHolder() (gas: 217274)\n[PASS] test_TheArtistChangesTheArtAndOnlyTheArt() (gas: 410113)\n[PASS] test_TheBuiltInCard() (gas: 3442144)\n[PASS] test_TheNamesNewOwnerUnlinksAStaleLink() (gas: 236080)\n[PASS] test_TheTollFollowsEveryChangeOfHands() (gas: 214766)\n[PASS] test_TheTollInImd() (gas: 1097163)\n[PASS] test_Unlink() (gas: 207675)\nSuite result: ok. 28 passed; 0 failed; 0 skipped; finished in 144.38ms (65.72ms CPU time)\n\nRan 19 tests for test/LARPBurnerEdges.t.sol:LARPBurnerEdgesTest\n[PASS] testFuzz_ABurnSpendsMinOfBalanceAndMaxBurn(uint256,uint256) (runs: 128, μ: 799753, ~: 797905)\nLogs:\n  Bound result 182452882424919949\n  Bound result 384285164318795929\n\n[PASS] testFuzz_QuoteIsLinearAndMonotone(uint256,uint256) (runs: 256, μ: 576833, ~: 576910)\nLogs:\n  Bound result 3471593299196916585\n  Bound result 6075711240114041836\n\n[PASS] testFuzz_SixPointNinePercentBuysIMD6900AndTheRestBurns(uint256) (runs: 256, μ: 577812, ~: 580495)\nLogs:\n  Bound result 2835717307\n\n[PASS] testFuzz_TwoBurnsInOneBlockSellAtMostOneCapOfWaitingEth(uint256,uint256,uint256) (runs: 192, μ: 1021385, ~: 1024664)\nLogs:\n  Bound result 499999000000000101\n  Bound result 20816\n  Bound result 1230\n\n[PASS] test_APartialFillOnPool4FallsToTheHooklessPool() (gas: 1846686)\n[PASS] test_AWethAnsweringShortIsIgnored() (gas: 534743)\n[PASS] test_AWethThatRefusesToUnwrapIsIgnored() (gas: 572334)\n[PASS] test_AWrongPool4KeyFallsToTheHooklessPool() (gas: 465447)\n[PASS] test_BelowTheLegBudgetABurnIsRefusedBeforeAnyLegRuns() (gas: 1030938)\n[PASS] test_Constants() (gas: 72853)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 9394)\n[PASS] test_ExactlyMaxBurnInOneCall() (gas: 615853)\n[PASS] test_NoPoolAtAllParksAndQuotesNothing() (gas: 613793)\n[PASS] test_NothingToBurnIsNotAnError() (gas: 383372)\n[PASS] test_OneWeiParks() (gas: 668242)\n[PASS] test_QuoteOfTheSmallestPrice() (gas: 549288)\n[PASS] test_ReceiveTakesEmptyCallsOnly() (gas: 66423)\n[PASS] test_TheBlockAllowanceCountsOnlyTheWaitingEth() (gas: 886201)\n[PASS] test_UnwrappedWethIsWaitingEth() (gas: 913857)\nSuite result: ok. 19 passed; 0 failed; 0 skipped; finished in 159.41ms (386.98ms CPU time)\n\nRan 18 tests for test/SwarmPrices.t.sol:SwarmPricesTest\n[PASS] testFuzz_AWrongRequestCannotSettleAPendingProposal(bytes32) (runs: 256, μ: 3602922, ~: 3603018)\n[PASS] test_AProposalForOldPricesGoesStale() (gas: 5746079)\n[PASS] test_ARejectedProposalChangesNothing() (gas: 3509710)\n[PASS] test_AVerdictCannotApproveAnotherPendingProposal() (gas: 5605415)\n[PASS] test_AVerdictMustBeUsedWithinTwoWeeks() (gas: 3484003)\n[PASS] test_AWeakPanelIsARejection() (gas: 9673020)\n[PASS] test_AnExpiredVerdictIsARejection() (gas: 3469488)\n[PASS] test_AnyoneProposesAndTheContractWritesTheQuestion() (gas: 4279995)\n[PASS] test_ApprovedThenAnyoneExecutes() (gas: 4114203)\n[PASS] test_ChangingTheSignedRequestIdInvalidatesTheSignature() (gas: 5740540)\n[PASS] test_ExecutedOnce() (gas: 3532702)\n[PASS] test_Guardrails() (gas: 218195)\n[PASS] test_NoVerdictClosesTheProposal() (gas: 3502151)\n[PASS] test_OneChangeAWeek() (gas: 5815824)\n[PASS] test_OnlyTheIntakeDeliversAndOnlyForItsOwnProposals() (gas: 3493956)\n[PASS] test_OnlyTheOraclesSignatureForThisContractCounts() (gas: 3635637)\n[PASS] test_StartPrices() (gas: 61091)\n[PASS] test_TheOracleMustBePaid() (gas: 239434)\nSuite result: ok. 18 passed; 0 failed; 0 skipped; finished in 157.93ms (179.20ms CPU time)\n\nRan 27 tests for test/LARPBurner.t.sol:LARPBurnerTest\n[PASS] test_AFeeAlwaysGoesThroughWhateverTheBlockSpent() (gas: 842662)\n[PASS] test_AGasEatingIMD6900IsSkippedNotFatal() (gas: 7966516)\n[PASS] test_AGasEatingPool4HookFallsToTheHooklessPool() (gas: 3732187)\n[PASS] test_AGenuineFailureIsNotMistakenForTooLittleGas() (gas: 505929)\n[PASS] test_ASwapOutOfGasReverts() (gas: 10080207)\n[PASS] test_AnEmptyPairPoolMeansItAllBurnsAsIMD() (gas: 456548)\n[PASS] test_AnIMD6900LegOutOfGasDeepDownReverts() (gas: 3825389)\n[PASS] test_AnIMD6900ThatWontBurnMeansItAllBurnsAsIMD() (gas: 793224)\n[PASS] test_AtMostMaxBurnPerCallAndPerBlockOfWaitingEth() (gas: 889900)\n[PASS] test_BurnCallsBatchedInOneTransactionSellOneCap() (gas: 666272)\n[PASS] test_BurnImdBurnsWhatArrivesInIMD() (gas: 523288)\n[PASS] test_BuysOnPool4First() (gas: 702809)\n[PASS] test_HostileLegsCostPaidCallsTheirBudgets() (gas: 11595661)\nLogs:\n  registration gas used with two hostile legs: 6033788\n\n[PASS] test_MinImd() (gas: 961796)\n[PASS] test_NoGasLimitSkipsAHeavyIMD6900Leg() (gas: 68273876)\n[PASS] test_NoGasLimitSkipsARoute() (gas: 6031485)\n[PASS] test_NoQuoteWithoutBothPools() (gas: 297470)\n[PASS] test_NoReentry() (gas: 467883)\n[PASS] test_OnlyThePoolManagerCallsBack() (gas: 32829)\n[PASS] test_ParkedWhenNoPoolCanAndBurnedLater() (gas: 1010640)\n[PASS] test_QuoteIsTheHigherOfTheTwoPools() (gas: 759415)\n[PASS] test_RoyaltiesArriveByPlainTransfer() (gas: 44081)\n[PASS] test_ShareBuysIMD6900AndBurnsIt() (gas: 855411)\n[PASS] test_SpacingAboveV4sLargestReverts() (gas: 11396)\n[PASS] test_SpacingsAreTakenUnsignedAndKeptAsInt24() (gas: 28301)\n[PASS] test_TheHooklessPoolIfPool4CantTakeIt() (gas: 814879)\n[PASS] test_WethRoyaltiesAreUnwrappedAndSold() (gas: 762106)\nSuite result: ok. 27 passed; 0 failed; 0 skipped; finished in 230.13ms (338.83ms CPU time)\n\nRan 1 test for test/LARPBurner.invariant.t.sol:LARPBurnerInvariantTest\n[PASS]\nLARPBurnerInvariantTest invariants:\n[PASS] invariant_DeadHoldsOnlyImd\n[PASS] invariant_EthLeavesOnlyAsASwap\n[PASS] invariant_Imd6900OnlyBurns\n[PASS] invariant_ImdGoesOnlyToDeadOrTheIMD6900Buy\n[PASS] invariant_NoImdOutlivesABurn\n[PASS] invariant_WaitingEthLeavesAtMostOneCapPerBlock\n LARPBurnerInvariantTest invariants (runs: 64, calls: 3072, reverts: 0)\n\n╭---------------+-------------------+-------+---------+----------╮\n| Contract      | Selector          | Calls | Reverts | Discards |\n+================================================================+\n| BurnerHandler | burn              | 380   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | burnImd           | 348   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | burnWithLittleGas | 391   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateEth         | 436   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateImd         | 373   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateWeth        | 362   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | nextBlock         | 355   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | trade             | 427   | 0       | 0        |\n╰---------------+-------------------+-------+---------+----------╯\n\nLogs:\n  Bound result 5999000000000000000401\n  Bound result 12870\n  Bound result 3007882\n  Bound result 5000000000000000\n  Bound result 2301\n  Bound result 284316827753434525\n  Bound result 358793239081170476\n  Bound result 4984\n  Bound result 184812773397540567\n  Bound result 2433318\n  Bound result 5999000000000000012346\n  Bound result 120000000000000000\n  Bound result 1341\n  Bound result 5476\n  Bound result 1\n  Bound result 6907\n  Bound result 303217537091289238245\n  Bound result 1\n  Bound result 599290589\n  Bound result 5357\n  Bound result 200000000000000000\n  Bound result 242\n  Bound result 2\n  Bound result 2\n  Bound result 299999999999999999\n  Bound result 1707490\n  Bound result 500000000000000000\n  Bound result 3714247997\n  Bound result 2138\n  Bound result 3500000000000000\n  Bound result 1\n  Bound result 739\n  Bound result 3\n  Bound result 50000000000000000\n  Bound result 14925\n  Bound result 499792917818885444\n  Bound result 848\n  Bound result 15275\n  Bound result 6058\n  Bound result 14066\n  Bound result 353945\n  Bound result 7200\n  Bound result 133378206054161229\n  Bound result 9307\n  Bound result 3007143\n  Bound result 1\n  Bound result 54243722424859933\n  Bound result 1933009\n  Bound result 194265960037000698\n  Bound result 1889567281\n  Bound result 3010305\n  Bound result 5999000000000000001219\n  Bound result 2834634216490329199\n  Bound result 120772534\n  Bound result 700000000000000\n  Bound result 2158778573\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 1.09s (1.09s CPU time)\n\nRan 1 test for test/SwarmPrices.invariant.t.sol:SwarmPricesInvariantTest\n[PASS]\nSwarmPricesInvariantTest invariants:\n[PASS] invariant_CountersMatchWhatHappened\n[PASS] invariant_NamesHoldsNothing\n[PASS] invariant_NoProposalReopens\n[PASS] invariant_PricesChangeOnlyByExecution\n[PASS] invariant_PricesWithinTheGuardrails\n SwarmPricesInvariantTest invariants (runs: 64, calls: 3072, reverts: 0)\n\n╭--------------+--------------+-------+---------+----------╮\n| Contract     | Selector     | Calls | Reverts | Discards |\n+==========================================================+\n| SwarmHandler | execute      | 358   | 0       | 0        |\n|--------------+--------------+-------+---------+----------|\n| SwarmHandler | fail         | 380   | 0       | 0        |\n|--------------+--------------+-------+---------+----------|\n| SwarmHandler | forge        | 387   | 0       | 0        |\n|--------------+--------------+-------+---------+----------|\n| SwarmHandler | pass         | 403   | 0       | 0        |\n|--------------+--------------+-------+---------+----------|\n| SwarmHandler | propose      | 372   | 0       | 0        |\n|--------------+--------------+-------+---------+----------|\n| SwarmHandler | proposeShare | 373   | 0       | 0        |\n|--------------+--------------+-------+---------+----------|\n| SwarmHandler | stranger     | 417   | 0       | 0        |\n|--------------+--------------+-------+---------+----------|\n| SwarmHandler | verdict      | 382   | 0       | 0        |\n╰--------------+--------------+-------+---------+----------╯\n\nLogs:\n  Bound result 18400000000007267\n  Bound result 4506666667166668\n  Bound result 1840000000003501\n  Bound result 1840000000014270\n  Bound result 400000000000006862\n  Bound result 11413393109712187\n  Bound result 3666273266303671\n  Bound result 1745319285444669\n  Bound result 1112981123637620\n  Bound result 517264651186736097\n  Bound result 20699999999999998\n  Bound result 874829310211014\n  Bound result 1840000000460513\n  Bound result 433449556699050\n  Bound result 600000000000000000\n  Bound result 18400000004500001\n  Bound result 3721504606846636\n  Bound result 1840000000009258\n  Bound result 1840000000013647\n  Bound result 400000000000007249\n  Bound result 775601\n  Bound result 1204\n  Bound result 18400000000011437\n  Bound result 4506666666667058\n  Bound result 1840002197196228\n  Bound result 1840000000032768\n  Bound result 405520000000000002\n  Bound result 187472\n  Bound result 80305\n  Bound result 19199999999999838\n  Bound result 4506666666680153\n  Bound result 1840000000004412\n  Bound result 1840000000032768\n  Bound result 400800000000000002\n  Bound result 345\n  Bound result 11\n  Bound result 9\n  Bound result 8\n  Bound result 4096\n  Bound result 4545475160555492\n  Bound result 2903256898865218\n  Bound result 2069999999999999\n  Bound result 230000000000003\n  Bound result 461991724938282062\n  Bound result 12799999999998642\n  Bound result 4506666666671294\n  Bound result 1840000000001820\n  Bound result 1840000000001033\n  Bound result 412298816980325935\n  Bound result 348\n  Bound result 776447\n  Bound result 8\n  Bound result 5\n  Bound result 8\n  Bound result 172800\n  Bound result 18400000000003413\n  Bound result 1000000000000000\n  Bound result 1840000000001807\n  Bound result 230000000000003\n  Bound result 400000000000000001\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 1.29s (1.28s CPU time)\n\nRan 3 tests for test/SwarmShareSettlement.invariant.t.sol:SwarmShareSettlementInvariantTest\n[PASS]\nSwarmShareSettlementInvariantTest invariants:\n[PASS] invariant_EveryDonatedImdIsWaitingSpentOrAtTheCanonicalBurn\n[PASS] invariant_ShareTracksOnlyApprovedExecutedTerms\n[PASS] invariant_ThePairOutputReallyLeavesTotalSupply\n SwarmShareSettlementInvariantTest invariants (runs: 256, calls: 16384, reverts: 0)\n\n╭------------------------+------------------+-------+---------+----------╮\n| Contract               | Selector         | Calls | Reverts | Discards |\n+========================================================================+\n| ShareSettlementHandler | approvePending   | 1252  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | burn             | 2467  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | donate           | 1286  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | execute          | 1315  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | fail             | 1226  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | forge            | 1249  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | pairAvailability | 1232  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | pass             | 1235  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | propose          | 1310  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | proposeShare     | 1258  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | stranger         | 1238  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | verdict          | 1316  | 0       | 0        |\n╰------------------------+------------------+-------+---------+----------╯\n\nLogs:\n  Bound result 9572\n  Bound result 1209\n  Bound result 12\n  Bound result 12\n  Bound result 8\n  Bound result 6999\n  Bound result 2127478271\n  Bound result 11\n  Bound result 11\n  Bound result 10\n  Bound result 35055\n  Bound result 1533\n  Bound result 11\n  Bound result 11\n  Bound result 8\n  Bound result 83033\n  Bound result 1070\n  Bound result 777\n  Bound result 774402\n  Bound result 539476058368865159823\n  Bound result 157827028405820975739\n  Bound result 157198259\n  Bound result 346\n  Bound result 616346\n  Bound result 8\n  Bound result 8\n  Bound result 7\n  Bound result 143619\n  Bound result 3363526365\n  Bound result 18400000000024577\n  Bound result 563333333333334\n  Bound result 1840000000007201\n  Bound result 1840000000007201\n  Bound result 400000000000000253\n  Bound result 1115\n  Bound result 1048\n  Bound result 1352\n  Bound result 12313727865990267\n  Bound result 1342640415440294\n  Bound result 1844769393566328\n  Bound result 1391052551394939\n  Bound result 592413384016495900\n\n[PASS] test_CallerGasCannotBypassShareButARefusingDependencyCanFallBack() (gas: 935033)\nLogs:\n  Bound result 100000000000000000000\n  Bound result 100000000000000000000\n\n[PASS] test_VotedShareCanReachZeroAndAllWithSettlementAtEveryStep() (gas: 40334412)\nLogs:\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n\nSuite result: ok. 3 passed; 0 failed; 0 skipped; finished in 5.47s (5.49s CPU time)\n\nRan 7 tests for test/LARPBurnerSettlement.t.sol:LARPBurnerSettlementTest\n[PASS] test_ParkedWaitingEthDoesNotConsumeTheBlocksAllowance() (gas: 1034032)\n[PASS] test_PreSyncCannotParkACrewFee() (gas: 945441)\n[PASS] test_PreSyncCannotParkARegistrationFee() (gas: 842669)\n[PASS] test_PreSyncCannotParkAResaleToll() (gas: 1239745)\n[PASS] test_PreSyncCannotParkTheHooklessRoute() (gas: 880379)\n[PASS] test_PreSyncCannotParkWaitingEthOrChooseTheBackup() (gas: 1179771)\n[PASS] test_PreSyncStillHonoursMinImdAndRollsBackTheAllowance() (gas: 675781)\nSuite result: ok. 7 passed; 0 failed; 0 skipped; finished in 5.48s (8.16ms CPU time)\n\nRan 2 tests for test/LARPLinks.invariant.t.sol:LARPLinksLifecycleInvariantTest\n[PASS]\nLARPLinksLifecycleInvariantTest invariants:\n[PASS] invariant_CardsFollowTheCurrentHolderAndSocialState\n[PASS] invariant_CrewFeesAreForwardedAndEthIsConserved\n[PASS] invariant_CrewMembershipCountsAndNamesAgree\n[PASS] invariant_FriendshipIsASymmetricSimpleGraph\n LARPLinksLifecycleInvariantTest invariants (runs: 256, calls: 16384, reverts: 0)\n\n╭------------------------+--------------+-------+---------+----------╮\n| Contract               | Selector     | Calls | Reverts | Discards |\n+====================================================================+\n| SocialLifecycleHandler | changeAgent  | 1760  | 0       | 0        |\n|------------------------+--------------+-------+---------+----------|\n| SocialLifecycleHandler | found        | 1867  | 0       | 0        |\n|------------------------+--------------+-------+---------+----------|\n| SocialLifecycleHandler | friendship   | 3677  | 0       | 0        |\n|------------------------+--------------+-------+---------+----------|\n| SocialLifecycleHandler | invite       | 1760  | 0       | 0        |\n|------------------------+--------------+-------+---------+----------|\n| SocialLifecycleHandler | joinOrLeave  | 1914  | 0       | 0        |\n|------------------------+--------------+-------+---------+----------|\n| SocialLifecycleHandler | manage       | 1800  | 0       | 0        |\n|------------------------+--------------+-------+---------+----------|\n| SocialLifecycleHandler | sellIdentity | 1747  | 0       | 0        |\n|------------------------+--------------+-------+---------+----------|\n| SocialLifecycleHandler | unauthorized | 1859  | 0       | 0        |\n╰------------------------+--------------+-------+---------+----------╯\n\n[PASS] test_HandlerExercisesInvitationsSuccessionAndNameReuse() (gas: 4223544)\nSuite result: ok. 2 passed; 0 failed; 0 skipped; finished in 34.08s (34.07s CPU time)\n\nRan 2 tests for test/IMDNames.invariant.t.sol:IMDNamesLifecycleInvariantTest\n[PASS]\nIMDNamesLifecycleInvariantTest invariants:\n[PASS] invariant_LiveLinksRoundTripAndRequireBothAssets\n[PASS] invariant_NameFeesAreForwardedAndEthIsConserved\n[PASS] invariant_NftBalancesEqualTheIndependentOwnershipLedger\n[PASS] invariant_OnlyTheLastPayingHolderHasAFreeLink\n[PASS] invariant_RecordsAndAgentsFollowTheirRecordedHolder\n IMDNamesLifecycleInvariantTest invariants (runs: 256, calls: 16384, reverts: 0)\n\n╭-----------------------+-------------------+-------+---------+----------╮\n| Contract              | Selector          | Calls | Reverts | Discards |\n+========================================================================+\n| NamesLifecycleHandler | changeAgent       | 1474  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | linkName          | 3062  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | refusePayment     | 1458  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | registerName      | 1408  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | resign            | 1521  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | setTextAndPrimary | 1506  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | transferIdentity  | 1496  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | transferName      | 1485  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | unauthorized      | 1505  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | unlinkName        | 1469  | 0       | 0        |\n╰-----------------------+-------------------+-------+---------+----------╯\n\n[PASS] test_HandlerExercisesPaidResalesAndRejectsFailures() (gas: 4218874)\nSuite result: ok. 2 passed; 0 failed; 0 skipped; finished in 35.96s (35.94s CPU time)\n\nRan 1 test for test/LARP.invariant.t.sol:LARPInvariantTest\n[PASS]\nLARPInvariantTest invariants:\n[PASS] invariant_LiveMeansThePlacerHoldsIt\n[PASS] invariant_NoMoreLiveCopiesThanHeld\n[PASS] invariant_OneTokenOneSpot\n LARPInvariantTest invariants (runs: 128, calls: 8192, reverts: 0)\n\n╭-------------+--------------+-------+---------+----------╮\n| Contract    | Selector     | Calls | Reverts | Discards |\n+=========================================================+\n| LarpHandler | equip1155    | 1184  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | equip721     | 1207  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveCopy     | 1175  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveIdentity | 1145  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveMask     | 1168  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | setFace      | 1122  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | takeOff      | 1191  | 0       | 0        |\n╰-------------+--------------+-------+---------+----------╯\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 37.67s (37.65s CPU time)\n\nRan 30 test suites in 37.68s (122.87s CPU time): 321 tests passed, 0 failed, 13 skipped (334 total tests)\n","passed":true},{"durationMs":175,"exitCode":0,"name":"source-index","output":"{\"v\":1,\"entryPoints\":[\"IMDNames.approve(address,uint256)\",\"IMDNames.execute(bytes32)\",\"IMDNames.link(uint256,uint256,uint256)\",\"IMDNames.linkWithImd(uint256,uint256,uint256)\",\"IMDNames.lockRenderer()\",\"IMDNames.onNoVerdict(bytes32,uint8,bytes32,uint16,uint16,bytes)\",\"IMDNames.onVerdict(bytes32,(bytes32,uint256,bytes32,uint8,bytes,uint256,uint64,uint64,bytes32,bytes32,uint16,uint16,uint16,uint64,uint64),bytes)\",\"IMDNames.propose((uint64,uint64,uint64,uint64,uint16),uint256)\",\"IMDNames.register(bytes32,address,uint256)\",\"IMDNames.registerWithImd(bytes32,address,uint256)\",\"IMDNames.safeTransferFrom(address,address,uint256)\",\"IMDNames.safeTransferFrom(address,address,uint256,bytes)\",\"IMDNames.setApprovalForAll(address,bool)\",\"IMDNames.setArtist(address)\",\"IMDNames.setPrimary(uint256)\",\"IMDNames.setRenderer(address)\",\"IMDNames.setText(uint256,string,string)\",\"IMDNames.transferFrom(address,address,uint256)\",\"IMDNames.unlink(uint256)\",\"LARP.clearFace(uint256)\",\"LARP.equip(uint256,uint256,address,uint256,uint8)\",\"LARP.resignAgent(uint256)\",\"LARP.setAgent(uint256,address)\",\"LARP.setAgentBySig(uint256,address,uint256,bytes)\",\"LARP.setFace(uint256,address,uint256)\",\"LARP.unequip(uint256,uint256)\",\"LARPBurner.burn(uint256)\",\"LARPBurner.burnImd()\",\"LARPBurner.receive()\",\"LARPBurner.unlockCallback(bytes)\",\"LARPLinks.disband(uint256)\",\"LARPLinks.foundCrew(uint256,bytes32,bool,uint256)\",\"LARPLinks.foundCrewWithImd(uint256,bytes32,bool,uint256)\",\"LARPLinks.fren(uint256,uint256)\",\"LARPLinks.invite(uint256,uint256,bool)\",\"LARPLinks.join(uint256,uint256)\",\"LARPLinks.kick(uint256,uint256)\",\"LARPLinks.leave(uint256)\",\"LARPLinks.passCaptain(uint256,uint256)\",\"LARPLinks.proveAlloc(uint64,uint256,address,uint256,bytes32[])\",\"LARPLinks.setOpen(uint256,bool)\",\"LARPLinks.unfren(uint256,uint256)\"],\"files\":{\".gitignore\":4,\"ADAPTATION.md\":189,\"AUDIT-COVERAGE.md\":199,\"AUDIT.md\":323,\"README.md\":235,\"foundry.toml\":34,\"script/place/gen.py\":122,\"src/IIMDNames.sol\":112,\"src/ILARP.sol\":120,\"src/IMDNames.sol\":358,\"src/LARP.sol\":330,\"src/LARPBurner.sol\":404,\"src/LARPLinks.sol\":457,\"src/Labels.sol\":53,\"src/SafeReads.sol\":63,\"src/SwarmPrices.sol\":370,\"src/place/LARPPlan.sol\":38,\"src/place/PlaceLARP.sol\":148,\"test/Base.sol\":328,\"test/ConstructorMatrix.t.sol\":168,\"test/ENTRYPOINT-COVERAGE.md\":212,\"test/IMDNames.invariant.t.sol\":456,\"test/IMDNames.t.sol\":481,\"test/IMDNamesEdges.t.sol\":458,\"test/LARP.invariant.t.sol\":184,\"test/LARP.t.sol\":324,\"test/LARPAgents.t.sol\":269,\"test/LARPBurner.invariant.t.sol\":495,\"test/LARPBurner.t.sol\":585,\"test/LARPBurnerEdges.t.sol\":459,\"test/LARPBurnerFloorEdges.t.sol\":103,\"test/LARPBurnerPairLeg.t.sol\":215,\"test/LARPBurnerSettlement.t.sol\":155,\"test/LARPBurnerShareEdges.t.sol\":107,\"test/LARPEdges.t.sol\":340,\"test/LARPItems.t.sol\":236,\"test/LARPLinks.invariant.t.sol\":398,\"test/LARPLinks.t.sol\":515,\"test/LARPLinksEdges.t.sol\":459,\"test/Launch.t.sol\":148,\"test/MainnetFork.t.sol\":371,\"test/Mocks.sol\":89,\"test/PaymentAtomicity.t.sol\":274,\"test/Placement.t.sol\":360,\"test/PlacementEdges.t.sol\":202,\"test/SwarmPrices.invariant.t.sol\":409,\"test/SwarmPrices.t.sol\":608,\"test/SwarmPricesEdges.t.sol\":353,\"test/SwarmShareSettlement.invariant.t.sol\":252,\"test/fixtures/allocs.json\":118},\"excluded\":[\"lib/\",\"node_modules/\"],\"truncated\":false}","passed":true}],"detail":"all checks passed","evaluation":"checks","profile":"foundry","status":"accepted","submissionHash":"126792b82b8dc2cd45a2f768bee53acbeca639b5fcaecf70aec7c82c8202b527","verifiedTreeHash":"960068fc370e0b350dff4a3d6aee4b0997c02165","verifierVersion":"0.1.0+7ff5db2c"},{"checks":[{"durationMs":176784,"exitCode":0,"name":"build","output":"Compiling 110 files with Solc 0.8.26\nSolc 0.8.26 finished in 176.57s\nCompiler run successful!\nwarning[boolean-cst]: misuse of a boolean constant\n   ╭▸ src/place/PlaceLARP.sol:49:98\n   │\n49 │             if (_proxy(LARPPlan.CREATEX, g).code.length == 0 && at.code.length == 0) return (at, true);\n   │                                                                                                  ━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:220:33\n    │\n220 │         if (at == 0) return (0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:228:42\n    │\n228 │         if (owner == address(0)) return (false, address(0), 0, false);\n    │                                          ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[unsafe-typecast]: typecast can truncate values\n   ╭▸ src/SafeReads.sol:21:46\n   │\n21 │         return ok && w >> 160 == 0 ? address(uint160(w)) : address(0);\n   │                                              ━━━━━━━━━━\n   │\n   ├ note: consider disabling this lint if you're certain the cast is safe\n   │       \n   │       // casting to 'uint160' is safe because [explain why]\n   │       // forge-lint: disable-next-line(unsafe-typecast)\n   │       \n   │       \n   ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:111:33\n    │\n111 │         if (at == 0) return (0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:120:64\n    │\n120 │         if (holder == address(0) || who == address(0)) return (false, holder);\n    │                                                                ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:121:36\n    │\n121 │         if (who == holder) return (true, holder);\n    │                                    ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:228:64\n    │\n228 │         if (owner == address(0)) return (false, address(0), 0, false);\n    │                                                                ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:240:33\n    │\n240 │         if (label == 0) return (false, address(0), 0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:240:55\n    │\n240 │         if (label == 0) return (false, address(0), 0, false);\n    │                                                       ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n   ╭▸ src/SafeReads.sol:47:40\n   │\n47 │         (bool ok, bytes memory data) = target.staticcall{gas: gasCap}(call);\n   │                                        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:265:36\n    │\n265 │         if (at == 0) return (0, 0, false);\n    │                                    ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n   ╭▸ src/place/PlaceLARP.sol:51:48\n   │\n51 │         return (_create3(address(this), salt), false);\n   │                                                ━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:247:37\n    │\n247 │         if (at == 0) return (0, \"\", false);\n    │                                     ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:320:25\n    │\n320 │                 return (true, r);\n    │                         ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:323:25\n    │\n323 │                 return (false, \"\");\n    │                         ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:329:21\n    │\n329 │             return (true, r);\n    │                     ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:331:21\n    │\n331 │             return (false, \"\");\n    │                     ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:208:9\n    │\n208 │         LARPBurner(payable(BURNER)).burn{value: msg.value}(minImd);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n   ╭▸ src/LARP.sol:78:13\n   │\n78 │         if (block.timestamp > deadline) revert Expired();\n   │             ━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARP.sol:138:9\n    │\n138 │         emit AgentSet(imdId, holder, agent);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:136:9\n    │\n136 │         address pairHook,\n    │         ━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:137:9\n    │\n137 │         address names\n    │         ━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:130:9\n    │\n130 │         address pool4Hook,\n    │         ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n    ╭▸ src/LARPBurner.sol:162:13\n    │\n162 │             n.staticcall{gas: SHARE_GAS}(abi.encodeWithSelector(IShareSource.imd6900ShareBps.selector));\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:172:16\n    │\n172 │         return int24(s);\n    │                ━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int24' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n   ╭▸ src/IMDNames.sol:67:63\n   │\n67 │     constructor(address identity, ILARP larp, address burner, address artist_, address intake, address oracleSigner)\n   │                                                               ━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:109:9\n    │\n109 │         LARPBurner(payable(BURNER)).burn{value: price}(minImd);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:123:24\n    │\n123 │         if (toll != 0) LARPBurner(payable(BURNER)).burn{value: toll}(minImd);\n    │                        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/LARPBurner.sol:319:17\n    │\n319 │             try POOL_MANAGER.unlock(data) returns (bytes memory r) {\n    │                 ━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/LARPBurner.sol:328:13\n    │\n328 │         try POOL_MANAGER.unlock{gas: LEG_GAS}(data) returns (bytes memory r) {\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:224:21\n    │\n224 │                     emit Bought(eth, imd, route);\n    │                     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:228:27\n    │\n228 │             if (imd == 0) emit Parked(eth);\n    │                           ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:302:9\n    │\n302 │         emit Burned(rest, share, burned6900);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[require-revert-in-loop]: `require` or `revert` inside a loop\n    ╭▸ src/LARPBurner.sol:322:49\n    │\n322 │                 if (gasleft() <= gasBefore / 4) revert TooLittleGas();\n    │                                                 ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/require-revert-in-loop\n\nwarning[require-revert-in-loop]: `require` or `revert` inside a loop\n    ╭▸ src/LARPBurner.sol:327:61\n    │\n327 │         if (gasleft() < LEG_GAS + LEG_GAS / 63 + AFTER_GAS) revert TooLittleGas();\n    │                                                             ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/require-revert-in-loop\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:207:39\n    │\n207 │         uint256 spent = _burnBlock == uint64(block.number) ? _burnedInBlock : 0;\n    │                                       ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:221:38\n    │\n221 │                         _burnBlock = uint64(block.number);\n    │                                      ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:222:42\n    │\n222 │                         _burnedInBlock = uint192(spent + waiting);\n    │                                          ━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint192' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:159:45\n    │\n159 │         return ok && answer.length >= 32 && bytes4(abi.decode(answer, (bytes32))) == 0x1626ba7e;\n    │                                             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes4' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:327:22\n    │\n327 │         (bool ok,) = LARP.canAct(c.captain, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPLinks.sol:342:39\n    │\n342 │         address distributor = address(uint160(w));\n    │                                       ━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint160' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPLinks.sol:380:31\n    │\n380 │             j.token = address(uint160(t));\n    │                               ━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint160' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:443:9\n    │\n443 │         (, c.faceCollection, c.faceTokenId, c.faceLive) = LARP.faceOf(imdId);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:88:13\n    │\n 88 │ ┏             abi.encodePacked(\n 89 │ ┃                 type(LARPBurner).creationCode,\n 90 │ ┃                 abi.encode(\n 91 │ ┃                     LARPPlan.POOL_MANAGER,\n    ‡ ┃\n104 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:454:22\n    │\n454 │         (bool ok,) = LARP.canAct(imdId, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:108:36\n    │\n108 │         _place(LARPPlan.LARP_SALT, abi.encodePacked(type(LARP).creationCode, abi.encode(LARPPlan.IDENTITY)), l, lx);\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:111:13\n    │\n111 │ ┏             abi.encodePacked(\n112 │ ┃                 type(IMDNames).creationCode,\n113 │ ┃                 abi.encode(LARPPlan.IDENTITY, l, b, LARPPlan.ARTIST, LARPPlan.INTAKE, LARPPlan.ORACLE_SIGNER)\n114 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/LARP.sol:310:15\n    │\n310 │             ++digits;\n    │               ━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:314:36\n    │\n314 │             out[--digits] = bytes1(uint8(48 + value % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:133:13\n    │\n133 │ ┏             abi.encodePacked(\n134 │ ┃                 type(LARPLinks).creationCode,\n135 │ ┃                 abi.encode(\n136 │ ┃                     LARPPlan.IDENTITY,\n    ‡ ┃\n142 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:325:22\n    │\n325 │             out[i] = bytes16(\"0123456789abcdef\")[v & 15];\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes16' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[uninitialized-local]: local variable is read before being initialized\n   ╭▸ src/Labels.sol:23:16\n   │\n23 │         while (n < 32 && label[n] != 0) ++n;\n   │                ━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:137:9\n    │\n137 │         emit NameRegistered(tokenId, label, to, price);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n   ╭▸ src/SwarmPrices.sol:87:38\n   │\n87 │     bytes32 public constant ACTION = bytes32(\"oracle.request@oracle-1\");\n   │                                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ├ note: consider disabling this lint if you're certain the cast is safe\n   │       \n   │       // casting to 'bytes32' is safe because [explain why]\n   │       // forge-lint: disable-next-line(unsafe-typecast)\n   │       \n   │       \n   ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:153:13\n    │\n153 │             emit NameUnlinked(old, imdId);\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:158:13\n    │\n158 │             emit NameUnlinked(tokenId, was - 1);\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:162:9\n    │\n162 │         emit NameLinked(tokenId, imdId, holder, toll);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/SwarmPrices.sol:137:33\n    │\n137 │     constructor(address intake, address oracleSigner, Prices memory start) {\n    │                                 ━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/SwarmPrices.sol:137:17\n    │\n137 │     constructor(address intake, address oracleSigner, Prices memory start) {\n    │                 ━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:185:9\n    │\n185 │         emit NameUnlinked(tokenId, imdId);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:181:22\n    │\n181 │         (bool ok,) = LARP.canAct(imdId, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:261:43\n    │\n261 │                 pair, SwapParams(imdIs0, -int256(amount), imdIs0 ? MIN_PRICE_LIMIT : MAX_PRICE_LIMIT), \"\"\n    │                                           ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:264:27\n    │\n264 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                           ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:264:49\n    │\n264 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                 ━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:264:67\n    │\n264 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                                   ━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:264:82\n    │\n264 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                                                  ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:265:30\n    │\n265 │             if (imdDelta != -int128(int256(amount)) || outDelta <= 0) revert Unfilled();\n    │                              ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:265:37\n    │\n265 │             if (imdDelta != -int128(int256(amount)) || outDelta <= 0) revert Unfilled();\n    │                                     ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPBurner.sol:268:13\n    │\n268 │             POOL_MANAGER.settle();\n    │             ━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:269:27\n    │\n269 │             uint256 out = uint128(outDelta);\n    │                           ━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:277:61\n    │\n277 │         int256 d = POOL_MANAGER.swap(key, SwapParams(true, -int256(amount), MIN_PRICE_LIMIT), \"\");\n    │                                                             ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:278:27\n    │\n278 │         int128 ethDelta = int128(d >> 128);\n    │                           ━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:279:25\n    │\n279 │         int128 bought = int128(d);\n    │                         ━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:280:26\n    │\n280 │         if (ethDelta != -int128(int256(amount)) || bought <= 0) revert Unfilled();\n    │                          ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:280:33\n    │\n280 │         if (ethDelta != -int128(int256(amount)) || bought <= 0) revert Unfilled();\n    │                                 ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPBurner.sol:283:9\n    │\n283 │         POOL_MANAGER.settle{value: amount}();\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:284:47\n    │\n284 │         POOL_MANAGER.take(IMD, address(this), uint128(bought));\n    │                                               ━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:285:27\n    │\n285 │         return abi.encode(uint256(uint128(bought)));\n    │                           ━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:285:35\n    │\n285 │         return abi.encode(uint256(uint128(bought)));\n    │                                   ━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/LARPBurner.sol:302:34\n    │\n302 │         emit Burned(rest, share, burned6900);\n    │                                  ━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/SwarmPrices.sol:176:9\n    │\n176 │         emit Proposed(requestId, number, msg.sender, next);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/IMDNames.sol:306:26\n    │\n306 │     function setRenderer(address renderer_) external {\n    │                          ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n    ╭▸ src/LARPBurner.sol:328:13\n    │\n328 │         try POOL_MANAGER.unlock{gas: LEG_GAS}(data) returns (bytes memory r) {\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/IMDNames.sol:314:24\n    │\n314 │     function setArtist(address artist_) external {\n    │                        ━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:189:16\n    │\n189 │             && block.timestamp <= a.expiresAt && a.answer.length == 32 && uint256(bytes32(a.answer)) == 1;\n    │                ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/SwarmPrices.sol:192:9\n    │\n192 │         emit Verdict(requestId, approved, a.agreed, a.panelSize);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:189:83\n    │\n189 │             && block.timestamp <= a.expiresAt && a.answer.length == 32 && uint256(bytes32(a.answer)) == 1;\n    │                                                                                   ━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes32' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:191:23\n    │\n191 │         p.decidedAt = uint64(block.timestamp);\n    │                       ━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:209:44\n    │\n209 │         if (p.status != Status.Approved || block.timestamp > p.decidedAt + EXECUTE_WINDOW) revert NotApproved();\n    │                                            ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:211:32\n    │\n211 │         if (lastChange != 0 && block.timestamp < lastChange + COOLDOWN) revert Cooling();\n    │                                ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:215:22\n    │\n215 │         lastChange = uint64(block.timestamp);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:340:36\n    │\n340 │             digits[i - 1] = bytes1(uint8(48 + frac % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/SwarmPrices.sol:356:15\n    │\n356 │             ++digits;\n    │               ━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:360:36\n    │\n360 │             out[--digits] = bytes1(uint8(48 + value % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/LARPAgents.t.sol:139:28\n    │\n139 │         uint256 deadline = block.timestamp + 1 hours;\n    │                            ━━━━━━━━━━━━━━━\n140 │         bytes memory sig = _sign(ownerKey, 7, agent, owner, 0, deadline);\n141 │         vm.warp(deadline + 1);\n    │         ───────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:203:60\n    │\n203 │             _attest(id, true, 0, \"\", block.chainid, uint64(block.timestamp + 1 days));\n    │                                                            ━━━━━━━━━━━━━━━\n    ‡\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:54:30\n    │\n 54 │             issuedAt: uint64(block.timestamp),\n    │                              ━━━━━━━━━━━━━━━\n    ‡\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:209:17\n    │\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────━━━━━━━━━━━━━━━─────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:203:60\n    │\n203 │             _attest(id, true, 0, \"\", block.chainid, uint64(block.timestamp + 1 days));\n    │                                                            ━━━━━━━━━━━━━━━\n    ‡\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ───────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:54:30\n    │\n 54 │             issuedAt: uint64(block.timestamp),\n    │                              ━━━━━━━━━━━━━━━\n    ‡\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ───────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:236:17\n    │\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ────────━━━━━━━━━━━━━━━────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\n","passed":true},{"durationMs":29794,"exitCode":0,"name":"test","output":"No files changed, compilation skipped\n\nRan 2 tests for test/Placement.t.sol:PlacementForkTest\n[SKIP] test_fork_ANameBurnsTheCanonicalWay() (gas: 0)\n[SKIP] test_fork_LandsAt6900ThroughTheRealCreateX() (gas: 0)\nSuite result: ok. 0 passed; 0 failed; 2 skipped; finished in 268.81µs (63.88µs CPU time)\n\nRan 11 tests for test/MainnetFork.t.sol:MainnetForkTest\n[SKIP] test_ACrewBuysAndBurnsRealIMD() (gas: 0)\n[SKIP] test_ANameBuysRealIMDOnPool4AndBurnsIt() (gas: 0)\n[SKIP] test_ANameChangesHandsAndBurns() (gas: 0)\n[SKIP] test_ANamePaidInRealImd() (gas: 0)\n[SKIP] test_APriceProposalThroughIMDsRealIntake() (gas: 0)\n[SKIP] test_AnAgentRunsTheTreasurysIdentity() (gas: 0)\n[SKIP] test_AnIdentityWearsAWorkerFren() (gas: 0)\n[SKIP] test_RealProofsRefuseTampering() (gas: 0)\n[SKIP] test_TheHooklessPoolTakesWhatPool4Cant() (gas: 0)\n[SKIP] test_TheRealJeetBoard() (gas: 0)\n[SKIP] test_TheTreasurysCard() (gas: 0)\nSuite result: ok. 0 passed; 0 failed; 11 skipped; finished in 344.14µs (113.27µs CPU time)\n\nRan 7 tests for test/ConstructorMatrix.t.sol:ConstructorMatrixTest\n[PASS] test_AllSixConstructorsAreNonpayable() (gas: 10208070)\n[PASS] test_AllThreeSpacingFieldsRejectValuesAboveV4sMaximum() (gas: 1901952)\n[PASS] test_EachRequiredBurnerAddressRejectsZeroIndependently() (gas: 624730)\n[PASS] test_EachRequiredLinksAddressRejectsZeroIndependently() (gas: 1335136)\n[PASS] test_EachRequiredNamesAddressRejectsZeroIndependently() (gas: 1527130)\n[PASS] test_RegistryRejectsZeroIdentityAndStoresThePlanIdentity() (gas: 1782307)\n[PASS] test_V4MinimumAndMaximumSpacingsSurviveTheUnsignedArguments() (gas: 1640037)\nSuite result: ok. 7 passed; 0 failed; 0 skipped; finished in 2.09ms (4.47ms CPU time)\n\nRan 14 tests for test/LARPItems.t.sol:LARPItemsTest\n[PASS] test_AFaceBecomesAnItem() (gas: 321185)\n[PASS] test_AnItemBecomesAnotherIdentitysFace() (gas: 306295)\n[PASS] test_EquipAnERC1155Copy() (gas: 195226)\n[PASS] test_EquipAnERC721() (gas: 228623)\n[PASS] test_OneCopyOnePlacement() (gas: 372050)\n[PASS] test_ReequippingTheSameCopyInTheSameSlot() (gas: 213412)\n[PASS] test_RefusedItems() (gas: 220243)\n[PASS] test_ReplacingAnItemFreesTheOldOne() (gas: 291522)\n[PASS] test_SellingACopyDarkensItsPlacementsUntilOneComesOff() (gas: 456264)\n[PASS] test_SellingTheIdentityDarkensItsItems() (gas: 360711)\n[PASS] test_SlotsAreOneToEight() (gas: 224747)\n[PASS] test_StrangersCantTakeItemsOff() (gas: 174966)\n[PASS] test_TheNewOwnerClearsTheOldItems() (gas: 343634)\n[PASS] test_ThePlacerTakesItsCopyBackAfterSellingTheIdentity() (gas: 399525)\nSuite result: ok. 14 passed; 0 failed; 0 skipped; finished in 2.84ms (1.87ms CPU time)\n\nRan 14 tests for test/LARPAgents.t.sol:LARPAgentsTest\n[PASS] test_AContractWalletSignsWithERC1271() (gas: 431060)\n[PASS] test_ASignatureWorksOnce() (gas: 230440)\n[PASS] test_AnAgentCantNameAgentsOrTheWallet() (gas: 195893)\n[PASS] test_AnAgentDressesTheIdentityWithTheOwnersNFTs() (gas: 396334)\n[PASS] test_AnAgentLapsesOnASale() (gas: 317701)\n[PASS] test_AnAgentLinksTheOwnersNameAndSetsTexts() (gas: 985791)\n[PASS] test_AnAgentResigns() (gas: 193582)\n[PASS] test_AnAgentRunsFrensAndCrews() (gas: 1230841)\n[PASS] test_AnyAgentChangeVoidsOutstandingSignatures() (gas: 188002)\n[PASS] test_BadSignatures() (gas: 364692)\n[PASS] test_OnlyTheOwnerSetsTheAgent() (gas: 40977)\n[PASS] test_SignaturesExpire() (gas: 49228)\n[PASS] test_TheOwnerConnectsAnAgentInOneCall() (gas: 188975)\n[PASS] test_TheOwnerSignsTheAgentSends() (gas: 176447)\nSuite result: ok. 14 passed; 0 failed; 0 skipped; finished in 7.48ms (4.44ms CPU time)\n\nRan 24 tests for test/LARP.t.sol:LARPFaceTest\n[PASS] testFuzz_OnlyTheHolderOfBothSetsAFace(address,uint256,uint256) (runs: 256, μ: 55784, ~: 56425)\nLogs:\n  Bound result 0\n  Bound result 9\n\n[PASS] test_AFaceComesBackWithBothTokens() (gas: 220934)\n[PASS] test_AMaskMovesToTheIdentityThatPutsItOn() (gas: 323750)\n[PASS] test_AvatarFormat() (gas: 249931)\n[PASS] test_ChangingMasksFreesTheOldOne() (gas: 274960)\n[PASS] test_ClearFace() (gas: 200738)\n[PASS] test_ClearingNoFaceDoesNothing() (gas: 36612)\n[PASS] test_FaceURIFallsBackOnABrokenTokenURI() (gas: 2152591)\n[PASS] test_OnlyTheIdentitysOwnerClears() (gas: 173845)\n[PASS] test_PuttingTheSameMaskOnAgain() (gas: 240094)\n[PASS] test_RefusesAMaskThatIsNotYours() (gas: 49187)\n[PASS] test_RefusesAnIdentityAsAMask() (gas: 41585)\n[PASS] test_RefusesAnIdentityThatDoesNotExist() (gas: 41653)\n[PASS] test_RefusesAnIdentityThatIsNotYours() (gas: 43653)\n[PASS] test_RefusesWhatIsNotAnNFT() (gas: 510494)\n[PASS] test_SellingTheIdentityTakesTheFaceDown() (gas: 252506)\n[PASS] test_SellingTheMaskTakesTheFaceDown() (gas: 223250)\n[PASS] test_SetFace() (gas: 266231)\n[PASS] test_SupportsInterface() (gas: 27637)\n[PASS] test_TheIdentitysNewOwnerClearsTheOldFace() (gas: 225470)\n[PASS] test_TheNewHolderOfAMaskTakesItOff() (gas: 321718)\n[PASS] test_TheNewOwnerMustChooseAgain() (gas: 327564)\n[PASS] test_WearerOfAnUnwornMask() (gas: 14020)\n[PASS] test_ZeroIdentityRefused() (gas: 4446)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 10.63ms (12.07ms CPU time)\n\nRan 23 tests for test/IMDNamesEdges.t.sol:IMDNamesEdgesTest\n[PASS] test_APrimaryWithoutANameIsLiveAndNameless() (gas: 182236)\n[PASS] test_ARendererThatAnswersNothingFallsBack() (gas: 383627)\n[PASS] test_ASaleDarkensTheLinkAndTheTextStays() (gas: 286579)\n[PASS] test_AStrangerCannotUnlink() (gas: 160730)\n[PASS] test_AnAgentLinksUnlinksAndWrites() (gas: 486024)\n[PASS] test_ApprovalsAndOperatorTransfers() (gas: 452506)\n[PASS] test_Constants() (gas: 191514)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 15761)\n[PASS] test_LockingIsIdempotentAndKeepsTheRenderer() (gas: 292103)\n[PASS] test_PrimaryAndTextRefusals() (gas: 147701)\n[PASS] test_ReadingNames() (gas: 64773)\n[PASS] test_RegisterRefusesLessThanThePrice() (gas: 216901)\n[PASS] test_RegisterWithAFloorTheBurnCannotMeet() (gas: 224254)\n[PASS] test_RegisterWithImdNeedsAnAllowance() (gas: 622307)\n[PASS] test_ResolveNameSpellings() (gas: 150173)\n[PASS] test_RoyaltyRounding() (gas: 35079)\n[PASS] test_SafeTransfersCheckTheReceiver() (gas: 603375)\n[PASS] test_TheArtistRenouncesAndTheArtIsFinal() (gas: 154258)\n[PASS] test_TheCardOfAnUnlinkedName() (gas: 2382338)\n[PASS] test_TheLongestAndShortestNames() (gas: 1245197)\n[PASS] test_TheTollInImdRespectsMaxImd() (gas: 1135610)\n[PASS] test_TransferRules() (gas: 144769)\n[PASS] test_UnlinkingNothingDoesNothing() (gas: 37821)\nSuite result: ok. 23 passed; 0 failed; 0 skipped; finished in 11.91ms (9.18ms CPU time)\n\nRan 7 tests for test/SwarmPrices.t.sol:SwarmShareTest\n[PASS] test_AndDownToNothing() (gas: 7807536)\n[PASS] test_ShareGuardrails() (gas: 5662641)\n[PASS] test_StartsAt6Point9AndTheBurnerReadsItFromIMDNames() (gas: 261284)\n[PASS] test_TheBurnerFallsBackTo6Point9() (gas: 429031)\n[PASS] test_TheQuestionNamesTheShare() (gas: 3495923)\n[PASS] test_TheSwarmMovesTheShareAndTheBurnerFollows() (gas: 2824892)\n[PASS] test_UpToAllOfIt() (gas: 7900169)\nSuite result: ok. 7 passed; 0 failed; 0 skipped; finished in 15.04ms (11.89ms CPU time)\n\nRan 7 tests for test/LARPBurnerSettlement.t.sol:LARPBurnerSettlementTest\n[PASS] test_ParkedWaitingEthDoesNotConsumeTheBlocksAllowance() (gas: 1404858)\n[PASS] test_PreSyncCannotParkACrewFee() (gas: 1316172)\n[PASS] test_PreSyncCannotParkARegistrationFee() (gas: 1213400)\n[PASS] test_PreSyncCannotParkAResaleToll() (gas: 1981207)\n[PASS] test_PreSyncCannotParkTheHooklessRoute() (gas: 1251240)\n[PASS] test_PreSyncCannotParkWaitingEthOrChooseTheBackup() (gas: 1176301)\n[PASS] test_PreSyncStillHonoursMinImdAndRollsBackTheAllowance() (gas: 1046616)\nSuite result: ok. 7 passed; 0 failed; 0 skipped; finished in 18.38ms (10.22ms CPU time)\n\nRan 15 tests for test/LARPEdges.t.sol:LARPEdgesTest\n[PASS] testFuzz_WearerOfRoundTripsForAnyIdentityId(uint256,uint8) (runs: 256, μ: 220198, ~: 220684)\nLogs:\n  Bound result 5962\n  Bound result 8\n\n[PASS] test_ACopyPlacedTwiceIsCountedTwice() (gas: 341053)\n[PASS] test_ASignatureFromAnotherChainIsRefused() (gas: 83326)\n[PASS] test_AgentsOfNothing() (gas: 146135)\n[PASS] test_AnAgentTakesOffThePreviousOwnersItems() (gas: 350579)\n[PASS] test_ConstantsAndDomain() (gas: 57230)\n[PASS] test_ContractWalletsThatRefuseOrMumble() (gas: 462979)\n[PASS] test_EmptySpots() (gas: 141020)\n[PASS] test_OddSignatureBytes() (gas: 342349)\n[PASS] test_OneAgentForTwoIdentities() (gas: 326950)\n[PASS] test_RemovingAnAgentBumpsTheNonce() (gas: 371695)\n[PASS] test_ResigningDoesNotBumpTheNonce() (gas: 288556)\n[PASS] test_SupportsInterfaceIsPure() (gas: 15273)\n[PASS] test_TakingOffAnEmptySlotIsSilent() (gas: 61582)\n[PASS] test_ThePlacerTakesOffWhatItPlacedAfterSellingTheIdentity() (gas: 426342)\nSuite result: ok. 15 passed; 0 failed; 0 skipped; finished in 19.27ms (18.28ms CPU time)\n\nRan 24 tests for test/LARPLinks.t.sol:LARPLinksTest\n[PASS] test_AGasHungryTokenCantSinkTheBoard() (gas: 1737463)\n[PASS] test_AnInnerNodeIsNotALeaf() (gas: 1448373)\n[PASS] test_AnUnreadableTokenCountsAsHeld() (gas: 1784660)\n[PASS] test_BadAllocations() (gas: 1754999)\n[PASS] test_CaptainsRun() (gas: 963173)\n[PASS] test_Card() (gas: 1645098)\n[PASS] test_CrewFoundingRules() (gas: 916902)\n[PASS] test_Disband() (gas: 1551949)\n[PASS] test_FoundACrewWithImd() (gas: 1180619)\n[PASS] test_FoundingACrewBurnsIMD() (gas: 749420)\n[PASS] test_FrenRules() (gas: 383139)\n[PASS] test_FrensPassWithTheIdentity() (gas: 302573)\n[PASS] test_FrensTakeTwo() (gas: 266329)\n[PASS] test_JeetsAreReadLive() (gas: 2364129)\n[PASS] test_JeetsInPages() (gas: 8424463)\n[PASS] test_OpenAndClosedCrews() (gas: 1696901)\n[PASS] test_PassTheCaptaincy() (gas: 948251)\n[PASS] test_ProveAnAllocation() (gas: 1534389)\n[PASS] test_RanksAcrossLaunches() (gas: 5184173)\n[PASS] test_TheCaptaincyPassesWithTheIdentity() (gas: 768169)\n[PASS] test_TheRankIsTheHoldersNow() (gas: 1748137)\n[PASS] test_Tiers() (gas: 80885)\n[PASS] test_Unfren() (gas: 271974)\n[PASS] test_WithdrawAndDeclineAsks() (gas: 244060)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 21.02ms (19.02ms CPU time)\n\nRan 4 tests for test/Launch.t.sol:LaunchTest\n[PASS] test_DeploysOnAFreshChain() (gas: 193241)\n[PASS] test_FitsOneTransaction() (gas: 25344)\nLogs:\n  launch gas, four creations: 8303\n\n[PASS] test_PassesTheAdmissionScan() (gas: 17796184)\n[PASS] test_UnderTheCodeSizeLimit() (gas: 11134)\nSuite result: ok. 4 passed; 0 failed; 0 skipped; finished in 40.82ms (40.76ms CPU time)\n\nRan 8 tests for test/PlacementEdges.t.sol:PlacementEdgesTest\n[PASS] testFuzz_MixedSquattersNeverChangeTheWiring(uint8,uint8) (runs: 64, μ: 10187022, ~: 10186346)\n[PASS] test_AllSixteenDestinationOccupancyCombinations() (gas: 163397975)\n[PASS] test_AllSixteenProxyOnlyOccupancyCombinations() (gas: 163459772)\n[PASS] test_CreateXReturningTheRightAddressWithoutCodeIsRefused() (gas: 412401)\n[PASS] test_EveryCreateXFailureRollsBackTheEntireLaunchAndCanRetry() (gas: 52708026)\n[PASS] test_PlaceLinksRequiresTheEarlierPlacement() (gas: 10374157)\n[PASS] test_PlacementAndApplicationsExposeNoOwnerOrUpgradeCalls() (gas: 10933004)\n[PASS] test_SecondLaunchCreatesItsOwnFourContracts() (gas: 20160127)\nSuite result: ok. 8 passed; 0 failed; 0 skipped; finished in 43.29ms (72.54ms CPU time)\n\nRan 24 tests for test/LARPLinksEdges.t.sol:LARPLinksEdgesTest\n[PASS] testFuzz_JeetBpsIsTheSoldShareOfTheAllocation(uint128,uint256,bool) (runs: 256, μ: 1665672, ~: 1535742)\nLogs:\n  Bound result 3474\n  Bound result 2571\n\n[PASS] testFuzz_TiersAreMonotoneInJeetPoints(uint256,uint256,uint256) (runs: 256, μ: 33064, ~: 33153)\nLogs:\n  Bound result 100\n  Bound result 21589\n  Bound result 979802\n\n[PASS] test_ACardWithALiveFace() (gas: 694335)\n[PASS] test_ADisbandedCrewIsGone() (gas: 995257)\n[PASS] test_ADistributorWithoutARootIsUnknown() (gas: 1411930)\n[PASS] test_ADistributorWithoutATokenCountsAsHeld() (gas: 1673522)\n[PASS] test_ALauncherAnsweringGarbageIsUnknown() (gas: 1533984)\n[PASS] test_AllocationBounds() (gas: 2897946)\n[PASS] test_AnAskSurvivesASaleOfEitherIdentity() (gas: 241341)\n[PASS] test_AnEmptyProofForASoloRound() (gas: 1509668)\n[PASS] test_AnIdentityNobodyHolds() (gas: 54774)\n[PASS] test_CaptainRules() (gas: 958767)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 13620)\n[PASS] test_CrewNamesAtTheEdges() (gas: 1430836)\n[PASS] test_Defaults() (gas: 177309)\n[PASS] test_FoundCrewWithImdRefusals() (gas: 1373283)\n[PASS] test_FoundCrewWithTheWrongValue() (gas: 364248)\n[PASS] test_InviteRules() (gas: 938730)\n[PASS] test_JoinLeaveRules() (gas: 1114710)\n[PASS] test_LaunchJeetPastTheEndReverts() (gas: 14394)\n[PASS] test_MembersCountFollowsEveryMove() (gas: 1096013)\n[PASS] test_TwoRoundsOfOneLaunchAreOneLevel() (gas: 1866769)\n[PASS] test_UnfrenClearsBothAsksAtOnce() (gas: 388582)\n[PASS] test_UnfrenWithNothingDoesNothing() (gas: 86806)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 50.46ms (83.90ms CPU time)\n\nRan 9 tests for test/Placement.t.sol:PlacementTest\n[PASS] test_ASaltUsedFirstIsNeverTaken() (gas: 10505351)\n[PASS] test_ArgumentsAsTheReadmeSays() (gas: 6240)\n[PASS] test_DeploysOnAFreshChain() (gas: 10038305)\n[PASS] test_FitsOneTransaction() (gas: 30974259)\nLogs:\n  the launch: gas, all in: 10989633\n  PlaceLARP initcode bytes: 39120\n  PlaceLinks initcode bytes: 12010\n\n[PASS] test_FreshChainFitsOneTransaction() (gas: 30694408)\nLogs:\n  the launch: gas, all in: 10932985\n  PlaceLARP initcode bytes: 39120\n  PlaceLinks initcode bytes: 12010\n\n[PASS] test_LandsWhereThePlanSays() (gas: 10319737)\n[PASS] test_PassesTheAdmissionScan() (gas: 42761993)\n[PASS] test_PlanFollowsFromTheSalts() (gas: 162797)\n[PASS] test_SameAddressesWhoeverRunsIt() (gas: 19914901)\nSuite result: ok. 9 passed; 0 failed; 0 skipped; finished in 55.04ms (143.47ms CPU time)\n\nRan 18 tests for test/SwarmPricesEdges.t.sol:SwarmPricesEdgesTest\n[PASS] testFuzz_TheGuardrailsAreExactlyTheDocumentedRule(uint64,uint64,uint64,uint64) (runs: 512, μ: 341670, ~: 60870)\nLogs:\n  Bound result 6676411726391504\n  Bound result 2800121725734695\n  Bound result 1255642554590168\n  Bound result 5319433\n\n[PASS] test_AFailureAfterAVerdictIsRefused() (gas: 2604143)\n[PASS] test_AVerdictExpiringThisSecondStillCounts() (gas: 2553440)\n[PASS] test_AnUnknownProposalIsNone() (gas: 18765)\n[PASS] test_ExactlyTwiceAndExactlyHalfAreAllowed() (gas: 7347888)\n[PASS] test_ExecutingNothingOrAPendingProposalIsRefused() (gas: 2515813)\n[PASS] test_OverpayingTheOracleIsTheProposersChoice() (gas: 2487436)\n[PASS] test_PricesAfterTwoChangesStayWithinTheRailsOfEach() (gas: 4219697)\n[PASS] test_ProposingNeedsTheProposersImd() (gas: 383908)\n[PASS] test_TheAnswerMustBeABoolTrueAboutThisChain() (gas: 7186081)\n[PASS] test_TheCallbackSelectorsAreTheProtocolsLayout() (gas: 2586325)\n[PASS] test_TheFirstChangeHasNoCooldown() (gas: 2592521)\n[PASS] test_TheLastSecondOfTheCooldown() (gas: 4323654)\n[PASS] test_TheLastSecondOfTheExecuteWindow() (gas: 2589107)\n[PASS] test_TheProtocolsOwnSignatureVerifies() (gas: 2774679)\n[PASS] test_TheProtocolsSignatureOnATamperedVectorIsRefused() (gas: 2814849)\n[PASS] test_TheVectorsSignerApprovesWithABoolAnswer() (gas: 2777870)\n[PASS] test_TwoProposalsOneVerdictEach() (gas: 4188577)\nSuite result: ok. 18 passed; 0 failed; 0 skipped; finished in 60.56ms (54.05ms CPU time)\n\nRan 6 tests for test/PaymentAtomicity.t.sol:PaymentAtomicityTest\n[PASS] test_AllSixPaymentsRejectCallerGasStarvationAtomically() (gas: 4834993)\n[PASS] test_AllSixPaymentsRollBackWhenCanonicalTransferFails() (gas: 5638122)\n[PASS] test_ForwardingInTheCallbackLeavesTheNextHolderOwingItsOwnToll() (gas: 1411737)\n[PASS] test_ImdTransferFailureDoesNotMintOrFoundOrPayAToll() (gas: 658883)\n[PASS] test_ReceiverCanPayItsTollInsideEitherSafeTransferCallback() (gas: 2241917)\n[PASS] test_RejectingReceiverRollsBackItsNestedPaymentRecordsAndSwap() (gas: 1263777)\nSuite result: ok. 6 passed; 0 failed; 0 skipped; finished in 71.67ms (8.94ms CPU time)\n\nRan 28 tests for test/IMDNames.t.sol:IMDNamesTest\n[PASS] test_ABrokenRendererFallsBackToTheCard() (gas: 10710970)\n[PASS] test_AFeeParksWhenNoPoolCanTakeIt() (gas: 8894621)\n[PASS] test_ANewOwnerPaysTheTollToLink() (gas: 1030272)\n[PASS] test_ARoyaltyPaymentIsBurned() (gas: 567939)\n[PASS] test_AnyoneRegistersAnyFreeName() (gas: 622149)\n[PASS] test_BadNames() (gas: 76271)\n[PASS] test_LinkRules() (gas: 227703)\n[PASS] test_LinkTheNameToAnIdentity() (gas: 188953)\n[PASS] test_NoImdPaymentWithoutBothPools() (gas: 233518)\n[PASS] test_OneNamePerIdentityOneIdentityPerName() (gas: 937678)\n[PASS] test_Prices() (gas: 63806)\n[PASS] test_Primary() (gas: 249738)\n[PASS] test_RegisterForSomeoneElse() (gas: 613058)\n[PASS] test_RegisterWithImd() (gas: 959072)\n[PASS] test_RegisterWithImdRespectsMaxImd() (gas: 784834)\n[PASS] test_RegisteringMintsTheNameAndBurnsTheFee() (gas: 657957)\n[PASS] test_RegistrationRules() (gas: 228053)\n[PASS] test_RoyaltiesGoToTheBurner() (gas: 40939)\n[PASS] test_SellingTheIdentityTakesItDown() (gas: 170626)\n[PASS] test_SellingTheNameTakesItDown() (gas: 207985)\n[PASS] test_ShortNamesHaveShortNameTolls() (gas: 661117)\n[PASS] test_TextRecordsStartOverWithANewHolder() (gas: 217274)\n[PASS] test_TheArtistChangesTheArtAndOnlyTheArt() (gas: 410113)\n[PASS] test_TheBuiltInCard() (gas: 3442144)\n[PASS] test_TheNamesNewOwnerUnlinksAStaleLink() (gas: 236080)\n[PASS] test_TheTollFollowsEveryChangeOfHands() (gas: 214766)\n[PASS] test_TheTollInImd() (gas: 1093347)\n[PASS] test_Unlink() (gas: 207675)\nSuite result: ok. 28 passed; 0 failed; 0 skipped; finished in 79.34ms (44.72ms CPU time)\n\nRan 18 tests for test/SwarmPrices.t.sol:SwarmPricesTest\n[PASS] testFuzz_AWrongRequestCannotSettleAPendingProposal(bytes32) (runs: 256, μ: 2670542, ~: 2670643)\n[PASS] test_AProposalForOldPricesGoesStale() (gas: 4240429)\n[PASS] test_ARejectedProposalChangesNothing() (gas: 2577335)\n[PASS] test_AVerdictCannotApproveAnotherPendingProposal() (gas: 4158565)\n[PASS] test_AVerdictMustBeUsedWithinTwoWeeks() (gas: 2551628)\n[PASS] test_AWeakPanelIsARejection() (gas: 7197220)\n[PASS] test_AnExpiredVerdictIsARejection() (gas: 2537113)\n[PASS] test_AnyoneProposesAndTheContractWritesTheQuestion() (gas: 3300450)\n[PASS] test_ApprovedThenAnyoneExecutes() (gas: 3923290)\n[PASS] test_ChangingTheSignedRequestIdInvalidatesTheSignature() (gas: 4234890)\n[PASS] test_ExecutedOnce() (gas: 2600327)\n[PASS] test_Guardrails() (gas: 218195)\n[PASS] test_NoVerdictClosesTheProposal() (gas: 2569776)\n[PASS] test_OneChangeAWeek() (gas: 4310174)\n[PASS] test_OnlyTheIntakeDeliversAndOnlyForItsOwnProposals() (gas: 2561581)\n[PASS] test_OnlyTheOraclesSignatureForThisContractCounts() (gas: 2703262)\n[PASS] test_StartPrices() (gas: 61091)\n[PASS] test_TheOracleMustBePaid() (gas: 238881)\nSuite result: ok. 18 passed; 0 failed; 0 skipped; finished in 79.34ms (92.80ms CPU time)\n\nRan 3 tests for test/LARPBurnerShareEdges.t.sol:LARPBurnerShareEdgesTest\n[PASS] testFuzz_ValidShareSplitsEveryWeiAndBurnsActualSupply(uint16,uint256) (runs: 256, μ: 357357, ~: 371521)\nLogs:\n  Bound result 4376\n  Bound result 173\n\n[PASS] test_DustOnBothSidesOfTheFirstNonzeroShare() (gas: 1182554)\n[PASS] test_OnlyOneAbiWordIsAnAcceptableShareAnswer() (gas: 476795)\nSuite result: ok. 3 passed; 0 failed; 0 skipped; finished in 83.92ms (82.08ms CPU time)\n\nRan 19 tests for test/LARPBurnerEdges.t.sol:LARPBurnerEdgesTest\n[PASS] testFuzz_ABurnSpendsMinOfBalanceAndMaxBurn(uint256,uint256) (runs: 128, μ: 796492, ~: 794339)\nLogs:\n  Bound result 182452882424919949\n  Bound result 384285164318795929\n\n[PASS] testFuzz_QuoteIsLinearAndMonotone(uint256,uint256) (runs: 256, μ: 576443, ~: 576522)\nLogs:\n  Bound result 1685701882424981683\n  Bound result 6285995003877838520\n\n[PASS] testFuzz_SixPointNinePercentBuysIMD6900AndTheRestBurns(uint256) (runs: 256, μ: 564579, ~: 556502)\nLogs:\n  Bound result 4301701373105919548\n\n[PASS] testFuzz_TwoBurnsInOneBlockSellAtMostOneCapOfWaitingEth(uint256,uint256,uint256) (runs: 192, μ: 1014151, ~: 1017342)\nLogs:\n  Bound result 499999000000000101\n  Bound result 20923\n  Bound result 8198\n\n[PASS] test_APartialFillOnPool4FallsToTheHooklessPool() (gas: 2588067)\n[PASS] test_AWethAnsweringShortIsIgnored() (gas: 905473)\n[PASS] test_AWethThatRefusesToUnwrapIsIgnored() (gas: 943064)\n[PASS] test_AWrongPool4KeyFallsToTheHooklessPool() (gas: 835984)\n[PASS] test_BelowTheLegBudgetABurnIsRefusedBeforeAnyLegRuns() (gas: 1008060)\n[PASS] test_Constants() (gas: 72853)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 9394)\n[PASS] test_ExactlyMaxBurnInOneCall() (gas: 1357561)\n[PASS] test_NoPoolAtAllParksAndQuotesNothing() (gas: 613447)\n[PASS] test_NothingToBurnIsNotAnError() (gas: 383300)\n[PASS] test_OneWeiParks() (gas: 668090)\n[PASS] test_QuoteOfTheSmallestPrice() (gas: 549094)\n[PASS] test_ReceiveTakesEmptyCallsOnly() (gas: 66423)\n[PASS] test_TheBlockAllowanceCountsOnlyTheWaitingEth() (gas: 2369304)\n[PASS] test_UnwrappedWethIsWaitingEth() (gas: 1655564)\nSuite result: ok. 19 passed; 0 failed; 0 skipped; finished in 87.27ms (265.69ms CPU time)\n\nRan 27 tests for test/LARPBurner.t.sol:LARPBurnerTest\n[PASS] test_AFeeAlwaysGoesThroughWhateverTheBlockSpent() (gas: 2325890)\n[PASS] test_AGasEatingIMD6900IsSkippedNotFatal() (gas: 7942385)\n[PASS] test_AGasEatingPool4HookFallsToTheHooklessPool() (gas: 4102897)\n[PASS] test_AGenuineFailureIsNotMistakenForTooLittleGas() (gas: 876639)\n[PASS] test_ASwapOutOfGasReverts() (gas: 10080186)\n[PASS] test_AnEmptyPairPoolMeansItAllBurnsAsIMD() (gas: 827279)\n[PASS] test_AnIMD6900LegOutOfGasDeepDownReverts() (gas: 3821761)\n[PASS] test_AnIMD6900ThatWontBurnMeansItAllBurnsAsIMD() (gas: 789638)\n[PASS] test_AtMostMaxBurnPerCallAndPerBlockOfWaitingEth() (gas: 2373317)\n[PASS] test_BurnCallsBatchedInOneTransactionSellOneCap() (gas: 1036999)\n[PASS] test_BurnImdBurnsWhatArrivesInIMD() (gas: 519860)\n[PASS] test_BuysOnPool4First() (gas: 1073540)\n[PASS] test_HostileLegsCostPaidCallsTheirBudgets() (gas: 11581009)\nLogs:\n  registration gas used with two hostile legs: 6026491\n\n[PASS] test_MinImd() (gas: 961486)\n[PASS] test_NoGasLimitSkipsAHeavyIMD6900Leg() (gas: 68136929)\n[PASS] test_NoGasLimitSkipsARoute() (gas: 5984012)\n[PASS] test_NoQuoteWithoutBothPools() (gas: 297276)\n[PASS] test_NoReentry() (gas: 467731)\n[PASS] test_OnlyThePoolManagerCallsBack() (gas: 32829)\n[PASS] test_ParkedWhenNoPoolCanAndBurnedLater() (gas: 1381349)\n[PASS] test_QuoteIsTheHigherOfTheTwoPools() (gas: 1129758)\n[PASS] test_RoyaltiesArriveByPlainTransfer() (gas: 44081)\n[PASS] test_ShareBuysIMD6900AndBurnsIt() (gas: 851825)\n[PASS] test_SpacingAboveV4sLargestReverts() (gas: 11396)\n[PASS] test_SpacingsAreTakenUnsignedAndKeptAsInt24() (gas: 28301)\n[PASS] test_TheHooklessPoolIfPool4CantTakeIt() (gas: 1185610)\n[PASS] test_WethRoyaltiesAreUnwrappedAndSold() (gas: 1132967)\nSuite result: ok. 27 passed; 0 failed; 0 skipped; finished in 110.49ms (187.30ms CPU time)\n\nRan 1 test for test/LARPBurner.invariant.t.sol:LARPBurnerInvariantTest\n[PASS]\nLARPBurnerInvariantTest invariants:\n[PASS] invariant_DeadHoldsOnlyImd\n[PASS] invariant_EthLeavesOnlyAsASwap\n[PASS] invariant_Imd6900OnlyBurns\n[PASS] invariant_ImdGoesOnlyToDeadOrTheIMD6900Buy\n[PASS] invariant_NoImdOutlivesABurn\n[PASS] invariant_WaitingEthLeavesAtMostOneCapPerBlock\n LARPBurnerInvariantTest invariants (runs: 64, calls: 3072, reverts: 0)\n\n╭---------------+-------------------+-------+---------+----------╮\n| Contract      | Selector          | Calls | Reverts | Discards |\n+================================================================+\n| BurnerHandler | burn              | 380   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | burnImd           | 348   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | burnWithLittleGas | 391   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateEth         | 436   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateImd         | 373   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateWeth        | 362   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | nextBlock         | 355   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | trade             | 427   | 0       | 0        |\n╰---------------+-------------------+-------+---------+----------╯\n\nLogs:\n  Bound result 5999000000000000000014\n  Bound result 12176\n  Bound result 3005718\n  Bound result 2577\n  Bound result 1947\n  Bound result 284316827753434525\n  Bound result 358793239081170476\n  Bound result 367959472086682925\n  Bound result 184812773397540567\n  Bound result 2433318\n  Bound result 5622060740456107708978\n  Bound result 500000000000000000\n  Bound result 144\n  Bound result 5295\n  Bound result 1\n  Bound result 6340\n  Bound result 303217537091289238245\n  Bound result 1\n  Bound result 599290589\n  Bound result 5231\n  Bound result 3150000\n  Bound result 95\n  Bound result 2\n  Bound result 3\n  Bound result 299999999999999999\n  Bound result 1707490\n  Bound result 2000\n  Bound result 69576962644345792\n  Bound result 1856\n  Bound result 3000000000000000\n  Bound result 1\n  Bound result 8999\n  Bound result 96\n  Bound result 86400\n  Bound result 14675\n  Bound result 499792917818885444\n  Bound result 2869\n  Bound result 16001\n  Bound result 5819\n  Bound result 14318\n  Bound result 3008672\n  Bound result 13900000000000000\n  Bound result 133378206054161229\n  Bound result 7652\n  Bound result 3006957\n  Bound result 3\n  Bound result 54243722424859933\n  Bound result 1933009\n  Bound result 194265960037000698\n  Bound result 1889567281\n  Bound result 3002237\n  Bound result 5999000000000000001613\n  Bound result 2834634216490329199\n  Bound result 3564\n  Bound result 99999999999999996667\n  Bound result 1380000000000000000\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 762.92ms (759.45ms CPU time)\n\nRan 1 test for test/SwarmPrices.invariant.t.sol:SwarmPricesInvariantTest\n[PASS]\nSwarmPricesInvariantTest invariants:\n[PASS] invariant_CountersMatchWhatHappened\n[PASS] invariant_NamesHoldsNothing\n[PASS] invariant_NoProposalReopens\n[PASS] invariant_PricesChangeOnlyByExecution\n[PASS] invariant_PricesWithinTheGuardrails\n SwarmPricesInvariantTest invariants (runs: 64, calls: 3072, reverts: 0)\n\n╭--------------+--------------+-------+---------+----------╮\n| Contract     | Selector     | Calls | Reverts | Discards |\n+==========================================================+\n| SwarmHandler | execute      | 358   | 0       | 0        |\n|--------------+--------------+-------+---------+----------|\n| SwarmHandler | fail         | 380   | 0       | 0        |\n|--------------+--------------+-------+---------+----------|\n| SwarmHandler | forge        | 387   | 0       | 0        |\n|--------------+--------------+-------+---------+----------|\n| SwarmHandler | pass         | 403   | 0       | 0        |\n|--------------+--------------+-------+---------+----------|\n| SwarmHandler | propose      | 372   | 0       | 0        |\n|--------------+--------------+-------+---------+----------|\n| SwarmHandler | proposeShare | 373   | 0       | 0        |\n|--------------+--------------+-------+---------+----------|\n| SwarmHandler | stranger     | 417   | 0       | 0        |\n|--------------+--------------+-------+---------+----------|\n| SwarmHandler | verdict      | 382   | 0       | 0        |\n╰--------------+--------------+-------+---------+----------╯\n\nLogs:\n  Bound result 18400000000006657\n  Bound result 4506666666666688\n  Bound result 1840000000001001\n  Bound result 1840000000014212\n  Bound result 400000000000006778\n  Bound result 11413393109712187\n  Bound result 3666273266303671\n  Bound result 1745319285444669\n  Bound result 1112981123637620\n  Bound result 517264651186736097\n  Bound result 20699999999999998\n  Bound result 874829310211014\n  Bound result 1840000000460513\n  Bound result 433449556699050\n  Bound result 600000000000000000\n  Bound result 11599999999999999\n  Bound result 4482130352297291\n  Bound result 1840001026354288\n  Bound result 719072395007115\n  Bound result 400000000000004750\n  Bound result 774401\n  Bound result 1204\n  Bound result 18400000404966218\n  Bound result 4506668829925112\n  Bound result 1840001742722250\n  Bound result 1840000000032768\n  Bound result 405520000000000003\n  Bound result 654848\n  Bound result 210008\n  Bound result 18400000006800001\n  Bound result 4506666666681469\n  Bound result 1840000000007301\n  Bound result 1840000000000129\n  Bound result 400400000000000002\n  Bound result 345\n  Bound result 11\n  Bound result 9\n  Bound result 5\n  Bound result 99\n  Bound result 4545475160555492\n  Bound result 2903256898865218\n  Bound result 2069999999999999\n  Bound result 230000000000003\n  Bound result 461991724938282062\n  Bound result 18400000000006401\n  Bound result 4506666666679489\n  Bound result 1840000000002191\n  Bound result 1840000000001143\n  Bound result 400000000000004098\n  Bound result 348\n  Bound result 775521\n  Bound result 8\n  Bound result 5\n  Bound result 8\n  Bound result 172800\n  Bound result 18400000000003076\n  Bound result 4799999999997960\n  Bound result 869992723996160\n  Bound result 1840000000000097\n  Bound result 400000000003150002\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 848.98ms (844.80ms CPU time)\n\nRan 3 tests for test/SwarmShareSettlement.invariant.t.sol:SwarmShareSettlementInvariantTest\n[PASS]\nSwarmShareSettlementInvariantTest invariants:\n[PASS] invariant_EveryDonatedImdIsWaitingSpentOrAtTheCanonicalBurn\n[PASS] invariant_ShareTracksOnlyApprovedExecutedTerms\n[PASS] invariant_ThePairOutputReallyLeavesTotalSupply\n SwarmShareSettlementInvariantTest invariants (runs: 256, calls: 16384, reverts: 0)\n\n╭------------------------+------------------+-------+---------+----------╮\n| Contract               | Selector         | Calls | Reverts | Discards |\n+========================================================================+\n| ShareSettlementHandler | approvePending   | 1252  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | burn             | 2467  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | donate           | 1286  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | execute          | 1315  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | fail             | 1226  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | forge            | 1249  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | pairAvailability | 1232  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | pass             | 1235  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | propose          | 1310  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | proposeShare     | 1258  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | stranger         | 1238  | 0       | 0        |\n|------------------------+------------------+-------+---------+----------|\n| ShareSettlementHandler | verdict          | 1316  | 0       | 0        |\n╰------------------------+------------------+-------+---------+----------╯\n\nLogs:\n  Bound result 9731\n  Bound result 1209\n  Bound result 12\n  Bound result 8\n  Bound result 7\n  Bound result 109355\n  Bound result 1903\n  Bound result 11\n  Bound result 7\n  Bound result 4\n  Bound result 12345\n  Bound result 1200000000000000\n  Bound result 11\n  Bound result 11\n  Bound result 8\n  Bound result 152896\n  Bound result 1070\n  Bound result 1369\n  Bound result 8228\n  Bound result 50000\n  Bound result 157827028405820975739\n  Bound result 157198259\n  Bound result 346\n  Bound result 32421\n  Bound result 12\n  Bound result 8\n  Bound result 4\n  Bound result 143620\n  Bound result 16\n  Bound result 18400000000024257\n  Bound result 4506666666666672\n  Bound result 1019999999999993\n  Bound result 1019999999999993\n  Bound result 400000000000005817\n  Bound result 1025\n  Bound result 1048\n  Bound result 1352\n  Bound result 12313727865990267\n  Bound result 1342640415440294\n  Bound result 1844769393566328\n  Bound result 1391052551394939\n  Bound result 592413384016495900\n\n[PASS] test_CallerGasCannotBypassShareButARefusingDependencyCanFallBack() (gas: 884872)\nLogs:\n  Bound result 100000000000000000000\n  Bound result 100000000000000000000\n\n[PASS] test_VotedShareCanReachZeroAndAllWithSettlementAtEveryStep() (gas: 33175731)\nLogs:\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n  Bound result 604800\n  Bound result 100000000000000000000\n\nSuite result: ok. 3 passed; 0 failed; 0 skipped; finished in 3.51s (3.53s CPU time)\n\nRan 2 tests for test/LARPLinks.invariant.t.sol:LARPLinksLifecycleInvariantTest\n[PASS]\nLARPLinksLifecycleInvariantTest invariants:\n[PASS] invariant_CardsFollowTheCurrentHolderAndSocialState\n[PASS] invariant_CrewFeesAreForwardedAndEthIsConserved\n[PASS] invariant_CrewMembershipCountsAndNamesAgree\n[PASS] invariant_FriendshipIsASymmetricSimpleGraph\n LARPLinksLifecycleInvariantTest invariants (runs: 256, calls: 16384, reverts: 0)\n\n╭------------------------+--------------+-------+---------+----------╮\n| Contract               | Selector     | Calls | Reverts | Discards |\n+====================================================================+\n| SocialLifecycleHandler | changeAgent  | 1760  | 0       | 0        |\n|------------------------+--------------+-------+---------+----------|\n| SocialLifecycleHandler | found        | 1867  | 0       | 0        |\n|------------------------+--------------+-------+---------+----------|\n| SocialLifecycleHandler | friendship   | 3677  | 0       | 0        |\n|------------------------+--------------+-------+---------+----------|\n| SocialLifecycleHandler | invite       | 1760  | 0       | 0        |\n|------------------------+--------------+-------+---------+----------|\n| SocialLifecycleHandler | joinOrLeave  | 1914  | 0       | 0        |\n|------------------------+--------------+-------+---------+----------|\n| SocialLifecycleHandler | manage       | 1800  | 0       | 0        |\n|------------------------+--------------+-------+---------+----------|\n| SocialLifecycleHandler | sellIdentity | 1747  | 0       | 0        |\n|------------------------+--------------+-------+---------+----------|\n| SocialLifecycleHandler | unauthorized | 1859  | 0       | 0        |\n╰------------------------+--------------+-------+---------+----------╯\n\n[PASS] test_HandlerExercisesInvitationsSuccessionAndNameReuse() (gas: 4219728)\nSuite result: ok. 2 passed; 0 failed; 0 skipped; finished in 25.52s (25.51s CPU time)\n\nRan 2 tests for test/IMDNames.invariant.t.sol:IMDNamesLifecycleInvariantTest\n[PASS]\nIMDNamesLifecycleInvariantTest invariants:\n[PASS] invariant_LiveLinksRoundTripAndRequireBothAssets\n[PASS] invariant_NameFeesAreForwardedAndEthIsConserved\n[PASS] invariant_NftBalancesEqualTheIndependentOwnershipLedger\n[PASS] invariant_OnlyTheLastPayingHolderHasAFreeLink\n[PASS] invariant_RecordsAndAgentsFollowTheirRecordedHolder\n IMDNamesLifecycleInvariantTest invariants (runs: 256, calls: 16384, reverts: 0)\n\n╭-----------------------+-------------------+-------+---------+----------╮\n| Contract              | Selector          | Calls | Reverts | Discards |\n+========================================================================+\n| NamesLifecycleHandler | changeAgent       | 1474  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | linkName          | 3062  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | refusePayment     | 1458  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | registerName      | 1408  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | resign            | 1521  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | setTextAndPrimary | 1506  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | transferIdentity  | 1496  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | transferName      | 1485  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | unauthorized      | 1505  | 0       | 0        |\n|-----------------------+-------------------+-------+---------+----------|\n| NamesLifecycleHandler | unlinkName        | 1469  | 0       | 0        |\n╰-----------------------+-------------------+-------+---------+----------╯\n\n[PASS] test_HandlerExercisesPaidResalesAndRejectsFailures() (gas: 4203682)\nSuite result: ok. 2 passed; 0 failed; 0 skipped; finished in 27.99s (27.99s CPU time)\n\nRan 1 test for test/LARP.invariant.t.sol:LARPInvariantTest\n[PASS]\nLARPInvariantTest invariants:\n[PASS] invariant_LiveMeansThePlacerHoldsIt\n[PASS] invariant_NoMoreLiveCopiesThanHeld\n[PASS] invariant_OneTokenOneSpot\n LARPInvariantTest invariants (runs: 128, calls: 8192, reverts: 0)\n\n╭-------------+--------------+-------+---------+----------╮\n| Contract    | Selector     | Calls | Reverts | Discards |\n+=========================================================+\n| LarpHandler | equip1155    | 1184  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | equip721     | 1207  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveCopy     | 1175  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveIdentity | 1145  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveMask     | 1168  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | setFace      | 1122  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | takeOff      | 1191  | 0       | 0        |\n╰-------------+--------------+-------+---------+----------╯\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 29.69s (29.69s CPU time)\n\nRan 28 test suites in 29.69s (89.19s CPU time): 309 tests passed, 0 failed, 13 skipped (322 total tests)\n","passed":true},{"durationMs":82,"exitCode":0,"name":"source-index","output":"{\"v\":1,\"entryPoints\":[\"IMDNames.approve(address,uint256)\",\"IMDNames.execute(bytes32)\",\"IMDNames.link(uint256,uint256,uint256)\",\"IMDNames.linkWithImd(uint256,uint256,uint256)\",\"IMDNames.lockRenderer()\",\"IMDNames.onNoVerdict(bytes32,uint8,bytes32,uint16,uint16,bytes)\",\"IMDNames.onVerdict(bytes32,(bytes32,uint256,bytes32,uint8,bytes,uint256,uint64,uint64,bytes32,bytes32,uint16,uint16,uint16,uint64,uint64),bytes)\",\"IMDNames.propose((uint64,uint64,uint64,uint64,uint16),uint256)\",\"IMDNames.register(bytes32,address,uint256)\",\"IMDNames.registerWithImd(bytes32,address,uint256)\",\"IMDNames.safeTransferFrom(address,address,uint256)\",\"IMDNames.safeTransferFrom(address,address,uint256,bytes)\",\"IMDNames.setApprovalForAll(address,bool)\",\"IMDNames.setArtist(address)\",\"IMDNames.setPrimary(uint256)\",\"IMDNames.setRenderer(address)\",\"IMDNames.setText(uint256,string,string)\",\"IMDNames.transferFrom(address,address,uint256)\",\"IMDNames.unlink(uint256)\",\"LARP.clearFace(uint256)\",\"LARP.equip(uint256,uint256,address,uint256,uint8)\",\"LARP.resignAgent(uint256)\",\"LARP.setAgent(uint256,address)\",\"LARP.setAgentBySig(uint256,address,uint256,bytes)\",\"LARP.setFace(uint256,address,uint256)\",\"LARP.unequip(uint256,uint256)\",\"LARPBurner.burn(uint256)\",\"LARPBurner.burnImd()\",\"LARPBurner.receive()\",\"LARPBurner.unlockCallback(bytes)\",\"LARPLinks.disband(uint256)\",\"LARPLinks.foundCrew(uint256,bytes32,bool,uint256)\",\"LARPLinks.foundCrewWithImd(uint256,bytes32,bool,uint256)\",\"LARPLinks.fren(uint256,uint256)\",\"LARPLinks.invite(uint256,uint256,bool)\",\"LARPLinks.join(uint256,uint256)\",\"LARPLinks.kick(uint256,uint256)\",\"LARPLinks.leave(uint256)\",\"LARPLinks.passCaptain(uint256,uint256)\",\"LARPLinks.proveAlloc(uint64,uint256,address,uint256,bytes32[])\",\"LARPLinks.setOpen(uint256,bool)\",\"LARPLinks.unfren(uint256,uint256)\"],\"files\":{\".gitignore\":4,\"ADAPTATION.md\":131,\"AUDIT-COVERAGE.md\":199,\"AUDIT.md\":278,\"README.md\":231,\"foundry.toml\":34,\"script/place/gen.py\":122,\"src/IIMDNames.sol\":112,\"src/ILARP.sol\":120,\"src/IMDNames.sol\":358,\"src/LARP.sol\":330,\"src/LARPBurner.sol\":364,\"src/LARPLinks.sol\":457,\"src/Labels.sol\":53,\"src/SafeReads.sol\":63,\"src/SwarmPrices.sol\":369,\"src/place/LARPPlan.sol\":38,\"src/place/PlaceLARP.sol\":148,\"test/Base.sol\":308,\"test/ConstructorMatrix.t.sol\":168,\"test/ENTRYPOINT-COVERAGE.md\":210,\"test/IMDNames.invariant.t.sol\":456,\"test/IMDNames.t.sol\":481,\"test/IMDNamesEdges.t.sol\":458,\"test/LARP.invariant.t.sol\":184,\"test/LARP.t.sol\":324,\"test/LARPAgents.t.sol\":269,\"test/LARPBurner.invariant.t.sol\":468,\"test/LARPBurner.t.sol\":585,\"test/LARPBurnerEdges.t.sol\":403,\"test/LARPBurnerSettlement.t.sol\":155,\"test/LARPBurnerShareEdges.t.sol\":86,\"test/LARPEdges.t.sol\":340,\"test/LARPItems.t.sol\":236,\"test/LARPLinks.invariant.t.sol\":398,\"test/LARPLinks.t.sol\":515,\"test/LARPLinksEdges.t.sol\":459,\"test/Launch.t.sol\":148,\"test/MainnetFork.t.sol\":344,\"test/Mocks.sol\":89,\"test/PaymentAtomicity.t.sol\":274,\"test/Placement.t.sol\":360,\"test/PlacementEdges.t.sol\":202,\"test/SwarmPrices.invariant.t.sol\":409,\"test/SwarmPrices.t.sol\":587,\"test/SwarmPricesEdges.t.sol\":353,\"test/SwarmShareSettlement.invariant.t.sol\":215,\"test/fixtures/allocs.json\":118},\"excluded\":[\"lib/\",\"node_modules/\"],\"truncated\":false}","passed":true}],"detail":"all checks passed","evaluation":"checks","profile":"foundry","status":"accepted","submissionHash":"67dbec99b3baa471d606fc861f1dcf29771f6c009f3cd4c7ea8e1037ce8757bb","verifiedTreeHash":"6299a08e5285c5cfe040fa75cfaa313b393159c2","verifierVersion":"0.1.0+fb8278c5"},{"checks":[{"durationMs":205251,"exitCode":0,"name":"build","output":"Compiling 104 files with Solc 0.8.26\nSolc 0.8.26 finished in 204.95s\nCompiler run successful!\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:333:25\n    │\n333 │                 return (true, r);\n    │                         ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:220:33\n    │\n220 │         if (at == 0) return (0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:228:42\n    │\n228 │         if (owner == address(0)) return (false, address(0), 0, false);\n    │                                          ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:228:64\n    │\n228 │         if (owner == address(0)) return (false, address(0), 0, false);\n    │                                                                ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n   ╭▸ src/place/PlaceLARP.sol:49:98\n   │\n49 │             if (_proxy(LARPPlan.CREATEX, g).code.length == 0 && at.code.length == 0) return (at, true);\n   │                                                                                                  ━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n   ╭▸ src/place/PlaceLARP.sol:51:48\n   │\n51 │         return (_create3(address(this), salt), false);\n   │                                                ━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[uninitialized-local]: local variable is read before being initialized\n   ╭▸ src/Labels.sol:23:16\n   │\n23 │         while (n < 32 && label[n] != 0) ++n;\n   │                ━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:240:33\n    │\n240 │         if (label == 0) return (false, address(0), 0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:240:55\n    │\n240 │         if (label == 0) return (false, address(0), 0, false);\n    │                                                       ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:247:37\n    │\n247 │         if (at == 0) return (0, \"\", false);\n    │                                     ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:336:25\n    │\n336 │                 return (false, \"\");\n    │                         ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:342:21\n    │\n342 │             return (true, r);\n    │                     ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:344:21\n    │\n344 │             return (false, \"\");\n    │                     ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[unsafe-typecast]: typecast can truncate values\n   ╭▸ src/SwarmPrices.sol:87:38\n   │\n87 │     bytes32 public constant ACTION = bytes32(\"oracle.request@oracle-1\");\n   │                                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ├ note: consider disabling this lint if you're certain the cast is safe\n   │       \n   │       // casting to 'bytes32' is safe because [explain why]\n   │       // forge-lint: disable-next-line(unsafe-typecast)\n   │       \n   │       \n   ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n   ╭▸ src/SafeReads.sol:21:46\n   │\n21 │         return ok && w >> 160 == 0 ? address(uint160(w)) : address(0);\n   │                                              ━━━━━━━━━━\n   │\n   ├ note: consider disabling this lint if you're certain the cast is safe\n   │       \n   │       // casting to 'uint160' is safe because [explain why]\n   │       // forge-lint: disable-next-line(unsafe-typecast)\n   │       \n   │       \n   ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/SwarmPrices.sol:137:17\n    │\n137 │     constructor(address intake, address oracleSigner, Prices memory start) {\n    │                 ━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/SwarmPrices.sol:137:33\n    │\n137 │     constructor(address intake, address oracleSigner, Prices memory start) {\n    │                                 ━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n   ╭▸ src/SafeReads.sol:47:40\n   │\n47 │         (bool ok, bytes memory data) = target.staticcall{gas: gasCap}(call);\n   │                                        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:147:9\n    │\n147 │         address names\n    │         ━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:146:9\n    │\n146 │         address pairHook,\n    │         ━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:140:9\n    │\n140 │         address pool4Hook,\n    │         ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n    ╭▸ src/LARPBurner.sol:172:13\n    │\n172 │             n.staticcall{gas: SHARE_GAS}(abi.encodeWithSelector(IShareSource.imd6900ShareBps.selector));\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:182:16\n    │\n182 │         return int24(s);\n    │                ━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int24' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n   ╭▸ src/IMDNames.sol:67:63\n   │\n67 │     constructor(address identity, ILARP larp, address burner, address artist_, address intake, address oracleSigner)\n   │                                                               ━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:109:9\n    │\n109 │         LARPBurner(payable(BURNER)).burn{value: price}(minImd);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:123:24\n    │\n123 │         if (toll != 0) LARPBurner(payable(BURNER)).burn{value: toll}(minImd);\n    │                        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:88:13\n    │\n 88 │ ┏             abi.encodePacked(\n 89 │ ┃                 type(LARPBurner).creationCode,\n 90 │ ┃                 abi.encode(\n 91 │ ┃                     LARPPlan.POOL_MANAGER,\n    ‡ ┃\n104 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/SwarmPrices.sol:176:9\n    │\n176 │         emit Proposed(requestId, number, msg.sender, next);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:108:36\n    │\n108 │         _place(LARPPlan.LARP_SALT, abi.encodePacked(type(LARP).creationCode, abi.encode(LARPPlan.IDENTITY)), l, lx);\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:111:13\n    │\n111 │ ┏             abi.encodePacked(\n112 │ ┃                 type(IMDNames).creationCode,\n113 │ ┃                 abi.encode(LARPPlan.IDENTITY, l, b, LARPPlan.ARTIST, LARPPlan.INTAKE, LARPPlan.ORACLE_SIGNER)\n114 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:133:13\n    │\n133 │ ┏             abi.encodePacked(\n134 │ ┃                 type(LARPLinks).creationCode,\n135 │ ┃                 abi.encode(\n136 │ ┃                     LARPPlan.IDENTITY,\n    ‡ ┃\n142 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:111:33\n    │\n111 │         if (at == 0) return (0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:120:64\n    │\n120 │         if (holder == address(0) || who == address(0)) return (false, holder);\n    │                                                                ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:121:36\n    │\n121 │         if (who == holder) return (true, holder);\n    │                                    ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:265:36\n    │\n265 │         if (at == 0) return (0, 0, false);\n    │                                    ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n   ╭▸ src/LARP.sol:78:13\n   │\n78 │         if (block.timestamp > deadline) revert Expired();\n   │             ━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARP.sol:138:9\n    │\n138 │         emit AgentSet(imdId, holder, agent);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:159:45\n    │\n159 │         return ok && answer.length >= 32 && bytes4(abi.decode(answer, (bytes32))) == 0x1626ba7e;\n    │                                             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes4' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/LARP.sol:310:15\n    │\n310 │             ++digits;\n    │               ━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:314:36\n    │\n314 │             out[--digits] = bytes1(uint8(48 + value % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:325:22\n    │\n325 │             out[i] = bytes16(\"0123456789abcdef\")[v & 15];\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes16' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/LARPBurner.sol:332:17\n    │\n332 │             try POOL_MANAGER.unlock(data) returns (bytes memory r) {\n    │                 ━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/LARPBurner.sol:341:13\n    │\n341 │         try POOL_MANAGER.unlock{gas: LEG_GAS}(data) returns (bytes memory r) {\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:236:21\n    │\n236 │                     emit Bought(eth, imd, route);\n    │                     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:240:27\n    │\n240 │             if (imd == 0) emit Parked(eth);\n    │                           ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:315:9\n    │\n315 │         emit Burned(rest, share, burned6900);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[require-revert-in-loop]: `require` or `revert` inside a loop\n    ╭▸ src/LARPBurner.sol:335:49\n    │\n335 │                 if (gasleft() <= gasBefore / 4) revert TooLittleGas();\n    │                                                 ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/require-revert-in-loop\n\nwarning[require-revert-in-loop]: `require` or `revert` inside a loop\n    ╭▸ src/LARPBurner.sol:340:61\n    │\n340 │         if (gasleft() < LEG_GAS + LEG_GAS / 63 + AFTER_GAS) revert TooLittleGas();\n    │                                                             ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/require-revert-in-loop\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:219:39\n    │\n219 │         uint256 spent = _burnBlock == uint64(block.number) ? _burnedInBlock : 0;\n    │                                       ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:233:38\n    │\n233 │                         _burnBlock = uint64(block.number);\n    │                                      ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:234:42\n    │\n234 │                         _burnedInBlock = uint192(spent + waiting);\n    │                                          ━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint192' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:137:9\n    │\n137 │         emit NameRegistered(tokenId, label, to, price);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:153:13\n    │\n153 │             emit NameUnlinked(old, imdId);\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:158:13\n    │\n158 │             emit NameUnlinked(tokenId, was - 1);\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:162:9\n    │\n162 │         emit NameLinked(tokenId, imdId, holder, toll);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:185:9\n    │\n185 │         emit NameUnlinked(tokenId, imdId);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:181:22\n    │\n181 │         (bool ok,) = LARP.canAct(imdId, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/IMDNames.sol:306:26\n    │\n306 │     function setRenderer(address renderer_) external {\n    │                          ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:189:16\n    │\n189 │             && block.timestamp <= a.expiresAt && a.answer.length == 32 && uint256(bytes32(a.answer)) == 1;\n    │                ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/SwarmPrices.sol:192:9\n    │\n192 │         emit Verdict(requestId, approved, a.agreed, a.panelSize);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:189:83\n    │\n189 │             && block.timestamp <= a.expiresAt && a.answer.length == 32 && uint256(bytes32(a.answer)) == 1;\n    │                                                                                   ━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes32' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:191:23\n    │\n191 │         p.decidedAt = uint64(block.timestamp);\n    │                       ━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/IMDNames.sol:314:24\n    │\n314 │     function setArtist(address artist_) external {\n    │                        ━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:272:43\n    │\n272 │                 pair, SwapParams(imdIs0, -int256(amount), imdIs0 ? MIN_PRICE_LIMIT : MAX_PRICE_LIMIT), \"\"\n    │                                           ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:275:27\n    │\n275 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                           ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:275:49\n    │\n275 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                 ━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:275:67\n    │\n275 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                                   ━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:275:82\n    │\n275 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                                                  ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:276:30\n    │\n276 │             if (imdDelta != -int128(int256(amount)) || outDelta <= 0) revert Unfilled();\n    │                              ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:276:37\n    │\n276 │             if (imdDelta != -int128(int256(amount)) || outDelta <= 0) revert Unfilled();\n    │                                     ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPBurner.sol:279:13\n    │\n279 │             POOL_MANAGER.settle();\n    │             ━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:280:27\n    │\n280 │             uint256 out = uint128(outDelta);\n    │                           ━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:288:61\n    │\n288 │         int256 d = POOL_MANAGER.swap(key, SwapParams(true, -int256(amount), MIN_PRICE_LIMIT), \"\");\n    │                                                             ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:289:27\n    │\n289 │         int128 ethDelta = int128(d >> 128);\n    │                           ━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:290:25\n    │\n290 │         int128 bought = int128(d);\n    │                         ━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:291:26\n    │\n291 │         if (ethDelta != -int128(int256(amount)) || bought <= 0) revert Unfilled();\n    │                          ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:291:33\n    │\n291 │         if (ethDelta != -int128(int256(amount)) || bought <= 0) revert Unfilled();\n    │                                 ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPBurner.sol:294:9\n    │\n294 │         POOL_MANAGER.settle{value: amount}();\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:295:47\n    │\n295 │         POOL_MANAGER.take(IMD, address(this), uint128(bought));\n    │                                               ━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:296:27\n    │\n296 │         return abi.encode(uint256(uint128(bought)));\n    │                           ━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:296:35\n    │\n296 │         return abi.encode(uint256(uint128(bought)));\n    │                                   ━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/LARPBurner.sol:315:34\n    │\n315 │         emit Burned(rest, share, burned6900);\n    │                                  ━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n    ╭▸ src/LARPBurner.sol:341:13\n    │\n341 │         try POOL_MANAGER.unlock{gas: LEG_GAS}(data) returns (bytes memory r) {\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:209:44\n    │\n209 │         if (p.status != Status.Approved || block.timestamp > p.decidedAt + EXECUTE_WINDOW) revert NotApproved();\n    │                                            ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:211:32\n    │\n211 │         if (lastChange != 0 && block.timestamp < lastChange + COOLDOWN) revert Cooling();\n    │                                ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:215:22\n    │\n215 │         lastChange = uint64(block.timestamp);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:341:36\n    │\n341 │             digits[i - 1] = bytes1(uint8(48 + frac % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/SwarmPrices.sol:357:15\n    │\n357 │             ++digits;\n    │               ━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:361:36\n    │\n361 │             out[--digits] = bytes1(uint8(48 + value % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:208:9\n    │\n208 │         LARPBurner(payable(BURNER)).burn{value: msg.value}(minImd);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:327:22\n    │\n327 │         (bool ok,) = LARP.canAct(c.captain, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPLinks.sol:342:39\n    │\n342 │         address distributor = address(uint160(w));\n    │                                       ━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint160' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPLinks.sol:380:31\n    │\n380 │             j.token = address(uint160(t));\n    │                               ━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint160' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:443:9\n    │\n443 │         (, c.faceCollection, c.faceTokenId, c.faceLive) = LARP.faceOf(imdId);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:454:22\n    │\n454 │         (bool ok,) = LARP.canAct(imdId, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/LARPAgents.t.sol:139:28\n    │\n139 │         uint256 deadline = block.timestamp + 1 hours;\n    │                            ━━━━━━━━━━━━━━━\n140 │         bytes memory sig = _sign(ownerKey, 7, agent, owner, 0, deadline);\n141 │         vm.warp(deadline + 1);\n    │         ───────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.number` may be reused across `vm.roll`\n   ╭▸ test/LARPBurnerPairLeg.t.sol:94:17\n   │\n94 │         vm.roll(block.number + 1);\n   │         ────────━━━━━━━━━━━━───── `vm.roll` changes this environment here\n   │\n   ├ help: capture it with `vm.getBlockNumber()` instead\n   ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:203:60\n    │\n203 │             _attest(id, true, 0, \"\", block.chainid, uint64(block.timestamp + 1 days));\n    │                                                            ━━━━━━━━━━━━━━━\n    ‡\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:54:30\n    │\n 54 │             issuedAt: uint64(block.timestamp),\n    │                              ━━━━━━━━━━━━━━━\n    ‡\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:209:17\n    │\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────━━━━━━━━━━━━━━━─────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:203:60\n    │\n203 │             _attest(id, true, 0, \"\", block.chainid, uint64(block.timestamp + 1 days));\n    │                                                            ━━━━━━━━━━━━━━━\n    ‡\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ───────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:54:30\n    │\n 54 │             issuedAt: uint64(block.timestamp),\n    │                              ━━━━━━━━━━━━━━━\n    ‡\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ───────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:236:17\n    │\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ────────━━━━━━━━━━━━━━━────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\n","passed":true},{"durationMs":36581,"exitCode":0,"name":"test","output":"No files changed, compilation skipped\n\nRan 7 tests for test/LARPBurnerSettlement.t.sol:LARPBurnerSettlementTest\n[PASS] test_ParkedWaitingEthDoesNotConsumeTheBlocksAllowance() (gas: 1034032)\n[PASS] test_PreSyncCannotParkACrewFee() (gas: 945441)\n[PASS] test_PreSyncCannotParkARegistrationFee() (gas: 842669)\n[PASS] test_PreSyncCannotParkAResaleToll() (gas: 1239745)\n[PASS] test_PreSyncCannotParkTheHooklessRoute() (gas: 880379)\n[PASS] test_PreSyncCannotParkWaitingEthOrChooseTheBackup() (gas: 1179771)\n[PASS] test_PreSyncStillHonoursMinImdAndRollsBackTheAllowance() (gas: 675781)\nSuite result: ok. 7 passed; 0 failed; 0 skipped; finished in 13.82ms (6.03ms CPU time)\n\nRan 14 tests for test/LARPAgents.t.sol:LARPAgentsTest\n[PASS] test_AContractWalletSignsWithERC1271() (gas: 431060)\n[PASS] test_ASignatureWorksOnce() (gas: 230440)\n[PASS] test_AnAgentCantNameAgentsOrTheWallet() (gas: 195893)\n[PASS] test_AnAgentDressesTheIdentityWithTheOwnersNFTs() (gas: 396334)\n[PASS] test_AnAgentLapsesOnASale() (gas: 317701)\n[PASS] test_AnAgentLinksTheOwnersNameAndSetsTexts() (gas: 615060)\n[PASS] test_AnAgentResigns() (gas: 193582)\n[PASS] test_AnAgentRunsFrensAndCrews() (gas: 860110)\n[PASS] test_AnyAgentChangeVoidsOutstandingSignatures() (gas: 188002)\n[PASS] test_BadSignatures() (gas: 364692)\n[PASS] test_OnlyTheOwnerSetsTheAgent() (gas: 40977)\n[PASS] test_SignaturesExpire() (gas: 49228)\n[PASS] test_TheOwnerConnectsAnAgentInOneCall() (gas: 188975)\n[PASS] test_TheOwnerSignsTheAgentSends() (gas: 176447)\nSuite result: ok. 14 passed; 0 failed; 0 skipped; finished in 19.73ms (3.81ms CPU time)\n\nRan 6 tests for test/LARPBurnerPairLeg.t.sol:LARPBurnerPairLegTest\n[PASS] test_AtAHundredPercentOnlyThePoolsRoomBuysIMD6900() (gas: 318615)\n[PASS] test_BurnFloorsTheSendersPartOrTheWholeSaleWhenItSendsNothing() (gas: 756118)\n[PASS] test_MinImdIsCheckedAgainstThePayersOwnFee() (gas: 630527)\n[PASS] test_TheIMD6900LegIsNotWorthSandwichingAtAnyShare() (gas: 1901512)\nLogs:\n  attacker's $IMD profit at 100%, 500 $IMD front (wei): -42829697176817851510\n\n[PASS] test_TheLaunchShareOfAFullBurnIsNotClipped() (gas: 280495)\n[PASS] test_TheRoomFollowsThePoolsDepth() (gas: 615537)\nSuite result: ok. 6 passed; 0 failed; 0 skipped; finished in 20.10ms (8.61ms CPU time)\n\nRan 23 tests for test/IMDNamesEdges.t.sol:IMDNamesEdgesTest\n[PASS] test_APrimaryWithoutANameIsLiveAndNameless() (gas: 182236)\n[PASS] test_ARendererThatAnswersNothingFallsBack() (gas: 383627)\n[PASS] test_ASaleDarkensTheLinkAndTheTextStays() (gas: 286579)\n[PASS] test_AStrangerCannotUnlink() (gas: 160730)\n[PASS] test_AnAgentLinksUnlinksAndWrites() (gas: 486024)\n[PASS] test_ApprovalsAndOperatorTransfers() (gas: 452506)\n[PASS] test_Constants() (gas: 191514)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 15761)\n[PASS] test_LockingIsIdempotentAndKeepsTheRenderer() (gas: 292103)\n[PASS] test_PrimaryAndTextRefusals() (gas: 147701)\n[PASS] test_ReadingNames() (gas: 64773)\n[PASS] test_RegisterRefusesLessThanThePrice() (gas: 216901)\n[PASS] test_RegisterWithAFloorTheBurnCannotMeet() (gas: 224412)\n[PASS] test_RegisterWithImdNeedsAnAllowance() (gas: 622695)\n[PASS] test_ResolveNameSpellings() (gas: 150173)\n[PASS] test_RoyaltyRounding() (gas: 35079)\n[PASS] test_SafeTransfersCheckTheReceiver() (gas: 603375)\n[PASS] test_TheArtistRenouncesAndTheArtIsFinal() (gas: 154258)\n[PASS] test_TheCardOfAnUnlinkedName() (gas: 2382338)\n[PASS] test_TheLongestAndShortestNames() (gas: 503735)\n[PASS] test_TheTollInImdRespectsMaxImd() (gas: 1139620)\n[PASS] test_TransferRules() (gas: 144769)\n[PASS] test_UnlinkingNothingDoesNothing() (gas: 37821)\nSuite result: ok. 23 passed; 0 failed; 0 skipped; finished in 20.50ms (11.26ms CPU time)\n\nRan 24 tests for test/LARPLinks.t.sol:LARPLinksTest\n[PASS] test_AGasHungryTokenCantSinkTheBoard() (gas: 1737463)\n[PASS] test_AnInnerNodeIsNotALeaf() (gas: 1448373)\n[PASS] test_AnUnreadableTokenCountsAsHeld() (gas: 1784660)\n[PASS] test_BadAllocations() (gas: 1754999)\n[PASS] test_CaptainsRun() (gas: 592442)\n[PASS] test_Card() (gas: 903636)\n[PASS] test_CrewFoundingRules() (gas: 546171)\n[PASS] test_Disband() (gas: 810487)\n[PASS] test_FoundACrewWithImd() (gas: 1184629)\n[PASS] test_FoundingACrewBurnsIMD() (gas: 378689)\n[PASS] test_FrenRules() (gas: 383139)\n[PASS] test_FrensPassWithTheIdentity() (gas: 302573)\n[PASS] test_FrensTakeTwo() (gas: 266329)\n[PASS] test_JeetsAreReadLive() (gas: 2364129)\n[PASS] test_JeetsInPages() (gas: 8424463)\n[PASS] test_OpenAndClosedCrews() (gas: 955439)\n[PASS] test_PassTheCaptaincy() (gas: 577520)\n[PASS] test_ProveAnAllocation() (gas: 1534389)\n[PASS] test_RanksAcrossLaunches() (gas: 5184173)\n[PASS] test_TheCaptaincyPassesWithTheIdentity() (gas: 397438)\n[PASS] test_TheRankIsTheHoldersNow() (gas: 1748137)\n[PASS] test_Tiers() (gas: 80885)\n[PASS] test_Unfren() (gas: 271974)\n[PASS] test_WithdrawAndDeclineAsks() (gas: 244060)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 24.65ms (20.07ms CPU time)\n\nRan 28 tests for test/IMDNames.t.sol:IMDNamesTest\n[PASS] test_ABrokenRendererFallsBackToTheCard() (gas: 10710970)\n[PASS] test_AFeeParksWhenNoPoolCanTakeIt() (gas: 8894773)\n[PASS] test_ANewOwnerPaysTheTollToLink() (gas: 659541)\n[PASS] test_ARoyaltyPaymentIsBurned() (gas: 197078)\n[PASS] test_AnyoneRegistersAnyFreeName() (gas: 251418)\n[PASS] test_BadNames() (gas: 76271)\n[PASS] test_LinkRules() (gas: 227703)\n[PASS] test_LinkTheNameToAnIdentity() (gas: 188953)\n[PASS] test_NoImdPaymentWithoutBothPools() (gas: 233712)\n[PASS] test_OneNamePerIdentityOneIdentityPerName() (gas: 566947)\n[PASS] test_Prices() (gas: 63806)\n[PASS] test_Primary() (gas: 249738)\n[PASS] test_RegisterForSomeoneElse() (gas: 242327)\n[PASS] test_RegisterWithImd() (gas: 962888)\n[PASS] test_RegisterWithImdRespectsMaxImd() (gas: 785222)\n[PASS] test_RegisteringMintsTheNameAndBurnsTheFee() (gas: 287226)\n[PASS] test_RegistrationRules() (gas: 228053)\n[PASS] test_RoyaltiesGoToTheBurner() (gas: 40939)\n[PASS] test_SellingTheIdentityTakesItDown() (gas: 170626)\n[PASS] test_SellingTheNameTakesItDown() (gas: 207985)\n[PASS] test_ShortNamesHaveShortNameTolls() (gas: 290386)\n[PASS] test_TextRecordsStartOverWithANewHolder() (gas: 217274)\n[PASS] test_TheArtistChangesTheArtAndOnlyTheArt() (gas: 410113)\n[PASS] test_TheBuiltInCard() (gas: 3442144)\n[PASS] test_TheNamesNewOwnerUnlinksAStaleLink() (gas: 236080)\n[PASS] test_TheTollFollowsEveryChangeOfHands() (gas: 214766)\n[PASS] test_TheTollInImd() (gas: 1097163)\n[PASS] test_Unlink() (gas: 207675)\nSuite result: ok. 28 passed; 0 failed; 0 skipped; finished in 44.60ms (52.49ms CPU time)\n\nRan 11 tests for test/MainnetFork.t.sol:MainnetForkTest\n[SKIP] test_ACrewBuysAndBurnsRealIMD() (gas: 0)\n[SKIP] test_ANameBuysRealIMDOnPool4AndBurnsIt() (gas: 0)\n[SKIP] test_ANameChangesHandsAndBurns() (gas: 0)\n[SKIP] test_ANamePaidInRealImd() (gas: 0)\n[SKIP] test_APriceProposalThroughIMDsRealIntake() (gas: 0)\n[SKIP] test_AnAgentRunsTheTreasurysIdentity() (gas: 0)\n[SKIP] test_AnIdentityWearsAWorkerFren() (gas: 0)\n[SKIP] test_RealProofsRefuseTampering() (gas: 0)\n[SKIP] test_TheHooklessPoolTakesWhatPool4Cant() (gas: 0)\n[SKIP] test_TheRealJeetBoard() (gas: 0)\n[SKIP] test_TheTreasurysCard() (gas: 0)\nSuite result: ok. 0 passed; 0 failed; 11 skipped; finished in 60.14ms (221.27µs CPU time)\n\nRan 24 tests for test/LARPLinksEdges.t.sol:LARPLinksEdgesTest\n[PASS] testFuzz_JeetBpsIsTheSoldShareOfTheAllocation(uint128,uint256,bool) (runs: 256, μ: 1665590, ~: 1535748)\nLogs:\n  Bound result 100000000000000001\n  Bound result 57\n\n[PASS] testFuzz_TiersAreMonotoneInJeetPoints(uint256,uint256,uint256) (runs: 256, μ: 33077, ~: 33218)\nLogs:\n  Bound result 259\n  Bound result 21375\n  Bound result 2581786\n\n[PASS] test_ACardWithALiveFace() (gas: 694335)\n[PASS] test_ADisbandedCrewIsGone() (gas: 624526)\n[PASS] test_ADistributorWithoutARootIsUnknown() (gas: 1411930)\n[PASS] test_ADistributorWithoutATokenCountsAsHeld() (gas: 1673522)\n[PASS] test_ALauncherAnsweringGarbageIsUnknown() (gas: 1533984)\n[PASS] test_AllocationBounds() (gas: 2897946)\n[PASS] test_AnAskSurvivesASaleOfEitherIdentity() (gas: 241341)\n[PASS] test_AnEmptyProofForASoloRound() (gas: 1509668)\n[PASS] test_AnIdentityNobodyHolds() (gas: 54774)\n[PASS] test_CaptainRules() (gas: 588036)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 13620)\n[PASS] test_CrewNamesAtTheEdges() (gas: 689374)\n[PASS] test_Defaults() (gas: 177309)\n[PASS] test_FoundCrewWithImdRefusals() (gas: 1002976)\n[PASS] test_FoundCrewWithTheWrongValue() (gas: 364406)\n[PASS] test_InviteRules() (gas: 567999)\n[PASS] test_JoinLeaveRules() (gas: 743979)\n[PASS] test_LaunchJeetPastTheEndReverts() (gas: 14394)\n[PASS] test_MembersCountFollowsEveryMove() (gas: 725282)\n[PASS] test_TwoRoundsOfOneLaunchAreOneLevel() (gas: 1866769)\n[PASS] test_UnfrenClearsBothAsksAtOnce() (gas: 388582)\n[PASS] test_UnfrenWithNothingDoesNothing() (gas: 86806)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 65.38ms (84.62ms CPU time)\n\nRan 14 tests for test/LARPItems.t.sol:LARPItemsTest\n[PASS] test_AFaceBecomesAnItem() (gas: 321185)\n[PASS] test_AnItemBecomesAnotherIdentitysFace() (gas: 306295)\n[PASS] test_EquipAnERC1155Copy() (gas: 195226)\n[PASS] test_EquipAnERC721() (gas: 228623)\n[PASS] test_OneCopyOnePlacement() (gas: 372050)\n[PASS] test_ReequippingTheSameCopyInTheSameSlot() (gas: 213412)\n[PASS] test_RefusedItems() (gas: 220243)\n[PASS] test_ReplacingAnItemFreesTheOldOne() (gas: 291522)\n[PASS] test_SellingACopyDarkensItsPlacementsUntilOneComesOff() (gas: 456264)\n[PASS] test_SellingTheIdentityDarkensItsItems() (gas: 360711)\n[PASS] test_SlotsAreOneToEight() (gas: 224747)\n[PASS] test_StrangersCantTakeItemsOff() (gas: 174966)\n[PASS] test_TheNewOwnerClearsTheOldItems() (gas: 343634)\n[PASS] test_ThePlacerTakesItsCopyBackAfterSellingTheIdentity() (gas: 399525)\nSuite result: ok. 14 passed; 0 failed; 0 skipped; finished in 83.19ms (8.79ms CPU time)\n\nRan 2 tests for test/Placement.t.sol:PlacementForkTest\n[SKIP] test_fork_ANameBurnsTheCanonicalWay() (gas: 0)\n[SKIP] test_fork_LandsAt6900ThroughTheRealCreateX() (gas: 0)\nSuite result: ok. 0 passed; 0 failed; 2 skipped; finished in 83.17ms (158.39µs CPU time)\n\nRan 18 tests for test/SwarmPricesEdges.t.sol:SwarmPricesEdgesTest\n[PASS] testFuzz_TheGuardrailsAreExactlyTheDocumentedRule(uint64,uint64,uint64,uint64) (runs: 512, μ: 451974, ~: 60870)\nLogs:\n  Bound result 12000000000009903\n  Bound result 2800000000003086\n  Bound result 1200000000069001\n  Bound result 599290589\n\n[PASS] test_AFailureAfterAVerdictIsRefused() (gas: 3536518)\n[PASS] test_AVerdictExpiringThisSecondStillCounts() (gas: 3485815)\n[PASS] test_AnUnknownProposalIsNone() (gas: 18765)\n[PASS] test_ExactlyTwiceAndExactlyHalfAreAllowed() (gas: 9955402)\n[PASS] test_ExecutingNothingOrAPendingProposalIsRefused() (gas: 3448188)\n[PASS] test_OverpayingTheOracleIsTheProposersChoice() (gas: 3419807)\n[PASS] test_PricesAfterTwoChangesStayWithinTheRailsOfEach() (gas: 5666539)\n[PASS] test_ProposingNeedsTheProposersImd() (gas: 384718)\n[PASS] test_TheAnswerMustBeABoolTrueAboutThisChain() (gas: 9661881)\n[PASS] test_TheCallbackSelectorsAreTheProtocolsLayout() (gas: 3565259)\n[PASS] test_TheFirstChangeHasNoCooldown() (gas: 3524896)\n[PASS] test_TheLastSecondOfTheCooldown() (gas: 5829304)\n[PASS] test_TheLastSecondOfTheExecuteWindow() (gas: 3521482)\n[PASS] test_TheProtocolsOwnSignatureVerifies() (gas: 3709734)\n[PASS] test_TheProtocolsSignatureOnATamperedVectorIsRefused() (gas: 3749904)\n[PASS] test_TheVectorsSignerApprovesWithABoolAnswer() (gas: 3712925)\n[PASS] test_TwoProposalsOneVerdictEach() (gas: 5635427)\nSuite result: ok. 18 passed; 0 failed; 0 skipped; finished in 83.21ms (90.43ms CPU time)\n\nRan 24 tests for test/LARP.t.sol:LARPFaceTest\n[PASS] testFuzz_OnlyTheHolderOfBothSetsAFace(address,uint256,uint256) (runs: 256, μ: 55832, ~: 56425)\nLogs:\n  Bound result 0\n  Bound result 9\n\n[PASS] test_AFaceComesBackWithBothTokens() (gas: 220934)\n[PASS] test_AMaskMovesToTheIdentityThatPutsItOn() (gas: 323750)\n[PASS] test_AvatarFormat() (gas: 249931)\n[PASS] test_ChangingMasksFreesTheOldOne() (gas: 274960)\n[PASS] test_ClearFace() (gas: 200738)\n[PASS] test_ClearingNoFaceDoesNothing() (gas: 36612)\n[PASS] test_FaceURIFallsBackOnABrokenTokenURI() (gas: 2152591)\n[PASS] test_OnlyTheIdentitysOwnerClears() (gas: 173845)\n[PASS] test_PuttingTheSameMaskOnAgain() (gas: 240094)\n[PASS] test_RefusesAMaskThatIsNotYours() (gas: 49187)\n[PASS] test_RefusesAnIdentityAsAMask() (gas: 41585)\n[PASS] test_RefusesAnIdentityThatDoesNotExist() (gas: 41653)\n[PASS] test_RefusesAnIdentityThatIsNotYours() (gas: 43653)\n[PASS] test_RefusesWhatIsNotAnNFT() (gas: 510494)\n[PASS] test_SellingTheIdentityTakesTheFaceDown() (gas: 252506)\n[PASS] test_SellingTheMaskTakesTheFaceDown() (gas: 223250)\n[PASS] test_SetFace() (gas: 266231)\n[PASS] test_SupportsInterface() (gas: 27637)\n[PASS] test_TheIdentitysNewOwnerClearsTheOldFace() (gas: 225470)\n[PASS] test_TheNewHolderOfAMaskTakesItOff() (gas: 321718)\n[PASS] test_TheNewOwnerMustChooseAgain() (gas: 327564)\n[PASS] test_WearerOfAnUnwornMask() (gas: 14020)\n[PASS] test_ZeroIdentityRefused() (gas: 4446)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 83.38ms (28.61ms CPU time)\n\nRan 7 tests for test/SwarmPrices.t.sol:SwarmShareTest\n[PASS] test_AndDownToNothing() (gas: 10341468)\n[PASS] test_ShareGuardrails() (gas: 7682664)\n[PASS] test_StartsAt6Point9AndTheBurnerReadsItFromIMDNames() (gas: 264776)\n[PASS] test_TheBurnerFallsBackTo6Point9() (gas: 429031)\n[PASS] test_TheQuestionNamesTheShare() (gas: 6758711)\n[PASS] test_TheSwarmMovesTheShareAndTheBurnerFollows() (gas: 3760618)\n[PASS] test_UpToAllOfIt() (gas: 10694969)\nSuite result: ok. 7 passed; 0 failed; 0 skipped; finished in 84.71ms (43.33ms CPU time)\n\nRan 15 tests for test/LARPEdges.t.sol:LARPEdgesTest\n[PASS] testFuzz_WearerOfRoundTripsForAnyIdentityId(uint256,uint8) (runs: 256, μ: 220265, ~: 220684)\nLogs:\n  Bound result 5962\n  Bound result 8\n\n[PASS] test_ACopyPlacedTwiceIsCountedTwice() (gas: 341053)\n[PASS] test_ASignatureFromAnotherChainIsRefused() (gas: 83326)\n[PASS] test_AgentsOfNothing() (gas: 146135)\n[PASS] test_AnAgentTakesOffThePreviousOwnersItems() (gas: 350579)\n[PASS] test_ConstantsAndDomain() (gas: 57230)\n[PASS] test_ContractWalletsThatRefuseOrMumble() (gas: 462979)\n[PASS] test_EmptySpots() (gas: 141020)\n[PASS] test_OddSignatureBytes() (gas: 342349)\n[PASS] test_OneAgentForTwoIdentities() (gas: 326950)\n[PASS] test_RemovingAnAgentBumpsTheNonce() (gas: 371695)\n[PASS] test_ResigningDoesNotBumpTheNonce() (gas: 288556)\n[PASS] test_SupportsInterfaceIsPure() (gas: 15273)\n[PASS] test_TakingOffAnEmptySlotIsSilent() (gas: 61582)\n[PASS] test_ThePlacerTakesOffWhatItPlacedAfterSellingTheIdentity() (gas: 426342)\nSuite result: ok. 15 passed; 0 failed; 0 skipped; finished in 92.43ms (102.31ms CPU time)\n\nRan 4 tests for test/Launch.t.sol:LaunchTest\n[PASS] test_DeploysOnAFreshChain() (gas: 193241)\n[PASS] test_FitsOneTransaction() (gas: 25789)\nLogs:\n  launch gas, four creations: 8303\n\n[PASS] test_PassesTheAdmissionScan() (gas: 18079372)\n[PASS] test_UnderTheCodeSizeLimit() (gas: 11134)\nSuite result: ok. 4 passed; 0 failed; 0 skipped; finished in 94.75ms (61.76ms CPU time)\n\nRan 8 tests for test/Placement.t.sol:PlacementTest\n[PASS] test_ASaltUsedFirstIsNeverTaken() (gas: 10723418)\n[PASS] test_ArgumentsAsTheReadmeSays() (gas: 6240)\n[PASS] test_DeploysOnAFreshChain() (gas: 10256242)\n[PASS] test_FitsOneTransaction() (gas: 31706762)\nLogs:\n  the launch: gas, all in: 11261279\n  PlaceLARP initcode bytes: 40310\n  PlaceLinks initcode bytes: 12010\n\n[PASS] test_LandsWhereThePlanSays() (gas: 10538646)\n[PASS] test_PassesTheAdmissionScan() (gas: 43505634)\n[PASS] test_PlanFollowsFromTheSalts() (gas: 162797)\n[PASS] test_SameAddressesWhoeverRunsIt() (gas: 20402429)\nSuite result: ok. 8 passed; 0 failed; 0 skipped; finished in 109.75ms (198.06ms CPU time)\n\nRan 18 tests for test/SwarmPrices.t.sol:SwarmPricesTest\n[PASS] testFuzz_AWrongRequestCannotSettleAPendingProposal(bytes32) (runs: 256, μ: 3602912, ~: 3603018)\n[PASS] test_AProposalForOldPricesGoesStale() (gas: 5746079)\n[PASS] test_ARejectedProposalChangesNothing() (gas: 3509710)\n[PASS] test_AVerdictCannotApproveAnotherPendingProposal() (gas: 5605415)\n[PASS] test_AVerdictMustBeUsedWithinTwoWeeks() (gas: 3484003)\n[PASS] test_AWeakPanelIsARejection() (gas: 9673020)\n[PASS] test_AnExpiredVerdictIsARejection() (gas: 3469488)\n[PASS] test_AnyoneProposesAndTheContractWritesTheQuestion() (gas: 4279995)\n[PASS] test_ApprovedThenAnyoneExecutes() (gas: 4114203)\n[PASS] test_ChangingTheSignedRequestIdInvalidatesTheSignature() (gas: 5740540)\n[PASS] test_ExecutedOnce() (gas: 3532702)\n[PASS] test_Guardrails() (gas: 218195)\n[PASS] test_NoVerdictClosesTheProposal() (gas: 3502151)\n[PASS] test_OneChangeAWeek() (gas: 5815824)\n[PASS] test_OnlyTheIntakeDeliversAndOnlyForItsOwnProposals() (gas: 3493956)\n[PASS] test_OnlyTheOraclesSignatureForThisContractCounts() (gas: 3635637)\n[PASS] test_StartPrices() (gas: 61091)\n[PASS] test_TheOracleMustBePaid() (gas: 239434)\nSuite result: ok. 18 passed; 0 failed; 0 skipped; finished in 109.81ms (107.33ms CPU time)\n\nRan 19 tests for test/LARPBurnerEdges.t.sol:LARPBurnerEdgesTest\n[PASS] testFuzz_ABurnSpendsMinOfBalanceAndMaxBurn(uint256,uint256) (runs: 128, μ: 798657, ~: 797905)\nLogs:\n  Bound result 182452882424919949\n  Bound result 384285164318795929\n\n[PASS] testFuzz_QuoteIsLinearAndMonotone(uint256,uint256) (runs: 256, μ: 576827, ~: 576910)\nLogs:\n  Bound result 3471593299196916585\n  Bound result 6075711240114041836\n\n[PASS] testFuzz_SixPointNinePercentBuysIMD6900AndTheRestBurns(uint256) (runs: 256, μ: 578066, ~: 580495)\nLogs:\n  Bound result 4301701373105919548\n\n[PASS] testFuzz_TwoBurnsInOneBlockSellAtMostOneCapOfWaitingEth(uint256,uint256,uint256) (runs: 192, μ: 1021213, ~: 1024672)\nLogs:\n  Bound result 499999000000002761\n  Bound result 2158778573\n  Bound result 302688375\n\n[PASS] test_APartialFillOnPool4FallsToTheHooklessPool() (gas: 1846686)\n[PASS] test_AWethAnsweringShortIsIgnored() (gas: 534743)\n[PASS] test_AWethThatRefusesToUnwrapIsIgnored() (gas: 572334)\n[PASS] test_AWrongPool4KeyFallsToTheHooklessPool() (gas: 465447)\n[PASS] test_BelowTheLegBudgetABurnIsRefusedBeforeAnyLegRuns() (gas: 1030938)\n[PASS] test_Constants() (gas: 72853)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 9394)\n[PASS] test_ExactlyMaxBurnInOneCall() (gas: 615853)\n[PASS] test_NoPoolAtAllParksAndQuotesNothing() (gas: 613793)\n[PASS] test_NothingToBurnIsNotAnError() (gas: 383372)\n[PASS] test_OneWeiParks() (gas: 668242)\n[PASS] test_QuoteOfTheSmallestPrice() (gas: 549288)\n[PASS] test_ReceiveTakesEmptyCallsOnly() (gas: 66423)\n[PASS] test_TheBlockAllowanceCountsOnlyTheWaitingEth() (gas: 886201)\n[PASS] test_UnwrappedWethIsWaitingEth() (gas: 913857)\nSuite result: ok. 19 passed; 0 failed; 0 skipped; finished in 109.99ms (271.71ms CPU time)\n\nRan 27 tests for test/LARPBurner.t.sol:LARPBurnerTest\n[PASS] test_AFeeAlwaysGoesThroughWhateverTheBlockSpent() (gas: 842662)\n[PASS] test_AGasEatingIMD6900IsSkippedNotFatal() (gas: 7966516)\n[PASS] test_AGasEatingPool4HookFallsToTheHooklessPool() (gas: 3732187)\n[PASS] test_AGenuineFailureIsNotMistakenForTooLittleGas() (gas: 505929)\n[PASS] test_ASwapOutOfGasReverts() (gas: 10080207)\n[PASS] test_AnEmptyPairPoolMeansItAllBurnsAsIMD() (gas: 456548)\n[PASS] test_AnIMD6900LegOutOfGasDeepDownReverts() (gas: 3825389)\n[PASS] test_AnIMD6900ThatWontBurnMeansItAllBurnsAsIMD() (gas: 793224)\n[PASS] test_AtMostMaxBurnPerCallAndPerBlockOfWaitingEth() (gas: 889900)\n[PASS] test_BurnCallsBatchedInOneTransactionSellOneCap() (gas: 666272)\n[PASS] test_BurnImdBurnsWhatArrivesInIMD() (gas: 523288)\n[PASS] test_BuysOnPool4First() (gas: 702809)\n[PASS] test_HostileLegsCostPaidCallsTheirBudgets() (gas: 11595661)\nLogs:\n  registration gas used with two hostile legs: 6033788\n\n[PASS] test_MinImd() (gas: 961796)\n[PASS] test_NoGasLimitSkipsAHeavyIMD6900Leg() (gas: 68273876)\n[PASS] test_NoGasLimitSkipsARoute() (gas: 6031485)\n[PASS] test_NoQuoteWithoutBothPools() (gas: 297470)\n[PASS] test_NoReentry() (gas: 467883)\n[PASS] test_OnlyThePoolManagerCallsBack() (gas: 32829)\n[PASS] test_ParkedWhenNoPoolCanAndBurnedLater() (gas: 1010640)\n[PASS] test_QuoteIsTheHigherOfTheTwoPools() (gas: 759415)\n[PASS] test_RoyaltiesArriveByPlainTransfer() (gas: 44081)\n[PASS] test_ShareBuysIMD6900AndBurnsIt() (gas: 855411)\n[PASS] test_SpacingAboveV4sLargestReverts() (gas: 11396)\n[PASS] test_SpacingsAreTakenUnsignedAndKeptAsInt24() (gas: 28301)\n[PASS] test_TheHooklessPoolIfPool4CantTakeIt() (gas: 814879)\n[PASS] test_WethRoyaltiesAreUnwrappedAndSold() (gas: 762106)\nSuite result: ok. 27 passed; 0 failed; 0 skipped; finished in 181.15ms (329.23ms CPU time)\n\nRan 1 test for test/SwarmPrices.invariant.t.sol:SwarmPricesInvariantTest\n[PASS]\nSwarmPricesInvariantTest invariants:\n[PASS] invariant_CountersMatchWhatHappened\n[PASS] invariant_NamesHoldsNothing\n[PASS] invariant_NoProposalReopens\n[PASS] invariant_PricesChangeOnlyByExecution\n[PASS] invariant_PricesWithinTheGuardrails\n SwarmPricesInvariantTest invariants (runs: 64, calls: 3072, reverts: 0)\n\n╭--------------+----------+-------+---------+----------╮\n| Contract     | Selector | Calls | Reverts | Discards |\n+======================================================+\n| SwarmHandler | execute  | 436   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | fail     | 446   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | forge    | 422   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | pass     | 441   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | propose  | 428   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | stranger | 455   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | verdict  | 444   | 0       | 0        |\n╰--------------+----------+-------+---------+----------╯\n\nLogs:\n  Bound result 2902941871486535\n  Bound result 4506666666683736\n  Bound result 1840000000048880\n  Bound result 1840000000000009\n  Bound result 400000000000007747\n  Bound result 770687\n  Bound result 6399999999983696\n  Bound result 4506666666666710\n  Bound result 1840000000004700\n  Bound result 1840000000014381\n  Bound result 400000002835717309\n  Bound result 474248\n  Bound result 18400000000001097\n  Bound result 4506666666666679\n  Bound result 1840000000024257\n  Bound result 1840000000003093\n  Bound result 400000000000004638\n  Bound result 18400000000007301\n  Bound result 4506666667666668\n  Bound result 1840000000003965\n  Bound result 1239999999999997\n  Bound result 450000000000000002\n  Bound result 584517\n  Bound result 251852\n  Bound result 18400000003000001\n  Bound result 4506666666678408\n  Bound result 1039999996739131\n  Bound result 1840004113140427\n  Bound result 400000000000076002\n  Bound result 18400000000014283\n  Bound result 4506666666666827\n  Bound result 1840000000000013\n  Bound result 1840000000012322\n  Bound result 400000000000005002\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 594.08ms (582.62ms CPU time)\n\nRan 1 test for test/LARPBurner.invariant.t.sol:LARPBurnerInvariantTest\n[PASS]\nLARPBurnerInvariantTest invariants:\n[PASS] invariant_DeadHoldsOnlyImd\n[PASS] invariant_EthLeavesOnlyAsASwap\n[PASS] invariant_Imd6900OnlyBurns\n[PASS] invariant_ImdGoesOnlyToDeadOrTheIMD6900Buy\n[PASS] invariant_NoImdOutlivesABurn\n[PASS] invariant_WaitingEthLeavesAtMostOneCapPerBlock\n LARPBurnerInvariantTest invariants (runs: 64, calls: 3072, reverts: 0)\n\n╭---------------+-------------------+-------+---------+----------╮\n| Contract      | Selector          | Calls | Reverts | Discards |\n+================================================================+\n| BurnerHandler | burn              | 380   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | burnImd           | 348   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | burnWithLittleGas | 391   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateEth         | 436   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateImd         | 373   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateWeth        | 362   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | nextBlock         | 355   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | trade             | 427   | 0       | 0        |\n╰---------------+-------------------+-------+---------+----------╯\n\nLogs:\n  Bound result 5622060740456107708978\n  Bound result 12870\n  Bound result 3007882\n  Bound result 1533\n  Bound result 2301\n  Bound result 284316827753434525\n  Bound result 358793239081170476\n  Bound result 4984\n  Bound result 184812773397540567\n  Bound result 2433318\n  Bound result 5999002760000000000001\n  Bound result 77040\n  Bound result 2577\n  Bound result 10785\n  Bound result 1\n  Bound result 6907\n  Bound result 303217537091289238245\n  Bound result 1\n  Bound result 81570759080747168\n  Bound result 5356\n  Bound result 75000\n  Bound result 40\n  Bound result 1\n  Bound result 1\n  Bound result 299999999999999999\n  Bound result 1707490\n  Bound result 69000\n  Bound result 194\n  Bound result 1990\n  Bound result 3450000000000000\n  Bound result 1\n  Bound result 738\n  Bound result 6\n  Bound result 16777215\n  Bound result 14837\n  Bound result 499792917818885444\n  Bound result 875\n  Bound result 16109\n  Bound result 6064\n  Bound result 14277\n  Bound result 353946\n  Bound result 26880\n  Bound result 133378206054161229\n  Bound result 8263\n  Bound result 2921074\n  Bound result 1\n  Bound result 54243722424859933\n  Bound result 1933009\n  Bound result 194265960037000698\n  Bound result 63\n  Bound result 3010306\n  Bound result 5999000000000000001276\n  Bound result 2834634216490329199\n  Bound result 115788162\n  Bound result 1532892063\n  Bound result 353073666\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 1.01s (1.00s CPU time)\n\nRan 1 test for test/LARP.invariant.t.sol:LARPInvariantTest\n[PASS]\nLARPInvariantTest invariants:\n[PASS] invariant_LiveMeansThePlacerHoldsIt\n[PASS] invariant_NoMoreLiveCopiesThanHeld\n[PASS] invariant_OneTokenOneSpot\n LARPInvariantTest invariants (runs: 128, calls: 8192, reverts: 0)\n\n╭-------------+--------------+-------+---------+----------╮\n| Contract    | Selector     | Calls | Reverts | Discards |\n+=========================================================+\n| LarpHandler | equip1155    | 1184  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | equip721     | 1207  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveCopy     | 1175  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveIdentity | 1145  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveMask     | 1168  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | setFace      | 1122  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | takeOff      | 1191  | 0       | 0        |\n╰-------------+--------------+-------+---------+----------╯\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 36.40s (36.39s CPU time)\n\nRan 22 test suites in 36.40s (39.38s CPU time): 283 tests passed, 0 failed, 13 skipped (296 total tests)\n","passed":true},{"durationMs":161,"exitCode":0,"name":"source-index","output":"{\"v\":1,\"entryPoints\":[\"IMDNames.approve(address,uint256)\",\"IMDNames.execute(bytes32)\",\"IMDNames.link(uint256,uint256,uint256)\",\"IMDNames.linkWithImd(uint256,uint256,uint256)\",\"IMDNames.lockRenderer()\",\"IMDNames.onNoVerdict(bytes32,uint8,bytes32,uint16,uint16,bytes)\",\"IMDNames.onVerdict(bytes32,(bytes32,uint256,bytes32,uint8,bytes,uint256,uint64,uint64,bytes32,bytes32,uint16,uint16,uint16,uint64,uint64),bytes)\",\"IMDNames.propose((uint64,uint64,uint64,uint64,uint16),uint256)\",\"IMDNames.register(bytes32,address,uint256)\",\"IMDNames.registerWithImd(bytes32,address,uint256)\",\"IMDNames.safeTransferFrom(address,address,uint256)\",\"IMDNames.safeTransferFrom(address,address,uint256,bytes)\",\"IMDNames.setApprovalForAll(address,bool)\",\"IMDNames.setArtist(address)\",\"IMDNames.setPrimary(uint256)\",\"IMDNames.setRenderer(address)\",\"IMDNames.setText(uint256,string,string)\",\"IMDNames.transferFrom(address,address,uint256)\",\"IMDNames.unlink(uint256)\",\"LARP.clearFace(uint256)\",\"LARP.equip(uint256,uint256,address,uint256,uint8)\",\"LARP.resignAgent(uint256)\",\"LARP.setAgent(uint256,address)\",\"LARP.setAgentBySig(uint256,address,uint256,bytes)\",\"LARP.setFace(uint256,address,uint256)\",\"LARP.unequip(uint256,uint256)\",\"LARPBurner.burn(uint256)\",\"LARPBurner.burnImd()\",\"LARPBurner.receive()\",\"LARPBurner.unlockCallback(bytes)\",\"LARPLinks.disband(uint256)\",\"LARPLinks.foundCrew(uint256,bytes32,bool,uint256)\",\"LARPLinks.foundCrewWithImd(uint256,bytes32,bool,uint256)\",\"LARPLinks.fren(uint256,uint256)\",\"LARPLinks.invite(uint256,uint256,bool)\",\"LARPLinks.join(uint256,uint256)\",\"LARPLinks.kick(uint256,uint256)\",\"LARPLinks.leave(uint256)\",\"LARPLinks.passCaptain(uint256,uint256)\",\"LARPLinks.proveAlloc(uint64,uint256,address,uint256,bytes32[])\",\"LARPLinks.setOpen(uint256,bool)\",\"LARPLinks.unfren(uint256,uint256)\"],\"files\":{\".gitignore\":4,\"ADAPTATION.md\":189,\"AUDIT-COVERAGE.md\":199,\"AUDIT.md\":323,\"README.md\":235,\"foundry.toml\":34,\"launch.json\":14,\"script/place/gen.py\":122,\"src/IIMDNames.sol\":112,\"src/ILARP.sol\":120,\"src/IMDNames.sol\":358,\"src/LARP.sol\":330,\"src/LARPBurner.sol\":404,\"src/LARPLinks.sol\":457,\"src/Labels.sol\":53,\"src/SafeReads.sol\":63,\"src/SwarmPrices.sol\":370,\"src/place/LARPPlan.sol\":38,\"src/place/PlaceLARP.sol\":148,\"test/Base.sol\":328,\"test/IMDNames.t.sol\":481,\"test/IMDNamesEdges.t.sol\":458,\"test/LARP.invariant.t.sol\":184,\"test/LARP.t.sol\":324,\"test/LARPAgents.t.sol\":269,\"test/LARPBurner.invariant.t.sol\":495,\"test/LARPBurner.t.sol\":585,\"test/LARPBurnerEdges.t.sol\":459,\"test/LARPBurnerPairLeg.t.sol\":215,\"test/LARPBurnerSettlement.t.sol\":155,\"test/LARPEdges.t.sol\":340,\"test/LARPItems.t.sol\":236,\"test/LARPLinks.t.sol\":515,\"test/LARPLinksEdges.t.sol\":459,\"test/Launch.t.sol\":134,\"test/MainnetFork.t.sol\":371,\"test/Mocks.sol\":89,\"test/Placement.t.sol\":347,\"test/SwarmPrices.invariant.t.sol\":364,\"test/SwarmPrices.t.sol\":608,\"test/SwarmPricesEdges.t.sol\":353,\"test/fixtures/allocs.json\":118},\"excluded\":[\"lib/\",\"node_modules/\"],\"truncated\":false}","passed":true}],"detail":"all checks passed","evaluation":"checks","profile":"foundry","status":"accepted","submissionHash":"74d418e80ef41f6df31fb67ef6a97407725f8418c813cc9a1c3ae587d2077367","verifiedTreeHash":"eb3024262d461bb3af2bd7d4194b0f486fe46192","verifierVersion":"0.1.0+7ff5db2c"},{"checks":[{"durationMs":121691,"exitCode":0,"name":"build","output":"Compiling 103 files with Solc 0.8.26\nSolc 0.8.26 finished in 121.50s\nCompiler run successful!\nwarning[boolean-cst]: misuse of a boolean constant\n   ╭▸ src/place/PlaceLARP.sol:49:98\n   │\n49 │             if (_proxy(LARPPlan.CREATEX, g).code.length == 0 && at.code.length == 0) return (at, true);\n   │                                                                                                  ━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:220:33\n    │\n220 │         if (at == 0) return (0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:228:42\n    │\n228 │         if (owner == address(0)) return (false, address(0), 0, false);\n    │                                          ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:228:64\n    │\n228 │         if (owner == address(0)) return (false, address(0), 0, false);\n    │                                                                ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:240:33\n    │\n240 │         if (label == 0) return (false, address(0), 0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:240:55\n    │\n240 │         if (label == 0) return (false, address(0), 0, false);\n    │                                                       ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[unsafe-typecast]: typecast can truncate values\n   ╭▸ src/SwarmPrices.sol:87:38\n   │\n87 │     bytes32 public constant ACTION = bytes32(\"oracle.request@oracle-1\");\n   │                                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ├ note: consider disabling this lint if you're certain the cast is safe\n   │       \n   │       // casting to 'bytes32' is safe because [explain why]\n   │       // forge-lint: disable-next-line(unsafe-typecast)\n   │       \n   │       \n   ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n   ╭▸ src/SafeReads.sol:21:46\n   │\n21 │         return ok && w >> 160 == 0 ? address(uint160(w)) : address(0);\n   │                                              ━━━━━━━━━━\n   │\n   ├ note: consider disabling this lint if you're certain the cast is safe\n   │       \n   │       // casting to 'uint160' is safe because [explain why]\n   │       // forge-lint: disable-next-line(unsafe-typecast)\n   │       \n   │       \n   ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:111:33\n    │\n111 │         if (at == 0) return (0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:120:64\n    │\n120 │         if (holder == address(0) || who == address(0)) return (false, holder);\n    │                                                                ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n   ╭▸ src/SafeReads.sol:47:40\n   │\n47 │         (bool ok, bytes memory data) = target.staticcall{gas: gasCap}(call);\n   │                                        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:247:37\n    │\n247 │         if (at == 0) return (0, \"\", false);\n    │                                     ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:121:36\n    │\n121 │         if (who == holder) return (true, holder);\n    │                                    ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/SwarmPrices.sol:137:17\n    │\n137 │     constructor(address intake, address oracleSigner, Prices memory start) {\n    │                 ━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:320:25\n    │\n320 │                 return (true, r);\n    │                         ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/SwarmPrices.sol:137:33\n    │\n137 │     constructor(address intake, address oracleSigner, Prices memory start) {\n    │                                 ━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:265:36\n    │\n265 │         if (at == 0) return (0, 0, false);\n    │                                    ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n   ╭▸ src/place/PlaceLARP.sol:51:48\n   │\n51 │         return (_create3(address(this), salt), false);\n   │                                                ━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:323:25\n    │\n323 │                 return (false, \"\");\n    │                         ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:329:21\n    │\n329 │             return (true, r);\n    │                     ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:331:21\n    │\n331 │             return (false, \"\");\n    │                     ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:136:9\n    │\n136 │         address pairHook,\n    │         ━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:130:9\n    │\n130 │         address pool4Hook,\n    │         ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:137:9\n    │\n137 │         address names\n    │         ━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n    ╭▸ src/LARPBurner.sol:162:13\n    │\n162 │             n.staticcall{gas: SHARE_GAS}(abi.encodeWithSelector(IShareSource.imd6900ShareBps.selector));\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n   ╭▸ src/LARP.sol:78:13\n   │\n78 │         if (block.timestamp > deadline) revert Expired();\n   │             ━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:172:16\n    │\n172 │         return int24(s);\n    │                ━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int24' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARP.sol:138:9\n    │\n138 │         emit AgentSet(imdId, holder, agent);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n   ╭▸ src/IMDNames.sol:67:63\n   │\n67 │     constructor(address identity, ILARP larp, address burner, address artist_, address intake, address oracleSigner)\n   │                                                               ━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:109:9\n    │\n109 │         LARPBurner(payable(BURNER)).burn{value: price}(minImd);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:123:24\n    │\n123 │         if (toll != 0) LARPBurner(payable(BURNER)).burn{value: toll}(minImd);\n    │                        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/SwarmPrices.sol:176:9\n    │\n176 │         emit Proposed(requestId, number, msg.sender, next);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/LARPBurner.sol:319:17\n    │\n319 │             try POOL_MANAGER.unlock(data) returns (bytes memory r) {\n    │                 ━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/LARPBurner.sol:328:13\n    │\n328 │         try POOL_MANAGER.unlock{gas: LEG_GAS}(data) returns (bytes memory r) {\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:224:21\n    │\n224 │                     emit Bought(eth, imd, route);\n    │                     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:228:27\n    │\n228 │             if (imd == 0) emit Parked(eth);\n    │                           ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:302:9\n    │\n302 │         emit Burned(rest, share, burned6900);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[require-revert-in-loop]: `require` or `revert` inside a loop\n    ╭▸ src/LARPBurner.sol:322:49\n    │\n322 │                 if (gasleft() <= gasBefore / 4) revert TooLittleGas();\n    │                                                 ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/require-revert-in-loop\n\nwarning[require-revert-in-loop]: `require` or `revert` inside a loop\n    ╭▸ src/LARPBurner.sol:327:61\n    │\n327 │         if (gasleft() < LEG_GAS + LEG_GAS / 63 + AFTER_GAS) revert TooLittleGas();\n    │                                                             ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/require-revert-in-loop\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:207:39\n    │\n207 │         uint256 spent = _burnBlock == uint64(block.number) ? _burnedInBlock : 0;\n    │                                       ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:221:38\n    │\n221 │                         _burnBlock = uint64(block.number);\n    │                                      ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:222:42\n    │\n222 │                         _burnedInBlock = uint192(spent + waiting);\n    │                                          ━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint192' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:88:13\n    │\n 88 │ ┏             abi.encodePacked(\n 89 │ ┃                 type(LARPBurner).creationCode,\n 90 │ ┃                 abi.encode(\n 91 │ ┃                     LARPPlan.POOL_MANAGER,\n    ‡ ┃\n104 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:108:36\n    │\n108 │         _place(LARPPlan.LARP_SALT, abi.encodePacked(type(LARP).creationCode, abi.encode(LARPPlan.IDENTITY)), l, lx);\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:111:13\n    │\n111 │ ┏             abi.encodePacked(\n112 │ ┃                 type(IMDNames).creationCode,\n113 │ ┃                 abi.encode(LARPPlan.IDENTITY, l, b, LARPPlan.ARTIST, LARPPlan.INTAKE, LARPPlan.ORACLE_SIGNER)\n114 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:133:13\n    │\n133 │ ┏             abi.encodePacked(\n134 │ ┃                 type(LARPLinks).creationCode,\n135 │ ┃                 abi.encode(\n136 │ ┃                     LARPPlan.IDENTITY,\n    ‡ ┃\n142 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:137:9\n    │\n137 │         emit NameRegistered(tokenId, label, to, price);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:153:13\n    │\n153 │             emit NameUnlinked(old, imdId);\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:158:13\n    │\n158 │             emit NameUnlinked(tokenId, was - 1);\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:162:9\n    │\n162 │         emit NameLinked(tokenId, imdId, holder, toll);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:185:9\n    │\n185 │         emit NameUnlinked(tokenId, imdId);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:181:22\n    │\n181 │         (bool ok,) = LARP.canAct(imdId, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:159:45\n    │\n159 │         return ok && answer.length >= 32 && bytes4(abi.decode(answer, (bytes32))) == 0x1626ba7e;\n    │                                             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes4' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/LARP.sol:310:15\n    │\n310 │             ++digits;\n    │               ━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:314:36\n    │\n314 │             out[--digits] = bytes1(uint8(48 + value % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:325:22\n    │\n325 │             out[i] = bytes16(\"0123456789abcdef\")[v & 15];\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes16' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/IMDNames.sol:306:26\n    │\n306 │     function setRenderer(address renderer_) external {\n    │                          ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:189:16\n    │\n189 │             && block.timestamp <= a.expiresAt && a.answer.length == 32 && uint256(bytes32(a.answer)) == 1;\n    │                ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/SwarmPrices.sol:192:9\n    │\n192 │         emit Verdict(requestId, approved, a.agreed, a.panelSize);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:189:83\n    │\n189 │             && block.timestamp <= a.expiresAt && a.answer.length == 32 && uint256(bytes32(a.answer)) == 1;\n    │                                                                                   ━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes32' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:261:43\n    │\n261 │                 pair, SwapParams(imdIs0, -int256(amount), imdIs0 ? MIN_PRICE_LIMIT : MAX_PRICE_LIMIT), \"\"\n    │                                           ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:264:27\n    │\n264 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                           ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:264:49\n    │\n264 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                 ━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:264:67\n    │\n264 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                                   ━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:264:82\n    │\n264 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                                                  ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:265:30\n    │\n265 │             if (imdDelta != -int128(int256(amount)) || outDelta <= 0) revert Unfilled();\n    │                              ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:265:37\n    │\n265 │             if (imdDelta != -int128(int256(amount)) || outDelta <= 0) revert Unfilled();\n    │                                     ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:191:23\n    │\n191 │         p.decidedAt = uint64(block.timestamp);\n    │                       ━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPBurner.sol:268:13\n    │\n268 │             POOL_MANAGER.settle();\n    │             ━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:269:27\n    │\n269 │             uint256 out = uint128(outDelta);\n    │                           ━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:277:61\n    │\n277 │         int256 d = POOL_MANAGER.swap(key, SwapParams(true, -int256(amount), MIN_PRICE_LIMIT), \"\");\n    │                                                             ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:278:27\n    │\n278 │         int128 ethDelta = int128(d >> 128);\n    │                           ━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:279:25\n    │\n279 │         int128 bought = int128(d);\n    │                         ━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:280:26\n    │\n280 │         if (ethDelta != -int128(int256(amount)) || bought <= 0) revert Unfilled();\n    │                          ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:280:33\n    │\n280 │         if (ethDelta != -int128(int256(amount)) || bought <= 0) revert Unfilled();\n    │                                 ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPBurner.sol:283:9\n    │\n283 │         POOL_MANAGER.settle{value: amount}();\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:284:47\n    │\n284 │         POOL_MANAGER.take(IMD, address(this), uint128(bought));\n    │                                               ━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:285:27\n    │\n285 │         return abi.encode(uint256(uint128(bought)));\n    │                           ━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:285:35\n    │\n285 │         return abi.encode(uint256(uint128(bought)));\n    │                                   ━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/LARPBurner.sol:302:34\n    │\n302 │         emit Burned(rest, share, burned6900);\n    │                                  ━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/IMDNames.sol:314:24\n    │\n314 │     function setArtist(address artist_) external {\n    │                        ━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n    ╭▸ src/LARPBurner.sol:328:13\n    │\n328 │         try POOL_MANAGER.unlock{gas: LEG_GAS}(data) returns (bytes memory r) {\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:209:44\n    │\n209 │         if (p.status != Status.Approved || block.timestamp > p.decidedAt + EXECUTE_WINDOW) revert NotApproved();\n    │                                            ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:211:32\n    │\n211 │         if (lastChange != 0 && block.timestamp < lastChange + COOLDOWN) revert Cooling();\n    │                                ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:215:22\n    │\n215 │         lastChange = uint64(block.timestamp);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:340:36\n    │\n340 │             digits[i - 1] = bytes1(uint8(48 + frac % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/SwarmPrices.sol:356:15\n    │\n356 │             ++digits;\n    │               ━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:360:36\n    │\n360 │             out[--digits] = bytes1(uint8(48 + value % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[uninitialized-local]: local variable is read before being initialized\n   ╭▸ src/Labels.sol:23:16\n   │\n23 │         while (n < 32 && label[n] != 0) ++n;\n   │                ━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:208:9\n    │\n208 │         LARPBurner(payable(BURNER)).burn{value: msg.value}(minImd);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:327:22\n    │\n327 │         (bool ok,) = LARP.canAct(c.captain, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPLinks.sol:342:39\n    │\n342 │         address distributor = address(uint160(w));\n    │                                       ━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint160' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPLinks.sol:380:31\n    │\n380 │             j.token = address(uint160(t));\n    │                               ━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint160' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:443:9\n    │\n443 │         (, c.faceCollection, c.faceTokenId, c.faceLive) = LARP.faceOf(imdId);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:454:22\n    │\n454 │         (bool ok,) = LARP.canAct(imdId, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/LARPAgents.t.sol:139:28\n    │\n139 │         uint256 deadline = block.timestamp + 1 hours;\n    │                            ━━━━━━━━━━━━━━━\n140 │         bytes memory sig = _sign(ownerKey, 7, agent, owner, 0, deadline);\n141 │         vm.warp(deadline + 1);\n    │         ───────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:203:60\n    │\n203 │             _attest(id, true, 0, \"\", block.chainid, uint64(block.timestamp + 1 days));\n    │                                                            ━━━━━━━━━━━━━━━\n    ‡\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:54:30\n    │\n 54 │             issuedAt: uint64(block.timestamp),\n    │                              ━━━━━━━━━━━━━━━\n    ‡\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:209:17\n    │\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────━━━━━━━━━━━━━━━─────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:203:60\n    │\n203 │             _attest(id, true, 0, \"\", block.chainid, uint64(block.timestamp + 1 days));\n    │                                                            ━━━━━━━━━━━━━━━\n    ‡\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ───────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:54:30\n    │\n 54 │             issuedAt: uint64(block.timestamp),\n    │                              ━━━━━━━━━━━━━━━\n    ‡\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ───────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:236:17\n    │\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ────────━━━━━━━━━━━━━━━────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\n","passed":true},{"durationMs":28692,"exitCode":0,"name":"test","output":"No files changed, compilation skipped\n\nRan 11 tests for test/MainnetFork.t.sol:MainnetForkTest\n[SKIP] test_ACrewBuysAndBurnsRealIMD() (gas: 0)\n[SKIP] test_ANameBuysRealIMDOnPool4AndBurnsIt() (gas: 0)\n[SKIP] test_ANameChangesHandsAndBurns() (gas: 0)\n[SKIP] test_ANamePaidInRealImd() (gas: 0)\n[SKIP] test_APriceProposalThroughIMDsRealIntake() (gas: 0)\n[SKIP] test_AnAgentRunsTheTreasurysIdentity() (gas: 0)\n[SKIP] test_AnIdentityWearsAWorkerFren() (gas: 0)\n[SKIP] test_RealProofsRefuseTampering() (gas: 0)\n[SKIP] test_TheHooklessPoolTakesWhatPool4Cant() (gas: 0)\n[SKIP] test_TheRealJeetBoard() (gas: 0)\n[SKIP] test_TheTreasurysCard() (gas: 0)\nSuite result: ok. 0 passed; 0 failed; 11 skipped; finished in 539.12µs (688.68µs CPU time)\n\nRan 2 tests for test/Placement.t.sol:PlacementForkTest\n[SKIP] test_fork_ANameBurnsTheCanonicalWay() (gas: 0)\n[SKIP] test_fork_LandsAt6900ThroughTheRealCreateX() (gas: 0)\nSuite result: ok. 0 passed; 0 failed; 2 skipped; finished in 248.16µs (29.85µs CPU time)\n\nRan 14 tests for test/LARPAgents.t.sol:LARPAgentsTest\n[PASS] test_AContractWalletSignsWithERC1271() (gas: 431060)\n[PASS] test_ASignatureWorksOnce() (gas: 230440)\n[PASS] test_AnAgentCantNameAgentsOrTheWallet() (gas: 195893)\n[PASS] test_AnAgentDressesTheIdentityWithTheOwnersNFTs() (gas: 396334)\n[PASS] test_AnAgentLapsesOnASale() (gas: 317701)\n[PASS] test_AnAgentLinksTheOwnersNameAndSetsTexts() (gas: 985791)\n[PASS] test_AnAgentResigns() (gas: 193582)\n[PASS] test_AnAgentRunsFrensAndCrews() (gas: 1230841)\n[PASS] test_AnyAgentChangeVoidsOutstandingSignatures() (gas: 188002)\n[PASS] test_BadSignatures() (gas: 364692)\n[PASS] test_OnlyTheOwnerSetsTheAgent() (gas: 40977)\n[PASS] test_SignaturesExpire() (gas: 49228)\n[PASS] test_TheOwnerConnectsAnAgentInOneCall() (gas: 188975)\n[PASS] test_TheOwnerSignsTheAgentSends() (gas: 176447)\nSuite result: ok. 14 passed; 0 failed; 0 skipped; finished in 8.50ms (6.40ms CPU time)\n\nRan 28 tests for test/IMDNames.t.sol:IMDNamesTest\n[PASS] test_ABrokenRendererFallsBackToTheCard() (gas: 10710970)\n[PASS] test_AFeeParksWhenNoPoolCanTakeIt() (gas: 8894621)\n[PASS] test_ANewOwnerPaysTheTollToLink() (gas: 1030272)\n[PASS] test_ARoyaltyPaymentIsBurned() (gas: 567939)\n[PASS] test_AnyoneRegistersAnyFreeName() (gas: 622149)\n[PASS] test_BadNames() (gas: 76271)\n[PASS] test_LinkRules() (gas: 227703)\n[PASS] test_LinkTheNameToAnIdentity() (gas: 188953)\n[PASS] test_NoImdPaymentWithoutBothPools() (gas: 233518)\n[PASS] test_OneNamePerIdentityOneIdentityPerName() (gas: 937678)\n[PASS] test_Prices() (gas: 63806)\n[PASS] test_Primary() (gas: 249738)\n[PASS] test_RegisterForSomeoneElse() (gas: 613058)\n[PASS] test_RegisterWithImd() (gas: 959072)\n[PASS] test_RegisterWithImdRespectsMaxImd() (gas: 784834)\n[PASS] test_RegisteringMintsTheNameAndBurnsTheFee() (gas: 657957)\n[PASS] test_RegistrationRules() (gas: 228053)\n[PASS] test_RoyaltiesGoToTheBurner() (gas: 40939)\n[PASS] test_SellingTheIdentityTakesItDown() (gas: 170626)\n[PASS] test_SellingTheNameTakesItDown() (gas: 207985)\n[PASS] test_ShortNamesHaveShortNameTolls() (gas: 661117)\n[PASS] test_TextRecordsStartOverWithANewHolder() (gas: 217274)\n[PASS] test_TheArtistChangesTheArtAndOnlyTheArt() (gas: 410113)\n[PASS] test_TheBuiltInCard() (gas: 3442144)\n[PASS] test_TheNamesNewOwnerUnlinksAStaleLink() (gas: 236080)\n[PASS] test_TheTollFollowsEveryChangeOfHands() (gas: 214766)\n[PASS] test_TheTollInImd() (gas: 1093347)\n[PASS] test_Unlink() (gas: 207675)\nSuite result: ok. 28 passed; 0 failed; 0 skipped; finished in 31.50ms (41.92ms CPU time)\n\nRan 4 tests for test/Launch.t.sol:LaunchTest\n[PASS] test_DeploysOnAFreshChain() (gas: 193241)\n[PASS] test_FitsOneTransaction() (gas: 25344)\nLogs:\n  launch gas, four creations: 8303\n\n[PASS] test_PassesTheAdmissionScan() (gas: 17795593)\n[PASS] test_UnderTheCodeSizeLimit() (gas: 11134)\nSuite result: ok. 4 passed; 0 failed; 0 skipped; finished in 36.31ms (35.02ms CPU time)\n\nRan 7 tests for test/SwarmPrices.t.sol:SwarmShareTest\n[PASS] test_AndDownToNothing() (gas: 7807536)\n[PASS] test_ShareGuardrails() (gas: 5662641)\n[PASS] test_StartsAt6Point9AndTheBurnerReadsItFromIMDNames() (gas: 261284)\n[PASS] test_TheBurnerFallsBackTo6Point9() (gas: 429031)\n[PASS] test_TheQuestionNamesTheShare() (gas: 3495923)\n[PASS] test_TheSwarmMovesTheShareAndTheBurnerFollows() (gas: 2824892)\n[PASS] test_UpToAllOfIt() (gas: 7900169)\nSuite result: ok. 7 passed; 0 failed; 0 skipped; finished in 36.25ms (7.99ms CPU time)\n\nRan 18 tests for test/SwarmPricesEdges.t.sol:SwarmPricesEdgesTest\n[PASS] testFuzz_TheGuardrailsAreExactlyTheDocumentedRule(uint64,uint64,uint64,uint64) (runs: 512, μ: 336769, ~: 60870)\nLogs:\n  Bound result 3000000000000002\n  Bound result 2298081454670989\n  Bound result 1200000001509599\n  Bound result 38279129710\n\n[PASS] test_AFailureAfterAVerdictIsRefused() (gas: 2604143)\n[PASS] test_AVerdictExpiringThisSecondStillCounts() (gas: 2553440)\n[PASS] test_AnUnknownProposalIsNone() (gas: 18765)\n[PASS] test_ExactlyTwiceAndExactlyHalfAreAllowed() (gas: 7347888)\n[PASS] test_ExecutingNothingOrAPendingProposalIsRefused() (gas: 2515813)\n[PASS] test_OverpayingTheOracleIsTheProposersChoice() (gas: 2487436)\n[PASS] test_PricesAfterTwoChangesStayWithinTheRailsOfEach() (gas: 4219697)\n[PASS] test_ProposingNeedsTheProposersImd() (gas: 383908)\n[PASS] test_TheAnswerMustBeABoolTrueAboutThisChain() (gas: 7186081)\n[PASS] test_TheCallbackSelectorsAreTheProtocolsLayout() (gas: 2586325)\n[PASS] test_TheFirstChangeHasNoCooldown() (gas: 2592521)\n[PASS] test_TheLastSecondOfTheCooldown() (gas: 4323654)\n[PASS] test_TheLastSecondOfTheExecuteWindow() (gas: 2589107)\n[PASS] test_TheProtocolsOwnSignatureVerifies() (gas: 2774679)\n[PASS] test_TheProtocolsSignatureOnATamperedVectorIsRefused() (gas: 2814849)\n[PASS] test_TheVectorsSignerApprovesWithABoolAnswer() (gas: 2777870)\n[PASS] test_TwoProposalsOneVerdictEach() (gas: 4188577)\nSuite result: ok. 18 passed; 0 failed; 0 skipped; finished in 38.59ms (47.69ms CPU time)\n\nRan 24 tests for test/LARPLinksEdges.t.sol:LARPLinksEdgesTest\n[PASS] testFuzz_JeetBpsIsTheSoldShareOfTheAllocation(uint128,uint256,bool) (runs: 256, μ: 1665674, ~: 1535742)\nLogs:\n  Bound result 3474\n  Bound result 2571\n\n[PASS] testFuzz_TiersAreMonotoneInJeetPoints(uint256,uint256,uint256) (runs: 256, μ: 33075, ~: 33188)\nLogs:\n  Bound result 1000\n  Bound result 4498\n  Bound result 4089455\n\n[PASS] test_ACardWithALiveFace() (gas: 694335)\n[PASS] test_ADisbandedCrewIsGone() (gas: 995257)\n[PASS] test_ADistributorWithoutARootIsUnknown() (gas: 1411930)\n[PASS] test_ADistributorWithoutATokenCountsAsHeld() (gas: 1673522)\n[PASS] test_ALauncherAnsweringGarbageIsUnknown() (gas: 1533984)\n[PASS] test_AllocationBounds() (gas: 2897946)\n[PASS] test_AnAskSurvivesASaleOfEitherIdentity() (gas: 241341)\n[PASS] test_AnEmptyProofForASoloRound() (gas: 1509668)\n[PASS] test_AnIdentityNobodyHolds() (gas: 54774)\n[PASS] test_CaptainRules() (gas: 958767)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 13620)\n[PASS] test_CrewNamesAtTheEdges() (gas: 1430836)\n[PASS] test_Defaults() (gas: 177309)\n[PASS] test_FoundCrewWithImdRefusals() (gas: 1373283)\n[PASS] test_FoundCrewWithTheWrongValue() (gas: 364248)\n[PASS] test_InviteRules() (gas: 938730)\n[PASS] test_JoinLeaveRules() (gas: 1114710)\n[PASS] test_LaunchJeetPastTheEndReverts() (gas: 14394)\n[PASS] test_MembersCountFollowsEveryMove() (gas: 1096013)\n[PASS] test_TwoRoundsOfOneLaunchAreOneLevel() (gas: 1866769)\n[PASS] test_UnfrenClearsBothAsksAtOnce() (gas: 388582)\n[PASS] test_UnfrenWithNothingDoesNothing() (gas: 86806)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 43.82ms (58.90ms CPU time)\n\nRan 23 tests for test/IMDNamesEdges.t.sol:IMDNamesEdgesTest\n[PASS] test_APrimaryWithoutANameIsLiveAndNameless() (gas: 182236)\n[PASS] test_ARendererThatAnswersNothingFallsBack() (gas: 383627)\n[PASS] test_ASaleDarkensTheLinkAndTheTextStays() (gas: 286579)\n[PASS] test_AStrangerCannotUnlink() (gas: 160730)\n[PASS] test_AnAgentLinksUnlinksAndWrites() (gas: 486024)\n[PASS] test_ApprovalsAndOperatorTransfers() (gas: 452506)\n[PASS] test_Constants() (gas: 191514)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 15761)\n[PASS] test_LockingIsIdempotentAndKeepsTheRenderer() (gas: 292103)\n[PASS] test_PrimaryAndTextRefusals() (gas: 147701)\n[PASS] test_ReadingNames() (gas: 64773)\n[PASS] test_RegisterRefusesLessThanThePrice() (gas: 216901)\n[PASS] test_RegisterWithAFloorTheBurnCannotMeet() (gas: 224254)\n[PASS] test_RegisterWithImdNeedsAnAllowance() (gas: 622307)\n[PASS] test_ResolveNameSpellings() (gas: 150173)\n[PASS] test_RoyaltyRounding() (gas: 35079)\n[PASS] test_SafeTransfersCheckTheReceiver() (gas: 603375)\n[PASS] test_TheArtistRenouncesAndTheArtIsFinal() (gas: 154258)\n[PASS] test_TheCardOfAnUnlinkedName() (gas: 2382338)\n[PASS] test_TheLongestAndShortestNames() (gas: 1245197)\n[PASS] test_TheTollInImdRespectsMaxImd() (gas: 1135610)\n[PASS] test_TransferRules() (gas: 144769)\n[PASS] test_UnlinkingNothingDoesNothing() (gas: 37821)\nSuite result: ok. 23 passed; 0 failed; 0 skipped; finished in 45.08ms (13.60ms CPU time)\n\nRan 24 tests for test/LARPLinks.t.sol:LARPLinksTest\n[PASS] test_AGasHungryTokenCantSinkTheBoard() (gas: 1737463)\n[PASS] test_AnInnerNodeIsNotALeaf() (gas: 1448373)\n[PASS] test_AnUnreadableTokenCountsAsHeld() (gas: 1784660)\n[PASS] test_BadAllocations() (gas: 1754999)\n[PASS] test_CaptainsRun() (gas: 963173)\n[PASS] test_Card() (gas: 1645098)\n[PASS] test_CrewFoundingRules() (gas: 916902)\n[PASS] test_Disband() (gas: 1551949)\n[PASS] test_FoundACrewWithImd() (gas: 1180619)\n[PASS] test_FoundingACrewBurnsIMD() (gas: 749420)\n[PASS] test_FrenRules() (gas: 383139)\n[PASS] test_FrensPassWithTheIdentity() (gas: 302573)\n[PASS] test_FrensTakeTwo() (gas: 266329)\n[PASS] test_JeetsAreReadLive() (gas: 2364129)\n[PASS] test_JeetsInPages() (gas: 8424463)\n[PASS] test_OpenAndClosedCrews() (gas: 1696901)\n[PASS] test_PassTheCaptaincy() (gas: 948251)\n[PASS] test_ProveAnAllocation() (gas: 1534389)\n[PASS] test_RanksAcrossLaunches() (gas: 5184173)\n[PASS] test_TheCaptaincyPassesWithTheIdentity() (gas: 768169)\n[PASS] test_TheRankIsTheHoldersNow() (gas: 1748137)\n[PASS] test_Tiers() (gas: 80885)\n[PASS] test_Unfren() (gas: 271974)\n[PASS] test_WithdrawAndDeclineAsks() (gas: 244060)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 45.33ms (25.83ms CPU time)\n\nRan 15 tests for test/LARPEdges.t.sol:LARPEdgesTest\n[PASS] testFuzz_WearerOfRoundTripsForAnyIdentityId(uint256,uint8) (runs: 256, μ: 220264, ~: 220684)\nLogs:\n  Bound result 381434001271594700221214433\n  Bound result 2\n\n[PASS] test_ACopyPlacedTwiceIsCountedTwice() (gas: 341053)\n[PASS] test_ASignatureFromAnotherChainIsRefused() (gas: 83326)\n[PASS] test_AgentsOfNothing() (gas: 146135)\n[PASS] test_AnAgentTakesOffThePreviousOwnersItems() (gas: 350579)\n[PASS] test_ConstantsAndDomain() (gas: 57230)\n[PASS] test_ContractWalletsThatRefuseOrMumble() (gas: 462979)\n[PASS] test_EmptySpots() (gas: 141020)\n[PASS] test_OddSignatureBytes() (gas: 342349)\n[PASS] test_OneAgentForTwoIdentities() (gas: 326950)\n[PASS] test_RemovingAnAgentBumpsTheNonce() (gas: 371695)\n[PASS] test_ResigningDoesNotBumpTheNonce() (gas: 288556)\n[PASS] test_SupportsInterfaceIsPure() (gas: 15273)\n[PASS] test_TakingOffAnEmptySlotIsSilent() (gas: 61582)\n[PASS] test_ThePlacerTakesOffWhatItPlacedAfterSellingTheIdentity() (gas: 426342)\nSuite result: ok. 15 passed; 0 failed; 0 skipped; finished in 53.51ms (19.00ms CPU time)\n\nRan 7 tests for test/LARPBurnerSettlement.t.sol:LARPBurnerSettlementTest\n[PASS] test_ParkedWaitingEthDoesNotConsumeTheBlocksAllowance() (gas: 1404858)\n[PASS] test_PreSyncCannotParkACrewFee() (gas: 1316172)\n[PASS] test_PreSyncCannotParkARegistrationFee() (gas: 1213400)\n[PASS] test_PreSyncCannotParkAResaleToll() (gas: 1981207)\n[PASS] test_PreSyncCannotParkTheHooklessRoute() (gas: 1251240)\n[PASS] test_PreSyncCannotParkWaitingEthOrChooseTheBackup() (gas: 1176301)\n[PASS] test_PreSyncStillHonoursMinImdAndRollsBackTheAllowance() (gas: 1046616)\nSuite result: ok. 7 passed; 0 failed; 0 skipped; finished in 65.57ms (14.61ms CPU time)\n\nRan 8 tests for test/Placement.t.sol:PlacementTest\n[PASS] test_ASaltUsedFirstIsNeverTaken() (gas: 10480519)\n[PASS] test_ArgumentsAsTheReadmeSays() (gas: 6240)\n[PASS] test_DeploysOnAFreshChain() (gas: 10013473)\n[PASS] test_FitsOneTransaction() (gas: 30974288)\nLogs:\n  the launch: gas, all in: 10989653\n  PlaceLARP initcode bytes: 39120\n  PlaceLinks initcode bytes: 12010\n\n[PASS] test_LandsWhereThePlanSays() (gas: 10294882)\n[PASS] test_PassesTheAdmissionScan() (gas: 42761993)\n[PASS] test_PlanFollowsFromTheSalts() (gas: 162797)\n[PASS] test_SameAddressesWhoeverRunsIt() (gas: 19914901)\nSuite result: ok. 8 passed; 0 failed; 0 skipped; finished in 77.14ms (95.32ms CPU time)\n\nRan 18 tests for test/SwarmPrices.t.sol:SwarmPricesTest\n[PASS] testFuzz_AWrongRequestCannotSettleAPendingProposal(bytes32) (runs: 256, μ: 2670536, ~: 2670643)\n[PASS] test_AProposalForOldPricesGoesStale() (gas: 4240429)\n[PASS] test_ARejectedProposalChangesNothing() (gas: 2577335)\n[PASS] test_AVerdictCannotApproveAnotherPendingProposal() (gas: 4158565)\n[PASS] test_AVerdictMustBeUsedWithinTwoWeeks() (gas: 2551628)\n[PASS] test_AWeakPanelIsARejection() (gas: 7197220)\n[PASS] test_AnExpiredVerdictIsARejection() (gas: 2537113)\n[PASS] test_AnyoneProposesAndTheContractWritesTheQuestion() (gas: 3300450)\n[PASS] test_ApprovedThenAnyoneExecutes() (gas: 3923290)\n[PASS] test_ChangingTheSignedRequestIdInvalidatesTheSignature() (gas: 4234890)\n[PASS] test_ExecutedOnce() (gas: 2600327)\n[PASS] test_Guardrails() (gas: 218195)\n[PASS] test_NoVerdictClosesTheProposal() (gas: 2569776)\n[PASS] test_OneChangeAWeek() (gas: 4310174)\n[PASS] test_OnlyTheIntakeDeliversAndOnlyForItsOwnProposals() (gas: 2561581)\n[PASS] test_OnlyTheOraclesSignatureForThisContractCounts() (gas: 2703262)\n[PASS] test_StartPrices() (gas: 61091)\n[PASS] test_TheOracleMustBePaid() (gas: 238881)\nSuite result: ok. 18 passed; 0 failed; 0 skipped; finished in 77.28ms (78.70ms CPU time)\n\nRan 19 tests for test/LARPBurnerEdges.t.sol:LARPBurnerEdgesTest\n[PASS] testFuzz_ABurnSpendsMinOfBalanceAndMaxBurn(uint256,uint256) (runs: 128, μ: 795694, ~: 794339)\nLogs:\n  Bound result 471587299196916465\n  Bound result 121570126832559236\n\n[PASS] testFuzz_QuoteIsLinearAndMonotone(uint256,uint256) (runs: 256, μ: 576445, ~: 576522)\nLogs:\n  Bound result 9999999000000000863\n  Bound result 9999999110336000862\n\n[PASS] testFuzz_SixPointNinePercentBuysIMD6900AndTheRestBurns(uint256) (runs: 256, μ: 564829, ~: 556502)\nLogs:\n  Bound result 96\n\n[PASS] testFuzz_TwoBurnsInOneBlockSellAtMostOneCapOfWaitingEth(uint256,uint256,uint256) (runs: 192, μ: 1014276, ~: 1017447)\nLogs:\n  Bound result 499999000000011652\n  Bound result 99999999999999999\n  Bound result 7068\n\n[PASS] test_APartialFillOnPool4FallsToTheHooklessPool() (gas: 2588067)\n[PASS] test_AWethAnsweringShortIsIgnored() (gas: 905473)\n[PASS] test_AWethThatRefusesToUnwrapIsIgnored() (gas: 943064)\n[PASS] test_AWrongPool4KeyFallsToTheHooklessPool() (gas: 835984)\n[PASS] test_BelowTheLegBudgetABurnIsRefusedBeforeAnyLegRuns() (gas: 1008060)\n[PASS] test_Constants() (gas: 72853)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 9394)\n[PASS] test_ExactlyMaxBurnInOneCall() (gas: 1357561)\n[PASS] test_NoPoolAtAllParksAndQuotesNothing() (gas: 613447)\n[PASS] test_NothingToBurnIsNotAnError() (gas: 383300)\n[PASS] test_OneWeiParks() (gas: 668090)\n[PASS] test_QuoteOfTheSmallestPrice() (gas: 549094)\n[PASS] test_ReceiveTakesEmptyCallsOnly() (gas: 66423)\n[PASS] test_TheBlockAllowanceCountsOnlyTheWaitingEth() (gas: 2369304)\n[PASS] test_UnwrappedWethIsWaitingEth() (gas: 1655564)\nSuite result: ok. 19 passed; 0 failed; 0 skipped; finished in 78.47ms (224.28ms CPU time)\n\nRan 27 tests for test/LARPBurner.t.sol:LARPBurnerTest\n[PASS] test_AFeeAlwaysGoesThroughWhateverTheBlockSpent() (gas: 2325890)\n[PASS] test_AGasEatingIMD6900IsSkippedNotFatal() (gas: 7942385)\n[PASS] test_AGasEatingPool4HookFallsToTheHooklessPool() (gas: 4102897)\n[PASS] test_AGenuineFailureIsNotMistakenForTooLittleGas() (gas: 876639)\n[PASS] test_ASwapOutOfGasReverts() (gas: 10080186)\n[PASS] test_AnEmptyPairPoolMeansItAllBurnsAsIMD() (gas: 827279)\n[PASS] test_AnIMD6900LegOutOfGasDeepDownReverts() (gas: 3821761)\n[PASS] test_AnIMD6900ThatWontBurnMeansItAllBurnsAsIMD() (gas: 789638)\n[PASS] test_AtMostMaxBurnPerCallAndPerBlockOfWaitingEth() (gas: 2373317)\n[PASS] test_BurnCallsBatchedInOneTransactionSellOneCap() (gas: 1036999)\n[PASS] test_BurnImdBurnsWhatArrivesInIMD() (gas: 519860)\n[PASS] test_BuysOnPool4First() (gas: 1073540)\n[PASS] test_HostileLegsCostPaidCallsTheirBudgets() (gas: 11581009)\nLogs:\n  registration gas used with two hostile legs: 6026491\n\n[PASS] test_MinImd() (gas: 961486)\n[PASS] test_NoGasLimitSkipsAHeavyIMD6900Leg() (gas: 68136929)\n[PASS] test_NoGasLimitSkipsARoute() (gas: 5984012)\n[PASS] test_NoQuoteWithoutBothPools() (gas: 297276)\n[PASS] test_NoReentry() (gas: 467731)\n[PASS] test_OnlyThePoolManagerCallsBack() (gas: 32829)\n[PASS] test_ParkedWhenNoPoolCanAndBurnedLater() (gas: 1381349)\n[PASS] test_QuoteIsTheHigherOfTheTwoPools() (gas: 1129758)\n[PASS] test_RoyaltiesArriveByPlainTransfer() (gas: 44081)\n[PASS] test_ShareBuysIMD6900AndBurnsIt() (gas: 851825)\n[PASS] test_SpacingAboveV4sLargestReverts() (gas: 11396)\n[PASS] test_SpacingsAreTakenUnsignedAndKeptAsInt24() (gas: 28301)\n[PASS] test_TheHooklessPoolIfPool4CantTakeIt() (gas: 1185610)\n[PASS] test_WethRoyaltiesAreUnwrappedAndSold() (gas: 1132967)\nSuite result: ok. 27 passed; 0 failed; 0 skipped; finished in 129.30ms (217.55ms CPU time)\n\nRan 1 test for test/SwarmPrices.invariant.t.sol:SwarmPricesInvariantTest\n[PASS]\nSwarmPricesInvariantTest invariants:\n[PASS] invariant_CountersMatchWhatHappened\n[PASS] invariant_NamesHoldsNothing\n[PASS] invariant_NoProposalReopens\n[PASS] invariant_PricesChangeOnlyByExecution\n[PASS] invariant_PricesWithinTheGuardrails\n SwarmPricesInvariantTest invariants (runs: 64, calls: 3072, reverts: 0)\n\n╭--------------+----------+-------+---------+----------╮\n| Contract     | Selector | Calls | Reverts | Discards |\n+======================================================+\n| SwarmHandler | execute  | 436   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | fail     | 446   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | forge    | 422   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | pass     | 441   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | propose  | 428   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | stranger | 455   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | verdict  | 444   | 0       | 0        |\n╰--------------+----------+-------+---------+----------╯\n\nLogs:\n  Bound result 18400000000018355\n  Bound result 4506666666683964\n  Bound result 1840000000057006\n  Bound result 1840000000000009\n  Bound result 400000000000008958\n  Bound result 770687\n  Bound result 18400000000000160\n  Bound result 4506666700207187\n  Bound result 1840000000004581\n  Bound result 1840000000014214\n  Bound result 400000002835717309\n  Bound result 7149\n  Bound result 18400000000001593\n  Bound result 4506666666715547\n  Bound result 1840000000001381\n  Bound result 1840000000003209\n  Bound result 400000000000005093\n  Bound result 18400000000003966\n  Bound result 4799999999997960\n  Bound result 1840000000004378\n  Bound result 1239999999999997\n  Bound result 400000000000003602\n  Bound result 53996\n  Bound result 251852\n  Bound result 18400000003000001\n  Bound result 4506666666678534\n  Bound result 1840000005500001\n  Bound result 1840000000000880\n  Bound result 599999999500000003\n  Bound result 18400000000014577\n  Bound result 4506666666966668\n  Bound result 1840002158778574\n  Bound result 1840000000012177\n  Bound result 400000000000002991\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 475.68ms (472.53ms CPU time)\n\nRan 14 tests for test/LARPItems.t.sol:LARPItemsTest\n[PASS] test_AFaceBecomesAnItem() (gas: 321185)\n[PASS] test_AnItemBecomesAnotherIdentitysFace() (gas: 306295)\n[PASS] test_EquipAnERC1155Copy() (gas: 195226)\n[PASS] test_EquipAnERC721() (gas: 228623)\n[PASS] test_OneCopyOnePlacement() (gas: 372050)\n[PASS] test_ReequippingTheSameCopyInTheSameSlot() (gas: 213412)\n[PASS] test_RefusedItems() (gas: 220243)\n[PASS] test_ReplacingAnItemFreesTheOldOne() (gas: 291522)\n[PASS] test_SellingACopyDarkensItsPlacementsUntilOneComesOff() (gas: 456264)\n[PASS] test_SellingTheIdentityDarkensItsItems() (gas: 360711)\n[PASS] test_SlotsAreOneToEight() (gas: 224747)\n[PASS] test_StrangersCantTakeItemsOff() (gas: 174966)\n[PASS] test_TheNewOwnerClearsTheOldItems() (gas: 343634)\n[PASS] test_ThePlacerTakesItsCopyBackAfterSellingTheIdentity() (gas: 399525)\nSuite result: ok. 14 passed; 0 failed; 0 skipped; finished in 477.16ms (2.66ms CPU time)\n\nRan 24 tests for test/LARP.t.sol:LARPFaceTest\n[PASS] testFuzz_OnlyTheHolderOfBothSetsAFace(address,uint256,uint256) (runs: 256, μ: 55838, ~: 56425)\nLogs:\n  Bound result 1\n  Bound result 10\n\n[PASS] test_AFaceComesBackWithBothTokens() (gas: 220934)\n[PASS] test_AMaskMovesToTheIdentityThatPutsItOn() (gas: 323750)\n[PASS] test_AvatarFormat() (gas: 249931)\n[PASS] test_ChangingMasksFreesTheOldOne() (gas: 274960)\n[PASS] test_ClearFace() (gas: 200738)\n[PASS] test_ClearingNoFaceDoesNothing() (gas: 36612)\n[PASS] test_FaceURIFallsBackOnABrokenTokenURI() (gas: 2152591)\n[PASS] test_OnlyTheIdentitysOwnerClears() (gas: 173845)\n[PASS] test_PuttingTheSameMaskOnAgain() (gas: 240094)\n[PASS] test_RefusesAMaskThatIsNotYours() (gas: 49187)\n[PASS] test_RefusesAnIdentityAsAMask() (gas: 41585)\n[PASS] test_RefusesAnIdentityThatDoesNotExist() (gas: 41653)\n[PASS] test_RefusesAnIdentityThatIsNotYours() (gas: 43653)\n[PASS] test_RefusesWhatIsNotAnNFT() (gas: 510494)\n[PASS] test_SellingTheIdentityTakesTheFaceDown() (gas: 252506)\n[PASS] test_SellingTheMaskTakesTheFaceDown() (gas: 223250)\n[PASS] test_SetFace() (gas: 266231)\n[PASS] test_SupportsInterface() (gas: 27637)\n[PASS] test_TheIdentitysNewOwnerClearsTheOldFace() (gas: 225470)\n[PASS] test_TheNewHolderOfAMaskTakesItOff() (gas: 321718)\n[PASS] test_TheNewOwnerMustChooseAgain() (gas: 327564)\n[PASS] test_WearerOfAnUnwornMask() (gas: 14020)\n[PASS] test_ZeroIdentityRefused() (gas: 4446)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 477.17ms (18.06ms CPU time)\n\nRan 1 test for test/LARPBurner.invariant.t.sol:LARPBurnerInvariantTest\n[PASS]\nLARPBurnerInvariantTest invariants:\n[PASS] invariant_DeadHoldsOnlyImd\n[PASS] invariant_EthLeavesOnlyAsASwap\n[PASS] invariant_Imd6900OnlyBurns\n[PASS] invariant_ImdGoesOnlyToDeadOrTheIMD6900Buy\n[PASS] invariant_NoImdOutlivesABurn\n[PASS] invariant_WaitingEthLeavesAtMostOneCapPerBlock\n LARPBurnerInvariantTest invariants (runs: 64, calls: 3072, reverts: 0)\n\n╭---------------+-------------------+-------+---------+----------╮\n| Contract      | Selector          | Calls | Reverts | Discards |\n+================================================================+\n| BurnerHandler | burn              | 380   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | burnImd           | 348   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | burnWithLittleGas | 391   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateEth         | 436   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateImd         | 373   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateWeth        | 362   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | nextBlock         | 355   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | trade             | 427   | 0       | 0        |\n╰---------------+-------------------+-------+---------+----------╯\n\nLogs:\n  Bound result 5622060740456107708978\n  Bound result 12176\n  Bound result 3005718\n  Bound result 500000000000000\n  Bound result 1947\n  Bound result 284316827753434525\n  Bound result 358793239081170476\n  Bound result 367959472086682925\n  Bound result 184812773397540567\n  Bound result 2433318\n  Bound result 5999005520000000000002\n  Bound result 500000000000000000\n  Bound result 69\n  Bound result 5295\n  Bound result 1\n  Bound result 6340\n  Bound result 303217537091289238245\n  Bound result 1\n  Bound result 81570759080747168\n  Bound result 5231\n  Bound result 300000000000000000\n  Bound result 127\n  Bound result 1\n  Bound result 2\n  Bound result 299999999999999999\n  Bound result 1707490\n  Bound result 76080\n  Bound result 69576962644345793\n  Bound result 1856\n  Bound result 845000000000000\n  Bound result 1\n  Bound result 6999\n  Bound result 264337593543950336\n  Bound result 273518312084598762\n  Bound result 14930\n  Bound result 499792917818885444\n  Bound result 2870\n  Bound result 15965\n  Bound result 5630\n  Bound result 13946\n  Bound result 2267419\n  Bound result 777600\n  Bound result 133378206054161229\n  Bound result 150001\n  Bound result 3006782\n  Bound result 2\n  Bound result 54243722424859933\n  Bound result 1933009\n  Bound result 194265960037000698\n  Bound result 63\n  Bound result 3002238\n  Bound result 5999000000000000001614\n  Bound result 2834634216490329199\n  Bound result 383779998\n  Bound result 1380000000000000000\n  Bound result 1532892063\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 774.48ms (767.45ms CPU time)\n\nRan 1 test for test/LARP.invariant.t.sol:LARPInvariantTest\n[PASS]\nLARPInvariantTest invariants:\n[PASS] invariant_LiveMeansThePlacerHoldsIt\n[PASS] invariant_NoMoreLiveCopiesThanHeld\n[PASS] invariant_OneTokenOneSpot\n LARPInvariantTest invariants (runs: 128, calls: 8192, reverts: 0)\n\n╭-------------+--------------+-------+---------+----------╮\n| Contract    | Selector     | Calls | Reverts | Discards |\n+=========================================================+\n| LarpHandler | equip1155    | 1184  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | equip721     | 1207  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveCopy     | 1175  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveIdentity | 1145  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveMask     | 1168  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | setFace      | 1122  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | takeOff      | 1191  | 0       | 0        |\n╰-------------+--------------+-------+---------+----------╯\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 28.59s (28.59s CPU time)\n\nRan 21 test suites in 28.59s (31.56s CPU time): 277 tests passed, 0 failed, 13 skipped (290 total tests)\n","passed":true},{"durationMs":90,"exitCode":0,"name":"source-index","output":"{\"v\":1,\"entryPoints\":[\"IMDNames.approve(address,uint256)\",\"IMDNames.execute(bytes32)\",\"IMDNames.link(uint256,uint256,uint256)\",\"IMDNames.linkWithImd(uint256,uint256,uint256)\",\"IMDNames.lockRenderer()\",\"IMDNames.onNoVerdict(bytes32,uint8,bytes32,uint16,uint16,bytes)\",\"IMDNames.onVerdict(bytes32,(bytes32,uint256,bytes32,uint8,bytes,uint256,uint64,uint64,bytes32,bytes32,uint16,uint16,uint16,uint64,uint64),bytes)\",\"IMDNames.propose((uint64,uint64,uint64,uint64,uint16),uint256)\",\"IMDNames.register(bytes32,address,uint256)\",\"IMDNames.registerWithImd(bytes32,address,uint256)\",\"IMDNames.safeTransferFrom(address,address,uint256)\",\"IMDNames.safeTransferFrom(address,address,uint256,bytes)\",\"IMDNames.setApprovalForAll(address,bool)\",\"IMDNames.setArtist(address)\",\"IMDNames.setPrimary(uint256)\",\"IMDNames.setRenderer(address)\",\"IMDNames.setText(uint256,string,string)\",\"IMDNames.transferFrom(address,address,uint256)\",\"IMDNames.unlink(uint256)\",\"LARP.clearFace(uint256)\",\"LARP.equip(uint256,uint256,address,uint256,uint8)\",\"LARP.resignAgent(uint256)\",\"LARP.setAgent(uint256,address)\",\"LARP.setAgentBySig(uint256,address,uint256,bytes)\",\"LARP.setFace(uint256,address,uint256)\",\"LARP.unequip(uint256,uint256)\",\"LARPBurner.burn(uint256)\",\"LARPBurner.burnImd()\",\"LARPBurner.receive()\",\"LARPBurner.unlockCallback(bytes)\",\"LARPLinks.disband(uint256)\",\"LARPLinks.foundCrew(uint256,bytes32,bool,uint256)\",\"LARPLinks.foundCrewWithImd(uint256,bytes32,bool,uint256)\",\"LARPLinks.fren(uint256,uint256)\",\"LARPLinks.invite(uint256,uint256,bool)\",\"LARPLinks.join(uint256,uint256)\",\"LARPLinks.kick(uint256,uint256)\",\"LARPLinks.leave(uint256)\",\"LARPLinks.passCaptain(uint256,uint256)\",\"LARPLinks.proveAlloc(uint64,uint256,address,uint256,bytes32[])\",\"LARPLinks.setOpen(uint256,bool)\",\"LARPLinks.unfren(uint256,uint256)\"],\"files\":{\".gitignore\":4,\"ADAPTATION.md\":131,\"AUDIT-COVERAGE.md\":199,\"AUDIT.md\":278,\"README.md\":231,\"foundry.toml\":34,\"launch.json\":14,\"script/place/gen.py\":122,\"src/IIMDNames.sol\":112,\"src/ILARP.sol\":120,\"src/IMDNames.sol\":358,\"src/LARP.sol\":330,\"src/LARPBurner.sol\":364,\"src/LARPLinks.sol\":457,\"src/Labels.sol\":53,\"src/SafeReads.sol\":63,\"src/SwarmPrices.sol\":369,\"src/place/LARPPlan.sol\":38,\"src/place/PlaceLARP.sol\":148,\"test/Base.sol\":308,\"test/IMDNames.t.sol\":481,\"test/IMDNamesEdges.t.sol\":458,\"test/LARP.invariant.t.sol\":184,\"test/LARP.t.sol\":324,\"test/LARPAgents.t.sol\":269,\"test/LARPBurner.invariant.t.sol\":468,\"test/LARPBurner.t.sol\":585,\"test/LARPBurnerEdges.t.sol\":403,\"test/LARPBurnerSettlement.t.sol\":155,\"test/LARPEdges.t.sol\":340,\"test/LARPItems.t.sol\":236,\"test/LARPLinks.t.sol\":515,\"test/LARPLinksEdges.t.sol\":459,\"test/Launch.t.sol\":134,\"test/MainnetFork.t.sol\":344,\"test/Mocks.sol\":89,\"test/Placement.t.sol\":347,\"test/SwarmPrices.invariant.t.sol\":364,\"test/SwarmPrices.t.sol\":587,\"test/SwarmPricesEdges.t.sol\":353,\"test/fixtures/allocs.json\":118},\"excluded\":[\"lib/\",\"node_modules/\"],\"truncated\":false}","passed":true}],"detail":"all checks passed","evaluation":"checks","profile":"foundry","status":"accepted","submissionHash":"b19ddcfcf896af2a5bbe3aa5c4c8a7f6be5e0599831700bdb6c2c61b78db86c3","verifiedTreeHash":"afd32f87faf019c8aa100128502b6983e1e1f77b","verifierVersion":"0.1.0+fb8278c5"},{"checks":[{"durationMs":288303,"exitCode":0,"name":"build","output":"Compiling 103 files with Solc 0.8.26\nSolc 0.8.26 finished in 287.88s\nCompiler run successful!\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:320:25\n    │\n320 │                 return (true, r);\n    │                         ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:220:33\n    │\n220 │         if (at == 0) return (0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:111:33\n    │\n111 │         if (at == 0) return (0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:120:64\n    │\n120 │         if (holder == address(0) || who == address(0)) return (false, holder);\n    │                                                                ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:121:36\n    │\n121 │         if (who == holder) return (true, holder);\n    │                                    ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:228:42\n    │\n228 │         if (owner == address(0)) return (false, address(0), 0, false);\n    │                                          ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:228:64\n    │\n228 │         if (owner == address(0)) return (false, address(0), 0, false);\n    │                                                                ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[uninitialized-local]: local variable is read before being initialized\n   ╭▸ src/Labels.sol:23:16\n   │\n23 │         while (n < 32 && label[n] != 0) ++n;\n   │                ━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:240:33\n    │\n240 │         if (label == 0) return (false, address(0), 0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:240:55\n    │\n240 │         if (label == 0) return (false, address(0), 0, false);\n    │                                                       ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:247:37\n    │\n247 │         if (at == 0) return (0, \"\", false);\n    │                                     ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:323:25\n    │\n323 │                 return (false, \"\");\n    │                         ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:329:21\n    │\n329 │             return (true, r);\n    │                     ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:331:21\n    │\n331 │             return (false, \"\");\n    │                     ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n   ╭▸ src/place/PlaceLARP.sol:49:98\n   │\n49 │             if (_proxy(LARPPlan.CREATEX, g).code.length == 0 && at.code.length == 0) return (at, true);\n   │                                                                                                  ━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n   ╭▸ src/place/PlaceLARP.sol:51:48\n   │\n51 │         return (_create3(address(this), salt), false);\n   │                                                ━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:265:36\n    │\n265 │         if (at == 0) return (0, 0, false);\n    │                                    ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[unsafe-typecast]: typecast can truncate values\n   ╭▸ src/SwarmPrices.sol:87:38\n   │\n87 │     bytes32 public constant ACTION = bytes32(\"oracle.request@oracle-1\");\n   │                                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ├ note: consider disabling this lint if you're certain the cast is safe\n   │       \n   │       // casting to 'bytes32' is safe because [explain why]\n   │       // forge-lint: disable-next-line(unsafe-typecast)\n   │       \n   │       \n   ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/SwarmPrices.sol:137:33\n    │\n137 │     constructor(address intake, address oracleSigner, Prices memory start) {\n    │                                 ━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/SwarmPrices.sol:137:17\n    │\n137 │     constructor(address intake, address oracleSigner, Prices memory start) {\n    │                 ━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:136:9\n    │\n136 │         address pairHook,\n    │         ━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:130:9\n    │\n130 │         address pool4Hook,\n    │         ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:137:9\n    │\n137 │         address names\n    │         ━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n   ╭▸ src/LARP.sol:78:13\n   │\n78 │         if (block.timestamp > deadline) revert Expired();\n   │             ━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n    ╭▸ src/LARPBurner.sol:162:13\n    │\n162 │             n.staticcall{gas: SHARE_GAS}(abi.encodeWithSelector(IShareSource.imd6900ShareBps.selector));\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:208:9\n    │\n208 │         LARPBurner(payable(BURNER)).burn{value: msg.value}(minImd);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:172:16\n    │\n172 │         return int24(s);\n    │                ━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int24' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n   ╭▸ src/IMDNames.sol:67:63\n   │\n67 │     constructor(address identity, ILARP larp, address burner, address artist_, address intake, address oracleSigner)\n   │                                                               ━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARP.sol:138:9\n    │\n138 │         emit AgentSet(imdId, holder, agent);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:109:9\n    │\n109 │         LARPBurner(payable(BURNER)).burn{value: price}(minImd);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:123:24\n    │\n123 │         if (toll != 0) LARPBurner(payable(BURNER)).burn{value: toll}(minImd);\n    │                        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:159:45\n    │\n159 │         return ok && answer.length >= 32 && bytes4(abi.decode(answer, (bytes32))) == 0x1626ba7e;\n    │                                             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes4' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:88:13\n    │\n 88 │ ┏             abi.encodePacked(\n 89 │ ┃                 type(LARPBurner).creationCode,\n 90 │ ┃                 abi.encode(\n 91 │ ┃                     LARPPlan.POOL_MANAGER,\n    ‡ ┃\n104 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/SwarmPrices.sol:176:9\n    │\n176 │         emit Proposed(requestId, number, msg.sender, next);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:108:36\n    │\n108 │         _place(LARPPlan.LARP_SALT, abi.encodePacked(type(LARP).creationCode, abi.encode(LARPPlan.IDENTITY)), l, lx);\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:111:13\n    │\n111 │ ┏             abi.encodePacked(\n112 │ ┃                 type(IMDNames).creationCode,\n113 │ ┃                 abi.encode(LARPPlan.IDENTITY, l, b, LARPPlan.ARTIST, LARPPlan.INTAKE, LARPPlan.ORACLE_SIGNER)\n114 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/LARPBurner.sol:319:17\n    │\n319 │             try POOL_MANAGER.unlock(data) returns (bytes memory r) {\n    │                 ━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:133:13\n    │\n133 │ ┏             abi.encodePacked(\n134 │ ┃                 type(LARPLinks).creationCode,\n135 │ ┃                 abi.encode(\n136 │ ┃                     LARPPlan.IDENTITY,\n    ‡ ┃\n142 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/LARPBurner.sol:328:13\n    │\n328 │         try POOL_MANAGER.unlock{gas: LEG_GAS}(data) returns (bytes memory r) {\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:327:22\n    │\n327 │         (bool ok,) = LARP.canAct(c.captain, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:224:21\n    │\n224 │                     emit Bought(eth, imd, route);\n    │                     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:228:27\n    │\n228 │             if (imd == 0) emit Parked(eth);\n    │                           ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:302:9\n    │\n302 │         emit Burned(rest, share, burned6900);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[require-revert-in-loop]: `require` or `revert` inside a loop\n    ╭▸ src/LARPBurner.sol:322:49\n    │\n322 │                 if (gasleft() <= gasBefore / 4) revert TooLittleGas();\n    │                                                 ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/require-revert-in-loop\n\nwarning[require-revert-in-loop]: `require` or `revert` inside a loop\n    ╭▸ src/LARPBurner.sol:327:61\n    │\n327 │         if (gasleft() < LEG_GAS + LEG_GAS / 63 + AFTER_GAS) revert TooLittleGas();\n    │                                                             ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/require-revert-in-loop\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:207:39\n    │\n207 │         uint256 spent = _burnBlock == uint64(block.number) ? _burnedInBlock : 0;\n    │                                       ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:221:38\n    │\n221 │                         _burnBlock = uint64(block.number);\n    │                                      ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:222:42\n    │\n222 │                         _burnedInBlock = uint192(spent + waiting);\n    │                                          ━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint192' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:137:9\n    │\n137 │         emit NameRegistered(tokenId, label, to, price);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPLinks.sol:342:39\n    │\n342 │         address distributor = address(uint160(w));\n    │                                       ━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint160' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:153:13\n    │\n153 │             emit NameUnlinked(old, imdId);\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:158:13\n    │\n158 │             emit NameUnlinked(tokenId, was - 1);\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:162:9\n    │\n162 │         emit NameLinked(tokenId, imdId, holder, toll);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPLinks.sol:380:31\n    │\n380 │             j.token = address(uint160(t));\n    │                               ━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint160' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/LARP.sol:310:15\n    │\n310 │             ++digits;\n    │               ━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:314:36\n    │\n314 │             out[--digits] = bytes1(uint8(48 + value % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:185:9\n    │\n185 │         emit NameUnlinked(tokenId, imdId);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:181:22\n    │\n181 │         (bool ok,) = LARP.canAct(imdId, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:325:22\n    │\n325 │             out[i] = bytes16(\"0123456789abcdef\")[v & 15];\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes16' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:443:9\n    │\n443 │         (, c.faceCollection, c.faceTokenId, c.faceLive) = LARP.faceOf(imdId);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:454:22\n    │\n454 │         (bool ok,) = LARP.canAct(imdId, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/IMDNames.sol:306:26\n    │\n306 │     function setRenderer(address renderer_) external {\n    │                          ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:261:43\n    │\n261 │                 pair, SwapParams(imdIs0, -int256(amount), imdIs0 ? MIN_PRICE_LIMIT : MAX_PRICE_LIMIT), \"\"\n    │                                           ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:264:27\n    │\n264 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                           ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:264:49\n    │\n264 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                 ━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:264:67\n    │\n264 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                                   ━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:264:82\n    │\n264 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                                                  ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:265:30\n    │\n265 │             if (imdDelta != -int128(int256(amount)) || outDelta <= 0) revert Unfilled();\n    │                              ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:265:37\n    │\n265 │             if (imdDelta != -int128(int256(amount)) || outDelta <= 0) revert Unfilled();\n    │                                     ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPBurner.sol:268:13\n    │\n268 │             POOL_MANAGER.settle();\n    │             ━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:269:27\n    │\n269 │             uint256 out = uint128(outDelta);\n    │                           ━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:277:61\n    │\n277 │         int256 d = POOL_MANAGER.swap(key, SwapParams(true, -int256(amount), MIN_PRICE_LIMIT), \"\");\n    │                                                             ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:278:27\n    │\n278 │         int128 ethDelta = int128(d >> 128);\n    │                           ━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:279:25\n    │\n279 │         int128 bought = int128(d);\n    │                         ━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:280:26\n    │\n280 │         if (ethDelta != -int128(int256(amount)) || bought <= 0) revert Unfilled();\n    │                          ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:280:33\n    │\n280 │         if (ethDelta != -int128(int256(amount)) || bought <= 0) revert Unfilled();\n    │                                 ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPBurner.sol:283:9\n    │\n283 │         POOL_MANAGER.settle{value: amount}();\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:284:47\n    │\n284 │         POOL_MANAGER.take(IMD, address(this), uint128(bought));\n    │                                               ━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:285:27\n    │\n285 │         return abi.encode(uint256(uint128(bought)));\n    │                           ━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:285:35\n    │\n285 │         return abi.encode(uint256(uint128(bought)));\n    │                                   ━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/LARPBurner.sol:302:34\n    │\n302 │         emit Burned(rest, share, burned6900);\n    │                                  ━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/IMDNames.sol:314:24\n    │\n314 │     function setArtist(address artist_) external {\n    │                        ━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n    ╭▸ src/LARPBurner.sol:328:13\n    │\n328 │         try POOL_MANAGER.unlock{gas: LEG_GAS}(data) returns (bytes memory r) {\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[unsafe-typecast]: typecast can truncate values\n   ╭▸ src/SafeReads.sol:21:46\n   │\n21 │         return ok && w >> 160 == 0 ? address(uint160(w)) : address(0);\n   │                                              ━━━━━━━━━━\n   │\n   ├ note: consider disabling this lint if you're certain the cast is safe\n   │       \n   │       // casting to 'uint160' is safe because [explain why]\n   │       // forge-lint: disable-next-line(unsafe-typecast)\n   │       \n   │       \n   ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n   ╭▸ src/SafeReads.sol:47:40\n   │\n47 │         (bool ok, bytes memory data) = target.staticcall{gas: gasCap}(call);\n   │                                        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:189:16\n    │\n189 │             && block.timestamp <= a.expiresAt && a.answer.length == 32 && uint256(bytes32(a.answer)) == 1;\n    │                ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/SwarmPrices.sol:192:9\n    │\n192 │         emit Verdict(requestId, approved, a.agreed, a.panelSize);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:189:83\n    │\n189 │             && block.timestamp <= a.expiresAt && a.answer.length == 32 && uint256(bytes32(a.answer)) == 1;\n    │                                                                                   ━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes32' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:191:23\n    │\n191 │         p.decidedAt = uint64(block.timestamp);\n    │                       ━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:209:44\n    │\n209 │         if (p.status != Status.Approved || block.timestamp > p.decidedAt + EXECUTE_WINDOW) revert NotApproved();\n    │                                            ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:211:32\n    │\n211 │         if (lastChange != 0 && block.timestamp < lastChange + COOLDOWN) revert Cooling();\n    │                                ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:215:22\n    │\n215 │         lastChange = uint64(block.timestamp);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:340:36\n    │\n340 │             digits[i - 1] = bytes1(uint8(48 + frac % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/SwarmPrices.sol:356:15\n    │\n356 │             ++digits;\n    │               ━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:360:36\n    │\n360 │             out[--digits] = bytes1(uint8(48 + value % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/LARPAgents.t.sol:139:28\n    │\n139 │         uint256 deadline = block.timestamp + 1 hours;\n    │                            ━━━━━━━━━━━━━━━\n140 │         bytes memory sig = _sign(ownerKey, 7, agent, owner, 0, deadline);\n141 │         vm.warp(deadline + 1);\n    │         ───────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:203:60\n    │\n203 │             _attest(id, true, 0, \"\", block.chainid, uint64(block.timestamp + 1 days));\n    │                                                            ━━━━━━━━━━━━━━━\n    ‡\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:54:30\n    │\n 54 │             issuedAt: uint64(block.timestamp),\n    │                              ━━━━━━━━━━━━━━━\n    ‡\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:209:17\n    │\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────━━━━━━━━━━━━━━━─────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:203:60\n    │\n203 │             _attest(id, true, 0, \"\", block.chainid, uint64(block.timestamp + 1 days));\n    │                                                            ━━━━━━━━━━━━━━━\n    ‡\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ───────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:54:30\n    │\n 54 │             issuedAt: uint64(block.timestamp),\n    │                              ━━━━━━━━━━━━━━━\n    ‡\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ───────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:236:17\n    │\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ────────━━━━━━━━━━━━━━━────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\n","passed":true},{"durationMs":54277,"exitCode":0,"name":"test","output":"No files changed, compilation skipped\n\nRan 11 tests for test/MainnetFork.t.sol:MainnetForkTest\n[SKIP] test_ACrewBuysAndBurnsRealIMD() (gas: 0)\n[SKIP] test_ANameBuysRealIMDOnPool4AndBurnsIt() (gas: 0)\n[SKIP] test_ANameChangesHandsAndBurns() (gas: 0)\n[SKIP] test_ANamePaidInRealImd() (gas: 0)\n[SKIP] test_APriceProposalThroughIMDsRealIntake() (gas: 0)\n[SKIP] test_AnAgentRunsTheTreasurysIdentity() (gas: 0)\n[SKIP] test_AnIdentityWearsAWorkerFren() (gas: 0)\n[SKIP] test_RealProofsRefuseTampering() (gas: 0)\n[SKIP] test_TheHooklessPoolTakesWhatPool4Cant() (gas: 0)\n[SKIP] test_TheRealJeetBoard() (gas: 0)\n[SKIP] test_TheTreasurysCard() (gas: 0)\nSuite result: ok. 0 passed; 0 failed; 11 skipped; finished in 1.05ms (192.03µs CPU time)\n\nRan 2 tests for test/Placement.t.sol:PlacementForkTest\n[SKIP] test_fork_ANameBurnsTheCanonicalWay() (gas: 0)\n[SKIP] test_fork_LandsAt6900ThroughTheRealCreateX() (gas: 0)\nSuite result: ok. 0 passed; 0 failed; 2 skipped; finished in 1.12ms (55.37µs CPU time)\n\nRan 14 tests for test/LARPItems.t.sol:LARPItemsTest\n[PASS] test_AFaceBecomesAnItem() (gas: 321185)\n[PASS] test_AnItemBecomesAnotherIdentitysFace() (gas: 306295)\n[PASS] test_EquipAnERC1155Copy() (gas: 195226)\n[PASS] test_EquipAnERC721() (gas: 228623)\n[PASS] test_OneCopyOnePlacement() (gas: 372050)\n[PASS] test_ReequippingTheSameCopyInTheSameSlot() (gas: 213412)\n[PASS] test_RefusedItems() (gas: 220243)\n[PASS] test_ReplacingAnItemFreesTheOldOne() (gas: 291522)\n[PASS] test_SellingACopyDarkensItsPlacementsUntilOneComesOff() (gas: 456264)\n[PASS] test_SellingTheIdentityDarkensItsItems() (gas: 360711)\n[PASS] test_SlotsAreOneToEight() (gas: 224747)\n[PASS] test_StrangersCantTakeItemsOff() (gas: 174966)\n[PASS] test_TheNewOwnerClearsTheOldItems() (gas: 343634)\n[PASS] test_ThePlacerTakesItsCopyBackAfterSellingTheIdentity() (gas: 399525)\nSuite result: ok. 14 passed; 0 failed; 0 skipped; finished in 5.47ms (5.50ms CPU time)\n\nRan 14 tests for test/LARPAgents.t.sol:LARPAgentsTest\n[PASS] test_AContractWalletSignsWithERC1271() (gas: 431060)\n[PASS] test_ASignatureWorksOnce() (gas: 230440)\n[PASS] test_AnAgentCantNameAgentsOrTheWallet() (gas: 195893)\n[PASS] test_AnAgentDressesTheIdentityWithTheOwnersNFTs() (gas: 396334)\n[PASS] test_AnAgentLapsesOnASale() (gas: 317701)\n[PASS] test_AnAgentLinksTheOwnersNameAndSetsTexts() (gas: 985791)\n[PASS] test_AnAgentResigns() (gas: 193582)\n[PASS] test_AnAgentRunsFrensAndCrews() (gas: 1230841)\n[PASS] test_AnyAgentChangeVoidsOutstandingSignatures() (gas: 188002)\n[PASS] test_BadSignatures() (gas: 364692)\n[PASS] test_OnlyTheOwnerSetsTheAgent() (gas: 40977)\n[PASS] test_SignaturesExpire() (gas: 49228)\n[PASS] test_TheOwnerConnectsAnAgentInOneCall() (gas: 188975)\n[PASS] test_TheOwnerSignsTheAgentSends() (gas: 176447)\nSuite result: ok. 14 passed; 0 failed; 0 skipped; finished in 13.75ms (7.12ms CPU time)\n\nRan 24 tests for test/LARP.t.sol:LARPFaceTest\n[PASS] testFuzz_OnlyTheHolderOfBothSetsAFace(address,uint256,uint256) (runs: 256, μ: 55838, ~: 56425)\nLogs:\n  Bound result 3\n  Bound result 9\n\n[PASS] test_AFaceComesBackWithBothTokens() (gas: 220934)\n[PASS] test_AMaskMovesToTheIdentityThatPutsItOn() (gas: 323750)\n[PASS] test_AvatarFormat() (gas: 249931)\n[PASS] test_ChangingMasksFreesTheOldOne() (gas: 274960)\n[PASS] test_ClearFace() (gas: 200738)\n[PASS] test_ClearingNoFaceDoesNothing() (gas: 36612)\n[PASS] test_FaceURIFallsBackOnABrokenTokenURI() (gas: 2152591)\n[PASS] test_OnlyTheIdentitysOwnerClears() (gas: 173845)\n[PASS] test_PuttingTheSameMaskOnAgain() (gas: 240094)\n[PASS] test_RefusesAMaskThatIsNotYours() (gas: 49187)\n[PASS] test_RefusesAnIdentityAsAMask() (gas: 41585)\n[PASS] test_RefusesAnIdentityThatDoesNotExist() (gas: 41653)\n[PASS] test_RefusesAnIdentityThatIsNotYours() (gas: 43653)\n[PASS] test_RefusesWhatIsNotAnNFT() (gas: 510494)\n[PASS] test_SellingTheIdentityTakesTheFaceDown() (gas: 252506)\n[PASS] test_SellingTheMaskTakesTheFaceDown() (gas: 223250)\n[PASS] test_SetFace() (gas: 266231)\n[PASS] test_SupportsInterface() (gas: 27637)\n[PASS] test_TheIdentitysNewOwnerClearsTheOldFace() (gas: 225470)\n[PASS] test_TheNewHolderOfAMaskTakesItOff() (gas: 321718)\n[PASS] test_TheNewOwnerMustChooseAgain() (gas: 327564)\n[PASS] test_WearerOfAnUnwornMask() (gas: 14020)\n[PASS] test_ZeroIdentityRefused() (gas: 4446)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 20.65ms (24.29ms CPU time)\n\nRan 7 tests for test/LARPBurnerSettlement.t.sol:LARPBurnerSettlementTest\n[PASS] test_ParkedWaitingEthDoesNotConsumeTheBlocksAllowance() (gas: 1404858)\n[PASS] test_PreSyncCannotParkACrewFee() (gas: 1316172)\n[PASS] test_PreSyncCannotParkARegistrationFee() (gas: 1213400)\n[PASS] test_PreSyncCannotParkAResaleToll() (gas: 1981207)\n[PASS] test_PreSyncCannotParkTheHooklessRoute() (gas: 1251240)\n[PASS] test_PreSyncCannotParkWaitingEthOrChooseTheBackup() (gas: 1176301)\n[PASS] test_PreSyncStillHonoursMinImdAndRollsBackTheAllowance() (gas: 1046616)\nSuite result: ok. 7 passed; 0 failed; 0 skipped; finished in 21.42ms (15.27ms CPU time)\n\nRan 7 tests for test/SwarmPrices.t.sol:SwarmShareTest\n[PASS] test_AndDownToNothing() (gas: 7807536)\n[PASS] test_ShareGuardrails() (gas: 5662641)\n[PASS] test_StartsAt6Point9AndTheBurnerReadsItFromIMDNames() (gas: 261284)\n[PASS] test_TheBurnerFallsBackTo6Point9() (gas: 429031)\n[PASS] test_TheQuestionNamesTheShare() (gas: 3495923)\n[PASS] test_TheSwarmMovesTheShareAndTheBurnerFollows() (gas: 2824892)\n[PASS] test_UpToAllOfIt() (gas: 7900169)\nSuite result: ok. 7 passed; 0 failed; 0 skipped; finished in 21.63ms (22.57ms CPU time)\n\nRan 23 tests for test/IMDNamesEdges.t.sol:IMDNamesEdgesTest\n[PASS] test_APrimaryWithoutANameIsLiveAndNameless() (gas: 182236)\n[PASS] test_ARendererThatAnswersNothingFallsBack() (gas: 383627)\n[PASS] test_ASaleDarkensTheLinkAndTheTextStays() (gas: 286579)\n[PASS] test_AStrangerCannotUnlink() (gas: 160730)\n[PASS] test_AnAgentLinksUnlinksAndWrites() (gas: 486024)\n[PASS] test_ApprovalsAndOperatorTransfers() (gas: 452506)\n[PASS] test_Constants() (gas: 191514)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 15761)\n[PASS] test_LockingIsIdempotentAndKeepsTheRenderer() (gas: 292103)\n[PASS] test_PrimaryAndTextRefusals() (gas: 147701)\n[PASS] test_ReadingNames() (gas: 64773)\n[PASS] test_RegisterRefusesLessThanThePrice() (gas: 216901)\n[PASS] test_RegisterWithAFloorTheBurnCannotMeet() (gas: 224254)\n[PASS] test_RegisterWithImdNeedsAnAllowance() (gas: 622307)\n[PASS] test_ResolveNameSpellings() (gas: 150173)\n[PASS] test_RoyaltyRounding() (gas: 35079)\n[PASS] test_SafeTransfersCheckTheReceiver() (gas: 603375)\n[PASS] test_TheArtistRenouncesAndTheArtIsFinal() (gas: 154258)\n[PASS] test_TheCardOfAnUnlinkedName() (gas: 2382338)\n[PASS] test_TheLongestAndShortestNames() (gas: 1245197)\n[PASS] test_TheTollInImdRespectsMaxImd() (gas: 1135610)\n[PASS] test_TransferRules() (gas: 144769)\n[PASS] test_UnlinkingNothingDoesNothing() (gas: 37821)\nSuite result: ok. 23 passed; 0 failed; 0 skipped; finished in 25.29ms (20.63ms CPU time)\n\nRan 28 tests for test/IMDNames.t.sol:IMDNamesTest\n[PASS] test_ABrokenRendererFallsBackToTheCard() (gas: 10710970)\n[PASS] test_AFeeParksWhenNoPoolCanTakeIt() (gas: 8894621)\n[PASS] test_ANewOwnerPaysTheTollToLink() (gas: 1030272)\n[PASS] test_ARoyaltyPaymentIsBurned() (gas: 567939)\n[PASS] test_AnyoneRegistersAnyFreeName() (gas: 622149)\n[PASS] test_BadNames() (gas: 76271)\n[PASS] test_LinkRules() (gas: 227703)\n[PASS] test_LinkTheNameToAnIdentity() (gas: 188953)\n[PASS] test_NoImdPaymentWithoutBothPools() (gas: 233518)\n[PASS] test_OneNamePerIdentityOneIdentityPerName() (gas: 937678)\n[PASS] test_Prices() (gas: 63806)\n[PASS] test_Primary() (gas: 249738)\n[PASS] test_RegisterForSomeoneElse() (gas: 613058)\n[PASS] test_RegisterWithImd() (gas: 959072)\n[PASS] test_RegisterWithImdRespectsMaxImd() (gas: 784834)\n[PASS] test_RegisteringMintsTheNameAndBurnsTheFee() (gas: 657957)\n[PASS] test_RegistrationRules() (gas: 228053)\n[PASS] test_RoyaltiesGoToTheBurner() (gas: 40939)\n[PASS] test_SellingTheIdentityTakesItDown() (gas: 170626)\n[PASS] test_SellingTheNameTakesItDown() (gas: 207985)\n[PASS] test_ShortNamesHaveShortNameTolls() (gas: 661117)\n[PASS] test_TextRecordsStartOverWithANewHolder() (gas: 217274)\n[PASS] test_TheArtistChangesTheArtAndOnlyTheArt() (gas: 410113)\n[PASS] test_TheBuiltInCard() (gas: 3442144)\n[PASS] test_TheNamesNewOwnerUnlinksAStaleLink() (gas: 236080)\n[PASS] test_TheTollFollowsEveryChangeOfHands() (gas: 214766)\n[PASS] test_TheTollInImd() (gas: 1093347)\n[PASS] test_Unlink() (gas: 207675)\nSuite result: ok. 28 passed; 0 failed; 0 skipped; finished in 38.28ms (68.60ms CPU time)\n\nRan 4 tests for test/Launch.t.sol:LaunchTest\n[PASS] test_DeploysOnAFreshChain() (gas: 193241)\n[PASS] test_FitsOneTransaction() (gas: 25344)\nLogs:\n  launch gas, four creations: 8303\n\n[PASS] test_PassesTheAdmissionScan() (gas: 17795593)\n[PASS] test_UnderTheCodeSizeLimit() (gas: 11134)\nSuite result: ok. 4 passed; 0 failed; 0 skipped; finished in 98.18ms (78.96ms CPU time)\n\nRan 15 tests for test/LARPEdges.t.sol:LARPEdgesTest\n[PASS] testFuzz_WearerOfRoundTripsForAnyIdentityId(uint256,uint8) (runs: 256, μ: 220264, ~: 220684)\nLogs:\n  Bound result 5962\n  Bound result 8\n\n[PASS] test_ACopyPlacedTwiceIsCountedTwice() (gas: 341053)\n[PASS] test_ASignatureFromAnotherChainIsRefused() (gas: 83326)\n[PASS] test_AgentsOfNothing() (gas: 146135)\n[PASS] test_AnAgentTakesOffThePreviousOwnersItems() (gas: 350579)\n[PASS] test_ConstantsAndDomain() (gas: 57230)\n[PASS] test_ContractWalletsThatRefuseOrMumble() (gas: 462979)\n[PASS] test_EmptySpots() (gas: 141020)\n[PASS] test_OddSignatureBytes() (gas: 342349)\n[PASS] test_OneAgentForTwoIdentities() (gas: 326950)\n[PASS] test_RemovingAnAgentBumpsTheNonce() (gas: 371695)\n[PASS] test_ResigningDoesNotBumpTheNonce() (gas: 288556)\n[PASS] test_SupportsInterfaceIsPure() (gas: 15273)\n[PASS] test_TakingOffAnEmptySlotIsSilent() (gas: 61582)\n[PASS] test_ThePlacerTakesOffWhatItPlacedAfterSellingTheIdentity() (gas: 426342)\nSuite result: ok. 15 passed; 0 failed; 0 skipped; finished in 98.77ms (101.94ms CPU time)\n\nRan 8 tests for test/Placement.t.sol:PlacementTest\n[PASS] test_ASaltUsedFirstIsNeverTaken() (gas: 10480519)\n[PASS] test_ArgumentsAsTheReadmeSays() (gas: 6240)\n[PASS] test_DeploysOnAFreshChain() (gas: 10013473)\n[PASS] test_FitsOneTransaction() (gas: 30974288)\nLogs:\n  the launch: gas, all in: 10989653\n  PlaceLARP initcode bytes: 39120\n  PlaceLinks initcode bytes: 12010\n\n[PASS] test_LandsWhereThePlanSays() (gas: 10294882)\n[PASS] test_PassesTheAdmissionScan() (gas: 42761993)\n[PASS] test_PlanFollowsFromTheSalts() (gas: 162797)\n[PASS] test_SameAddressesWhoeverRunsIt() (gas: 19914901)\nSuite result: ok. 8 passed; 0 failed; 0 skipped; finished in 116.37ms (218.00ms CPU time)\n\nRan 24 tests for test/LARPLinksEdges.t.sol:LARPLinksEdgesTest\n[PASS] testFuzz_JeetBpsIsTheSoldShareOfTheAllocation(uint128,uint256,bool) (runs: 256, μ: 1665674, ~: 1535742)\nLogs:\n  Bound result 3474\n  Bound result 2571\n\n[PASS] testFuzz_TiersAreMonotoneInJeetPoints(uint256,uint256,uint256) (runs: 256, μ: 33075, ~: 33188)\nLogs:\n  Bound result 1000\n  Bound result 4498\n  Bound result 4089455\n\n[PASS] test_ACardWithALiveFace() (gas: 694335)\n[PASS] test_ADisbandedCrewIsGone() (gas: 995257)\n[PASS] test_ADistributorWithoutARootIsUnknown() (gas: 1411930)\n[PASS] test_ADistributorWithoutATokenCountsAsHeld() (gas: 1673522)\n[PASS] test_ALauncherAnsweringGarbageIsUnknown() (gas: 1533984)\n[PASS] test_AllocationBounds() (gas: 2897946)\n[PASS] test_AnAskSurvivesASaleOfEitherIdentity() (gas: 241341)\n[PASS] test_AnEmptyProofForASoloRound() (gas: 1509668)\n[PASS] test_AnIdentityNobodyHolds() (gas: 54774)\n[PASS] test_CaptainRules() (gas: 958767)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 13620)\n[PASS] test_CrewNamesAtTheEdges() (gas: 1430836)\n[PASS] test_Defaults() (gas: 177309)\n[PASS] test_FoundCrewWithImdRefusals() (gas: 1373283)\n[PASS] test_FoundCrewWithTheWrongValue() (gas: 364248)\n[PASS] test_InviteRules() (gas: 938730)\n[PASS] test_JoinLeaveRules() (gas: 1114710)\n[PASS] test_LaunchJeetPastTheEndReverts() (gas: 14394)\n[PASS] test_MembersCountFollowsEveryMove() (gas: 1096013)\n[PASS] test_TwoRoundsOfOneLaunchAreOneLevel() (gas: 1866769)\n[PASS] test_UnfrenClearsBothAsksAtOnce() (gas: 388582)\n[PASS] test_UnfrenWithNothingDoesNothing() (gas: 86806)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 132.70ms (213.25ms CPU time)\n\nRan 24 tests for test/LARPLinks.t.sol:LARPLinksTest\n[PASS] test_AGasHungryTokenCantSinkTheBoard() (gas: 1737463)\n[PASS] test_AnInnerNodeIsNotALeaf() (gas: 1448373)\n[PASS] test_AnUnreadableTokenCountsAsHeld() (gas: 1784660)\n[PASS] test_BadAllocations() (gas: 1754999)\n[PASS] test_CaptainsRun() (gas: 963173)\n[PASS] test_Card() (gas: 1645098)\n[PASS] test_CrewFoundingRules() (gas: 916902)\n[PASS] test_Disband() (gas: 1551949)\n[PASS] test_FoundACrewWithImd() (gas: 1180619)\n[PASS] test_FoundingACrewBurnsIMD() (gas: 749420)\n[PASS] test_FrenRules() (gas: 383139)\n[PASS] test_FrensPassWithTheIdentity() (gas: 302573)\n[PASS] test_FrensTakeTwo() (gas: 266329)\n[PASS] test_JeetsAreReadLive() (gas: 2364129)\n[PASS] test_JeetsInPages() (gas: 8424463)\n[PASS] test_OpenAndClosedCrews() (gas: 1696901)\n[PASS] test_PassTheCaptaincy() (gas: 948251)\n[PASS] test_ProveAnAllocation() (gas: 1534389)\n[PASS] test_RanksAcrossLaunches() (gas: 5184173)\n[PASS] test_TheCaptaincyPassesWithTheIdentity() (gas: 768169)\n[PASS] test_TheRankIsTheHoldersNow() (gas: 1748137)\n[PASS] test_Tiers() (gas: 80885)\n[PASS] test_Unfren() (gas: 271974)\n[PASS] test_WithdrawAndDeclineAsks() (gas: 244060)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 140.52ms (29.68ms CPU time)\n\nRan 18 tests for test/SwarmPricesEdges.t.sol:SwarmPricesEdgesTest\n[PASS] testFuzz_TheGuardrailsAreExactlyTheDocumentedRule(uint64,uint64,uint64,uint64) (runs: 512, μ: 336769, ~: 60870)\nLogs:\n  Bound result 4378297350523736\n  Bound result 2800920687512860\n  Bound result 1200000000220975\n  Bound result 1393227266704998\n\n[PASS] test_AFailureAfterAVerdictIsRefused() (gas: 2604143)\n[PASS] test_AVerdictExpiringThisSecondStillCounts() (gas: 2553440)\n[PASS] test_AnUnknownProposalIsNone() (gas: 18765)\n[PASS] test_ExactlyTwiceAndExactlyHalfAreAllowed() (gas: 7347888)\n[PASS] test_ExecutingNothingOrAPendingProposalIsRefused() (gas: 2515813)\n[PASS] test_OverpayingTheOracleIsTheProposersChoice() (gas: 2487436)\n[PASS] test_PricesAfterTwoChangesStayWithinTheRailsOfEach() (gas: 4219697)\n[PASS] test_ProposingNeedsTheProposersImd() (gas: 383908)\n[PASS] test_TheAnswerMustBeABoolTrueAboutThisChain() (gas: 7186081)\n[PASS] test_TheCallbackSelectorsAreTheProtocolsLayout() (gas: 2586325)\n[PASS] test_TheFirstChangeHasNoCooldown() (gas: 2592521)\n[PASS] test_TheLastSecondOfTheCooldown() (gas: 4323654)\n[PASS] test_TheLastSecondOfTheExecuteWindow() (gas: 2589107)\n[PASS] test_TheProtocolsOwnSignatureVerifies() (gas: 2774679)\n[PASS] test_TheProtocolsSignatureOnATamperedVectorIsRefused() (gas: 2814849)\n[PASS] test_TheVectorsSignerApprovesWithABoolAnswer() (gas: 2777870)\n[PASS] test_TwoProposalsOneVerdictEach() (gas: 4188577)\nSuite result: ok. 18 passed; 0 failed; 0 skipped; finished in 140.50ms (123.09ms CPU time)\n\nRan 19 tests for test/LARPBurnerEdges.t.sol:LARPBurnerEdgesTest\n[PASS] testFuzz_ABurnSpendsMinOfBalanceAndMaxBurn(uint256,uint256) (runs: 128, μ: 795694, ~: 794339)\nLogs:\n  Bound result 182452882424919949\n  Bound result 384285164318795929\n\n[PASS] testFuzz_QuoteIsLinearAndMonotone(uint256,uint256) (runs: 256, μ: 576445, ~: 576522)\nLogs:\n  Bound result 1685701882424981683\n  Bound result 6285995003877838520\n\n[PASS] testFuzz_SixPointNinePercentBuysIMD6900AndTheRestBurns(uint256) (runs: 256, μ: 564829, ~: 556502)\nLogs:\n  Bound result 96\n\n[PASS] testFuzz_TwoBurnsInOneBlockSellAtMostOneCapOfWaitingEth(uint256,uint256,uint256) (runs: 192, μ: 1014276, ~: 1017447)\nLogs:\n  Bound result 499999000157198260\n  Bound result 20923\n  Bound result 8198\n\n[PASS] test_APartialFillOnPool4FallsToTheHooklessPool() (gas: 2588067)\n[PASS] test_AWethAnsweringShortIsIgnored() (gas: 905473)\n[PASS] test_AWethThatRefusesToUnwrapIsIgnored() (gas: 943064)\n[PASS] test_AWrongPool4KeyFallsToTheHooklessPool() (gas: 835984)\n[PASS] test_BelowTheLegBudgetABurnIsRefusedBeforeAnyLegRuns() (gas: 1008060)\n[PASS] test_Constants() (gas: 72853)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 9394)\n[PASS] test_ExactlyMaxBurnInOneCall() (gas: 1357561)\n[PASS] test_NoPoolAtAllParksAndQuotesNothing() (gas: 613447)\n[PASS] test_NothingToBurnIsNotAnError() (gas: 383300)\n[PASS] test_OneWeiParks() (gas: 668090)\n[PASS] test_QuoteOfTheSmallestPrice() (gas: 549094)\n[PASS] test_ReceiveTakesEmptyCallsOnly() (gas: 66423)\n[PASS] test_TheBlockAllowanceCountsOnlyTheWaitingEth() (gas: 2369304)\n[PASS] test_UnwrappedWethIsWaitingEth() (gas: 1655564)\nSuite result: ok. 19 passed; 0 failed; 0 skipped; finished in 140.75ms (379.40ms CPU time)\n\nRan 18 tests for test/SwarmPrices.t.sol:SwarmPricesTest\n[PASS] testFuzz_AWrongRequestCannotSettleAPendingProposal(bytes32) (runs: 256, μ: 2670536, ~: 2670643)\n[PASS] test_AProposalForOldPricesGoesStale() (gas: 4240429)\n[PASS] test_ARejectedProposalChangesNothing() (gas: 2577335)\n[PASS] test_AVerdictCannotApproveAnotherPendingProposal() (gas: 4158565)\n[PASS] test_AVerdictMustBeUsedWithinTwoWeeks() (gas: 2551628)\n[PASS] test_AWeakPanelIsARejection() (gas: 7197220)\n[PASS] test_AnExpiredVerdictIsARejection() (gas: 2537113)\n[PASS] test_AnyoneProposesAndTheContractWritesTheQuestion() (gas: 3300450)\n[PASS] test_ApprovedThenAnyoneExecutes() (gas: 3923290)\n[PASS] test_ChangingTheSignedRequestIdInvalidatesTheSignature() (gas: 4234890)\n[PASS] test_ExecutedOnce() (gas: 2600327)\n[PASS] test_Guardrails() (gas: 218195)\n[PASS] test_NoVerdictClosesTheProposal() (gas: 2569776)\n[PASS] test_OneChangeAWeek() (gas: 4310174)\n[PASS] test_OnlyTheIntakeDeliversAndOnlyForItsOwnProposals() (gas: 2561581)\n[PASS] test_OnlyTheOraclesSignatureForThisContractCounts() (gas: 2703262)\n[PASS] test_StartPrices() (gas: 61091)\n[PASS] test_TheOracleMustBePaid() (gas: 238881)\nSuite result: ok. 18 passed; 0 failed; 0 skipped; finished in 140.67ms (128.17ms CPU time)\n\nRan 27 tests for test/LARPBurner.t.sol:LARPBurnerTest\n[PASS] test_AFeeAlwaysGoesThroughWhateverTheBlockSpent() (gas: 2325890)\n[PASS] test_AGasEatingIMD6900IsSkippedNotFatal() (gas: 7942385)\n[PASS] test_AGasEatingPool4HookFallsToTheHooklessPool() (gas: 4102897)\n[PASS] test_AGenuineFailureIsNotMistakenForTooLittleGas() (gas: 876639)\n[PASS] test_ASwapOutOfGasReverts() (gas: 10080186)\n[PASS] test_AnEmptyPairPoolMeansItAllBurnsAsIMD() (gas: 827279)\n[PASS] test_AnIMD6900LegOutOfGasDeepDownReverts() (gas: 3821761)\n[PASS] test_AnIMD6900ThatWontBurnMeansItAllBurnsAsIMD() (gas: 789638)\n[PASS] test_AtMostMaxBurnPerCallAndPerBlockOfWaitingEth() (gas: 2373317)\n[PASS] test_BurnCallsBatchedInOneTransactionSellOneCap() (gas: 1036999)\n[PASS] test_BurnImdBurnsWhatArrivesInIMD() (gas: 519860)\n[PASS] test_BuysOnPool4First() (gas: 1073540)\n[PASS] test_HostileLegsCostPaidCallsTheirBudgets() (gas: 11581009)\nLogs:\n  registration gas used with two hostile legs: 6026491\n\n[PASS] test_MinImd() (gas: 961486)\n[PASS] test_NoGasLimitSkipsAHeavyIMD6900Leg() (gas: 68136929)\n[PASS] test_NoGasLimitSkipsARoute() (gas: 5984012)\n[PASS] test_NoQuoteWithoutBothPools() (gas: 297276)\n[PASS] test_NoReentry() (gas: 467731)\n[PASS] test_OnlyThePoolManagerCallsBack() (gas: 32829)\n[PASS] test_ParkedWhenNoPoolCanAndBurnedLater() (gas: 1381349)\n[PASS] test_QuoteIsTheHigherOfTheTwoPools() (gas: 1129758)\n[PASS] test_RoyaltiesArriveByPlainTransfer() (gas: 44081)\n[PASS] test_ShareBuysIMD6900AndBurnsIt() (gas: 851825)\n[PASS] test_SpacingAboveV4sLargestReverts() (gas: 11396)\n[PASS] test_SpacingsAreTakenUnsignedAndKeptAsInt24() (gas: 28301)\n[PASS] test_TheHooklessPoolIfPool4CantTakeIt() (gas: 1185610)\n[PASS] test_WethRoyaltiesAreUnwrappedAndSold() (gas: 1132967)\nSuite result: ok. 27 passed; 0 failed; 0 skipped; finished in 260.12ms (407.96ms CPU time)\n\nRan 1 test for test/SwarmPrices.invariant.t.sol:SwarmPricesInvariantTest\n[PASS]\nSwarmPricesInvariantTest invariants:\n[PASS] invariant_CountersMatchWhatHappened\n[PASS] invariant_NamesHoldsNothing\n[PASS] invariant_NoProposalReopens\n[PASS] invariant_PricesChangeOnlyByExecution\n[PASS] invariant_PricesWithinTheGuardrails\n SwarmPricesInvariantTest invariants (runs: 64, calls: 3072, reverts: 0)\n\n╭--------------+----------+-------+---------+----------╮\n| Contract     | Selector | Calls | Reverts | Discards |\n+======================================================+\n| SwarmHandler | execute  | 436   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | fail     | 446   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | forge    | 422   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | pass     | 441   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | propose  | 428   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | stranger | 455   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | verdict  | 444   | 0       | 0        |\n╰--------------+----------+-------+---------+----------╯\n\nLogs:\n  Bound result 18400000000018355\n  Bound result 4506666666683964\n  Bound result 1840000000057006\n  Bound result 1840000000000009\n  Bound result 400000000000008958\n  Bound result 770687\n  Bound result 18400000000000160\n  Bound result 4506666700207187\n  Bound result 1840000000004581\n  Bound result 1840000000014214\n  Bound result 400000002835717309\n  Bound result 7149\n  Bound result 18400000000001593\n  Bound result 4506666666715547\n  Bound result 1840000000001381\n  Bound result 1840000000003209\n  Bound result 400000000000005093\n  Bound result 18400000000003966\n  Bound result 4799999999997960\n  Bound result 1840000000004378\n  Bound result 1239999999999997\n  Bound result 400000000000003602\n  Bound result 53996\n  Bound result 251852\n  Bound result 18400000003000001\n  Bound result 4506666666678534\n  Bound result 1840000005500001\n  Bound result 1840000000000880\n  Bound result 599999999500000003\n  Bound result 18400000000014577\n  Bound result 4506666666966668\n  Bound result 1840002158778574\n  Bound result 1840000000012177\n  Bound result 400000000000002991\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 940.02ms (920.04ms CPU time)\n\nRan 1 test for test/LARPBurner.invariant.t.sol:LARPBurnerInvariantTest\n[PASS]\nLARPBurnerInvariantTest invariants:\n[PASS] invariant_DeadHoldsOnlyImd\n[PASS] invariant_EthLeavesOnlyAsASwap\n[PASS] invariant_Imd6900OnlyBurns\n[PASS] invariant_ImdGoesOnlyToDeadOrTheIMD6900Buy\n[PASS] invariant_NoImdOutlivesABurn\n[PASS] invariant_WaitingEthLeavesAtMostOneCapPerBlock\n LARPBurnerInvariantTest invariants (runs: 64, calls: 3072, reverts: 0)\n\n╭---------------+-------------------+-------+---------+----------╮\n| Contract      | Selector          | Calls | Reverts | Discards |\n+================================================================+\n| BurnerHandler | burn              | 380   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | burnImd           | 348   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | burnWithLittleGas | 391   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateEth         | 436   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateImd         | 373   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateWeth        | 362   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | nextBlock         | 355   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | trade             | 427   | 0       | 0        |\n╰---------------+-------------------+-------+---------+----------╯\n\nLogs:\n  Bound result 5622060740456107708978\n  Bound result 12176\n  Bound result 3005718\n  Bound result 500000000000000\n  Bound result 1947\n  Bound result 284316827753434525\n  Bound result 358793239081170476\n  Bound result 367959472086682925\n  Bound result 184812773397540567\n  Bound result 2433318\n  Bound result 5999005520000000000002\n  Bound result 500000000000000000\n  Bound result 69\n  Bound result 5295\n  Bound result 1\n  Bound result 6340\n  Bound result 303217537091289238245\n  Bound result 1\n  Bound result 81570759080747168\n  Bound result 5231\n  Bound result 300000000000000000\n  Bound result 127\n  Bound result 1\n  Bound result 2\n  Bound result 299999999999999999\n  Bound result 1707490\n  Bound result 76080\n  Bound result 69576962644345793\n  Bound result 1856\n  Bound result 845000000000000\n  Bound result 1\n  Bound result 6999\n  Bound result 264337593543950336\n  Bound result 273518312084598762\n  Bound result 14930\n  Bound result 499792917818885444\n  Bound result 2870\n  Bound result 15965\n  Bound result 5630\n  Bound result 13946\n  Bound result 2267419\n  Bound result 777600\n  Bound result 133378206054161229\n  Bound result 150001\n  Bound result 3006782\n  Bound result 2\n  Bound result 54243722424859933\n  Bound result 1933009\n  Bound result 194265960037000698\n  Bound result 63\n  Bound result 3002238\n  Bound result 5999000000000000001614\n  Bound result 2834634216490329199\n  Bound result 383779998\n  Bound result 1380000000000000000\n  Bound result 1532892063\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 1.47s (1.46s CPU time)\n\nRan 1 test for test/LARP.invariant.t.sol:LARPInvariantTest\n[PASS]\nLARPInvariantTest invariants:\n[PASS] invariant_LiveMeansThePlacerHoldsIt\n[PASS] invariant_NoMoreLiveCopiesThanHeld\n[PASS] invariant_OneTokenOneSpot\n LARPInvariantTest invariants (runs: 128, calls: 8192, reverts: 0)\n\n╭-------------+--------------+-------+---------+----------╮\n| Contract    | Selector     | Calls | Reverts | Discards |\n+=========================================================+\n| LarpHandler | equip1155    | 1184  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | equip721     | 1207  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveCopy     | 1175  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveIdentity | 1145  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveMask     | 1168  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | setFace      | 1122  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | takeOff      | 1191  | 0       | 0        |\n╰-------------+--------------+-------+---------+----------╯\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 54.05s (54.05s CPU time)\n\nRan 21 test suites in 54.06s (57.88s CPU time): 277 tests passed, 0 failed, 13 skipped (290 total tests)\n","passed":true},{"durationMs":178,"exitCode":0,"name":"source-index","output":"{\"v\":1,\"entryPoints\":[\"IMDNames.approve(address,uint256)\",\"IMDNames.execute(bytes32)\",\"IMDNames.link(uint256,uint256,uint256)\",\"IMDNames.linkWithImd(uint256,uint256,uint256)\",\"IMDNames.lockRenderer()\",\"IMDNames.onNoVerdict(bytes32,uint8,bytes32,uint16,uint16,bytes)\",\"IMDNames.onVerdict(bytes32,(bytes32,uint256,bytes32,uint8,bytes,uint256,uint64,uint64,bytes32,bytes32,uint16,uint16,uint16,uint64,uint64),bytes)\",\"IMDNames.propose((uint64,uint64,uint64,uint64,uint16),uint256)\",\"IMDNames.register(bytes32,address,uint256)\",\"IMDNames.registerWithImd(bytes32,address,uint256)\",\"IMDNames.safeTransferFrom(address,address,uint256)\",\"IMDNames.safeTransferFrom(address,address,uint256,bytes)\",\"IMDNames.setApprovalForAll(address,bool)\",\"IMDNames.setArtist(address)\",\"IMDNames.setPrimary(uint256)\",\"IMDNames.setRenderer(address)\",\"IMDNames.setText(uint256,string,string)\",\"IMDNames.transferFrom(address,address,uint256)\",\"IMDNames.unlink(uint256)\",\"LARP.clearFace(uint256)\",\"LARP.equip(uint256,uint256,address,uint256,uint8)\",\"LARP.resignAgent(uint256)\",\"LARP.setAgent(uint256,address)\",\"LARP.setAgentBySig(uint256,address,uint256,bytes)\",\"LARP.setFace(uint256,address,uint256)\",\"LARP.unequip(uint256,uint256)\",\"LARPBurner.burn(uint256)\",\"LARPBurner.burnImd()\",\"LARPBurner.receive()\",\"LARPBurner.unlockCallback(bytes)\",\"LARPLinks.disband(uint256)\",\"LARPLinks.foundCrew(uint256,bytes32,bool,uint256)\",\"LARPLinks.foundCrewWithImd(uint256,bytes32,bool,uint256)\",\"LARPLinks.fren(uint256,uint256)\",\"LARPLinks.invite(uint256,uint256,bool)\",\"LARPLinks.join(uint256,uint256)\",\"LARPLinks.kick(uint256,uint256)\",\"LARPLinks.leave(uint256)\",\"LARPLinks.passCaptain(uint256,uint256)\",\"LARPLinks.proveAlloc(uint64,uint256,address,uint256,bytes32[])\",\"LARPLinks.setOpen(uint256,bool)\",\"LARPLinks.unfren(uint256,uint256)\"],\"files\":{\".gitignore\":4,\"ADAPTATION.md\":131,\"AUDIT-COVERAGE.md\":199,\"AUDIT.md\":278,\"README.md\":231,\"foundry.toml\":34,\"script/place/gen.py\":122,\"src/IIMDNames.sol\":112,\"src/ILARP.sol\":120,\"src/IMDNames.sol\":358,\"src/LARP.sol\":330,\"src/LARPBurner.sol\":364,\"src/LARPLinks.sol\":457,\"src/Labels.sol\":53,\"src/SafeReads.sol\":63,\"src/SwarmPrices.sol\":369,\"src/place/LARPPlan.sol\":38,\"src/place/PlaceLARP.sol\":148,\"test/Base.sol\":308,\"test/IMDNames.t.sol\":481,\"test/IMDNamesEdges.t.sol\":458,\"test/LARP.invariant.t.sol\":184,\"test/LARP.t.sol\":324,\"test/LARPAgents.t.sol\":269,\"test/LARPBurner.invariant.t.sol\":468,\"test/LARPBurner.t.sol\":585,\"test/LARPBurnerEdges.t.sol\":403,\"test/LARPBurnerSettlement.t.sol\":155,\"test/LARPEdges.t.sol\":340,\"test/LARPItems.t.sol\":236,\"test/LARPLinks.t.sol\":515,\"test/LARPLinksEdges.t.sol\":459,\"test/Launch.t.sol\":134,\"test/MainnetFork.t.sol\":344,\"test/Mocks.sol\":89,\"test/Placement.t.sol\":347,\"test/SwarmPrices.invariant.t.sol\":364,\"test/SwarmPrices.t.sol\":587,\"test/SwarmPricesEdges.t.sol\":353,\"test/fixtures/allocs.json\":118},\"excluded\":[\"lib/\",\"node_modules/\"],\"truncated\":false}","passed":true},{"durationMs":12151,"exitCode":0,"name":"slither","output":"[medium/high] incorrect-equality at src/LARPBurner.sol:203: LARPBurner.burn(uint256) (src/LARPBurner.sol#203-232) uses a dangerous strict equality:\n[medium/high] incorrect-equality at src/LARPBurner.sol:203: LARPBurner.burn(uint256) (src/LARPBurner.sol#203-232) uses a dangerous strict equality:\n[medium/medium] reentrancy-no-eth at src/LARPBurner.sol:203: Reentrancy in LARPBurner.burn(uint256) (src/LARPBurner.sol#203-232):\n[medium/medium] uninitialized-local at src/SwarmPrices.sol:354: SwarmPrices._decimal(uint256).digits (src/SwarmPrices.sol#354) is a local variable never initialized\n[medium/medium] uninitialized-local at src/LARP.sol:308: LARP._decimal(uint256).digits (src/LARP.sol#308) is a local variable never initialized\n[medium/medium] uninitialized-local at src/LARPBurner.sol:294: LARPBurner._burnImd().burned6900 (src/LARPBurner.sol#294) is a local variable never initialized\n[medium/medium] unused-return at src/IMDNames.sol:105: IMDNames.register(bytes32,address,uint256) (src/IMDNames.sol#105-110) ignores return value by LARPBurner(address(BURNER)).burn{value: price}(minImd) (src/IMDNames.sol#109)\n[medium/medium] unused-return at src/IMDNames.sol:120: IMDNames.link(uint256,uint256,uint256) (src/IMDNames.sol#120-124) ignores return value by LARPBurner(address(BURNER)).burn{value: toll}(minImd) (src/IMDNames.sol#123)\n[medium/medium] unused-return at src/LARPBurner.sol:252: LARPBurner.unlockCallback(bytes) (src/LARPBurner.sol#252-286) ignores return value by POOL_MANAGER.settle{value: amount}() (src/LARPBurner.sol#283)\n[medium/medium] unused-return at src/LARPBurner.sol:252: LARPBurner.unlockCallback(bytes) (src/LARPBurner.sol#252-286) ignores return value by POOL_MANAGER.settle() (src/LARPBurner.sol#268)\n[medium/medium] unused-return at src/LARPLinks.sol:453: LARPLinks._own(uint256) (src/LARPLinks.sol#453-456) ignores return value by (ok,None) = LARP.canAct(imdId,msg.sender) (src/LARPLinks.sol#454)\n[medium/medium] unused-return at src/LARPLinks.sol:324: LARPLinks._captain(uint256) (src/LARPLinks.sol#324-329) ignores return value by (ok,None) = LARP.canAct(c.captain,msg.sender) (src/LARPLinks.sol#327)\n[medium/medium] unused-return at src/LARPLinks.sol:201: LARPLinks.foundCrew(uint256,bytes32,bool,uint256) (src/LARPLinks.sol#201-209) ignores return value by LARPBurner(address(BURNER)).burn{value: msg.value}(minImd) (src/LARPLinks.sol#208)\n[medium/medium] unused-return at src/IMDNames.sol:178: IMDNames.unlink(uint256) (src/IMDNames.sol#178-186) ignores return value by (ok,None) = LARP.canAct(imdId,msg.sender) (src/IMDNames.sol#181)\n[medium/medium] unused-return at src/LARPLinks.sol:439: LARPLinks.cardOf(uint256) (src/LARPLinks.sol#439-450) ignores return value by (None,c.faceCollection,c.faceTokenId,c.faceLive) = LARP.faceOf(imdId) (src/LARPLinks.sol#443)\n[low/medium] missing-zero-check at src/LARPBurner.sol:136: LARPBurner.constructor(address,address,uint24,uint24,address,uint24,uint24,address,uint24,uint24,address,address).pairHook (src/LARPBurner.sol#136) lacks a zero-check on :\n[low/medium] missing-zero-check at src/IMDNames.sol:306: IMDNames.setRenderer(address).renderer_ (src/IMDNames.sol#306) lacks a zero-check on :\n[low/medium] missing-zero-check at src/LARPBurner.sol:130: LARPBurner.constructor(address,address,uint24,uint24,address,uint24,uint24,address,uint24,uint24,address,address).pool4Hook (src/LARPBurner.sol#130) lacks a zero-check on :\n[low/medium] missing-zero-check at src/LARPBurner.sol:137: LARPBurner.constructor(address,address,uint24,uint24,address,uint24,uint24,address,uint24,uint24,address,address).names (src/LARPBurner.sol#137) lacks a zero-check on :\n[low/medium] missing-zero-check at src/IMDNames.sol:67: IMDNames.constructor(address,ILARP,address,address,address,address).artist_ (src/IMDNames.sol#67) lacks a zero-check on :\n[low/medium] missing-zero-check at src/IMDNames.sol:314: IMDNames.setArtist(address).artist_ (src/IMDNames.sol#314) lacks a zero-check on :\n[low/medium] calls-loop at src/LARPBurner.sol:315: LARPBurner._tryUnlock(uint8,uint256) (src/LARPBurner.sol#315-333) has external calls inside a loop: r_scope_0 = POOL_MANAGER.unlock{gas: LEG_GAS}(data) (src/LARPBurner.sol#328-332)\n[low/medium] calls-loop at src/LARPBurner.sol:315: LARPBurner._tryUnlock(uint8,uint256) (src/LARPBurner.sol#315-333) has external calls inside a loop: r = POOL_MANAGER.unlock(data) (src/LARPBurner.sol#319-324)\n[low/medium] reentrancy-benign at src/SwarmPrices.sol:152: Reentrancy in SwarmPrices.propose(SwarmPrices.Prices,uint256) (src/SwarmPrices.sol#152-177):\n[low/medium] reentrancy-events at src/SwarmPrices.sol:152: Reentrancy in SwarmPrices.propose(SwarmPrices.Prices,uint256) (src/SwarmPrices.sol#152-177):\n[low/medium] reentrancy-events at src/LARPBurner.sol:203: Reentrancy in LARPBurner.burn(uint256) (src/LARPBurner.sol#203-232):\n[low/medium] reentrancy-events at src/LARPBurner.sol:290: Reentrancy in LARPBurner._burnImd() (src/LARPBurner.sol#290-303):\n[low/medium] reentrancy-events at src/LARPBurner.sol:203: Reentrancy in LARPBurner.burn(uint256) (src/LARPBurner.sol#203-232):\n[low/medium] return-bomb at src/LARPBurner.sol:315: LARPBurner._tryUnlock(uint8,uint256) (src/LARPBurner.sol#315-333) tries to limit the gas of an external call that controls implicit decoding\n[low/medium] return-bomb at src/LARPBurner.sol:158: LARPBurner.shareBps() (src/LARPBurner.sol#158-166) tries to limit the gas of an external call that controls implicit decoding\n[low/medium] timestamp at src/SwarmPrices.sol:182: SwarmPrices.onVerdict(bytes32,Attestation,bytes) (src/SwarmPrices.sol#182-193) uses timestamp for comparisons\n[low/medium] timestamp at src/LARP.sol:77: LARP.setAgentBySig(uint256,address,uint256,bytes) (src/LARP.sol#77-91) uses timestamp for comparisons\n[low/medium] timestamp at src/SwarmPrices.sol:207: SwarmPrices.execute(bytes32) (src/SwarmPrices.sol#207-217) uses timestamp for comparisons","passed":true},{"durationMs":892,"exitCode":0,"name":"aderyn","output":"[high] abi-encode-packed-hash-collision at src/place/PlaceLARP.sol:40: `abi.encodePacked()` Hash Collision (5 places)\n[high] contract-locks-ether at src/IMDNames.sol:21: Contract locks Ether without a withdraw function (3 places)\n[high] reentrancy-state-change at src/IMDNames.sol:181: Reentrancy: State change after external call (4 places)\n[low] costly-loop at src/LARPBurner.sol:215: Costly operations inside loop\n[low] ecrecover at src/LARP.sol:153: `ecrecover` Signature Malleability (2 places)\n[low] internal-function-used-once at src/Labels.sol:9: Internal Function Used Only Once (2 places)\n[low] large-numeric-literal at src/IMDNames.sol:34: Large Numeric Literal (12 places)\n[low] literal-instead-of-constant at src/IMDNames.sol:68: Literal Instead of Constant (64 places)\n[low] missing-inheritance at src/LARPBurner.sol:53: Missing Inheritance\n[low] push-zero-opcode at src/IIMDNames.sol:2: PUSH0 Opcode (11 places)\n[low] require-revert-in-loop at src/LARPBurner.sol:215: Loop Contains `require`/`revert`\n[low] state-no-address-check at src/IMDNames.sol:74: Address State Variable Set Without Checks (3 places)\n[low] unchecked-return at src/LARPBurner.sol:268: Unchecked Return\n[low] uninitialized-local-variable at src/LARPBurner.sol:215: Uninitialized Local Variable (5 places)\n[low] unspecific-solidity-pragma at src/IIMDNames.sol:2: Unspecific Solidity Pragma (8 places)\n[low] unused-public-function at src/IMDNames.sol:98: Public Function Not Used Internally\n[low] unused-state-variable at src/LARPBurner.sol:77: Unused State Variable","passed":true}],"detail":"all checks passed","evaluation":"checks","profile":"foundry","status":"accepted","submissionHash":"b1b03f91ffc1bc9ad169f60fc3af7c7a69a6cec69811519059d6c26655a825a0","verifiedTreeHash":"0e8b822afa19f9777545560fae69661c54b4715a","verifierVersion":"0.1.0+fb8278c5"},{"checks":[{"durationMs":143197,"exitCode":0,"name":"build","output":"Compiling 104 files with Solc 0.8.26\nSolc 0.8.26 finished in 142.98s\nCompiler run successful!\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:111:33\n    │\n111 │         if (at == 0) return (0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:120:64\n    │\n120 │         if (holder == address(0) || who == address(0)) return (false, holder);\n    │                                                                ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:121:36\n    │\n121 │         if (who == holder) return (true, holder);\n    │                                    ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[uninitialized-local]: local variable is read before being initialized\n   ╭▸ src/Labels.sol:23:16\n   │\n23 │         while (n < 32 && label[n] != 0) ++n;\n   │                ━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:333:25\n    │\n333 │                 return (true, r);\n    │                         ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:336:25\n    │\n336 │                 return (false, \"\");\n    │                         ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:342:21\n    │\n342 │             return (true, r);\n    │                     ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARPBurner.sol:344:21\n    │\n344 │             return (false, \"\");\n    │                     ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/LARP.sol:265:36\n    │\n265 │         if (at == 0) return (0, 0, false);\n    │                                    ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[unsafe-typecast]: typecast can truncate values\n   ╭▸ src/SwarmPrices.sol:87:38\n   │\n87 │     bytes32 public constant ACTION = bytes32(\"oracle.request@oracle-1\");\n   │                                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ├ note: consider disabling this lint if you're certain the cast is safe\n   │       \n   │       // casting to 'bytes32' is safe because [explain why]\n   │       // forge-lint: disable-next-line(unsafe-typecast)\n   │       \n   │       \n   ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/SwarmPrices.sol:137:17\n    │\n137 │     constructor(address intake, address oracleSigner, Prices memory start) {\n    │                 ━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/SwarmPrices.sol:137:33\n    │\n137 │     constructor(address intake, address oracleSigner, Prices memory start) {\n    │                                 ━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n   ╭▸ src/LARP.sol:78:13\n   │\n78 │         if (block.timestamp > deadline) revert Expired();\n   │             ━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARP.sol:138:9\n    │\n138 │         emit AgentSet(imdId, holder, agent);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:208:9\n    │\n208 │         LARPBurner(payable(BURNER)).burn{value: msg.value}(minImd);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:147:9\n    │\n147 │         address names\n    │         ━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:140:9\n    │\n140 │         address pool4Hook,\n    │         ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/LARPBurner.sol:146:9\n    │\n146 │         address pairHook,\n    │         ━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n    ╭▸ src/LARPBurner.sol:172:13\n    │\n172 │             n.staticcall{gas: SHARE_GAS}(abi.encodeWithSelector(IShareSource.imd6900ShareBps.selector));\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:182:16\n    │\n182 │         return int24(s);\n    │                ━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int24' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/SwarmPrices.sol:176:9\n    │\n176 │         emit Proposed(requestId, number, msg.sender, next);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:159:45\n    │\n159 │         return ok && answer.length >= 32 && bytes4(abi.decode(answer, (bytes32))) == 0x1626ba7e;\n    │                                             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes4' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:327:22\n    │\n327 │         (bool ok,) = LARP.canAct(c.captain, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPLinks.sol:342:39\n    │\n342 │         address distributor = address(uint160(w));\n    │                                       ━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint160' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPLinks.sol:380:31\n    │\n380 │             j.token = address(uint160(t));\n    │                               ━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint160' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:443:9\n    │\n443 │         (, c.faceCollection, c.faceTokenId, c.faceLive) = LARP.faceOf(imdId);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPLinks.sol:454:22\n    │\n454 │         (bool ok,) = LARP.canAct(imdId, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/LARP.sol:310:15\n    │\n310 │             ++digits;\n    │               ━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:314:36\n    │\n314 │             out[--digits] = bytes1(uint8(48 + value % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[boolean-cst]: misuse of a boolean constant\n   ╭▸ src/place/PlaceLARP.sol:49:98\n   │\n49 │             if (_proxy(LARPPlan.CREATEX, g).code.length == 0 && at.code.length == 0) return (at, true);\n   │                                                                                                  ━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARP.sol:325:22\n    │\n325 │             out[i] = bytes16(\"0123456789abcdef\")[v & 15];\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes16' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[boolean-cst]: misuse of a boolean constant\n   ╭▸ src/place/PlaceLARP.sol:51:48\n   │\n51 │         return (_create3(address(this), salt), false);\n   │                                                ━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:88:13\n    │\n 88 │ ┏             abi.encodePacked(\n 89 │ ┃                 type(LARPBurner).creationCode,\n 90 │ ┃                 abi.encode(\n 91 │ ┃                     LARPPlan.POOL_MANAGER,\n    ‡ ┃\n104 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:108:36\n    │\n108 │         _place(LARPPlan.LARP_SALT, abi.encodePacked(type(LARP).creationCode, abi.encode(LARPPlan.IDENTITY)), l, lx);\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:111:13\n    │\n111 │ ┏             abi.encodePacked(\n112 │ ┃                 type(IMDNames).creationCode,\n113 │ ┃                 abi.encode(LARPPlan.IDENTITY, l, b, LARPPlan.ARTIST, LARPPlan.INTAKE, LARPPlan.ORACLE_SIGNER)\n114 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/place/PlaceLARP.sol:133:13\n    │\n133 │ ┏             abi.encodePacked(\n134 │ ┃                 type(LARPLinks).creationCode,\n135 │ ┃                 abi.encode(\n136 │ ┃                     LARPPlan.IDENTITY,\n    ‡ ┃\n142 │ ┃             ),\n    │ ┗━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[unsafe-typecast]: typecast can truncate values\n   ╭▸ src/SafeReads.sol:21:46\n   │\n21 │         return ok && w >> 160 == 0 ? address(uint160(w)) : address(0);\n   │                                              ━━━━━━━━━━\n   │\n   ├ note: consider disabling this lint if you're certain the cast is safe\n   │       \n   │       // casting to 'uint160' is safe because [explain why]\n   │       // forge-lint: disable-next-line(unsafe-typecast)\n   │       \n   │       \n   ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n   ╭▸ src/SafeReads.sol:47:40\n   │\n47 │         (bool ok, bytes memory data) = target.staticcall{gas: gasCap}(call);\n   │                                        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:220:33\n    │\n220 │         if (at == 0) return (0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:228:42\n    │\n228 │         if (owner == address(0)) return (false, address(0), 0, false);\n    │                                          ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:228:64\n    │\n228 │         if (owner == address(0)) return (false, address(0), 0, false);\n    │                                                                ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:240:33\n    │\n240 │         if (label == 0) return (false, address(0), 0, false);\n    │                                 ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:240:55\n    │\n240 │         if (label == 0) return (false, address(0), 0, false);\n    │                                                       ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/IMDNames.sol:247:37\n    │\n247 │         if (at == 0) return (0, \"\", false);\n    │                                     ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/LARPBurner.sol:332:17\n    │\n332 │             try POOL_MANAGER.unlock(data) returns (bytes memory r) {\n    │                 ━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/LARPBurner.sol:341:13\n    │\n341 │         try POOL_MANAGER.unlock{gas: LEG_GAS}(data) returns (bytes memory r) {\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:236:21\n    │\n236 │                     emit Bought(eth, imd, route);\n    │                     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:240:27\n    │\n240 │             if (imd == 0) emit Parked(eth);\n    │                           ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/LARPBurner.sol:315:9\n    │\n315 │         emit Burned(rest, share, burned6900);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[require-revert-in-loop]: `require` or `revert` inside a loop\n    ╭▸ src/LARPBurner.sol:335:49\n    │\n335 │                 if (gasleft() <= gasBefore / 4) revert TooLittleGas();\n    │                                                 ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/require-revert-in-loop\n\nwarning[require-revert-in-loop]: `require` or `revert` inside a loop\n    ╭▸ src/LARPBurner.sol:340:61\n    │\n340 │         if (gasleft() < LEG_GAS + LEG_GAS / 63 + AFTER_GAS) revert TooLittleGas();\n    │                                                             ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/require-revert-in-loop\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:219:39\n    │\n219 │         uint256 spent = _burnBlock == uint64(block.number) ? _burnedInBlock : 0;\n    │                                       ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:233:38\n    │\n233 │                         _burnBlock = uint64(block.number);\n    │                                      ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:234:42\n    │\n234 │                         _burnedInBlock = uint192(spent + waiting);\n    │                                          ━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint192' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n   ╭▸ src/IMDNames.sol:67:63\n   │\n67 │     constructor(address identity, ILARP larp, address burner, address artist_, address intake, address oracleSigner)\n   │                                                               ━━━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:109:9\n    │\n109 │         LARPBurner(payable(BURNER)).burn{value: price}(minImd);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:123:24\n    │\n123 │         if (toll != 0) LARPBurner(payable(BURNER)).burn{value: toll}(minImd);\n    │                        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:137:9\n    │\n137 │         emit NameRegistered(tokenId, label, to, price);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:153:13\n    │\n153 │             emit NameUnlinked(old, imdId);\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:158:13\n    │\n158 │             emit NameUnlinked(tokenId, was - 1);\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:162:9\n    │\n162 │         emit NameLinked(tokenId, imdId, holder, toll);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMDNames.sol:185:9\n    │\n185 │         emit NameUnlinked(tokenId, imdId);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/IMDNames.sol:181:22\n    │\n181 │         (bool ok,) = LARP.canAct(imdId, msg.sender);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/IMDNames.sol:306:26\n    │\n306 │     function setRenderer(address renderer_) external {\n    │                          ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/IMDNames.sol:314:24\n    │\n314 │     function setArtist(address artist_) external {\n    │                        ━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:189:16\n    │\n189 │             && block.timestamp <= a.expiresAt && a.answer.length == 32 && uint256(bytes32(a.answer)) == 1;\n    │                ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/SwarmPrices.sol:192:9\n    │\n192 │         emit Verdict(requestId, approved, a.agreed, a.panelSize);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:189:83\n    │\n189 │             && block.timestamp <= a.expiresAt && a.answer.length == 32 && uint256(bytes32(a.answer)) == 1;\n    │                                                                                   ━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'bytes32' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:191:23\n    │\n191 │         p.decidedAt = uint64(block.timestamp);\n    │                       ━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:272:43\n    │\n272 │                 pair, SwapParams(imdIs0, -int256(amount), imdIs0 ? MIN_PRICE_LIMIT : MAX_PRICE_LIMIT), \"\"\n    │                                           ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:275:27\n    │\n275 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                           ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:275:49\n    │\n275 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                 ━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:275:67\n    │\n275 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                                   ━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:275:82\n    │\n275 │                 imdIs0 ? (int128(delta >> 128), int128(delta)) : (int128(delta), int128(delta >> 128));\n    │                                                                                  ━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:276:30\n    │\n276 │             if (imdDelta != -int128(int256(amount)) || outDelta <= 0) revert Unfilled();\n    │                              ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:276:37\n    │\n276 │             if (imdDelta != -int128(int256(amount)) || outDelta <= 0) revert Unfilled();\n    │                                     ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPBurner.sol:279:13\n    │\n279 │             POOL_MANAGER.settle();\n    │             ━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:280:27\n    │\n280 │             uint256 out = uint128(outDelta);\n    │                           ━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:288:61\n    │\n288 │         int256 d = POOL_MANAGER.swap(key, SwapParams(true, -int256(amount), MIN_PRICE_LIMIT), \"\");\n    │                                                             ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:289:27\n    │\n289 │         int128 ethDelta = int128(d >> 128);\n    │                           ━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:290:25\n    │\n290 │         int128 bought = int128(d);\n    │                         ━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:291:26\n    │\n291 │         if (ethDelta != -int128(int256(amount)) || bought <= 0) revert Unfilled();\n    │                          ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:291:33\n    │\n291 │         if (ethDelta != -int128(int256(amount)) || bought <= 0) revert Unfilled();\n    │                                 ━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'int256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/LARPBurner.sol:294:9\n    │\n294 │         POOL_MANAGER.settle{value: amount}();\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:295:47\n    │\n295 │         POOL_MANAGER.take(IMD, address(this), uint128(bought));\n    │                                               ━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:296:27\n    │\n296 │         return abi.encode(uint256(uint128(bought)));\n    │                           ━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint256' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/LARPBurner.sol:296:35\n    │\n296 │         return abi.encode(uint256(uint128(bought)));\n    │                                   ━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint128' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/LARPBurner.sol:315:34\n    │\n315 │         emit Burned(rest, share, burned6900);\n    │                                  ━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n    ╭▸ src/LARPBurner.sol:341:13\n    │\n341 │         try POOL_MANAGER.unlock{gas: LEG_GAS}(data) returns (bytes memory r) {\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:209:44\n    │\n209 │         if (p.status != Status.Approved || block.timestamp > p.decidedAt + EXECUTE_WINDOW) revert NotApproved();\n    │                                            ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/SwarmPrices.sol:211:32\n    │\n211 │         if (lastChange != 0 && block.timestamp < lastChange + COOLDOWN) revert Cooling();\n    │                                ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:215:22\n    │\n215 │         lastChange = uint64(block.timestamp);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint64' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:341:36\n    │\n341 │             digits[i - 1] = bytes1(uint8(48 + frac % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/SwarmPrices.sol:357:15\n    │\n357 │             ++digits;\n    │               ━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/SwarmPrices.sol:361:36\n    │\n361 │             out[--digits] = bytes1(uint8(48 + value % 10));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint8' is safe because [explain why]\n    │       // forge-lint: disable-next-line(unsafe-typecast)\n    │       \n    │       \n    ╰ help: https://getfoundry.sh/forge/linting/unsafe-typecast\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/LARPAgents.t.sol:139:28\n    │\n139 │         uint256 deadline = block.timestamp + 1 hours;\n    │                            ━━━━━━━━━━━━━━━\n140 │         bytes memory sig = _sign(ownerKey, 7, agent, owner, 0, deadline);\n141 │         vm.warp(deadline + 1);\n    │         ───────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.number` may be reused across `vm.roll`\n   ╭▸ test/LARPBurnerPairLeg.t.sol:94:17\n   │\n94 │         vm.roll(block.number + 1);\n   │         ────────━━━━━━━━━━━━───── `vm.roll` changes this environment here\n   │\n   ├ help: capture it with `vm.getBlockNumber()` instead\n   ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:203:60\n    │\n203 │             _attest(id, true, 0, \"\", block.chainid, uint64(block.timestamp + 1 days));\n    │                                                            ━━━━━━━━━━━━━━━\n    ‡\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:54:30\n    │\n 54 │             issuedAt: uint64(block.timestamp),\n    │                              ━━━━━━━━━━━━━━━\n    ‡\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:209:17\n    │\n209 │         vm.warp(block.timestamp + 14 days);\n    │         ────────━━━━━━━━━━━━━━━─────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:203:60\n    │\n203 │             _attest(id, true, 0, \"\", block.chainid, uint64(block.timestamp + 1 days));\n    │                                                            ━━━━━━━━━━━━━━━\n    ‡\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ───────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:54:30\n    │\n 54 │             issuedAt: uint64(block.timestamp),\n    │                              ━━━━━━━━━━━━━━━\n    ‡\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ───────────────────────────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\nwarning[environment-read-across-mutation]: `block.timestamp` may be reused across `vm.warp`\n    ╭▸ test/SwarmPricesEdges.t.sol:236:17\n    │\n236 │         vm.warp(block.timestamp + 7 days);\n    │         ────────━━━━━━━━━━━━━━━────────── `vm.warp` changes this environment here\n    │\n    ├ help: capture it with `vm.getBlockTimestamp()` instead\n    ╰ help: https://getfoundry.sh/forge/linting/environment-read-across-mutation\n\n","passed":true},{"durationMs":29587,"exitCode":0,"name":"test","output":"No files changed, compilation skipped\n\nRan 2 tests for test/Placement.t.sol:PlacementForkTest\n[SKIP] test_fork_ANameBurnsTheCanonicalWay() (gas: 0)\n[SKIP] test_fork_LandsAt6900ThroughTheRealCreateX() (gas: 0)\nSuite result: ok. 0 passed; 0 failed; 2 skipped; finished in 2.76ms (133.42µs CPU time)\n\nRan 6 tests for test/LARPBurnerPairLeg.t.sol:LARPBurnerPairLegTest\n[PASS] test_AtAHundredPercentOnlyThePoolsRoomBuysIMD6900() (gas: 318615)\n[PASS] test_BurnFloorsTheSendersPartOrTheWholeSaleWhenItSendsNothing() (gas: 756118)\n[PASS] test_MinImdIsCheckedAgainstThePayersOwnFee() (gas: 630527)\n[PASS] test_TheIMD6900LegIsNotWorthSandwichingAtAnyShare() (gas: 1901512)\nLogs:\n  attacker's $IMD profit at 100%, 500 $IMD front (wei): -42829697176817851510\n\n[PASS] test_TheLaunchShareOfAFullBurnIsNotClipped() (gas: 280495)\n[PASS] test_TheRoomFollowsThePoolsDepth() (gas: 615537)\nSuite result: ok. 6 passed; 0 failed; 0 skipped; finished in 8.98ms (7.40ms CPU time)\n\nRan 14 tests for test/LARPAgents.t.sol:LARPAgentsTest\n[PASS] test_AContractWalletSignsWithERC1271() (gas: 431060)\n[PASS] test_ASignatureWorksOnce() (gas: 230440)\n[PASS] test_AnAgentCantNameAgentsOrTheWallet() (gas: 195893)\n[PASS] test_AnAgentDressesTheIdentityWithTheOwnersNFTs() (gas: 396334)\n[PASS] test_AnAgentLapsesOnASale() (gas: 317701)\n[PASS] test_AnAgentLinksTheOwnersNameAndSetsTexts() (gas: 615060)\n[PASS] test_AnAgentResigns() (gas: 193582)\n[PASS] test_AnAgentRunsFrensAndCrews() (gas: 860110)\n[PASS] test_AnyAgentChangeVoidsOutstandingSignatures() (gas: 188002)\n[PASS] test_BadSignatures() (gas: 364692)\n[PASS] test_OnlyTheOwnerSetsTheAgent() (gas: 40977)\n[PASS] test_SignaturesExpire() (gas: 49228)\n[PASS] test_TheOwnerConnectsAnAgentInOneCall() (gas: 188975)\n[PASS] test_TheOwnerSignsTheAgentSends() (gas: 176447)\nSuite result: ok. 14 passed; 0 failed; 0 skipped; finished in 12.49ms (7.48ms CPU time)\n\nRan 14 tests for test/LARPItems.t.sol:LARPItemsTest\n[PASS] test_AFaceBecomesAnItem() (gas: 321185)\n[PASS] test_AnItemBecomesAnotherIdentitysFace() (gas: 306295)\n[PASS] test_EquipAnERC1155Copy() (gas: 195226)\n[PASS] test_EquipAnERC721() (gas: 228623)\n[PASS] test_OneCopyOnePlacement() (gas: 372050)\n[PASS] test_ReequippingTheSameCopyInTheSameSlot() (gas: 213412)\n[PASS] test_RefusedItems() (gas: 220243)\n[PASS] test_ReplacingAnItemFreesTheOldOne() (gas: 291522)\n[PASS] test_SellingACopyDarkensItsPlacementsUntilOneComesOff() (gas: 456264)\n[PASS] test_SellingTheIdentityDarkensItsItems() (gas: 360711)\n[PASS] test_SlotsAreOneToEight() (gas: 224747)\n[PASS] test_StrangersCantTakeItemsOff() (gas: 174966)\n[PASS] test_TheNewOwnerClearsTheOldItems() (gas: 343634)\n[PASS] test_ThePlacerTakesItsCopyBackAfterSellingTheIdentity() (gas: 399525)\nSuite result: ok. 14 passed; 0 failed; 0 skipped; finished in 14.23ms (3.81ms CPU time)\n\nRan 24 tests for test/LARPLinks.t.sol:LARPLinksTest\n[PASS] test_AGasHungryTokenCantSinkTheBoard() (gas: 1737463)\n[PASS] test_AnInnerNodeIsNotALeaf() (gas: 1448373)\n[PASS] test_AnUnreadableTokenCountsAsHeld() (gas: 1784660)\n[PASS] test_BadAllocations() (gas: 1754999)\n[PASS] test_CaptainsRun() (gas: 592442)\n[PASS] test_Card() (gas: 903636)\n[PASS] test_CrewFoundingRules() (gas: 546171)\n[PASS] test_Disband() (gas: 810487)\n[PASS] test_FoundACrewWithImd() (gas: 1184629)\n[PASS] test_FoundingACrewBurnsIMD() (gas: 378689)\n[PASS] test_FrenRules() (gas: 383139)\n[PASS] test_FrensPassWithTheIdentity() (gas: 302573)\n[PASS] test_FrensTakeTwo() (gas: 266329)\n[PASS] test_JeetsAreReadLive() (gas: 2364129)\n[PASS] test_JeetsInPages() (gas: 8424463)\n[PASS] test_OpenAndClosedCrews() (gas: 955439)\n[PASS] test_PassTheCaptaincy() (gas: 577520)\n[PASS] test_ProveAnAllocation() (gas: 1534389)\n[PASS] test_RanksAcrossLaunches() (gas: 5184173)\n[PASS] test_TheCaptaincyPassesWithTheIdentity() (gas: 397438)\n[PASS] test_TheRankIsTheHoldersNow() (gas: 1748137)\n[PASS] test_Tiers() (gas: 80885)\n[PASS] test_Unfren() (gas: 271974)\n[PASS] test_WithdrawAndDeclineAsks() (gas: 244060)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 18.99ms (11.83ms CPU time)\n\nRan 23 tests for test/IMDNamesEdges.t.sol:IMDNamesEdgesTest\n[PASS] test_APrimaryWithoutANameIsLiveAndNameless() (gas: 182236)\n[PASS] test_ARendererThatAnswersNothingFallsBack() (gas: 383627)\n[PASS] test_ASaleDarkensTheLinkAndTheTextStays() (gas: 286579)\n[PASS] test_AStrangerCannotUnlink() (gas: 160730)\n[PASS] test_AnAgentLinksUnlinksAndWrites() (gas: 486024)\n[PASS] test_ApprovalsAndOperatorTransfers() (gas: 452506)\n[PASS] test_Constants() (gas: 191514)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 15761)\n[PASS] test_LockingIsIdempotentAndKeepsTheRenderer() (gas: 292103)\n[PASS] test_PrimaryAndTextRefusals() (gas: 147701)\n[PASS] test_ReadingNames() (gas: 64773)\n[PASS] test_RegisterRefusesLessThanThePrice() (gas: 216901)\n[PASS] test_RegisterWithAFloorTheBurnCannotMeet() (gas: 224412)\n[PASS] test_RegisterWithImdNeedsAnAllowance() (gas: 622695)\n[PASS] test_ResolveNameSpellings() (gas: 150173)\n[PASS] test_RoyaltyRounding() (gas: 35079)\n[PASS] test_SafeTransfersCheckTheReceiver() (gas: 603375)\n[PASS] test_TheArtistRenouncesAndTheArtIsFinal() (gas: 154258)\n[PASS] test_TheCardOfAnUnlinkedName() (gas: 2382338)\n[PASS] test_TheLongestAndShortestNames() (gas: 503735)\n[PASS] test_TheTollInImdRespectsMaxImd() (gas: 1139620)\n[PASS] test_TransferRules() (gas: 144769)\n[PASS] test_UnlinkingNothingDoesNothing() (gas: 37821)\nSuite result: ok. 23 passed; 0 failed; 0 skipped; finished in 21.31ms (24.74ms CPU time)\n\nRan 24 tests for test/LARP.t.sol:LARPFaceTest\n[PASS] testFuzz_OnlyTheHolderOfBothSetsAFace(address,uint256,uint256) (runs: 256, μ: 55832, ~: 56425)\nLogs:\n  Bound result 0\n  Bound result 9\n\n[PASS] test_AFaceComesBackWithBothTokens() (gas: 220934)\n[PASS] test_AMaskMovesToTheIdentityThatPutsItOn() (gas: 323750)\n[PASS] test_AvatarFormat() (gas: 249931)\n[PASS] test_ChangingMasksFreesTheOldOne() (gas: 274960)\n[PASS] test_ClearFace() (gas: 200738)\n[PASS] test_ClearingNoFaceDoesNothing() (gas: 36612)\n[PASS] test_FaceURIFallsBackOnABrokenTokenURI() (gas: 2152591)\n[PASS] test_OnlyTheIdentitysOwnerClears() (gas: 173845)\n[PASS] test_PuttingTheSameMaskOnAgain() (gas: 240094)\n[PASS] test_RefusesAMaskThatIsNotYours() (gas: 49187)\n[PASS] test_RefusesAnIdentityAsAMask() (gas: 41585)\n[PASS] test_RefusesAnIdentityThatDoesNotExist() (gas: 41653)\n[PASS] test_RefusesAnIdentityThatIsNotYours() (gas: 43653)\n[PASS] test_RefusesWhatIsNotAnNFT() (gas: 510494)\n[PASS] test_SellingTheIdentityTakesTheFaceDown() (gas: 252506)\n[PASS] test_SellingTheMaskTakesTheFaceDown() (gas: 223250)\n[PASS] test_SetFace() (gas: 266231)\n[PASS] test_SupportsInterface() (gas: 27637)\n[PASS] test_TheIdentitysNewOwnerClearsTheOldFace() (gas: 225470)\n[PASS] test_TheNewHolderOfAMaskTakesItOff() (gas: 321718)\n[PASS] test_TheNewOwnerMustChooseAgain() (gas: 327564)\n[PASS] test_WearerOfAnUnwornMask() (gas: 14020)\n[PASS] test_ZeroIdentityRefused() (gas: 4446)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 32.71ms (36.90ms CPU time)\n\nRan 18 tests for test/SwarmPricesEdges.t.sol:SwarmPricesEdgesTest\n[PASS] testFuzz_TheGuardrailsAreExactlyTheDocumentedRule(uint64,uint64,uint64,uint64) (runs: 512, μ: 451974, ~: 60870)\nLogs:\n  Bound result 4378297350523736\n  Bound result 2800920687512860\n  Bound result 1200000000220975\n  Bound result 1393227266704998\n\n[PASS] test_AFailureAfterAVerdictIsRefused() (gas: 3536518)\n[PASS] test_AVerdictExpiringThisSecondStillCounts() (gas: 3485815)\n[PASS] test_AnUnknownProposalIsNone() (gas: 18765)\n[PASS] test_ExactlyTwiceAndExactlyHalfAreAllowed() (gas: 9955402)\n[PASS] test_ExecutingNothingOrAPendingProposalIsRefused() (gas: 3448188)\n[PASS] test_OverpayingTheOracleIsTheProposersChoice() (gas: 3419807)\n[PASS] test_PricesAfterTwoChangesStayWithinTheRailsOfEach() (gas: 5666539)\n[PASS] test_ProposingNeedsTheProposersImd() (gas: 384718)\n[PASS] test_TheAnswerMustBeABoolTrueAboutThisChain() (gas: 9661881)\n[PASS] test_TheCallbackSelectorsAreTheProtocolsLayout() (gas: 3565259)\n[PASS] test_TheFirstChangeHasNoCooldown() (gas: 3524896)\n[PASS] test_TheLastSecondOfTheCooldown() (gas: 5829304)\n[PASS] test_TheLastSecondOfTheExecuteWindow() (gas: 3521482)\n[PASS] test_TheProtocolsOwnSignatureVerifies() (gas: 3709734)\n[PASS] test_TheProtocolsSignatureOnATamperedVectorIsRefused() (gas: 3749904)\n[PASS] test_TheVectorsSignerApprovesWithABoolAnswer() (gas: 3712925)\n[PASS] test_TwoProposalsOneVerdictEach() (gas: 5635427)\nSuite result: ok. 18 passed; 0 failed; 0 skipped; finished in 33.39ms (51.77ms CPU time)\n\nRan 15 tests for test/LARPEdges.t.sol:LARPEdgesTest\n[PASS] testFuzz_WearerOfRoundTripsForAnyIdentityId(uint256,uint8) (runs: 256, μ: 220265, ~: 220684)\nLogs:\n  Bound result 5962\n  Bound result 8\n\n[PASS] test_ACopyPlacedTwiceIsCountedTwice() (gas: 341053)\n[PASS] test_ASignatureFromAnotherChainIsRefused() (gas: 83326)\n[PASS] test_AgentsOfNothing() (gas: 146135)\n[PASS] test_AnAgentTakesOffThePreviousOwnersItems() (gas: 350579)\n[PASS] test_ConstantsAndDomain() (gas: 57230)\n[PASS] test_ContractWalletsThatRefuseOrMumble() (gas: 462979)\n[PASS] test_EmptySpots() (gas: 141020)\n[PASS] test_OddSignatureBytes() (gas: 342349)\n[PASS] test_OneAgentForTwoIdentities() (gas: 326950)\n[PASS] test_RemovingAnAgentBumpsTheNonce() (gas: 371695)\n[PASS] test_ResigningDoesNotBumpTheNonce() (gas: 288556)\n[PASS] test_SupportsInterfaceIsPure() (gas: 15273)\n[PASS] test_TakingOffAnEmptySlotIsSilent() (gas: 61582)\n[PASS] test_ThePlacerTakesOffWhatItPlacedAfterSellingTheIdentity() (gas: 426342)\nSuite result: ok. 15 passed; 0 failed; 0 skipped; finished in 52.74ms (30.48ms CPU time)\n\nRan 7 tests for test/SwarmPrices.t.sol:SwarmShareTest\n[PASS] test_AndDownToNothing() (gas: 10341468)\n[PASS] test_ShareGuardrails() (gas: 7682664)\n[PASS] test_StartsAt6Point9AndTheBurnerReadsItFromIMDNames() (gas: 264776)\n[PASS] test_TheBurnerFallsBackTo6Point9() (gas: 429031)\n[PASS] test_TheQuestionNamesTheShare() (gas: 6758711)\n[PASS] test_TheSwarmMovesTheShareAndTheBurnerFollows() (gas: 3760618)\n[PASS] test_UpToAllOfIt() (gas: 10694969)\nSuite result: ok. 7 passed; 0 failed; 0 skipped; finished in 54.51ms (33.08ms CPU time)\n\nRan 24 tests for test/LARPLinksEdges.t.sol:LARPLinksEdgesTest\n[PASS] testFuzz_JeetBpsIsTheSoldShareOfTheAllocation(uint128,uint256,bool) (runs: 256, μ: 1665590, ~: 1535748)\nLogs:\n  Bound result 1\n  Bound result 0\n\n[PASS] testFuzz_TiersAreMonotoneInJeetPoints(uint256,uint256,uint256) (runs: 256, μ: 33077, ~: 33218)\nLogs:\n  Bound result 259\n  Bound result 21375\n  Bound result 2581786\n\n[PASS] test_ACardWithALiveFace() (gas: 694335)\n[PASS] test_ADisbandedCrewIsGone() (gas: 624526)\n[PASS] test_ADistributorWithoutARootIsUnknown() (gas: 1411930)\n[PASS] test_ADistributorWithoutATokenCountsAsHeld() (gas: 1673522)\n[PASS] test_ALauncherAnsweringGarbageIsUnknown() (gas: 1533984)\n[PASS] test_AllocationBounds() (gas: 2897946)\n[PASS] test_AnAskSurvivesASaleOfEitherIdentity() (gas: 241341)\n[PASS] test_AnEmptyProofForASoloRound() (gas: 1509668)\n[PASS] test_AnIdentityNobodyHolds() (gas: 54774)\n[PASS] test_CaptainRules() (gas: 588036)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 13620)\n[PASS] test_CrewNamesAtTheEdges() (gas: 689374)\n[PASS] test_Defaults() (gas: 177309)\n[PASS] test_FoundCrewWithImdRefusals() (gas: 1002976)\n[PASS] test_FoundCrewWithTheWrongValue() (gas: 364406)\n[PASS] test_InviteRules() (gas: 567999)\n[PASS] test_JoinLeaveRules() (gas: 743979)\n[PASS] test_LaunchJeetPastTheEndReverts() (gas: 14394)\n[PASS] test_MembersCountFollowsEveryMove() (gas: 725282)\n[PASS] test_TwoRoundsOfOneLaunchAreOneLevel() (gas: 1866769)\n[PASS] test_UnfrenClearsBothAsksAtOnce() (gas: 388582)\n[PASS] test_UnfrenWithNothingDoesNothing() (gas: 86806)\nSuite result: ok. 24 passed; 0 failed; 0 skipped; finished in 55.10ms (101.40ms CPU time)\n\nRan 4 tests for test/Launch.t.sol:LaunchTest\n[PASS] test_DeploysOnAFreshChain() (gas: 193241)\n[PASS] test_FitsOneTransaction() (gas: 25789)\nLogs:\n  launch gas, four creations: 8303\n\n[PASS] test_PassesTheAdmissionScan() (gas: 18079372)\n[PASS] test_UnderTheCodeSizeLimit() (gas: 11134)\nSuite result: ok. 4 passed; 0 failed; 0 skipped; finished in 71.72ms (52.07ms CPU time)\n\nRan 11 tests for test/MainnetFork.t.sol:MainnetForkTest\n[SKIP] test_ACrewBuysAndBurnsRealIMD() (gas: 0)\n[SKIP] test_ANameBuysRealIMDOnPool4AndBurnsIt() (gas: 0)\n[SKIP] test_ANameChangesHandsAndBurns() (gas: 0)\n[SKIP] test_ANamePaidInRealImd() (gas: 0)\n[SKIP] test_APriceProposalThroughIMDsRealIntake() (gas: 0)\n[SKIP] test_AnAgentRunsTheTreasurysIdentity() (gas: 0)\n[SKIP] test_AnIdentityWearsAWorkerFren() (gas: 0)\n[SKIP] test_RealProofsRefuseTampering() (gas: 0)\n[SKIP] test_TheHooklessPoolTakesWhatPool4Cant() (gas: 0)\n[SKIP] test_TheRealJeetBoard() (gas: 0)\n[SKIP] test_TheTreasurysCard() (gas: 0)\nSuite result: ok. 0 passed; 0 failed; 11 skipped; finished in 84.99ms (720.46µs CPU time)\n\nRan 18 tests for test/SwarmPrices.t.sol:SwarmPricesTest\n[PASS] testFuzz_AWrongRequestCannotSettleAPendingProposal(bytes32) (runs: 256, μ: 3602912, ~: 3603018)\n[PASS] test_AProposalForOldPricesGoesStale() (gas: 5746079)\n[PASS] test_ARejectedProposalChangesNothing() (gas: 3509710)\n[PASS] test_AVerdictCannotApproveAnotherPendingProposal() (gas: 5605415)\n[PASS] test_AVerdictMustBeUsedWithinTwoWeeks() (gas: 3484003)\n[PASS] test_AWeakPanelIsARejection() (gas: 9673020)\n[PASS] test_AnExpiredVerdictIsARejection() (gas: 3469488)\n[PASS] test_AnyoneProposesAndTheContractWritesTheQuestion() (gas: 4279995)\n[PASS] test_ApprovedThenAnyoneExecutes() (gas: 4114203)\n[PASS] test_ChangingTheSignedRequestIdInvalidatesTheSignature() (gas: 5740540)\n[PASS] test_ExecutedOnce() (gas: 3532702)\n[PASS] test_Guardrails() (gas: 218195)\n[PASS] test_NoVerdictClosesTheProposal() (gas: 3502151)\n[PASS] test_OneChangeAWeek() (gas: 5815824)\n[PASS] test_OnlyTheIntakeDeliversAndOnlyForItsOwnProposals() (gas: 3493956)\n[PASS] test_OnlyTheOraclesSignatureForThisContractCounts() (gas: 3635637)\n[PASS] test_StartPrices() (gas: 61091)\n[PASS] test_TheOracleMustBePaid() (gas: 239434)\nSuite result: ok. 18 passed; 0 failed; 0 skipped; finished in 99.29ms (105.22ms CPU time)\n\nRan 8 tests for test/Placement.t.sol:PlacementTest\n[PASS] test_ASaltUsedFirstIsNeverTaken() (gas: 10723418)\n[PASS] test_ArgumentsAsTheReadmeSays() (gas: 6240)\n[PASS] test_DeploysOnAFreshChain() (gas: 10256242)\n[PASS] test_FitsOneTransaction() (gas: 31706762)\nLogs:\n  the launch: gas, all in: 11261279\n  PlaceLARP initcode bytes: 40310\n  PlaceLinks initcode bytes: 12010\n\n[PASS] test_LandsWhereThePlanSays() (gas: 10538646)\n[PASS] test_PassesTheAdmissionScan() (gas: 43505634)\n[PASS] test_PlanFollowsFromTheSalts() (gas: 162797)\n[PASS] test_SameAddressesWhoeverRunsIt() (gas: 20402429)\nSuite result: ok. 8 passed; 0 failed; 0 skipped; finished in 99.30ms (123.89ms CPU time)\n\nRan 28 tests for test/IMDNames.t.sol:IMDNamesTest\n[PASS] test_ABrokenRendererFallsBackToTheCard() (gas: 10710970)\n[PASS] test_AFeeParksWhenNoPoolCanTakeIt() (gas: 8894773)\n[PASS] test_ANewOwnerPaysTheTollToLink() (gas: 659541)\n[PASS] test_ARoyaltyPaymentIsBurned() (gas: 197078)\n[PASS] test_AnyoneRegistersAnyFreeName() (gas: 251418)\n[PASS] test_BadNames() (gas: 76271)\n[PASS] test_LinkRules() (gas: 227703)\n[PASS] test_LinkTheNameToAnIdentity() (gas: 188953)\n[PASS] test_NoImdPaymentWithoutBothPools() (gas: 233712)\n[PASS] test_OneNamePerIdentityOneIdentityPerName() (gas: 566947)\n[PASS] test_Prices() (gas: 63806)\n[PASS] test_Primary() (gas: 249738)\n[PASS] test_RegisterForSomeoneElse() (gas: 242327)\n[PASS] test_RegisterWithImd() (gas: 962888)\n[PASS] test_RegisterWithImdRespectsMaxImd() (gas: 785222)\n[PASS] test_RegisteringMintsTheNameAndBurnsTheFee() (gas: 287226)\n[PASS] test_RegistrationRules() (gas: 228053)\n[PASS] test_RoyaltiesGoToTheBurner() (gas: 40939)\n[PASS] test_SellingTheIdentityTakesItDown() (gas: 170626)\n[PASS] test_SellingTheNameTakesItDown() (gas: 207985)\n[PASS] test_ShortNamesHaveShortNameTolls() (gas: 290386)\n[PASS] test_TextRecordsStartOverWithANewHolder() (gas: 217274)\n[PASS] test_TheArtistChangesTheArtAndOnlyTheArt() (gas: 410113)\n[PASS] test_TheBuiltInCard() (gas: 3442144)\n[PASS] test_TheNamesNewOwnerUnlinksAStaleLink() (gas: 236080)\n[PASS] test_TheTollFollowsEveryChangeOfHands() (gas: 214766)\n[PASS] test_TheTollInImd() (gas: 1097163)\n[PASS] test_Unlink() (gas: 207675)\nSuite result: ok. 28 passed; 0 failed; 0 skipped; finished in 99.57ms (46.59ms CPU time)\n\nRan 19 tests for test/LARPBurnerEdges.t.sol:LARPBurnerEdgesTest\n[PASS] testFuzz_ABurnSpendsMinOfBalanceAndMaxBurn(uint256,uint256) (runs: 128, μ: 798657, ~: 797905)\nLogs:\n  Bound result 182452882424919949\n  Bound result 384285164318795929\n\n[PASS] testFuzz_QuoteIsLinearAndMonotone(uint256,uint256) (runs: 256, μ: 576827, ~: 576910)\nLogs:\n  Bound result 1685701882424981683\n  Bound result 6285995003877838520\n\n[PASS] testFuzz_SixPointNinePercentBuysIMD6900AndTheRestBurns(uint256) (runs: 256, μ: 578066, ~: 580495)\nLogs:\n  Bound result 4301701373105919548\n\n[PASS] testFuzz_TwoBurnsInOneBlockSellAtMostOneCapOfWaitingEth(uint256,uint256,uint256) (runs: 192, μ: 1021213, ~: 1024672)\nLogs:\n  Bound result 26713859483468978\n  Bound result 10000000000000000\n  Bound result 6628\n\n[PASS] test_APartialFillOnPool4FallsToTheHooklessPool() (gas: 1846686)\n[PASS] test_AWethAnsweringShortIsIgnored() (gas: 534743)\n[PASS] test_AWethThatRefusesToUnwrapIsIgnored() (gas: 572334)\n[PASS] test_AWrongPool4KeyFallsToTheHooklessPool() (gas: 465447)\n[PASS] test_BelowTheLegBudgetABurnIsRefusedBeforeAnyLegRuns() (gas: 1030938)\n[PASS] test_Constants() (gas: 72853)\n[PASS] test_ConstructorRefusesZeroAddresses() (gas: 9394)\n[PASS] test_ExactlyMaxBurnInOneCall() (gas: 615853)\n[PASS] test_NoPoolAtAllParksAndQuotesNothing() (gas: 613793)\n[PASS] test_NothingToBurnIsNotAnError() (gas: 383372)\n[PASS] test_OneWeiParks() (gas: 668242)\n[PASS] test_QuoteOfTheSmallestPrice() (gas: 549288)\n[PASS] test_ReceiveTakesEmptyCallsOnly() (gas: 66423)\n[PASS] test_TheBlockAllowanceCountsOnlyTheWaitingEth() (gas: 886201)\n[PASS] test_UnwrappedWethIsWaitingEth() (gas: 913857)\nSuite result: ok. 19 passed; 0 failed; 0 skipped; finished in 99.49ms (246.63ms CPU time)\n\nRan 7 tests for test/LARPBurnerSettlement.t.sol:LARPBurnerSettlementTest\n[PASS] test_ParkedWaitingEthDoesNotConsumeTheBlocksAllowance() (gas: 1034032)\n[PASS] test_PreSyncCannotParkACrewFee() (gas: 945441)\n[PASS] test_PreSyncCannotParkARegistrationFee() (gas: 842669)\n[PASS] test_PreSyncCannotParkAResaleToll() (gas: 1239745)\n[PASS] test_PreSyncCannotParkTheHooklessRoute() (gas: 880379)\n[PASS] test_PreSyncCannotParkWaitingEthOrChooseTheBackup() (gas: 1179771)\n[PASS] test_PreSyncStillHonoursMinImdAndRollsBackTheAllowance() (gas: 675781)\nSuite result: ok. 7 passed; 0 failed; 0 skipped; finished in 180.17ms (7.58ms CPU time)\n\nRan 27 tests for test/LARPBurner.t.sol:LARPBurnerTest\n[PASS] test_AFeeAlwaysGoesThroughWhateverTheBlockSpent() (gas: 842662)\n[PASS] test_AGasEatingIMD6900IsSkippedNotFatal() (gas: 7966516)\n[PASS] test_AGasEatingPool4HookFallsToTheHooklessPool() (gas: 3732187)\n[PASS] test_AGenuineFailureIsNotMistakenForTooLittleGas() (gas: 505929)\n[PASS] test_ASwapOutOfGasReverts() (gas: 10080207)\n[PASS] test_AnEmptyPairPoolMeansItAllBurnsAsIMD() (gas: 456548)\n[PASS] test_AnIMD6900LegOutOfGasDeepDownReverts() (gas: 3825389)\n[PASS] test_AnIMD6900ThatWontBurnMeansItAllBurnsAsIMD() (gas: 793224)\n[PASS] test_AtMostMaxBurnPerCallAndPerBlockOfWaitingEth() (gas: 889900)\n[PASS] test_BurnCallsBatchedInOneTransactionSellOneCap() (gas: 666272)\n[PASS] test_BurnImdBurnsWhatArrivesInIMD() (gas: 523288)\n[PASS] test_BuysOnPool4First() (gas: 702809)\n[PASS] test_HostileLegsCostPaidCallsTheirBudgets() (gas: 11595661)\nLogs:\n  registration gas used with two hostile legs: 6033788\n\n[PASS] test_MinImd() (gas: 961796)\n[PASS] test_NoGasLimitSkipsAHeavyIMD6900Leg() (gas: 68273876)\n[PASS] test_NoGasLimitSkipsARoute() (gas: 6031485)\n[PASS] test_NoQuoteWithoutBothPools() (gas: 297470)\n[PASS] test_NoReentry() (gas: 467883)\n[PASS] test_OnlyThePoolManagerCallsBack() (gas: 32829)\n[PASS] test_ParkedWhenNoPoolCanAndBurnedLater() (gas: 1010640)\n[PASS] test_QuoteIsTheHigherOfTheTwoPools() (gas: 759415)\n[PASS] test_RoyaltiesArriveByPlainTransfer() (gas: 44081)\n[PASS] test_ShareBuysIMD6900AndBurnsIt() (gas: 855411)\n[PASS] test_SpacingAboveV4sLargestReverts() (gas: 11396)\n[PASS] test_SpacingsAreTakenUnsignedAndKeptAsInt24() (gas: 28301)\n[PASS] test_TheHooklessPoolIfPool4CantTakeIt() (gas: 814879)\n[PASS] test_WethRoyaltiesAreUnwrappedAndSold() (gas: 762106)\nSuite result: ok. 27 passed; 0 failed; 0 skipped; finished in 180.25ms (262.85ms CPU time)\n\nRan 1 test for test/SwarmPrices.invariant.t.sol:SwarmPricesInvariantTest\n[PASS]\nSwarmPricesInvariantTest invariants:\n[PASS] invariant_CountersMatchWhatHappened\n[PASS] invariant_NamesHoldsNothing\n[PASS] invariant_NoProposalReopens\n[PASS] invariant_PricesChangeOnlyByExecution\n[PASS] invariant_PricesWithinTheGuardrails\n SwarmPricesInvariantTest invariants (runs: 64, calls: 3072, reverts: 0)\n\n╭--------------+----------+-------+---------+----------╮\n| Contract     | Selector | Calls | Reverts | Discards |\n+======================================================+\n| SwarmHandler | execute  | 436   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | fail     | 446   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | forge    | 422   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | pass     | 441   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | propose  | 428   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | stranger | 455   | 0       | 0        |\n|--------------+----------+-------+---------+----------|\n| SwarmHandler | verdict  | 444   | 0       | 0        |\n╰--------------+----------+-------+---------+----------╯\n\nLogs:\n  Bound result 2902941871486535\n  Bound result 4506666666683736\n  Bound result 1840000000048880\n  Bound result 1840000000000009\n  Bound result 400000000000007747\n  Bound result 770687\n  Bound result 6399999999983696\n  Bound result 4506666666666710\n  Bound result 1840000000004700\n  Bound result 1840000000014381\n  Bound result 400000002835717309\n  Bound result 474248\n  Bound result 18400000000001097\n  Bound result 4506666666666679\n  Bound result 1840000000024257\n  Bound result 1840000000003093\n  Bound result 400000000000004638\n  Bound result 18400000000007301\n  Bound result 4506666667666668\n  Bound result 1840000000003965\n  Bound result 1239999999999997\n  Bound result 450000000000000002\n  Bound result 584517\n  Bound result 251852\n  Bound result 18400000003000001\n  Bound result 4506666666678408\n  Bound result 1039999996739131\n  Bound result 1840004113140427\n  Bound result 400000000000076002\n  Bound result 18400000000014283\n  Bound result 4506666666666827\n  Bound result 1840000000000013\n  Bound result 1840000000012322\n  Bound result 400000000000005002\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 493.68ms (486.42ms CPU time)\n\nRan 1 test for test/LARPBurner.invariant.t.sol:LARPBurnerInvariantTest\n[PASS]\nLARPBurnerInvariantTest invariants:\n[PASS] invariant_DeadHoldsOnlyImd\n[PASS] invariant_EthLeavesOnlyAsASwap\n[PASS] invariant_Imd6900OnlyBurns\n[PASS] invariant_ImdGoesOnlyToDeadOrTheIMD6900Buy\n[PASS] invariant_NoImdOutlivesABurn\n[PASS] invariant_WaitingEthLeavesAtMostOneCapPerBlock\n LARPBurnerInvariantTest invariants (runs: 64, calls: 3072, reverts: 0)\n\n╭---------------+-------------------+-------+---------+----------╮\n| Contract      | Selector          | Calls | Reverts | Discards |\n+================================================================+\n| BurnerHandler | burn              | 380   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | burnImd           | 348   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | burnWithLittleGas | 391   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateEth         | 436   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateImd         | 373   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | donateWeth        | 362   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | nextBlock         | 355   | 0       | 0        |\n|---------------+-------------------+-------+---------+----------|\n| BurnerHandler | trade             | 427   | 0       | 0        |\n╰---------------+-------------------+-------+---------+----------╯\n\nLogs:\n  Bound result 5622060740456107708978\n  Bound result 12870\n  Bound result 3007882\n  Bound result 1533\n  Bound result 2301\n  Bound result 284316827753434525\n  Bound result 358793239081170476\n  Bound result 4984\n  Bound result 184812773397540567\n  Bound result 2433318\n  Bound result 5999002760000000000001\n  Bound result 77040\n  Bound result 2577\n  Bound result 10785\n  Bound result 1\n  Bound result 6907\n  Bound result 303217537091289238245\n  Bound result 1\n  Bound result 81570759080747168\n  Bound result 5356\n  Bound result 75000\n  Bound result 40\n  Bound result 1\n  Bound result 1\n  Bound result 299999999999999999\n  Bound result 1707490\n  Bound result 69000\n  Bound result 194\n  Bound result 1990\n  Bound result 3450000000000000\n  Bound result 1\n  Bound result 738\n  Bound result 6\n  Bound result 16777215\n  Bound result 14837\n  Bound result 499792917818885444\n  Bound result 875\n  Bound result 16109\n  Bound result 6064\n  Bound result 14277\n  Bound result 353946\n  Bound result 26880\n  Bound result 133378206054161229\n  Bound result 8263\n  Bound result 2921074\n  Bound result 1\n  Bound result 54243722424859933\n  Bound result 1933009\n  Bound result 194265960037000698\n  Bound result 63\n  Bound result 3010306\n  Bound result 5999000000000000001276\n  Bound result 2834634216490329199\n  Bound result 115788162\n  Bound result 1532892063\n  Bound result 353073666\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 848.36ms (843.77ms CPU time)\n\nRan 1 test for test/LARP.invariant.t.sol:LARPInvariantTest\n[PASS]\nLARPInvariantTest invariants:\n[PASS] invariant_LiveMeansThePlacerHoldsIt\n[PASS] invariant_NoMoreLiveCopiesThanHeld\n[PASS] invariant_OneTokenOneSpot\n LARPInvariantTest invariants (runs: 128, calls: 8192, reverts: 0)\n\n╭-------------+--------------+-------+---------+----------╮\n| Contract    | Selector     | Calls | Reverts | Discards |\n+=========================================================+\n| LarpHandler | equip1155    | 1184  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | equip721     | 1207  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveCopy     | 1175  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveIdentity | 1145  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | giveMask     | 1168  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | setFace      | 1122  | 0       | 0        |\n|-------------+--------------+-------+---------+----------|\n| LarpHandler | takeOff      | 1191  | 0       | 0        |\n╰-------------+--------------+-------+---------+----------╯\n\nSuite result: ok. 1 passed; 0 failed; 0 skipped; finished in 29.46s (29.45s CPU time)\n\nRan 22 test suites in 29.46s (32.02s CPU time): 283 tests passed, 0 failed, 13 skipped (296 total tests)\n","passed":true},{"durationMs":111,"exitCode":0,"name":"source-index","output":"{\"v\":1,\"entryPoints\":[\"IMDNames.approve(address,uint256)\",\"IMDNames.execute(bytes32)\",\"IMDNames.link(uint256,uint256,uint256)\",\"IMDNames.linkWithImd(uint256,uint256,uint256)\",\"IMDNames.lockRenderer()\",\"IMDNames.onNoVerdict(bytes32,uint8,bytes32,uint16,uint16,bytes)\",\"IMDNames.onVerdict(bytes32,(bytes32,uint256,bytes32,uint8,bytes,uint256,uint64,uint64,bytes32,bytes32,uint16,uint16,uint16,uint64,uint64),bytes)\",\"IMDNames.propose((uint64,uint64,uint64,uint64,uint16),uint256)\",\"IMDNames.register(bytes32,address,uint256)\",\"IMDNames.registerWithImd(bytes32,address,uint256)\",\"IMDNames.safeTransferFrom(address,address,uint256)\",\"IMDNames.safeTransferFrom(address,address,uint256,bytes)\",\"IMDNames.setApprovalForAll(address,bool)\",\"IMDNames.setArtist(address)\",\"IMDNames.setPrimary(uint256)\",\"IMDNames.setRenderer(address)\",\"IMDNames.setText(uint256,string,string)\",\"IMDNames.transferFrom(address,address,uint256)\",\"IMDNames.unlink(uint256)\",\"LARP.clearFace(uint256)\",\"LARP.equip(uint256,uint256,address,uint256,uint8)\",\"LARP.resignAgent(uint256)\",\"LARP.setAgent(uint256,address)\",\"LARP.setAgentBySig(uint256,address,uint256,bytes)\",\"LARP.setFace(uint256,address,uint256)\",\"LARP.unequip(uint256,uint256)\",\"LARPBurner.burn(uint256)\",\"LARPBurner.burnImd()\",\"LARPBurner.receive()\",\"LARPBurner.unlockCallback(bytes)\",\"LARPLinks.disband(uint256)\",\"LARPLinks.foundCrew(uint256,bytes32,bool,uint256)\",\"LARPLinks.foundCrewWithImd(uint256,bytes32,bool,uint256)\",\"LARPLinks.fren(uint256,uint256)\",\"LARPLinks.invite(uint256,uint256,bool)\",\"LARPLinks.join(uint256,uint256)\",\"LARPLinks.kick(uint256,uint256)\",\"LARPLinks.leave(uint256)\",\"LARPLinks.passCaptain(uint256,uint256)\",\"LARPLinks.proveAlloc(uint64,uint256,address,uint256,bytes32[])\",\"LARPLinks.setOpen(uint256,bool)\",\"LARPLinks.unfren(uint256,uint256)\"],\"files\":{\".gitignore\":4,\"ADAPTATION.md\":189,\"AUDIT-COVERAGE.md\":199,\"AUDIT.md\":323,\"README.md\":235,\"foundry.toml\":34,\"script/place/gen.py\":122,\"src/IIMDNames.sol\":112,\"src/ILARP.sol\":120,\"src/IMDNames.sol\":358,\"src/LARP.sol\":330,\"src/LARPBurner.sol\":404,\"src/LARPLinks.sol\":457,\"src/Labels.sol\":53,\"src/SafeReads.sol\":63,\"src/SwarmPrices.sol\":370,\"src/place/LARPPlan.sol\":38,\"src/place/PlaceLARP.sol\":148,\"test/Base.sol\":328,\"test/IMDNames.t.sol\":481,\"test/IMDNamesEdges.t.sol\":458,\"test/LARP.invariant.t.sol\":184,\"test/LARP.t.sol\":324,\"test/LARPAgents.t.sol\":269,\"test/LARPBurner.invariant.t.sol\":495,\"test/LARPBurner.t.sol\":585,\"test/LARPBurnerEdges.t.sol\":459,\"test/LARPBurnerPairLeg.t.sol\":215,\"test/LARPBurnerSettlement.t.sol\":155,\"test/LARPEdges.t.sol\":340,\"test/LARPItems.t.sol\":236,\"test/LARPLinks.t.sol\":515,\"test/LARPLinksEdges.t.sol\":459,\"test/Launch.t.sol\":134,\"test/MainnetFork.t.sol\":371,\"test/Mocks.sol\":89,\"test/Placement.t.sol\":347,\"test/SwarmPrices.invariant.t.sol\":364,\"test/SwarmPrices.t.sol\":608,\"test/SwarmPricesEdges.t.sol\":353,\"test/fixtures/allocs.json\":118},\"excluded\":[\"lib/\",\"node_modules/\"],\"truncated\":false}","passed":true},{"durationMs":6053,"exitCode":0,"name":"slither","output":"[medium/high] incorrect-equality at src/LARPBurner.sol:215: LARPBurner.burn(uint256) (src/LARPBurner.sol#215-246) uses a dangerous strict equality:\n[medium/high] incorrect-equality at src/LARPBurner.sol:215: LARPBurner.burn(uint256) (src/LARPBurner.sol#215-246) uses a dangerous strict equality:\n[medium/medium] reentrancy-no-eth at src/LARPBurner.sol:215: Reentrancy in LARPBurner.burn(uint256) (src/LARPBurner.sol#215-246):\n[medium/medium] uninitialized-local at src/SwarmPrices.sol:355: SwarmPrices._decimal(uint256).digits (src/SwarmPrices.sol#355) is a local variable never initialized\n[medium/medium] uninitialized-local at src/LARP.sol:308: LARP._decimal(uint256).digits (src/LARP.sol#308) is a local variable never initialized\n[medium/medium] uninitialized-local at src/LARPBurner.sol:307: LARPBurner._burnImd().burned6900 (src/LARPBurner.sol#307) is a local variable never initialized\n[medium/medium] unused-return at src/IMDNames.sol:105: IMDNames.register(bytes32,address,uint256) (src/IMDNames.sol#105-110) ignores return value by LARPBurner(address(BURNER)).burn{value: price}(minImd) (src/IMDNames.sol#109)\n[medium/medium] unused-return at src/IMDNames.sol:120: IMDNames.link(uint256,uint256,uint256) (src/IMDNames.sol#120-124) ignores return value by LARPBurner(address(BURNER)).burn{value: toll}(minImd) (src/IMDNames.sol#123)\n[medium/medium] unused-return at src/LARPBurner.sol:266: LARPBurner.unlockCallback(bytes) (src/LARPBurner.sol#266-297) ignores return value by POOL_MANAGER.settle{value: amount}() (src/LARPBurner.sol#294)\n[medium/medium] unused-return at src/LARPLinks.sol:453: LARPLinks._own(uint256) (src/LARPLinks.sol#453-456) ignores return value by (ok,None) = LARP.canAct(imdId,msg.sender) (src/LARPLinks.sol#454)\n[medium/medium] unused-return at src/LARPBurner.sol:266: LARPBurner.unlockCallback(bytes) (src/LARPBurner.sol#266-297) ignores return value by POOL_MANAGER.settle() (src/LARPBurner.sol#279)\n[medium/medium] unused-return at src/LARPLinks.sol:324: LARPLinks._captain(uint256) (src/LARPLinks.sol#324-329) ignores return value by (ok,None) = LARP.canAct(c.captain,msg.sender) (src/LARPLinks.sol#327)\n[medium/medium] unused-return at src/LARPLinks.sol:201: LARPLinks.foundCrew(uint256,bytes32,bool,uint256) (src/LARPLinks.sol#201-209) ignores return value by LARPBurner(address(BURNER)).burn{value: msg.value}(minImd) (src/LARPLinks.sol#208)\n[medium/medium] unused-return at src/IMDNames.sol:178: IMDNames.unlink(uint256) (src/IMDNames.sol#178-186) ignores return value by (ok,None) = LARP.canAct(imdId,msg.sender) (src/IMDNames.sol#181)\n[medium/medium] unused-return at src/LARPLinks.sol:439: LARPLinks.cardOf(uint256) (src/LARPLinks.sol#439-450) ignores return value by (None,c.faceCollection,c.faceTokenId,c.faceLive) = LARP.faceOf(imdId) (src/LARPLinks.sol#443)\n[low/medium] missing-zero-check at src/LARPBurner.sol:147: LARPBurner.constructor(address,address,uint24,uint24,address,uint24,uint24,address,uint24,uint24,address,address).names (src/LARPBurner.sol#147) lacks a zero-check on :\n[low/medium] missing-zero-check at src/IMDNames.sol:306: IMDNames.setRenderer(address).renderer_ (src/IMDNames.sol#306) lacks a zero-check on :\n[low/medium] missing-zero-check at src/IMDNames.sol:67: IMDNames.constructor(address,ILARP,address,address,address,address).artist_ (src/IMDNames.sol#67) lacks a zero-check on :\n[low/medium] missing-zero-check at src/IMDNames.sol:314: IMDNames.setArtist(address).artist_ (src/IMDNames.sol#314) lacks a zero-check on :\n[low/medium] missing-zero-check at src/LARPBurner.sol:140: LARPBurner.constructor(address,address,uint24,uint24,address,uint24,uint24,address,uint24,uint24,address,address).pool4Hook (src/LARPBurner.sol#140) lacks a zero-check on :\n[low/medium] missing-zero-check at src/LARPBurner.sol:146: LARPBurner.constructor(address,address,uint24,uint24,address,uint24,uint24,address,uint24,uint24,address,address).pairHook (src/LARPBurner.sol#146) lacks a zero-check on :\n[low/medium] calls-loop at src/LARPBurner.sol:328: LARPBurner._tryUnlock(uint8,uint256) (src/LARPBurner.sol#328-346) has external calls inside a loop: r_scope_0 = POOL_MANAGER.unlock{gas: LEG_GAS}(data) (src/LARPBurner.sol#341-345)\n[low/medium] calls-loop at src/LARPBurner.sol:328: LARPBurner._tryUnlock(uint8,uint256) (src/LARPBurner.sol#328-346) has external calls inside a loop: r = POOL_MANAGER.unlock(data) (src/LARPBurner.sol#332-337)\n[low/medium] reentrancy-benign at src/SwarmPrices.sol:152: Reentrancy in SwarmPrices.propose(SwarmPrices.Prices,uint256) (src/SwarmPrices.sol#152-177):\n[low/medium] reentrancy-events at src/LARPBurner.sol:215: Reentrancy in LARPBurner.burn(uint256) (src/LARPBurner.sol#215-246):\n[low/medium] reentrancy-events at src/LARPBurner.sol:215: Reentrancy in LARPBurner.burn(uint256) (src/LARPBurner.sol#215-246):\n[low/medium] reentrancy-events at src/SwarmPrices.sol:152: Reentrancy in SwarmPrices.propose(SwarmPrices.Prices,uint256) (src/SwarmPrices.sol#152-177):\n[low/medium] reentrancy-events at src/LARPBurner.sol:301: Reentrancy in LARPBurner._burnImd() (src/LARPBurner.sol#301-316):\n[low/medium] return-bomb at src/LARPBurner.sol:328: LARPBurner._tryUnlock(uint8,uint256) (src/LARPBurner.sol#328-346) tries to limit the gas of an external call that controls implicit decoding\n[low/medium] return-bomb at src/LARPBurner.sol:168: LARPBurner.shareBps() (src/LARPBurner.sol#168-176) tries to limit the gas of an external call that controls implicit decoding\n[low/medium] timestamp at src/SwarmPrices.sol:182: SwarmPrices.onVerdict(bytes32,Attestation,bytes) (src/SwarmPrices.sol#182-193) uses timestamp for comparisons\n[low/medium] timestamp at src/LARP.sol:77: LARP.setAgentBySig(uint256,address,uint256,bytes) (src/LARP.sol#77-91) uses timestamp for comparisons\n[low/medium] timestamp at src/SwarmPrices.sol:207: SwarmPrices.execute(bytes32) (src/SwarmPrices.sol#207-217) uses timestamp for comparisons","passed":true},{"durationMs":547,"exitCode":0,"name":"aderyn","output":"[high] abi-encode-packed-hash-collision at src/place/PlaceLARP.sol:40: `abi.encodePacked()` Hash Collision (5 places)\n[high] contract-locks-ether at src/IMDNames.sol:21: Contract locks Ether without a withdraw function (3 places)\n[high] reentrancy-state-change at src/IMDNames.sol:181: Reentrancy: State change after external call (4 places)\n[low] costly-loop at src/LARPBurner.sol:227: Costly operations inside loop\n[low] ecrecover at src/LARP.sol:153: `ecrecover` Signature Malleability (2 places)\n[low] internal-function-used-once at src/Labels.sol:9: Internal Function Used Only Once (2 places)\n[low] large-numeric-literal at src/IMDNames.sol:34: Large Numeric Literal (13 places)\n[low] literal-instead-of-constant at src/IMDNames.sol:68: Literal Instead of Constant (68 places)\n[low] missing-inheritance at src/LARPBurner.sol:55: Missing Inheritance\n[low] push-zero-opcode at src/IIMDNames.sol:2: PUSH0 Opcode (11 places)\n[low] require-revert-in-loop at src/LARPBurner.sol:227: Loop Contains `require`/`revert`\n[low] state-no-address-check at src/IMDNames.sol:74: Address State Variable Set Without Checks (3 places)\n[low] unchecked-return at src/LARPBurner.sol:279: Unchecked Return\n[low] uninitialized-local-variable at src/LARPBurner.sol:227: Uninitialized Local Variable (5 places)\n[low] unspecific-solidity-pragma at src/IIMDNames.sol:2: Unspecific Solidity Pragma (8 places)\n[low] unused-public-function at src/IMDNames.sol:98: Public Function Not Used Internally\n[low] unused-state-variable at src/LARPBurner.sol:87: Unused State Variable","passed":true},{"durationMs":18246,"exitCode":0,"name":"proof 22bc735e0861","output":"Compiling 85 files with Solc 0.8.26\nSolc 0.8.26 finished in 17.51s\nCompiler run successful!\n\nRan 2 tests for test/imd-proof-71a1ae40/Proof_22bc735e0861.t.sol:PairLegSandwichTest\n[PASS] test_AtLaunchShareItLoses() (gas: 735146)\n[PASS] test_TheIMD6900LegIsNotWorthSandwichingAtAnyAllowedShare() (gas: 706167)\nLogs:\n  attacker profit, $IMD (wei): -42829697176817851510\n\nSuite result: ok. 2 passed; 0 failed; 0 skipped; finished in 2.22ms (1.45ms CPU time)\n\nRan 1 test suite in 3.11ms (2.22ms CPU time): 2 tests passed, 0 failed, 0 skipped (2 total tests)\n","passed":true}],"detail":"all checks passed","evaluation":"checks","profile":"foundry","status":"accepted","submissionHash":"d33a8ae4d619f939da0907ddd57a1268108af025780646ce18e081318a6e8967","verifiedTreeHash":"b00356c1a3d3813e53d6cfe5e4655764aa137392","verifierVersion":"0.1.0+7ff5db2c"}]}