{"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":"24ff6bc1-caa5-4c35-91e8-ada33e53d726","kind":"shape:chain","nodes":[{"acceptedSubmissionHash":null,"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":"failed"},{"acceptedSubmissionHash":null,"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":"waiting"},{"acceptedSubmissionHash":null,"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":"waiting"},{"acceptedSubmissionHash":"8c9bc2d1b40dd8b3bd960c435018eb6fbe2699f8d2961ee9186dc1fc43be1a47","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":null,"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":"waiting"},{"acceptedSubmissionHash":null,"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":"waiting"},{"acceptedSubmissionHash":null,"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":"waiting"},{"acceptedSubmissionHash":null,"dependsOn":["adapt_contract_project"],"execution":{"network":false,"profile":"foundry","requires":[],"tools":[]},"key":"manifest","kind":"code","role":"integrate","skillHash":null,"skillId":null,"state":"waiting"},{"acceptedSubmissionHash":null,"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":"waiting"}],"objective":"Deploy IMD6900RobinhoodLaunch (src/IMD6900RobinhoodLaunch.sol) on Robinhood Chain exactly as it is in the repository: one contract, four constructor arguments in this order: 0x35da9c0303507ddf708e87f2568eddf12c47a059 (owner: the team wallet), 0x8366a39CC670B4001A1121B8F6A443A643e40951 (Uniswap v4's PoolManager on Robinhood Chain), 0x0000198C940D8cD70Cb9ACeC5E3af8216ac57d2F (Robinhood's IMDSTR, the old token that claims the new coin 1:1), 0x16D3f65B708883DF042d98E1C7a49B32A33E2A14 (the Robinhood timelock: owns the hook and recovers ETH). Its constructor creates IMD6900LockedPool and nothing else (no salt mining: about 6.9M gas from any deployer address). After the deploy, createHook(salt) (anyone, once) creates IMD6900Hook with CREATE2 from the launch at a salt mined off-chain for its address (script/launch.sh hook: its address carries exactly the hook's permission flags and doesn't start with 0x91; the hook is owned by the timelock); the team calls it, the deploy does not need to. The pool's fee is static: 4.44% (POOL_FEE 44_400), the same for every trade, so Uniswap's router routes the pool on its own (no dynamic fee, no return deltas); it accrues to the locked position, whose fees anyone can collect. A v4 pool's fee can't change, so IMD6900LockedPool.lowerFee (the timelock only, lower only) moves the whole position in one unlock to a new pool at the lower fee and the same price. It calls nothing that existed before it, so it deploys the same on a fresh chain (test_DeploysOnAFreshChain); it fits one transaction (test_FitsOneTransaction, ~6.9M gas, the same from any deployer); no contract shows CALLCODE, DELEGATECALL or SELFDESTRUCT, creation code included (test_PassesTheAdmissionScan). Later, its owner launches the coin IMD6900 at a 0x6900… address mined for this contract's address (launch(): the coin with CREATE2, the pool opened with the whole 1B supply as coin-only liquidity, locked for good, and the opening buy, in one transaction), through Programmable's custom launch, which binds every component to the exact source: do not change the source, the compiler settings (solc 0.8.26, via-IR, 200 runs, cancun, bytecode_hash none), the constructor, the hook's permissions, the 4.44% static fee and lowerFee's lower-only move (refused while the perps engine has positions open), the fee refund (IMD6900LockedPool.feeCheckpoint/feeRefund: only the hook's perps engine and the launch's sellHeld trade fee-free), the pool's lack of any liquidity removal (only lowerFee's move from one pool into the next), the coin's plain ERC20 (no owner, no mint, no tax) and launch()'s refusal of any coin address not starting with 0x6900, the fee split's defaults (90% the pot bridge, which feeds IMD6900's NFT floor pot on Ethereum; 10% $IMD bought for IMD's canonical Robinhood burn executor 0x4D6537ec564aFf82eABb1Ce5f355E817cBEA1e07, fixed in the code), the perps engine's fees (addPerpFees: all of it as ETH to the pot bridge), the split and every landing address being the timelock's alone to change (setPayees, setPerpFeeTo, setCoinFeeTo, setImdBurn, setImdPool), or the timelock's role (the hook's owner; it alone recovers ETH, releases the excess or sells the coins the launch holds back into the pool for the opening buy's ETH (sellHeld), ends the claims early (endClaims), repoints $IMD's pool and sets the split). The perps are part of this project and of every audit and test step: src/perps/PerpEngine.sol, PerpVault.sol and PerpSwapLib.sol (inlined, internal functions only: no DELEGATECALL anywhere, the engine under EIP-170 at about 24.4KB). They are not deployed with the launch (the engine's constructor binds to the live pool): IMD6900LockedPool.createPerps creates them right after launch() from exactly the code whose keccak256 is ENGINE_CODE_HASH / VAULT_CODE_HASH (test_ThePerpsCodeIsTheAuditedCode): any fix to src/perps must update those two constants, or the test fails; the engine stays owned by the Robinhood timelock and is wired into the hook at once (initPerpEngine), fee-free by refund; audit its no-bad-debt liquidation inside the hook's pre-trade sweep, the refund pair, the vault's accounting and the fee split (20% stakers, 10% insurance, 70% to the launch's addPerpFees). test/Perps.t.sol covers creation, longs, shorts, the sweep's liquidations and fees. test/RobinhoodFork.t.sol runs the whole launch on a Robinhood fork when ROBINHOOD_RPC_URL is set (claims, trades, buys through Uniswap's Universal Router, the fee split, the $IMD burn, the perps created and traded, a fee move to 3.33%) and skips otherwise. Everything builds offline (lib/ is vendored; v4-core's PoolManager is used by the tests only).","parentJobId":null,"planHash":"99396a0b8724ac395c474eed3c20b5dcb90783bc27c618f5800e7b201700b1ed","previousHash":"0000000000000000000000000000000000000000000000000000000000000000","projectId":"24ff6bc1-caa5-4c35-91e8-ada33e53d726","publication":{"commit":null,"deliveredAt":null,"repoUrl":"https://github.com/identity-md-launches/launch-1548-imd6900robinhoodlaunch"},"receiptIdentity":{"adapter":"0xde152afb7db5373f34876e1499fbd893a82dd336","chainId":1,"collection":"0x0000ec93127baa929e58e97dd0095a2bfb38ec1d","registry":"0x8004a169fb4a3325136eb29fa0ceb6d2e539a432"},"registry":"0xb6d0a187b050fa5bb0b87033a203f37becf4a775","research":[],"schema":"identitymd-work-v1","signals":[{"agentId":"52585","feedbackHash":"22677f50407727edaaa7aab41abb64ed18b3857df559a82883aff6b7f2b51235","nodeKey":"adapt_contract_project","submissionHash":"b6e40a31979785a6e47cd55141cf0e6342b179ef1db5ff01f38d9a3d26c6d344","tag1":"verification:checks","tag2":"acceptance-v2","value":0},{"agentId":"52095","feedbackHash":"22d2c9ee88e2930e8716c0d5b438fbb773b35857d61c9ccee242fb66a2642ab7","nodeKey":"adapt_contract_project","submissionHash":"976f4f025d236304ca21fa11c2b30480bfe60b20b55b5a80f9cf4d0152d77aaa","tag1":"verification:checks","tag2":"acceptance-v2","value":0},{"agentId":"52603","feedbackHash":"ba77097b6111851f349a41bf79804f96965bc699726dbbf47deedf5ac3cf648a","nodeKey":"audit_imported_code","submissionHash":"8c9bc2d1b40dd8b3bd960c435018eb6fbe2699f8d2961ee9186dc1fc43be1a47","tag1":"review:submission","tag2":"acceptance-v2","value":1}],"site":null,"snapshotHash":"7cd96cd41c81f4172cd228febfaa74100be6b8ca5e7d00a7a81e5e3ed88d729b","state":"blocked","submissions":[{"artifacts":[],"attempt":1,"bundleHash":null,"device":"7e64d4917fa814e6","findings":[{"citation":"resolved","description":"createPerps accepts only code whose keccak256 equals ENGINE_CODE_HASH / VAULT_CODE_HASH. With the repository's own pinned settings (solc 0.8.26, via-IR, 200 runs, cancun, bytecode_hash none) keccak256(type(PerpEngine).creationCode) is 0x3ce566f987e94e7d6e37f1e6eae05488d1ec6893765f381bd37b12579e9ade3f, not the pinned 0x136b10b3...0651 (the vault's hash does match, so the compiler is the same; the engine source changed after the constant was set: the commit says 24,441 bytes of runtime, this build is 24,453). So no input satisfies the check, test/Perps.t.sol's setUp already reverts with NotThePerpsCode() on this commit, script/launch.sh's perps step refuses, and the launch's documented path to perps (engine owned by the timelock, wired fee-free through initPerpEngine) is dead. The only alternative is the timelock deploying its own engine and calling setPerpEngine/setPerpRefunded, outside the audited flow. Any fix to src/perps must recompute both constants.","line":69,"path":"src/IMD6900LockedPool.sol","proof":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.26;\n\nimport {Test} from \"forge-std/Test.sol\";\nimport {IPoolManager} from \"@uniswap/v4-core/src/interfaces/IPoolManager.sol\";\nimport {PoolManager} from \"@uniswap/v4-core/src/PoolManager.sol\";\nimport {Hooks} from \"@uniswap/v4-core/src/libraries/Hooks.sol\";\nimport {FullMath} from \"@uniswap/v4-core/src/libraries/FullMath.sol\";\nimport {IMD6900Hook} from \"src/IMD6900Hook.sol\";\nimport {IMD6900LockedPool} from \"src/IMD6900LockedPool.sol\";\nimport {IMD6900RobinhoodLaunch} from \"src/IMD6900RobinhoodLaunch.sol\";\nimport {PerpEngine} from \"src/perps/PerpEngine.sol\";\nimport {PerpVault} from \"src/perps/PerpVault.sol\";\n\n/// ENGINE_CODE_HASH in IMD6900LockedPool is not the keccak256 of the PerpEngine this repository builds (solc 0.8.26,\n/// via-IR, 200 runs, cancun, bytecode_hash none), so createPerps refuses the only code that exists and the perps can\n/// never be created the way the launch documents. Fails now with NotThePerpsCode(); passes once the constant matches\n/// the source (or the source matches the constant).\ncontract PerpsCodeHashProof is Test {\n    address constant OWNER = address(0xA11CE);\n    address constant TL = address(0x71E10C);\n    uint256 constant SUPPLY = 1_000_000_000 ether;\n\n    IPoolManager PM;\n    IMD6900RobinhoodLaunch L;\n    IMD6900LockedPool pool;\n\n    function setUp() public {\n        PM = IPoolManager(address(new PoolManager(address(this))));\n        L = new IMD6900RobinhoodLaunch(OWNER, PM, address(0xBEEF), TL);\n        L.createHook(_mineHook(L));\n        pool = L.pool();\n        bytes32 salt = _mineCoin(L);\n        address expected = L.tokenAddress(salt);\n        uint160 price = uint160(_sqrt(FullMath.mulDiv(SUPPLY, 1 << 192, 19.18 ether)));\n        vm.deal(OWNER, 2.81 ether);\n        vm.prank(OWNER);\n        L.launch{value: 2.81 ether}(salt, expected, price, 0, address(L));\n    }\n\n    function test_CreatePerpsAcceptsTheEngineThisRepositoryBuilds() public {\n        assertEq(keccak256(type(PerpVault).creationCode), pool.VAULT_CODE_HASH(), \"the vault hash matches the build\");\n        assertEq(keccak256(type(PerpEngine).creationCode), pool.ENGINE_CODE_HASH(), \"the engine hash matches the build\");\n        vm.deal(address(this), 1 ether);\n        (address e, address v) =\n            pool.createPerps{value: 0.05 ether}(type(PerpEngine).creationCode, type(PerpVault).creationCode);\n        assertTrue(e != address(0) && v != address(0));\n        assertEq(IMD6900Hook(L.hook()).perpEngine(), e, \"wired at once\");\n    }\n\n    function _mineHook(IMD6900RobinhoodLaunch l) internal view returns (bytes32) {\n        bytes32 initHash = l.hookInitCodeHash();\n        uint160 flags = l.FLAGS();\n        for (uint256 i;; ++i) {\n            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(l), i, initHash)))));\n            if (uint160(a) & Hooks.ALL_HOOK_MASK == flags && uint160(a) >> 152 != 0x91) return bytes32(i);\n        }\n    }\n\n    function _mineCoin(IMD6900RobinhoodLaunch l) internal view returns (bytes32) {\n        bytes32 initHash = l.tokenInitCodeHash();\n        for (uint256 i;; ++i) {\n            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(l), i, initHash)))));\n            if (uint160(a) >> 144 == 0x6900) return bytes32(i);\n        }\n    }\n\n    function _sqrt(uint256 x) internal pure returns (uint256 y) {\n        if (x == 0) return 0;\n        y = x;\n        uint256 z = (x + 1) / 2;\n        while (z < y) (y, z) = (z, (x / z + z) / 2);\n    }\n}","reproduction":"After launch(), call pool.createPerps(type(PerpEngine).creationCode, type(PerpVault).creationCode) with the engine built from this tree. Expected: the engine and vault are created and hook.perpEngine() is set. Actual: revert NotThePerpsCode(). forge test --match-path test/Perps.t.sol fails in setUp with NotThePerpsCode().","severity":"high","snippet":"    bytes32 public constant ENGINE_CODE_HASH = 0x136b10b3b461616f618358a9d4ad7fff26b80ac920c5d8092be808bdb60c0651;","title":"ENGINE_CODE_HASH is not the hash of the PerpEngine this tree builds: createPerps can never succeed"},{"citation":"resolved","description":"In PerpSwapLib.swapLeg the engine calls IMD6900LockedPool.feeRefund right after poolManager.swap and before _settle(poolManager, quote, paid). feeRefund pokes the position and does poolManager.take(currency0, engine, fee), and take pays from the PoolManager's native balance, not from deltas. The engine's own ETH input has not been paid in yet, so the manager must already hold at least the refund (4.65% of the engine's buy) from other sources. After the timelock sells the held coins back for the opening buy's ETH (sellHeld, the documented way to recover it; fee-free so it drains nearly all of the liquidity's ETH, leaving the manager under 0.02 ETH while activeEthDepth still reports ~19 ETH of virtual depth), every engine buy reverts: openLong, a short's close() and a short's liquidation. A short liquidation inside the hook's pre-trade sweep then makes sweepLiquidations revert and _beforeSwap reverts every trade with SweepUnavailable until the timelock sets sweepFailOpen. Settle the input first (or take the refund as a delta credit) so the manager holds the ETH when it pays it out.","line":529,"path":"src/perps/PerpSwapLib.sol","proof":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.26;\n\nimport {Test} from \"forge-std/Test.sol\";\nimport {IPoolManager} from \"@uniswap/v4-core/src/interfaces/IPoolManager.sol\";\nimport {PoolManager} from \"@uniswap/v4-core/src/PoolManager.sol\";\nimport {Hooks} from \"@uniswap/v4-core/src/libraries/Hooks.sol\";\nimport {PoolKey} from \"@uniswap/v4-core/src/types/PoolKey.sol\";\nimport {Currency} from \"@uniswap/v4-core/src/types/Currency.sol\";\nimport {BalanceDelta} from \"@uniswap/v4-core/src/types/BalanceDelta.sol\";\nimport {SwapParams} from \"@uniswap/v4-core/src/types/PoolOperation.sol\";\nimport {TickMath} from \"@uniswap/v4-core/src/libraries/TickMath.sol\";\nimport {FullMath} from \"@uniswap/v4-core/src/libraries/FullMath.sol\";\nimport {IMD6900Hook} from \"src/IMD6900Hook.sol\";\nimport {IMD6900LockedPool} from \"src/IMD6900LockedPool.sol\";\nimport {IMD6900RobinhoodLaunch} from \"src/IMD6900RobinhoodLaunch.sol\";\nimport {PerpEngine} from \"src/perps/PerpEngine.sol\";\nimport {PerpVault} from \"src/perps/PerpVault.sol\";\n\ninterface IERC20Min {\n    function balanceOf(address) external view returns (uint256);\n    function approve(address, uint256) external returns (bool);\n    function transfer(address, uint256) external returns (bool);\n}\n\n/// A plain trader: swaps through the PoolManager as any router would\ncontract Trader {\n    IPoolManager immutable pm;\n    PoolKey key;\n    constructor(IPoolManager pm_) { pm = pm_; }\n    function swap(PoolKey calldata k, bool buy, int256 amountSpecified) external payable returns (BalanceDelta d) {\n        key = k;\n        d = abi.decode(pm.unlock(abi.encode(buy, amountSpecified)), (BalanceDelta));\n    }\n    function unlockCallback(bytes calldata data) external returns (bytes memory) {\n        (bool buy, int256 amt) = abi.decode(data, (bool, int256));\n        BalanceDelta d = pm.swap(key, SwapParams(buy, amt, buy ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1), \"\");\n        _settle(key.currency0, d.amount0());\n        _settle(key.currency1, d.amount1());\n        return abi.encode(d);\n    }\n    function _settle(Currency c, int128 v) internal {\n        if (v < 0) {\n            if (c.isAddressZero()) pm.settle{value: uint128(-v)}();\n            else { pm.sync(c); IERC20Min(Currency.unwrap(c)).transfer(address(pm), uint128(-v)); pm.settle(); }\n        } else if (v > 0) pm.take(c, address(this), uint128(v));\n    }\n    receive() external payable {}\n}\n\n/// PerpSwapLib.swapLeg takes the engine's fee refund (IMD6900LockedPool.feeRefund -> PoolManager.take of the input\n/// currency) BEFORE the engine settles its own input. PoolManager.take pays from its balance, so when the manager\n/// holds less ETH than the refund (4.65% of the engine's buy), the take fails with OutOfFunds and the whole swap\n/// reverts. That is the pool's state once the timelock sells the held coins back for the opening buy's ETH\n/// (sellHeld, as designed): from then on every engine buy reverts: openLong, a short's close, a short's\n/// liquidation (inside the hook's pre-trade sweep: SweepUnavailable for everyone's trade while a short is open).\n/// Fails now (openLong reverts); passes once the input is settled before the refund is taken.\ncontract RefundTakenBeforeSettleProof is Test {\n    address constant OWNER = address(0xA11CE);\n    address constant TL = address(0x71E10C);\n    address constant STAKER = address(0x57A4E);\n    uint256 constant SUPPLY = 1_000_000_000 ether;\n\n    IPoolManager PM;\n    IMD6900RobinhoodLaunch L;\n    IMD6900Hook hook;\n    IMD6900LockedPool pool;\n    PerpEngine engine;\n    PerpVault vault;\n    address t;\n    PoolKey k;\n\n    function setUp() public {\n        PM = IPoolManager(address(new PoolManager(address(this))));\n        L = new IMD6900RobinhoodLaunch(OWNER, PM, address(0xBEEF), TL);\n        hook = L.createHook(_mineHook(L));\n        pool = L.pool();\n        bytes32 salt = _mineCoin(L);\n        address expected = L.tokenAddress(salt);\n        uint160 price = uint160(_sqrt(FullMath.mulDiv(SUPPLY, 1 << 192, 19.18 ether)));\n        vm.deal(OWNER, 2.81 ether);\n        vm.prank(OWNER);\n        (t,) = L.launch{value: 2.81 ether}(salt, expected, price, 0, address(L));\n        k = pool.poolKey();\n        // the perps as the timelock could wire them (createPerps is closed by the hash mismatch, a separate finding)\n        engine = new PerpEngine(PM, address(hook), t, pool.fee(), 60, address(L), address(this));\n        vault = new PerpVault(address(engine));\n        engine.setVault(address(vault));\n        engine.fundInsurance{value: 0.05 ether}();\n        engine.transferOwnership(TL);\n        vm.startPrank(TL);\n        hook.setPerpEngine(address(engine));\n        hook.setPerpRefunded(true);\n        vm.stopPrank();\n        vm.deal(STAKER, 20 ether);\n        vm.prank(STAKER);\n        vault.depositEth{value: 10 ether}();\n    }\n\n    function test_ALongOpensAfterTheHeldCoinsAreSoldBack() public {\n        vm.prank(TL);\n        L.sellHeld(0, 0, TL);\n        assertLt(address(PM).balance, 0.02 ether, \"the manager holds almost no ETH now\");\n        (uint160 sp,,) = pool.state();\n        assertLt(sp, TickMath.getSqrtPriceAtTick(pool.upperTick()), \"the price is still inside the range\");\n        assertGt(engine.activeEthDepth(), 15 ether, \"and the engine's depth model still reports ~19 ETH\");\n\n        address alice = address(0xA1);\n        vm.deal(alice, 1 ether);\n        vm.prank(alice);\n        uint256 id = engine.openLong{value: 0.1 ether}(5, 0);\n        assertEq(engine.openCount(), 1);\n        assertGt(id, 0);\n    }\n\n    function _mineHook(IMD6900RobinhoodLaunch l) internal view returns (bytes32) {\n        bytes32 initHash = l.hookInitCodeHash();\n        uint160 flags = l.FLAGS();\n        for (uint256 i;; ++i) {\n            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(l), i, initHash)))));\n            if (uint160(a) & Hooks.ALL_HOOK_MASK == flags && uint160(a) >> 152 != 0x91) return bytes32(i);\n        }\n    }\n\n    function _mineCoin(IMD6900RobinhoodLaunch l) internal view returns (bytes32) {\n        bytes32 initHash = l.tokenInitCodeHash();\n        for (uint256 i;; ++i) {\n            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(l), i, initHash)))));\n            if (uint160(a) >> 144 == 0x6900) return bytes32(i);\n        }\n    }\n\n    function _sqrt(uint256 x) internal pure returns (uint256 y) {\n        if (x == 0) return 0;\n        y = x;\n        uint256 z = (x + 1) / 2;\n        while (z < y) (y, z) = (z, (x / z + z) / 2);\n    }\n\n    receive() external payable {}\n}","reproduction":"Launch (opening buy 2.81 ETH), wire the engine (timelock path), stakers deposit 10 ETH. Timelock: sellHeld(0, 0, TL). Now address(poolManager).balance < 0.02 ether, the price is inside the range and engine.activeEthDepth() > 15 ether. Alice: engine.openLong{value: 0.1 ether}(5, 0). Expected: the long opens (the pool holds the whole supply to sell). Actual: revert, wrapped by the PoolManager: PoolManager.take(ETH, engine, 0.0216 ether) -> OutOfFunds (NativeTransferFailed), because the engine's 0.487 ETH input is settled only after the refund.","severity":"high","snippet":"            (uint256 r0, uint256 r1) = IFeeRefund(launcher).feeRefund(address(this));","title":"swapLeg takes the fee refund before settling the engine's input: every engine buy reverts (OutOfFunds) once the pool's ETH is low, bricking longs, short closes and the sweep"},{"citation":"resolved","description":"The hook skips the sweep for every swap whose sender is the engine ('they are the sweep'), but openShort, openLong and close are not sweeps: openShort sells borrowed coins into the pool (price down) and close/_settle of a long does the same, moving the price without first liquidating the positions the move sinks. The only guard is _sweepAfterOpen, which runs AFTER the price moved, best-effort, and is skipped entirely when gasleft() <= 250_000 (PerpEngine.sol:514), so a caller sizes the gas of each openShort to skip it. Shorts are capped at 10% of the token depth (~20% price move) and each at 3.5%, so three shorts sent with just enough gas move the price ~20% with no liquidation in between; a 5x long opened before them (trigger at a 12% mark drop, principal 80% of notional) is then liquidated by the next swap's sweep at a price where its sale returns less than its principal: bad debt paid by insurance then plv (_replenishPlv), the 'NO BAD DEBT, BY CONSTRUCTION' guarantee broken by the engine's own order flow. Run the pre-trade sweep (with the projection) for the engine's opens and closes too, or make the post-open sweep mandatory.","line":230,"path":"src/IMD6900Hook.sol","reproduction":"Stakers: 10 ETH to vault.depositEth and ~3 ETH worth of coins to vault.depositToken. Victim: openLong{0.13 ETH}(5, 0) (notional ~0.6 ETH, principal ~0.48). Attacker: three openShort{0.17 ETH}(5, 0) calls, each with gas such that gasleft() after the open is <= 250_000 so _sweepAfterOpen returns without sweeping; each sells ~0.8 ETH of coins fee-free (sender == engine: no pre-trade sweep). Price falls ~20%; the victim is now liquidatable (isLiquidatable(id) == true) at a price where its coins sell for ~0.76 of notional < 0.8 principal. Attacker calls liquidate(id): BadDebt(shortfall > 0) is emitted and insuranceEth falls. Expected: the longs the shorts would sink are liquidated at the price before each short's sale, as every other swap gets.","severity":"medium","snippet":"        if (engine == address(0) || sender == engine) return;","title":"The engine's own opens and closes run no pre-trade sweep: a short's sale (fee-free, up to 10% of depth) can sink longs past their trigger before any liquidation runs"},{"citation":"resolved","description":"ethDepth integrates the curve from the current price to SQRT_MAX (full range). IMD6900LockedPool's single position is [-887220, upperTick], upperTick being the opening price, so the ETH actually in the pool is L*(1/sqrtP - 1/sqrtP_upper)*2^96, zero at the opening price. Right after the launch the virtual depth is ~19 ETH while the pool holds the opening buy's 2.81 ETH; after sellHeld it holds ~0 while activeEthDepth() still reports ~19 ETH. maxNotionalBps (3.5%), maxOiBps (5%), maxShortOiBps (10%), the per-timestamp throttle and _project all scale on that number, and exitInsolvent prices a long's close on the curve beyond upperTick, where no ETH exists, so a long is reported solvent when its sale would run the pool dry. PerpSwapLib's own comment ('If the book ever stops being full range this must be revisited') describes exactly this pool. Use the ETH between the price and upperTick for the long side's depth and close-out test.","line":366,"path":"src/perps/PerpSwapLib.sol","reproduction":"After launch and sellHeld(0,0,TL): address(poolManager).balance < 0.02 ether, yet engine.activeEthDepth() > 15 ether and a 5x long of 0.47 ETH notional passes _checkNotional/_refuseBornLiquidatable (it only fails today because of the refund-before-settle revert). Expected: depth, caps and the close-out test reflect the ~0 ETH a sale can take out.","severity":"medium","snippet":"        uint256 term = FullMath.mulDiv(uint256(L), uint256(SQRT_MAX) - sp, uint256(SQRT_MAX));","title":"Every depth-based limit uses the virtual full-range depth L/sqrtP although the locked position ends at upperTick: caps, projection and close-out test are sized on ETH the pool does not hold"},{"citation":"resolved","description":"feeCheckpoint/feeRefund assume nothing but the caller's swap earns fees between the two. For the launch's sellHeld, the hook's _afterSwap sweep runs inside that window (sender is the launch, not the engine): a liquidation there makes the engine call feeCheckpoint, which _poke()s everything earned so far, including the launch's own fee, to the locked pool. The launch's feeRefund then returns 0, `back` is 0, the fee coins are not re-sold, and they are burned at the next collect instead of coming back to the timelock as ETH.","line":501,"path":"src/IMD6900RobinhoodLaunch.sol","reproduction":"With the engine wired and a long that the price after the timelock's sale leaves underwater but the pre-trade projection does not condemn (small sale, 2x long), call sellHeld(amount, 0, to). Expected: HeldSold.eth equals the fee-free proceeds of `amount`. Actual: FeeRefunded(launch, ..., tokens: 0); the 4.44% stays with the locked pool and Collected(..., tokensBurned) burns it.","severity":"low","snippet":"                (, uint256 back) = pool.feeRefund(address(this));","title":"sellHeld's fee refund is taken by the hook's post-trade sweep when it liquidates: the timelock's sale pays the 4.44% after all"},{"citation":"resolved","description":"A failed payment is left in the balance (PayFailed) and the whole balance minus imdBucket is split again on the next call, including the part already attributed to the failed payee. The burn executor's share is booked as imdBucket each time, so repeated failures of the pot bridge move its share into $IMD buys: 100 ETH with the bridge refusing: split #1 books 10 to imdBucket, 90 stays; split #2 books 9 more and tries 81; and so on, converging on all of it going to $IMD rather than the 90/10 the defaults promise. Track what is owed to a failed payee (or revert) instead of leaving it in the common balance.","line":454,"path":"src/IMD6900RobinhoodLaunch.sol","reproduction":"Set POT_BRIDGE's code to a contract whose receive() reverts (or a payee that reverts via setPayees). Send 100 ETH of fees, call split() twice. Expected: imdBucket == 10 ether after both. Actual: imdBucket == 19 ether after the second.","severity":"low","snippet":"            (bool ok,) = to[i].call{value: part}(\"\");","title":"split() re-splits a payee's refused share next time, so the $IMD bucket takes more than its 10% whenever the pot bridge rejects ETH"},{"citation":"resolved","description":"Read in full: src/IMD6900RobinhoodLaunch.sol, src/IMD6900LockedPool.sol, src/IMD6900Hook.sol, src/IMD6900.sol, src/perps/PerpEngine.sol, src/perps/PerpVault.sol, src/perps/PerpSwapLib.sol, test/*.sol, foundry.toml. forge build and the non-fork suite were run (44 launch tests pass; test/Perps.t.sol fails in setUp, finding 1). Not reached: the vendored lib/ (v4-core, v4-periphery, solady, OpenZeppelin) was trusted as published; test/RobinhoodFork.t.sol was not run (no ROBINHOOD_RPC_URL), so the live PoolManager, IMDSTR, the pot bridge (whether it accepts plain ETH), $IMD's pool parameters and the burn executor addresses are unverified offline; script/*.py, script/launch.sh and jobs/ were only skimmed. The launch forbids nothing found here: no DELEGATECALL/CALLCODE/SELFDESTRUCT, no proxy, no mint/pause/blacklist on the coin; the hook's setPerpEngine/setSweepFailOpen and the engine's risk setters are post-deployment configuration behind the timelock, by design.","line":44,"path":"src/IMD6900RobinhoodLaunch.sol","reproduction":"n/a","severity":"info","snippet":"contract IMD6900RobinhoodLaunch is Ownable, ReentrancyGuard {","title":"Coverage: what was read and what could not be reached"}],"hash":"8c9bc2d1b40dd8b3bd960c435018eb6fbe2699f8d2961ee9186dc1fc43be1a47","nodeId":"816dff9a-cabc-4e9c-afc1-032229136eff","outcome":"completed","summary":"The review is complete. Findings are in `.imd-findings.json` at the repository root (7 entries, 2 with Foundry proofs that fail on this tree as stated). No tracked file was modified; only `test/scratch/` holds my proof files.\n\n**What I found**\n\n- **High, proven: the perps can never be created.** The pinned engine hash in `IMD6900LockedPool` does not match the PerpEngine this tree builds with its own compiler settings. The vault's hash does match, so the engine source drifted after the constant was set. `createPerps` rejects the only code that exists, and the shipped `test/Perps.t.sol` already fails in setUp with NotThePerpsCode. The documented perps path is dead until both constants are recomputed.\n- **High, proven: the engine's fee refund is taken before its input is settled.** In `PerpSwapLib.swapLeg` the refund's `take` pulls ETH from the PoolManager's balance before the engine pays its ETH in. Once the timelock sells the held coins back (the designed way to recover the opening ETH), the manager holds almost no ETH and every engine buy reverts with OutOfFunds: opening longs, closing shorts, and liquidating shorts. A short liquidation inside the hook's pre-trade sweep then makes every swap revert with SweepUnavailable.\n- **Medium: the engine's own opens and closes skip the pre-trade sweep.** A short's fee-free sale moves the price without liquidating the longs it sinks; the post-open sweep is best-effort and skipped when gas is tight, so three gas-limited shorts can jump a long past its trigger into bad debt.\n- **Medium: every depth-based limit uses the virtual full-range depth** while the locked position ends at the opening tick. After sellHeld the pool holds about zero ETH but the engine reports about 19 ETH of depth, so caps, projection and the close-out test are sized on ETH that does not exist.\n- **Low:** sellHeld's refund is swallowed when the post-trade sweep liquidates in the window, and `split()` re-splits refused payouts so the $IMD bucket drifts above 10% when the pot bridge rejects ETH.\n- **Info:** all seven source files and the tests were read; vendored libs, the fork test (no RPC) and the live Robinhood addresses were not verified.\n\n**What I dropped.** I attempted a proof that a sale could walk the pool past its top tick and brick every swap. Fee-paying sellers can never drain the last ETH, so that state was not reachable and I did not report it.\n\n**Next for the adapter:** recompute both code hashes after any engine change, settle the engine's input before taking the refund, and run the pre-trade sweep for the engine's own opens and closes.","treeHash":null,"usage":{"cachedInputTokens":2446571,"inputTokens":450,"model":"claude-fable-5-1","outputTokens":93059,"runtime":"claude","turns":29,"wallClockMs":1411534}},{"artifacts":[],"attempt":3,"bundleHash":"f5d0217f14ffee6b2ab0b073e7cfac14b6633ab7daf0677db645601a44237f2a","device":"8310b806f0fcfbea","findings":[],"hash":"976f4f025d236304ca21fa11c2b30480bfe60b20b55b5a80f9cf4d0152d77aaa","nodeId":"d276f497-4bc0-46dd-afad-735221eb873d","outcome":"completed","summary":"Implemented the audit fixes, vault reward precision correction, and regression tests.\n\nOffline build passed: **71 tests passed, 1 fork test skipped** because no RPC was configured. Admission checks passed; deployment used **7.95M gas**.\n\nChanges and validation are documented in [ADAPTATION.md](/home/imd14/.identitymd/work/24ff6bc1-caa5-4c35-91e8-ada33e53d726/d276f497-4bc0-46dd-afad-735221eb873d/ADAPTATION.md).","treeHash":"f4ad9f8ba831f957ceeeb6d5ab69043c2e0db69c","usage":{"cachedInputTokens":9196544,"inputTokens":206050,"model":"gpt-6-astra","outputTokens":54874,"runtime":"codex","turns":13,"wallClockMs":2596853}},{"artifacts":[],"attempt":1,"bundleHash":"6782e89cab1fcf2cd01cdc015f8dc26fd50e7e71a7173b63d4318e08286e407e","device":"3c1226d190150ef0","findings":[],"hash":"b6e40a31979785a6e47cd55141cf0e6342b179ef1db5ff01f38d9a3d26c6d344","nodeId":"d276f497-4bc0-46dd-afad-735221eb873d","outcome":"completed","summary":"`IMD6900RobinhoodLaunch` needed no change to launch: its constructor already takes the four addresses in the brief's order, calls no existing contract and creates only `IMD6900LockedPool`. The work was fixing the audit findings. Six findings reproduced and are fixed, each with a test. `forge build` and `forge test` pass: 60 tests, with the Robinhood fork test skipping because there's no RPC set. Everything is committed as `4917744`.\n\n| # | Finding | Fix |\n|---|---|---|\n| 1 high | `ENGINE_CODE_HASH` didn't match the built engine, so `createPerps` always reverted | Recomputed it after the engine fixes below. `VAULT_CODE_HASH` already matched. `test/Perps.t.sol` passes again. |\n| 2 high | The engine took its fee refund before paying its ETH in, so engine buys failed when the pool had little ETH | `PerpSwapLib.swapLeg` now pays ETH in before taking the refund. Token sales keep the old order, because the engine may not hold the full amount until the refund comes back. |\n| 3 medium | The engine's own opens and closes ran no pre-trade liquidation sweep, and the backup sweep could be skipped by sending low gas | The hook now runs the sweep before and after the engine's own trades too. The engine's liquidations return from it at once. The skippable backup sweep is removed. |\n| 4 medium | Liquidation pricing assumed ETH above the pool's top price that isn't there | A long's sale proceeds are now capped by the ETH the pool really holds. |\n| 5 low | During `sellHeld`, a liquidation could take the launch's fee refund | Refund windows can now nest in `IMD6900LockedPool`, and an outer refund gets back what an inner one booked. |\n| 6 low | `split()` re-split a refused share, so the $IMD share grew past 10% | A refused payment now reverts the split. |\n\nThe info-level coverage note needed no code change.\n\nThings to know before the next review:\n\n- **Behaviour changes:**\n  - Opening or closing a perp now reverts when the liquidation sweep can't finish. Before, the open went through anyway.\n  - Once the pool's ETH is drained, for example after `sellHeld`, new longs are refused and open longs are liquidated first.\n  - `PayFailed` is now an error rather than an event.\n- **Finding 4 is only partly addressed.** The open-size caps, the liquidation throttle and the price projection still use the larger theoretical depth. Bad debt depends on the liquidation test, which now uses the real ETH. Moving the caps too would have limited perps right after launch to about 3.5% of the opening buy's ETH. That's a risk setting for the owner to decide, and `ADAPTATION.md` explains it.\n- **Not checked against the original code:** I didn't run the new tests on the code as it arrived. The audit's proofs for findings 1 and 2 did fail on it.\n- **The audit's proof for finding 2 still fails, as intended.** It expects a long to open after `sellHeld`; the finding 4 fix correctly refuses that.\n- **`test/HookSalt.sol` changed.** The salt-mining helper ran out of memory on a deep salt after the hook's code changed. It now hashes in place and finds the same salts.\n- **Not run:** Slither, Mythril, fuzzing and the fork test.\n- **Commit author:** git had no identity set, so I committed with your email as the author for that one commit, without changing any git configuration.\n\nThe PerpEngine is 24,167 bytes, 409 under the contract size limit.","treeHash":"38b6f166f77bb2be86e65b6a0c20e58e182dc13e","usage":{"cachedInputTokens":4096628,"inputTokens":66,"model":"claude-opus-5-5","outputTokens":73147,"runtime":"claude","turns":37,"wallClockMs":1124254}},{"artifacts":[],"attempt":2,"bundleHash":null,"device":"1eba9b0f789fcc77","findings":[],"hash":"d07099448f57bf053b34f368ad88447b2843fb60468c19e6c257261bf65db8dc","nodeId":"d276f497-4bc0-46dd-afad-735221eb873d","outcome":"failed","summary":"Reading additional input from stdin...; the agent's last message was: The new reproductions show overstated ETH depth and engine shorts bypassing the sweep. The fixes now use the locked range for risk limits, require a sweep before user-initiated engine swaps, and apply fee refunds as PoolManager credits before settling the net input. I’ve also moved `sellHeld`’s post-trade sweep after its refund and made failed splits revert atomically.\n","treeHash":null,"usage":{"cachedInputTokens":0,"inputTokens":0,"model":"gpt-6-astra","outputTokens":0,"runtime":"codex","turns":4,"wallClockMs":562303}}],"verification":[{"checks":[{"durationMs":49552,"exitCode":137,"name":"build","output":"Compiling 92 files with Solc 0.8.26\nSolc 0.8.26 finished in 32.08s\nCompiler run successful with warnings:\nWarning (2018): Function state mutability can be restricted to pure\n   --> src/perps/PerpEngine.sol:398:5:\n    |\n398 |     function _quoteAt(uint256 size, uint256 sp) internal view returns (uint256) {\n    |     ^ (Relevant source part starts here and spans across multiple lines).\n\nWarning (2018): Function state mutability can be restricted to pure\n   --> src/perps/PerpVault.sol:365:5:\n    |\n365 |     function _toYieldUnit(uint256 v) private view returns (uint256) {\n    |     ^ (Relevant source part starts here and spans across multiple lines).\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/perps/PerpSwapLib.sol:257:43\n    │\n257 │         if (nowTs <= MIN_TWAP) return (0, false);\n    │                                           ━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/boolean-cst\n\nwarning[tx-origin]: `tx.origin` is used for authorization\n    ╭▸ src/perps/PerpEngine.sol:916:13\n    │\n916 │ ┏             !_liqReentry\n917 │ ┃                 && _doSweep(tx.origin, true, r.buy && r.exactOut ? int256(r.amount) : -int256(r.amount), r.buy, r.limit)\n918 │ ┃                     != SWEEP_OK\n    │ ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/tx-origin\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/perps/PerpSwapLib.sol:271:32\n    │\n271 │         if (n == 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/perps/PerpSwapLib.sol:277:62\n    │\n277 │                 if (nowTs - oldest.ts < MIN_TWAP) 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/perps/PerpEngine.sol:1278:45\n     │\n1278 │         if (p.trader == address(0)) return (false, 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/perps/PerpEngine.sol:1278:58\n     │\n1278 │         if (p.trader == address(0)) return (false, 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/perps/PerpSwapLib.sol:299:35\n    │\n299 │         if (span == 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/IMD6900Hook.sol:81:44\n   │\n81 │     constructor(IPoolManager poolManager_, address pool_, address owner_) BaseHook(poolManager_) {\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/IMD6900LockedPool.sol:121:57\n    │\n121 │     constructor(IPoolManager poolManager_, uint24 fee_, address launcher_, address timelock_) {\n    │                                                         ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/perps/PerpSwapLib.sol:183:45\n    │\n183 │         if (sqrtP == 0 || reserveIn == 0 || amountIn == 0) return sqrtP;\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/IMD6900LockedPool.sol:121:76\n    │\n121 │     constructor(IPoolManager poolManager_, uint24 fee_, address launcher_, address timelock_) {\n    │                                                                            ━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:163:24\n    │\n163 │             amountIn = uint256(-amountSpecified);\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/perps/PerpSwapLib.sol:165:28\n    │\n165 │             uint256 dOut = uint256(amountSpecified);\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[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/IMD6900Hook.sol:126:28\n    │\n126 │     function setPerpEngine(address engine) external onlyOwner {\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/IMD6900Hook.sol:128:9\n    │\n128 │         emit PerpEngineSet(engine);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:236:16\n    │\n236 │         return uint160(out);\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-events-access-control]: `claimRoot` is changed without an event but is used for access control\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:266:9\n    │\n266 │         (claimRoot, claimTotal, claimDeadline) = (root, total, deadline);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-events-access-control\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/perps/PerpSwapLib.sol:284:20\n    │\n284 │             while (lo < hi) {\n    │                    ━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:256:24\n    │\n256 │         uint32 nowTs = uint32(block.timestamp);\n    │                        ━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint32' 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/perps/PerpSwapLib.sol:300:16\n    │\n300 │         tick = int24((cumNow - useCum) / span);\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[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:319:24\n    │\n319 │         uint32 nowTs = uint32(block.timestamp);\n    │                        ━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint32' 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/IMD6900RobinhoodLaunch.sol:170:77\n    │\n170 │     constructor(address owner_, IPoolManager poolManager_, address imdstr_, address timelock_) {\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/IMD6900RobinhoodLaunch.sol:170:60\n    │\n170 │     constructor(address owner_, IPoolManager poolManager_, address imdstr_, address timelock_) {\n    │                                                            ━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[reentrancy-no-eth]: external call can be reentered before `hook` is updated\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:194:9\n    │\n194 │         pool.setHook(h);\n    │         ━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/perps/PerpSwapLib.sol:568:28\n    │\n568 │             spent = paid - refundTok;\n    │                            ━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/perps/PerpSwapLib.sol:562:28\n    │\n562 │             spent = paid - refundQuote;\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/IMD6900RobinhoodLaunch.sol:197:9\n    │\n197 │         emit HookCreated(h, salt);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:524:33\n    │\n524 │             spec = r.exactOut ? int256(r.amount) : -int256(r.amount);\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/perps/PerpSwapLib.sol:524:53\n    │\n524 │             spec = r.exactOut ? int256(r.amount) : -int256(r.amount);\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[arbitrary-send-eth]: ETH is sent to a user-controlled destination; restrict the destination or the caller\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:218:9\n    │\n218 │         SafeTransferLib.safeTransferETH(to, msg.value);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/arbitrary-send-eth\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:526:21\n    │\n526 │             spec = -int256(r.amount);\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[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:219:9\n    │\n219 │         emit PerpFeesForwarded(to, msg.value);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:539:51\n    │\n539 │             if (spec < 0 && key.fee != 0) spec = -int256(_grossUp(poolManager, key, z, uint256(-spec)));\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/perps/PerpSwapLib.sol:539:88\n    │\n539 │             if (spec < 0 && key.fee != 0) spec = -int256(_grossUp(poolManager, key, z, uint256(-spec)));\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[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:229:27\n    │\n229 │                 keccak256(abi.encodePacked(type(IMD6900).creationCode, abi.encode(address(this))))\n    │                           ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:560:28\n    │\n560 │             uint256 paid = uint256(uint128(-quoteAmt));\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/perps/PerpSwapLib.sol:560:36\n    │\n560 │             uint256 paid = uint256(uint128(-quoteAmt));\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/perps/PerpSwapLib.sol:561:19\n    │\n561 │             got = uint256(uint128(tokAmt));\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/perps/PerpSwapLib.sol:561:27\n    │\n561 │             got = uint256(uint128(tokAmt));\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[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:237:26\n    │\n237 │         return keccak256(abi.encodePacked(type(IMD6900).creationCode, abi.encode(address(this))));\n    │                          ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:566:28\n    │\n566 │             uint256 paid = uint256(uint128(-tokAmt));\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/perps/PerpSwapLib.sol:566:36\n    │\n566 │             uint256 paid = uint256(uint128(-tokAmt));\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/perps/PerpSwapLib.sol:567:19\n    │\n567 │             got = uint256(uint128(quoteAmt));\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/perps/PerpSwapLib.sol:567:27\n    │\n567 │             got = uint256(uint128(quoteAmt));\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[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:267:9\n    │\n267 │         emit ClaimsSet(root, total, deadline);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[arbitrary-send-eth]: ETH is sent to a user-controlled destination; restrict the destination or the caller\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:276:9\n    │\n276 │         SafeTransferLib.safeTransferETH(to, amount);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/arbitrary-send-eth\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/perps/PerpSwapLib.sol:606:13\n    │\n606 │             poolManager.settle{value: amount}();\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[non-reentrant-not-first]: `nonReentrant` is not the first modifier\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:272:73\n    │\n272 │     function withdrawEth(address to, uint256 amount) external onlyOwner nonReentrant {\n    │                                                                         ━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/non-reentrant-not-first\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/perps/PerpSwapLib.sol:616:13\n    │\n616 │             poolManager.settle();\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/IMD6900RobinhoodLaunch.sol:277:9\n    │\n277 │         emit EthWithdrawn(to, amount);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:715:20\n    │\n715 │             return uint160(r < MIN_LIMIT ? MIN_LIMIT : r);\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/perps/PerpSwapLib.sol:719:16\n    │\n719 │         return uint160(r >= SQRT_MAX ? SQRT_MAX - 1 : r);\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/perps/PerpSwapLib.sol:728:20\n    │\n728 │             return uint160(r < MIN_LIMIT ? MIN_LIMIT : (r >= uint256(sp) ? uint256(sp) - 1 : r));\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/perps/PerpSwapLib.sol:732:16\n    │\n732 │         return uint160(up >= SQRT_MAX ? SQRT_MAX - 1 : up);\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[non-reentrant-not-first]: `nonReentrant` is not the first modifier\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:290:9\n    │\n290 │         nonReentrant\n    │         ━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/non-reentrant-not-first\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:294:32\n    │\n294 │         if (claimTotal != 0 && claimDeadline < block.timestamp + MIN_CLAIM_WINDOW) revert BadClaims();\n    │                                ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/block-timestamp\n\nwarning[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/IMD6900LockedPool.sol:138:22\n    │\n138 │     function setHook(address hook_) external {\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/IMD6900RobinhoodLaunch.sol:315:9\n    │\n315 │         emit Launched(t, sqrtPriceX96, pool.upperTick(), spend, bought, excess, excessTo);\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/IMD6900RobinhoodLaunch.sol:301:9\n    │\n301 │         pool.open(t, sqrtPriceX96, SUPPLY);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[non-reentrant-not-first]: `nonReentrant` is not the first modifier\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:319:62\n    │\n319 │     function releaseUnclaimed(address to) external onlyOwner nonReentrant {\n    │                                                              ━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/non-reentrant-not-first\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:321:13\n    │\n321 │         if (block.timestamp < claimDeadline) revert ClaimsOpen();\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/IMD6900RobinhoodLaunch.sol:329:9\n    │\n329 │         emit UnclaimedReleased(to, amount);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[non-reentrant-not-first]: `nonReentrant` is not the first modifier\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:333:75\n    │\n333 │     function releaseImdstr(uint256 amount, address to) external onlyOwner nonReentrant {\n    │                                                                           ━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/non-reentrant-not-first\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:338:9\n    │\n338 │         emit ImdstrReleased(to, amount);\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/IMD6900Hook.sol:134:29\n    │\n134 │     function initPerpEngine(address engine) external {\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/IMD6900Hook.sol:146:9\n    │\n146 │         emit PerpRefundedSet(on);\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/IMD6900Hook.sol:151:9\n    │\n151 │         emit SweepFailOpenSet(on);\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/perps/PerpVault.sol:201:17\n    │\n201 │     constructor(address _engine) {\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/perps/PerpVault.sol:283:9\n    │\n283 │         emit DepositEth(msg.sender, amount, shares);\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/IMD6900LockedPool.sol:148:19\n    │\n148 │     function open(address token_, uint160 sqrtPriceX96, uint256 amount) external nonReentrant returns (uint128 liq) {\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/IMD6900LockedPool.sol:168:9\n    │\n168 │         emit Opened(start, upper, used, liq);\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/IMD6900LockedPool.sol:160:9\n    │\n160 │         poolManager.initialize(poolKey(), start);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/IMD6900LockedPool.sol:164:15\n    │\n164 │         liq = uint128(l - 1);\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[reentrancy-no-eth]: external call can be reentered before `ethBackingMark` is updated\n    ╭▸ src/perps/PerpVault.sol:318:23\n    │\n318 │         if (paid > 0) engine.withdrawPlvTo(paid, msg.sender); // INTERACTION last\n    │                       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/perps/PerpVault.sol:320:9\n    │\n320 │         emit WithdrawEth(msg.sender, shares, paid, queued);\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/perps/PerpVault.sol:455:13\n    │\n455 │             emit QueueWrittenDown(false, claims, QSCALE);\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/perps/PerpVault.sol:462:9\n    │\n462 │         emit QueueWrittenDown(false, claims - FullMath.mulDiv(units, newIdx, QSCALE), newIdx);\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/IMD6900LockedPool.sol:390:9\n    │\n390 │         emit Collected(eth, tokens);\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/IMD6900LockedPool.sol:194:9\n    │\n194 │         emit FeeLowered(from, newFee, poolKey().toId(), liq);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-no-eth]: external call can be reentered before `ethBackingMark` is updated\n    ╭▸ src/perps/PerpVault.sol:517:9\n    │\n517 │         engine.withdrawPlvTo(paid, msg.sender);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n    ╭▸ src/IMD6900LockedPool.sol:183:43\n    │\n183 │             (bool ok, bytes memory ret) = engine.staticcall{gas: 100_000}(abi.encodeCall(IPerpsWiring.openCount, ()));\n    │                                           ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n    ╭▸ src/IMD6900Hook.sol:244:43\n    │\n244 │               (bool ok, bytes memory out) = engine.call{gas: g - reserve}(\n    │ ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n245 │ ┃                 abi.encodeCall(IPerpSweep.sweepLiquidations, (tx.origin, spec, isBuy, limit))\n246 │ ┃             );\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/IMD6900LockedPool.sol:190:9\n    │\n190 │         poolManager.initialize(poolKey(), sqrtPriceX96); // the hook serves the new pool from here on\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/perps/PerpVault.sol:499:13\n    │\n499 │             emit ClaimEth(msg.sender, 0);\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/perps/PerpVault.sol:505:13\n    │\n505 │             emit ClaimEth(msg.sender, 0);\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/perps/PerpVault.sol:519:9\n    │\n519 │         emit ClaimEth(msg.sender, paid);\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/perps/PerpVault.sol:594:13\n    │\n594 │             emit TokYieldForfeited(yieldEpoch, lost);\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:353:13\n    │\n353 │             sum += bps[i];\n    │             ━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[require-revert-in-loop]: `require` or `revert` inside a loop\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:351:38\n    │\n351 │             if (to[i] == address(0)) revert BadPayees();\n    │                                      ━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/require-revert-in-loop\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:356:23\n    │\n356 │         _payeeCount = uint8(n);\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-no-eth]: external call can be reentered before `_status` is updated\n    ╭▸ src/perps/PerpVault.sol:290:13\n    │\n290 │             asset.call(abi.encodeWithSignature(\"transferFrom(address,address,uint256)\", from, address(this), amount));\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[reentrancy-no-eth]: external call can be reentered before `_status` is updated\n    ╭▸ src/perps/PerpVault.sol:295:22\n    │\n295 │         (bool ok,) = asset.call(abi.encodeWithSignature(\"approve(address,uint256)\", spender, amount));\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[reentrancy-no-eth]: external call can be reentered before `_status` is updated\n    ╭▸ src/perps/PerpVault.sol:652:9\n    │\n652 │         engine.fundTokenFromVault(amount);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/perps/PerpVault.sol:553:17\n    │\n553 │                 emit UnattributedYield(cum - last);\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/IMD6900LockedPool.sol:198:27\n    │\n198 │     function setCoinFeeTo(address to) external {\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/perps/PerpVault.sol:653:9\n    │\n653 │         emit DepositTok(msg.sender, amount, shares);\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/IMD6900LockedPool.sol:209:9\n    │\n209 │         poolManager.unlock(abi.encode(COLLECT, uint128(0)));\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[arbitrary-send-eth]: ETH is sent to a user-controlled destination; restrict the destination or the caller\n    ╭▸ src/IMD6900LockedPool.sol:240:29\n    │\n240 │         if (msg.value != 0) IPerpsSetup(engine).fundInsurance{value: msg.value}();\n    │                             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/arbitrary-send-eth\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMD6900LockedPool.sol:243:9\n    │\n243 │         emit PerpsCreated(engine, vault, msg.value);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-no-eth]: external call can be reentered before `_status` is updated\n    ╭▸ src/perps/PerpVault.sol:668:24\n    │\n668 │         if (paid != 0) engine.withdrawTokYieldTo(paid, msg.sender); // from the segregated pot\n    │                        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/IMD6900LockedPool.sol:233:13\n    │\n233 │ ┏             abi.encodePacked(\n234 │ ┃                 engineCode, abi.encode(poolManager, hook, token, fee, TICK_SPACING, launcher, address(this))\n235 │ ┃             )\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/IMD6900LockedPool.sol:237:26\n    │\n237 │         vault = _create2(abi.encodePacked(vaultCode, abi.encode(engine)));\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/perps/PerpVault.sol:669:9\n    │\n669 │         emit ClaimTokYield(msg.sender, paid);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-no-eth]: external call can be reentered before `_status` is updated\n    ╭▸ src/perps/PerpVault.sol:690:23\n    │\n690 │         if (paid > 0) engine.withdrawPlvTokenTo(paid, msg.sender);\n    │                       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/perps/PerpVault.sol:691:9\n    │\n691 │         emit WithdrawTok(msg.sender, shares, paid, queued);\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/perps/PerpVault.sol:740:13\n    │\n740 │             emit QueueWrittenDown(true, claims, QSCALE);\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/perps/PerpVault.sol:744:9\n    │\n744 │         emit QueueWrittenDown(true, claims - backing, newIdx);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-no-eth]: external call can be reentered before `_status` is updated\n    ╭▸ src/perps/PerpVault.sol:787:9\n    │\n787 │         engine.withdrawPlvTokenTo(paid, msg.sender);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/perps/PerpVault.sol:769:13\n    │\n769 │             emit ClaimTok(msg.sender, 0);\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/perps/PerpVault.sol:775:13\n    │\n775 │             emit ClaimTok(msg.sender, 0);\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/perps/PerpVault.sol:788:9\n    │\n788 │         emit ClaimTok(msg.sender, paid);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/perps/PerpVault.sol:864:39\n    │\n864 │         return FullMath.mulDiv(owed + earned, tokYieldScale, 1e18);\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/IMD6900RobinhoodLaunch.sol:368:9\n    │\n368 │         emit EthRecovered(to, amount);\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/IMD6900LockedPool.sol:296:9\n    │\n296 │         emit FeeRefunded(msg.sender, to, eth, tokens);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/IMD6900LockedPool.sol:289:19\n    │\n289 │             eth = uint256(uint128(d.amount0()));\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/IMD6900LockedPool.sol:289:27\n    │\n289 │             eth = uint256(uint128(d.amount0()));\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/IMD6900LockedPool.sol:290:22\n    │\n290 │             tokens = uint256(uint128(d.amount1()));\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/IMD6900LockedPool.sol:290:30\n    │\n290 │             tokens = uint256(uint128(d.amount1()));\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/IMD6900LockedPool.sol:332:23\n    │\n332 │         uint256 eth = uint256(int256(out.amount0() - earned.amount0()));\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/IMD6900LockedPool.sol:333:25\n    │\n333 │         uint256 coins = uint256(int256(out.amount1() - earned.amount1()));\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[unused-return]: return value of an external call is not used\n    ╭▸ src/IMD6900LockedPool.sol:350:21\n    │\n350 │         if (a0 < 0) poolManager.settle{value: uint256(uint128(-a0))}();\n    │                     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/IMD6900LockedPool.sol:350:47\n    │\n350 │         if (a0 < 0) poolManager.settle{value: uint256(uint128(-a0))}();\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/IMD6900LockedPool.sol:350:55\n    │\n350 │         if (a0 < 0) poolManager.settle{value: uint256(uint128(-a0))}();\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/IMD6900LockedPool.sol:351:73\n    │\n351 │         else if (a0 > 0) poolManager.take(key.currency0, address(this), uint256(uint128(a0)));\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/IMD6900LockedPool.sol:351:81\n    │\n351 │         else if (a0 > 0) poolManager.take(key.currency0, address(this), uint256(uint128(a0)));\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/IMD6900LockedPool.sol:354:71\n    │\n354 │             SafeTransferLib.safeTransfer(token, address(poolManager), uint256(uint128(-a1)));\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/IMD6900LockedPool.sol:354:79\n    │\n354 │             SafeTransferLib.safeTransfer(token, address(poolManager), uint256(uint128(-a1)));\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[unused-return]: return value of an external call is not used\n    ╭▸ src/IMD6900LockedPool.sol:355:13\n    │\n355 │             poolManager.settle();\n    │             ━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/IMD6900LockedPool.sol:357:60\n    │\n357 │             poolManager.take(key.currency1, address(this), uint256(uint128(a1)));\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/IMD6900LockedPool.sol:357:68\n    │\n357 │             poolManager.take(key.currency1, address(this), uint256(uint128(a1)));\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/IMD6900LockedPool.sol:376:60\n    │\n376 │         return l > type(uint128).max ? type(uint128).max : uint128(l);\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/IMD6900LockedPool.sol:397:15\n    │\n397 │         eth = uint256(uint128(d.amount0()));\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/IMD6900LockedPool.sol:397:23\n    │\n397 │         eth = uint256(uint128(d.amount0()));\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/IMD6900LockedPool.sol:398:18\n    │\n398 │         tokens = uint256(uint128(d.amount1()));\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/IMD6900LockedPool.sol:398:26\n    │\n398 │         tokens = uint256(uint128(d.amount1()));\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/IMD6900LockedPool.sol:415:24\n    │\n415 │         return v < 0 ? uint256(uint128(-v)) : uint256(uint128(v));\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/IMD6900LockedPool.sol:415:32\n    │\n415 │         return v < 0 ? uint256(uint128(-v)) : uint256(uint128(v));\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/IMD6900LockedPool.sol:415:47\n    │\n415 │         return v < 0 ? uint256(uint128(-v)) : uint256(uint128(v));\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/IMD6900LockedPool.sol:415:55\n    │\n415 │         return v < 0 ? uint256(uint128(-v)) : uint256(uint128(v));\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[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:380:9\n    │\n380 │         emit ExcessReleased(to, amount);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-no-eth]: external call can be reentered before `excessHeld` is updated\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:405:34\n    │\n405 │         (eth, sold) = abi.decode(poolManager.unlock(abi.encode(uint8(2), amount)), (uint256, uint256));\n    │                                  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:409:9\n    │\n409 │         emit HeldSold(sold, eth, to);\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/IMD6900RobinhoodLaunch.sol:451:9\n    │\n451 │         emit Claimed(msg.sender, amount);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[arbitrary-send-eth]: ETH is sent to a user-controlled destination; restrict the destination or the caller\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:469:13\n    │\n469 │             SafeTransferLib.safeTransferETH(to[i], part);\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/arbitrary-send-eth\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:471:9\n    │\n471 │         emit Split(amount);\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/IMD6900RobinhoodLaunch.sol:485:9\n    │\n485 │         emit ImdBurned(spend, imd);\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/IMD6900RobinhoodLaunch.sol:495:9\n    │\n495 │         pool.collect();\n    │         ━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:522:17\n    │\n522 │                 sold += paid - back;\n    │                 ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:518:17\n    │\n518 │                 ethOut += uint256(uint128(s.amount0()));\n    │                 ━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:513:29\n    │\n513 │             for (uint256 i; i < 3 && left != 0; ++i) {\n    │                             ━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:514:17\n    │\n514 │                 pool.feeCheckpoint();\n    │                 ━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:515:34\n    │\n515 │                 BalanceDelta s = poolManager.swap(k, SwapParams(false, -int256(left), TickMath.MAX_SQRT_PRICE - 1), \"\");\n    │                                  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:516:36\n    │\n516 │                 (, uint256 back) = pool.feeRefund(address(this));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:519:17\n    │\n519 │                 poolManager.sync(k.currency1);\n    │                 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:521:17\n    │\n521 │                 poolManager.settle();\n    │                 ━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:523:17\n    │\n523 │                 hook.afterHeldSwap();\n    │                 ━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:515:73\n    │\n515 │                 BalanceDelta s = poolManager.swap(k, SwapParams(false, -int256(left), TickMath.MAX_SQRT_PRICE - 1), \"\");\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/IMD6900RobinhoodLaunch.sol:516:36\n    │\n516 │                 (, uint256 back) = pool.feeRefund(address(this));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:517:32\n    │\n517 │                 uint256 paid = uint256(uint128(-s.amount1()));\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/IMD6900RobinhoodLaunch.sol:517:40\n    │\n517 │                 uint256 paid = uint256(uint128(-s.amount1()));\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/IMD6900RobinhoodLaunch.sol:518:27\n    │\n518 │                 ethOut += uint256(uint128(s.amount0()));\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/IMD6900RobinhoodLaunch.sol:518:35\n    │\n518 │                 ethOut += uint256(uint128(s.amount0()));\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[unused-return]: return value of an external call is not used\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:521:17\n    │\n521 │                 poolManager.settle();\n    │                 ━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:531:66\n    │\n531 │         BalanceDelta d = poolManager.swap(key, SwapParams(true, -int256(spend), TickMath.MIN_SQRT_PRICE + 1), \"\");\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/IMD6900RobinhoodLaunch.sol:532:25\n    │\n532 │         uint256 ethIn = uint256(uint128(-d.amount0()));\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/IMD6900RobinhoodLaunch.sol:532:33\n    │\n532 │         uint256 ethIn = uint256(uint128(-d.amount0()));\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/IMD6900RobinhoodLaunch.sol:533:23\n    │\n533 │         uint256 out = uint256(uint128(d.amount1()));\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/IMD6900RobinhoodLaunch.sol:533:31\n    │\n533 │         uint256 out = uint256(uint128(d.amount1()));\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[unused-return]: return value of an external call is not used\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:534:9\n    │\n534 │         poolManager.settle{value: ethIn}();\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/IMD6900RobinhoodLaunch.sol:542:16\n    │\n542 │         return abi.encodePacked(type(IMD6900Hook).creationCode, abi.encode(poolManager, address(pool), timelock));\n    │                ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\n","passed":false}],"detail":"build failed with exit code 137","evaluation":"checks","profile":"foundry","status":"rejected","submissionHash":"976f4f025d236304ca21fa11c2b30480bfe60b20b55b5a80f9cf4d0152d77aaa","verifiedTreeHash":"f4ad9f8ba831f957ceeeb6d5ab69043c2e0db69c","verifierVersion":"0.1.0+327e1e9f"},{"checks":[{"durationMs":95420,"exitCode":137,"name":"build","output":"Compiling 92 files with Solc 0.8.26\nSolc 0.8.26 finished in 52.95s\nCompiler run successful with warnings:\nWarning (2018): Function state mutability can be restricted to pure\n   --> src/perps/PerpEngine.sol:358:5:\n    |\n358 |     function _quoteAt(uint256 size, uint256 sp) internal view returns (uint256) {\n    |     ^ (Relevant source part starts here and spans across multiple lines).\n\nWarning (2018): Function state mutability can be restricted to pure\n   --> src/perps/PerpVault.sol:364:5:\n    |\n364 |     function _toYieldUnit(uint256 v) private view returns (uint256) {\n    |     ^ (Relevant source part starts here and spans across multiple lines).\n\nwarning[boolean-cst]: misuse of a boolean constant\n     ╭▸ src/perps/PerpEngine.sol:1145:45\n     │\n1145 │         if (p.trader == address(0)) return (false, 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/perps/PerpSwapLib.sol:256:43\n    │\n256 │         if (nowTs <= MIN_TWAP) 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/perps/PerpEngine.sol:1145:58\n     │\n1145 │         if (p.trader == address(0)) return (false, 0, 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/IMD6900Hook.sol:79:44\n   │\n79 │     constructor(IPoolManager poolManager_, address pool_, address owner_) BaseHook(poolManager_) {\n   │                                            ━━━━━━━━━━━━━\n   │\n   ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[boolean-cst]: misuse of a boolean constant\n    ╭▸ src/perps/PerpSwapLib.sol:266:32\n    │\n266 │         if (n == 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/perps/PerpSwapLib.sol:270:70\n    │\n270 │             unchecked { if (nowTs - oldest.ts < MIN_TWAP) 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/perps/PerpSwapLib.sol:288:35\n    │\n288 │         if (span == 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/IMD6900Hook.sol:124:28\n    │\n124 │     function setPerpEngine(address engine) external onlyOwner {\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/IMD6900Hook.sol:126:9\n    │\n126 │         emit PerpEngineSet(engine);\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/IMD6900LockedPool.sol:125:76\n    │\n125 │     constructor(IPoolManager poolManager_, uint24 fee_, address launcher_, address timelock_) {\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/IMD6900LockedPool.sol:125:57\n    │\n125 │     constructor(IPoolManager poolManager_, uint24 fee_, address launcher_, address timelock_) {\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/perps/PerpVault.sol:198:17\n    │\n198 │     constructor(address _engine) {\n    │                 ━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/perps/PerpSwapLib.sol:181:45\n    │\n181 │         if (sqrtP == 0 || reserveIn == 0 || amountIn == 0) return sqrtP;\n    │                                             ━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:161:24\n    │\n161 │             amountIn = uint256(-amountSpecified);\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/perps/PerpSwapLib.sol:163:28\n    │\n163 │             uint256 dOut = uint256(amountSpecified);\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/perps/PerpSwapLib.sol:235:16\n    │\n235 │         return uint160(out);\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/perps/PerpSwapLib.sol:274:20\n    │\n274 │             while (lo < hi) {\n    │                    ━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:255:24\n    │\n255 │         uint32 nowTs = uint32(block.timestamp);\n    │                        ━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint32' 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/perps/PerpVault.sol:280:9\n    │\n280 │         emit DepositEth(msg.sender, amount, shares);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:289:16\n    │\n289 │         tick = int24((cumNow - useCum) / span);\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[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:308:24\n    │\n308 │         uint32 nowTs = uint32(block.timestamp);\n    │                        ━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ├ note: consider disabling this lint if you're certain the cast is safe\n    │       \n    │       // casting to 'uint32' 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-events-access-control]: `claimRoot` is changed without an event but is used for access control\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:252:9\n    │\n252 │         (claimRoot, claimTotal, claimDeadline) = (root, total, deadline);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-events-access-control\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:512:33\n    │\n512 │             spec = r.exactOut ? int256(r.amount) : -int256(r.amount);\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/perps/PerpSwapLib.sol:512:53\n    │\n512 │             spec = r.exactOut ? int256(r.amount) : -int256(r.amount);\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/perps/PerpSwapLib.sol:514:21\n    │\n514 │             spec = -int256(r.amount);\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/perps/PerpSwapLib.sol:527:51\n    │\n527 │             if (spec < 0 && key.fee != 0) spec = -int256(_grossUp(poolManager, key, z, uint256(-spec)));\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/perps/PerpSwapLib.sol:527:88\n    │\n527 │             if (spec < 0 && key.fee != 0) spec = -int256(_grossUp(poolManager, key, z, uint256(-spec)));\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/perps/PerpSwapLib.sol:541:17\n    │\n541 │         spent = uint256(uint128(-(r.buy ? quoteAmt : tokAmt)));\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/perps/PerpSwapLib.sol:541:25\n    │\n541 │         spent = uint256(uint128(-(r.buy ? quoteAmt : tokAmt)));\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/perps/PerpSwapLib.sol:542:15\n    │\n542 │         got = uint256(uint128(r.buy ? tokAmt : quoteAmt));\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/perps/PerpSwapLib.sol:542:23\n    │\n542 │         got = uint256(uint128(r.buy ? tokAmt : quoteAmt));\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[missing-zero-check]: address parameter is used in a state write or value transfer without a zero-address check\n    ╭▸ src/IMD6900LockedPool.sol:142:22\n    │\n142 │     function setHook(address hook_) 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/IMD6900RobinhoodLaunch.sol:163:77\n    │\n163 │     constructor(address owner_, IPoolManager poolManager_, address imdstr_, address timelock_) {\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/IMD6900RobinhoodLaunch.sol:163:60\n    │\n163 │     constructor(address owner_, IPoolManager poolManager_, address imdstr_, address timelock_) {\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/perps/PerpSwapLib.sol:590:13\n    │\n590 │             poolManager.settle{value: amount}();\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[reentrancy-no-eth]: external call can be reentered before `hook` is updated\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:185:9\n    │\n185 │         pool.setHook(h);\n    │         ━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[unused-return]: return value of an external call is not used\n    ╭▸ src/perps/PerpSwapLib.sol:601:13\n    │\n601 │             poolManager.settle();\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/IMD6900RobinhoodLaunch.sol:188:9\n    │\n188 │         emit HookCreated(h, salt);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[arbitrary-send-eth]: ETH is sent to a user-controlled destination; restrict the destination or the caller\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:209:9\n    │\n209 │         SafeTransferLib.safeTransferETH(to, msg.value);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/arbitrary-send-eth\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:708:20\n    │\n708 │             return uint160(r < MIN_LIMIT ? MIN_LIMIT : r);\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/IMD6900RobinhoodLaunch.sol:210:9\n    │\n210 │         emit PerpFeesForwarded(to, msg.value);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:712:16\n    │\n712 │         return uint160(r >= SQRT_MAX ? SQRT_MAX - 1 : r);\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[encode-packed-collision]: `abi.encodePacked()` called with multiple dynamic type arguments; hash collisions possible\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:217:62\n    │\n217 │                 bytes1(0xff), address(this), salt, keccak256(abi.encodePacked(type(IMD6900).creationCode, abi.encode(address(this))))\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/IMD6900RobinhoodLaunch.sol:225:26\n    │\n225 │         return keccak256(abi.encodePacked(type(IMD6900).creationCode, abi.encode(address(this))));\n    │                          ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/perps/PerpSwapLib.sol:725:20\n    │\n725 │             return uint160(r < MIN_LIMIT ? MIN_LIMIT : (r >= uint256(sp) ? uint256(sp) - 1 : r));\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/perps/PerpSwapLib.sol:729:16\n    │\n729 │         return uint160(up >= SQRT_MAX ? SQRT_MAX - 1 : up);\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/IMD6900RobinhoodLaunch.sol:253:9\n    │\n253 │         emit ClaimsSet(root, total, deadline);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[arbitrary-send-eth]: ETH is sent to a user-controlled destination; restrict the destination or the caller\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:262:9\n    │\n262 │         SafeTransferLib.safeTransferETH(to, amount);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/arbitrary-send-eth\n\nwarning[non-reentrant-not-first]: `nonReentrant` is not the first modifier\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:258:73\n    │\n258 │     function withdrawEth(address to, uint256 amount) external onlyOwner nonReentrant {\n    │                                                                         ━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/non-reentrant-not-first\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:263:9\n    │\n263 │         emit EthWithdrawn(to, amount);\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/IMD6900Hook.sol:132:29\n    │\n132 │     function initPerpEngine(address engine) external {\n    │                             ━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[reentrancy-no-eth]: external call can be reentered before `ethBackingMark` is updated\n    ╭▸ src/perps/PerpVault.sol:316:23\n    │\n316 │         if (paid > 0) engine.withdrawPlvTo(paid, msg.sender); // INTERACTION last\n    │                       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMD6900Hook.sol:144:9\n    │\n144 │         emit PerpRefundedSet(on);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[non-reentrant-not-first]: `nonReentrant` is not the first modifier\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:276:9\n    │\n276 │         nonReentrant\n    │         ━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/non-reentrant-not-first\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:280:32\n    │\n280 │         if (claimTotal != 0 && claimDeadline < block.timestamp + MIN_CLAIM_WINDOW) revert BadClaims();\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/IMD6900Hook.sol:149:9\n    │\n149 │         emit SweepFailOpenSet(on);\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/IMD6900RobinhoodLaunch.sol:301:9\n    │\n301 │         emit Launched(t, sqrtPriceX96, pool.upperTick(), spend, bought, excess, excessTo);\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/IMD6900RobinhoodLaunch.sol:287:9\n    │\n287 │         pool.open(t, sqrtPriceX96, SUPPLY);\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/perps/PerpVault.sol:318:9\n    │\n318 │         emit WithdrawEth(msg.sender, shares, paid, queued);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[non-reentrant-not-first]: `nonReentrant` is not the first modifier\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:305:62\n    │\n305 │     function releaseUnclaimed(address to) external onlyOwner nonReentrant {\n    │                                                              ━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/non-reentrant-not-first\n\nwarning[block-timestamp]: usage of `block.timestamp` in a comparison may be manipulated by validators\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:307:13\n    │\n307 │         if (block.timestamp < claimDeadline) revert ClaimsOpen();\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/IMD6900RobinhoodLaunch.sol:315:9\n    │\n315 │         emit UnclaimedReleased(to, amount);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[non-reentrant-not-first]: `nonReentrant` is not the first modifier\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:319:75\n    │\n319 │     function releaseImdstr(uint256 amount, address to) external onlyOwner nonReentrant {\n    │                                                                           ━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/non-reentrant-not-first\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:324:9\n    │\n324 │         emit ImdstrReleased(to, amount);\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/perps/PerpVault.sol:448:13\n    │\n448 │             emit QueueWrittenDown(false, claims, QSCALE);\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/perps/PerpVault.sol:455:9\n    │\n455 │         emit QueueWrittenDown(false, claims - FullMath.mulDiv(units, newIdx, QSCALE), newIdx);\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/IMD6900LockedPool.sol:152:19\n    │\n152 │     function open(address token_, uint160 sqrtPriceX96, uint256 amount) external nonReentrant returns (uint128 liq) {\n    │                   ━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/missing-zero-check\n\nwarning[reentrancy-no-eth]: external call can be reentered before `ethBackingMark` is updated\n    ╭▸ src/perps/PerpVault.sol:503:9\n    │\n503 │         engine.withdrawPlvTo(paid, msg.sender);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMD6900LockedPool.sol:172:9\n    │\n172 │         emit Opened(start, upper, used, liq);\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/IMD6900LockedPool.sol:164:9\n    │\n164 │         poolManager.initialize(poolKey(), start);\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/perps/PerpVault.sol:490:53\n    │\n490 │         if (owed == 0) { _dropEthUnits(msg.sender); emit ClaimEth(msg.sender, 0); return 0; }\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/perps/PerpVault.sol:493:26\n    │\n493 │         if (paid == 0) { emit ClaimEth(msg.sender, 0); return 0; }\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/perps/PerpVault.sol:505:9\n    │\n505 │         emit ClaimEth(msg.sender, paid);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/IMD6900LockedPool.sol:168:15\n    │\n168 │         liq = uint128(l - 1);\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[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/perps/PerpVault.sol:578:13\n    │\n578 │             emit TokYieldForfeited(yieldEpoch, lost);\n    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-no-eth]: external call can be reentered before `_status` is updated\n    ╭▸ src/perps/PerpVault.sol:286:39\n    │\n286 │           (bool ok, bytes memory ret) = asset.call(\n    │ ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n287 │ ┃             abi.encodeWithSignature(\"transferFrom(address,address,uint256)\", from, address(this), amount)\n288 │ ┃         );\n    │ ┗━━━━━━━━━┛\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[return-bomb]: external call with a gas limit may copy unbounded return data\n    ╭▸ src/IMD6900Hook.sol:237:17\n    │\n237 │                 engine.call{gas: g - reserve}(abi.encodeCall(IPerpSweep.sweepLiquidations, (tx.origin, spec, isBuy, limit)));\n    │                 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/return-bomb\n\nwarning[reentrancy-no-eth]: external call can be reentered before `_status` is updated\n    ╭▸ src/perps/PerpVault.sol:293:23\n    │\n293 │         (bool ok, ) = asset.call(abi.encodeWithSignature(\"approve(address,uint256)\", spender, amount));\n    │                       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[reentrancy-no-eth]: external call can be reentered before `_status` is updated\n    ╭▸ src/perps/PerpVault.sol:633:9\n    │\n633 │         engine.fundTokenFromVault(amount);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/perps/PerpVault.sol:539:17\n    │\n539 │                 emit UnattributedYield(cum - last);\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/perps/PerpVault.sol:634:9\n    │\n634 │         emit DepositTok(msg.sender, amount, shares);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-no-eth]: external call can be reentered before `_status` is updated\n    ╭▸ src/perps/PerpVault.sol:647:24\n    │\n647 │         if (paid != 0) engine.withdrawTokYieldTo(paid, msg.sender); // from the segregated pot\n    │                        ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/perps/PerpVault.sol:648:9\n    │\n648 │         emit ClaimTokYield(msg.sender, paid);\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/IMD6900LockedPool.sol:401:9\n    │\n401 │         emit Collected(eth, tokens);\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/IMD6900LockedPool.sol:198:9\n    │\n198 │         emit FeeLowered(from, newFee, poolKey().toId(), liq);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:339:13\n    │\n339 │             sum += bps[i];\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/IMD6900LockedPool.sol:187:43\n    │\n187 │             (bool ok, bytes memory ret) = engine.staticcall{gas: 100_000}(abi.encodeCall(IPerpsWiring.openCount, ()));\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/IMD6900LockedPool.sol:194:9\n    │\n194 │         poolManager.initialize(poolKey(), sqrtPriceX96); // the hook serves the new pool from here on\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[require-revert-in-loop]: `require` or `revert` inside a loop\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:337:38\n    │\n337 │             if (to[i] == address(0)) revert BadPayees();\n    │                                      ━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/require-revert-in-loop\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:342:23\n    │\n342 │         _payeeCount = uint8(n);\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-no-eth]: external call can be reentered before `_status` is updated\n    ╭▸ src/perps/PerpVault.sol:668:23\n    │\n668 │         if (paid > 0) engine.withdrawPlvTokenTo(paid, msg.sender);\n    │                       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/perps/PerpVault.sol:669:9\n    │\n669 │         emit WithdrawTok(msg.sender, shares, paid, queued);\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/perps/PerpVault.sol:712:13\n    │\n712 │             emit QueueWrittenDown(true, claims, QSCALE);\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/perps/PerpVault.sol:716:9\n    │\n716 │         emit QueueWrittenDown(true, claims - backing, newIdx);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[reentrancy-no-eth]: external call can be reentered before `_status` is updated\n    ╭▸ src/perps/PerpVault.sol:752:9\n    │\n752 │         engine.withdrawPlvTokenTo(paid, msg.sender);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/perps/PerpVault.sol:739:53\n    │\n739 │         if (owed == 0) { _dropTokUnits(msg.sender); emit ClaimTok(msg.sender, 0); return 0; }\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/perps/PerpVault.sol:742:26\n    │\n742 │         if (paid == 0) { emit ClaimTok(msg.sender, 0); return 0; }\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/perps/PerpVault.sol:753:9\n    │\n753 │         emit ClaimTok(msg.sender, paid);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/perps/PerpVault.sol:819:39\n    │\n819 │         return FullMath.mulDiv(owed + earned, tokYieldScale, 1e18);\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/IMD6900LockedPool.sol:202:27\n    │\n202 │     function setCoinFeeTo(address to) 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/IMD6900LockedPool.sol:213:9\n    │\n213 │         poolManager.unlock(abi.encode(COLLECT, uint128(0)));\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[arbitrary-send-eth]: ETH is sent to a user-controlled destination; restrict the destination or the caller\n    ╭▸ src/IMD6900LockedPool.sol:238:29\n    │\n238 │         if (msg.value != 0) IPerpsSetup(engine).fundInsurance{value: msg.value}();\n    │                             ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/arbitrary-send-eth\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMD6900LockedPool.sol:241:9\n    │\n241 │         emit PerpsCreated(engine, vault, msg.value);\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/IMD6900LockedPool.sol:234:27\n    │\n234 │ …= _create2(abi.encodePacked(engineCode, abi.encode(poolManager, hook, token, fee, TICK_SPACING, launcher, address(this))));\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/IMD6900LockedPool.sol:235:26\n    │\n235 │         vault = _create2(abi.encodePacked(vaultCode, abi.encode(engine)));\n    │                          ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\nwarning[arbitrary-send-eth]: ETH is sent to a user-controlled destination; restrict the destination or the caller\n    ╭▸ src/IMD6900LockedPool.sol:305:28\n    │\n305 │         if (extraEth != 0) SafeTransferLib.safeTransferETH(to, extraEth);\n    │                            ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/arbitrary-send-eth\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/IMD6900LockedPool.sol:304:13\n    │\n304 │         if (extraTokens != 0) SafeTransferLib.safeTransfer(token, to, extraTokens);\n    │             ━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/IMD6900LockedPool.sol:305:13\n    │\n305 │         if (extraEth != 0) SafeTransferLib.safeTransferETH(to, extraEth);\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/IMD6900LockedPool.sol:307:9\n    │\n307 │         emit FeeRefunded(msg.sender, to, eth, tokens);\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/IMD6900RobinhoodLaunch.sol:354:9\n    │\n354 │         emit EthRecovered(to, amount);\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/IMD6900RobinhoodLaunch.sol:366:9\n    │\n366 │         emit ExcessReleased(to, amount);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/IMD6900LockedPool.sol:343:23\n    │\n343 │         uint256 eth = uint256(int256(out.amount0() - earned.amount0()));\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/IMD6900LockedPool.sol:344:25\n    │\n344 │         uint256 coins = uint256(int256(out.amount1() - earned.amount1()));\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[unused-return]: return value of an external call is not used\n    ╭▸ src/IMD6900LockedPool.sol:361:21\n    │\n361 │         if (a0 < 0) poolManager.settle{value: uint256(uint128(-a0))}();\n    │                     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/IMD6900LockedPool.sol:361:47\n    │\n361 │         if (a0 < 0) poolManager.settle{value: uint256(uint128(-a0))}();\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/IMD6900LockedPool.sol:361:55\n    │\n361 │         if (a0 < 0) poolManager.settle{value: uint256(uint128(-a0))}();\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/IMD6900LockedPool.sol:362:73\n    │\n362 │         else if (a0 > 0) poolManager.take(key.currency0, address(this), uint256(uint128(a0)));\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/IMD6900LockedPool.sol:362:81\n    │\n362 │         else if (a0 > 0) poolManager.take(key.currency0, address(this), uint256(uint128(a0)));\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/IMD6900LockedPool.sol:365:71\n    │\n365 │             SafeTransferLib.safeTransfer(token, address(poolManager), uint256(uint128(-a1)));\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/IMD6900LockedPool.sol:365:79\n    │\n365 │             SafeTransferLib.safeTransfer(token, address(poolManager), uint256(uint128(-a1)));\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[unused-return]: return value of an external call is not used\n    ╭▸ src/IMD6900LockedPool.sol:366:13\n    │\n366 │             poolManager.settle();\n    │             ━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/IMD6900LockedPool.sol:368:60\n    │\n368 │             poolManager.take(key.currency1, address(this), uint256(uint128(a1)));\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/IMD6900LockedPool.sol:368:68\n    │\n368 │             poolManager.take(key.currency1, address(this), uint256(uint128(a1)));\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/IMD6900LockedPool.sol:387:60\n    │\n387 │         return l > type(uint128).max ? type(uint128).max : uint128(l);\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/IMD6900LockedPool.sol:408:15\n    │\n408 │         eth = uint256(uint128(d.amount0()));\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/IMD6900LockedPool.sol:408:23\n    │\n408 │         eth = uint256(uint128(d.amount0()));\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/IMD6900LockedPool.sol:409:18\n    │\n409 │         tokens = uint256(uint128(d.amount1()));\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/IMD6900LockedPool.sol:409:26\n    │\n409 │         tokens = uint256(uint128(d.amount1()));\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/IMD6900LockedPool.sol:426:24\n    │\n426 │         return v < 0 ? uint256(uint128(-v)) : uint256(uint128(v));\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/IMD6900LockedPool.sol:426:32\n    │\n426 │         return v < 0 ? uint256(uint128(-v)) : uint256(uint128(v));\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/IMD6900LockedPool.sol:426:47\n    │\n426 │         return v < 0 ? uint256(uint128(-v)) : uint256(uint128(v));\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/IMD6900LockedPool.sol:426:55\n    │\n426 │         return v < 0 ? uint256(uint128(-v)) : uint256(uint128(v));\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[reentrancy-no-eth]: external call can be reentered before `excessHeld` is updated\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:391:34\n    │\n391 │         (eth, sold) = abi.decode(poolManager.unlock(abi.encode(uint8(2), amount)), (uint256, uint256));\n    │                                  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-no-eth\n\nwarning[reentrancy-events]: event emitted after an external call; reentrancy can reorder or fabricate logs that off-chain consumers rely on\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:395:9\n    │\n395 │         emit HeldSold(sold, eth, to);\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/IMD6900RobinhoodLaunch.sol:437:9\n    │\n437 │         emit Claimed(msg.sender, amount);\n    │         ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/reentrancy-events\n\nwarning[arbitrary-send-eth]: ETH is sent to a user-controlled destination; restrict the destination or the caller\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:456:26\n    │\n456 │             (bool ok,) = to[i].call{value: part}(\"\");\n    │                          ━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/arbitrary-send-eth\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:456:26\n    │\n456 │             (bool ok,) = to[i].call{value: part}(\"\");\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/IMD6900RobinhoodLaunch.sol:459:9\n    │\n459 │         emit Split(amount);\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/IMD6900RobinhoodLaunch.sol:457:22\n    │\n457 │             if (!ok) revert PayFailed(to[i], part);\n    │                      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/require-revert-in-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/IMD6900RobinhoodLaunch.sol:473:9\n    │\n473 │         emit ImdBurned(spend, imd);\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/IMD6900RobinhoodLaunch.sol:482:9\n    │\n482 │         pool.collect();\n    │         ━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:500:29\n    │\n500 │             for (uint256 i; i < 3 && left != 0; ++i) {\n    │                             ━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:509:17\n    │\n509 │                 sold += paid - back;\n    │                 ━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[uninitialized-local]: local variable is read before being initialized\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:505:17\n    │\n505 │                 ethOut += uint256(uint128(s.amount0()));\n    │                 ━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/uninitialized-local\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:501:17\n    │\n501 │                 pool.feeCheckpoint();\n    │                 ━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:502:34\n    │\n502 │                 BalanceDelta s = poolManager.swap(k, SwapParams(false, -int256(left), TickMath.MAX_SQRT_PRICE - 1), \"\");\n    │                                  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:503:36\n    │\n503 │                 (, uint256 back) = pool.feeRefund(address(this));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:506:17\n    │\n506 │                 poolManager.sync(k.currency1);\n    │                 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[calls-loop]: external call inside a loop\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:508:17\n    │\n508 │                 poolManager.settle();\n    │                 ━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/calls-loop\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:502:73\n    │\n502 │                 BalanceDelta s = poolManager.swap(k, SwapParams(false, -int256(left), TickMath.MAX_SQRT_PRICE - 1), \"\");\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/IMD6900RobinhoodLaunch.sol:503:36\n    │\n503 │                 (, uint256 back) = pool.feeRefund(address(this));\n    │                                    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:504:32\n    │\n504 │                 uint256 paid = uint256(uint128(-s.amount1()));\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/IMD6900RobinhoodLaunch.sol:504:40\n    │\n504 │                 uint256 paid = uint256(uint128(-s.amount1()));\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/IMD6900RobinhoodLaunch.sol:505:27\n    │\n505 │                 ethOut += uint256(uint128(s.amount0()));\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/IMD6900RobinhoodLaunch.sol:505:35\n    │\n505 │                 ethOut += uint256(uint128(s.amount0()));\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[unused-return]: return value of an external call is not used\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:508:17\n    │\n508 │                 poolManager.settle();\n    │                 ━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/unused-return\n\nwarning[unsafe-typecast]: typecast can truncate values\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:517:66\n    │\n517 │         BalanceDelta d = poolManager.swap(key, SwapParams(true, -int256(spend), TickMath.MIN_SQRT_PRICE + 1), \"\");\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/IMD6900RobinhoodLaunch.sol:518:25\n    │\n518 │         uint256 ethIn = uint256(uint128(-d.amount0()));\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/IMD6900RobinhoodLaunch.sol:518:33\n    │\n518 │         uint256 ethIn = uint256(uint128(-d.amount0()));\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/IMD6900RobinhoodLaunch.sol:519:23\n    │\n519 │         uint256 out = uint256(uint128(d.amount1()));\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/IMD6900RobinhoodLaunch.sol:519:31\n    │\n519 │         uint256 out = uint256(uint128(d.amount1()));\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[unused-return]: return value of an external call is not used\n    ╭▸ src/IMD6900RobinhoodLaunch.sol:520:9\n    │\n520 │         poolManager.settle{value: ethIn}();\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/IMD6900RobinhoodLaunch.sol:528:16\n    │\n528 │         return abi.encodePacked(type(IMD6900Hook).creationCode, abi.encode(poolManager, address(pool), timelock));\n    │                ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n    │\n    ╰ help: https://getfoundry.sh/forge/linting/encode-packed-collision\n\n","passed":false}],"detail":"build failed with exit code 137","evaluation":"checks","profile":"foundry","status":"rejected","submissionHash":"b6e40a31979785a6e47cd55141cf0e6342b179ef1db5ff01f38d9a3d26c6d344","verifiedTreeHash":"38b6f166f77bb2be86e65b6a0c20e58e182dc13e","verifierVersion":"0.1.0+327e1e9f"}]}