// 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 {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PLEAToken} from "src/PLEAToken.sol";
import {PleaHook} from "src/PleaHook.sol";
import {PleaCourt} from "src/PleaCourt.sol";

contract ScratchIMD is ERC20 {
    constructor() ERC20("IMD", "IMD") {
        _mint(msg.sender, 1e30);
    }
}

/// @dev Stands in for the launch factory: opens the pool and seeds full-range liquidity.
contract ScratchFactory is IUnlockCallback {
    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function initialize(PoolKey memory key, uint160 price) external {
        manager.initialize(key, price);
    }

    function addLiquidity(PoolKey memory key, int256 liquidity) external {
        manager.unlock(abi.encode(key, liquidity));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "not manager");
        (PoolKey memory key, int256 liquidity) = abi.decode(data, (PoolKey, int256));
        (BalanceDelta delta,) = manager.modifyLiquidity(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(key.tickSpacing),
                tickUpper: TickMath.maxUsableTick(key.tickSpacing),
                liquidityDelta: liquidity,
                salt: 0
            }),
            ""
        );
        _pay(key.currency0, delta.amount0());
        _pay(key.currency1, delta.amount1());
        return "";
    }

    function _pay(Currency c, int128 amount) private {
        if (amount < 0) {
            manager.sync(c);
            IERC20(Currency.unwrap(c)).transfer(address(manager), uint256(uint128(-amount)));
            manager.settle();
        }
    }
}

/// @notice An upheld objection must void the seller's season points (README: "their season points are
/// voided"). When the season has ended between the verdict and the ruling, `endSeason` has already turned
/// those points into claimable IMD and `_strike` only zeroes the *next* season, so the struck seller keeps
/// the prize. The seller can force this: `endSeason` is permissionless.
contract StrikeAfterSeasonEndTest is Test {
    uint160 internal constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint160 internal constant FLAGS = (1 << 13) | (1 << 11) | (1 << 7);

    address internal owner = makeAddr("owner");
    address internal seller = makeAddr("seller");
    address internal objector = makeAddr("objector");

    PoolManager internal manager;
    ScratchIMD internal imd;
    ScratchFactory internal factory;
    PLEAToken internal token;
    PleaHook internal hook;
    PleaCourt internal court;
    PoolKey internal key;
    address[] internal judges;

    function setUp() public {
        manager = new PoolManager(address(this));
        imd = new ScratchIMD();
        factory = new ScratchFactory(manager);
        token = new PLEAToken();

        bytes memory initCode =
            abi.encodePacked(type(PleaHook).creationCode, abi.encode(manager, address(token), owner, address(factory)));
        bytes32 salt = _mine(initCode);
        hook = new PleaHook{salt: salt}(manager, address(token), owner, address(factory));
        court = hook.court();

        (address c0, address c1) =
            address(token) < address(imd) ? (address(token), address(imd)) : (address(imd), address(token));
        key = PoolKey({
            currency0: Currency.wrap(c0),
            currency1: Currency.wrap(c1),
            fee: 12_500,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        factory.initialize(key, SQRT_PRICE_1_1);
        token.transfer(address(factory), 1e24);
        imd.transfer(address(factory), 1e24);
        factory.addLiquidity(key, 1e21);

        token.transfer(seller, 1e22);
        imd.transfer(objector, 10e18);

        for (uint256 i = 0; i < 30; i++) {
            judges.push(makeAddr(string.concat("judge", vm.toString(i))));
        }
        vm.prank(owner);
        court.setJudges(judges);

        // The prize pot: 100 IMD held by the court that is nobody's yet.
        imd.transfer(address(court), 100e18);
    }

    function test_upheldObjectionDoesNotVoidPrizeAfterSeasonEnd() public {
        // The season is over but nobody has called endSeason yet.
        vm.warp(court.seasonStart() + court.SEASON_LENGTH());

        vm.prank(seller);
        uint256 pleaId = court.submitPlea("I only sell to pay my rent. Fact: rent is due.", 1e21);
        for (uint256 i = 0; i < 17; i++) {
            vm.prank(judges[i]);
            court.judge(pleaId, 45, 26);
        }
        assertEq(court.seasonPoints(1, seller), 45, "median 45 awarded to season 1");

        // The seller closes the season themselves: the points become claimable IMD at once.
        vm.prank(seller);
        try court.endSeason() {} catch {}

        // The seller sells inside the 7-minute window, and the sale is objected to and upheld by 17 judges.
        vm.startPrank(seller);
        token.approve(address(hook), 1e21);
        (uint256 saleId,) = hook.sell(1e21, 0);
        vm.stopPrank();

        vm.startPrank(objector);
        imd.approve(address(court), court.OBJECTION_BOND());
        uint256 objectionId = court.object(saleId);
        vm.stopPrank();
        for (uint256 i = 0; i < 17; i++) {
            vm.prank(judges[i]);
            court.ruleObjection(objectionId, true);
        }
        assertGt(court.bannedUntil(seller), block.timestamp, "seller is banned");

        // Give any fix that defers the season end a chance to settle it now.
        vm.warp(block.timestamp + 3 days);
        try court.endSeason() {} catch {}

        // Expected: a seller whose sale was struck gets no season prize. Actual: 100 IMD is claimable.
        assertEq(court.claimable(seller), 0, "struck seller keeps the season-1 prize");
    }

    function _mine(bytes memory initCode) internal view returns (bytes32) {
        bytes32 h = keccak256(initCode);
        for (uint256 i = 0; i < 1_000_000; i++) {
            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), h)))));
            if ((uint160(a) & ((1 << 14) - 1)) == FLAGS) return bytes32(i);
        }
        revert("no salt");
    }
}

// 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 {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {HookFlags} from "src/HookFlags.sol";
import {PLEAToken} from "src/PLEAToken.sol";
import {PleaHook} from "src/PleaHook.sol";
import {PleaCourt} from "src/PleaCourt.sol";
import {IPleaCourt} from "src/interfaces/IPleaCourt.sol";

contract MockIMD is ERC20 {
    constructor() ERC20("IMD", "IMD") {
        _mint(msg.sender, 1e30);
    }
}

/// @dev Anyone may route a swap or a liquidity change through this. Liquidity is keyed to the caller,
/// as a public position manager does; to the pool manager the `sender` is always this contract.
contract Router is IUnlockCallback {
    IPoolManager public immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function deployToken() external returns (PLEAToken) {
        return new PLEAToken();
    }

    function deploy(bytes memory code, bytes32 salt) external returns (address deployed) {
        assembly ("memory-safe") {
            deployed := create2(0, add(code, 32), mload(code), salt)
        }
        require(deployed != address(0), "deploy failed");
    }

    function initialize(PoolKey memory key, uint160 price) external {
        manager.initialize(key, price);
    }

    function send(IERC20 token, address to, uint256 amount) external {
        token.transfer(to, amount);
    }

    function swap(PoolKey memory key, bool zeroForOne, uint256 amountIn) external {
        manager.unlock(abi.encode(true, msg.sender, key, zeroForOne, amountIn, int24(0), int24(0), int256(0)));
    }

    function modify(PoolKey memory key, int24 lower, int24 upper, int256 liquidity) external {
        manager.unlock(abi.encode(false, msg.sender, key, false, uint256(0), lower, upper, liquidity));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "not manager");
        (bool isSwap, address who, PoolKey memory key, bool z, uint256 amt, int24 lo, int24 hi, int256 liq) =
            abi.decode(data, (bool, address, PoolKey, bool, uint256, int24, int24, int256));
        BalanceDelta delta;
        if (isSwap) {
            delta = manager.swap(
                key,
                SwapParams({
                    zeroForOne: z,
                    amountSpecified: -int256(amt),
                    sqrtPriceLimitX96: z ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
                }),
                ""
            );
        } else {
            (delta,) = manager.modifyLiquidity(
                key,
                ModifyLiquidityParams({
                    tickLower: lo,
                    tickUpper: hi,
                    liquidityDelta: liq,
                    salt: bytes32(uint256(uint160(who)))
                }),
                ""
            );
        }
        _settle(key.currency0, delta.amount0(), who);
        _settle(key.currency1, delta.amount1(), who);
        return "";
    }

    function _settle(Currency currency, int128 amount, address who) private {
        if (amount < 0) {
            manager.sync(currency);
            IERC20(Currency.unwrap(currency)).transferFrom(who, address(manager), uint256(uint128(-amount)));
            manager.settle();
        } else if (amount > 0) {
            manager.take(currency, who, uint256(uint128(amount)));
        }
    }
}

abstract contract Fixture is Test {
    address internal owner = makeAddr("owner");
    address internal seller = makeAddr("seller");
    address internal stranger = makeAddr("stranger");
    address internal buyer = makeAddr("buyer");

    PoolManager internal manager;
    MockIMD internal imd;
    Router internal factory;
    PLEAToken internal token;
    PleaHook internal hook;
    PleaCourt internal court;
    PoolKey internal key;
    address[] internal judges;

    function setUp() public virtual {
        manager = new PoolManager(address(this));
        imd = new MockIMD();
        factory = new Router(manager);
        token = factory.deployToken();
        bytes memory code =
            abi.encodePacked(type(PleaHook).creationCode, abi.encode(manager, address(token), owner, address(factory)));
        uint160 flags = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_ADD_LIQUIDITY | HookFlags.BEFORE_SWAP;
        bytes32 hash = keccak256(code);
        bytes32 salt;
        for (uint256 i = 0; i < 500_000; i++) {
            address p = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(factory), bytes32(i), hash)))));
            if (HookFlags.matches(p, flags)) {
                salt = bytes32(i);
                break;
            }
        }
        hook = PleaHook(factory.deploy(code, salt));
        court = hook.court();
        (address c0, address c1) =
            address(token) < address(imd) ? (address(token), address(imd)) : (address(imd), address(token));
        key = PoolKey(Currency.wrap(c0), Currency.wrap(c1), 12_500, 60, IHooks(address(hook)));
        factory.initialize(key, 79228162514264337593543950336);

        imd.transfer(address(factory), 1e24);
        factory.send(IERC20(address(token)), address(this), 1e26);
        token.approve(address(factory), type(uint256).max);
        imd.approve(address(factory), type(uint256).max);
        factory.modify(key, TickMath.minUsableTick(60), TickMath.maxUsableTick(60), 1e21);

        factory.send(IERC20(address(token)), seller, 1e24);
        factory.send(IERC20(address(token)), stranger, 1e24);
        imd.transfer(buyer, 1e24);
        imd.transfer(stranger, 1e24);
        for (uint256 i = 0; i < 30; i++) {
            judges.push(makeAddr(string.concat("judge", vm.toString(i))));
        }
    }

    function installCabal() internal {
        vm.prank(owner);
        court.setJudges(judges);
    }

    function isSellZeroForOne() internal view returns (bool) {
        return Currency.unwrap(key.currency0) == address(token);
    }

    function vote(uint256 id, uint256 from, uint256 to, uint8 score, uint8 facts) internal {
        for (uint256 i = from; i < to; i++) {
            vm.prank(judges[i]);
            court.judge(id, score, facts);
        }
    }

    function plead(address who, uint256 amount) internal returns (uint256 id) {
        vm.prank(who);
        id = court.submitPlea("the facts: the sky is blue", amount);
    }
}

/// @dev All 30 judges vote, 15 on each side. Neither side reaches 17, nobody can vote again, and only the
/// seller can clear the plea. It stays Pending, the dead-man clock keeps running and the gate falls for good.
contract SplitPanelTest is Fixture {
    function test_fullPanelSplitMustNotFreeTrading() public {
        installCabal();
        uint256 id = plead(seller, 1e18);
        vote(id, 0, 15, 45, 26); // 15 approvals
        vote(id, 15, 30, 10, 0); // 15 denials: every judge has now voted

        vm.warp(block.timestamp + 33 hours);
        assertFalse(court.tradesFreely(), "a full panel voted, yet its plea hung and freed trading forever");
    }
}

// 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 {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {HookFlags} from "src/HookFlags.sol";
import {PLEAToken} from "src/PLEAToken.sol";
import {PleaHook} from "src/PleaHook.sol";
import {PleaCourt} from "src/PleaCourt.sol";
import {IPleaCourt} from "src/interfaces/IPleaCourt.sol";

contract MockIMD is ERC20 {
    constructor() ERC20("IMD", "IMD") {
        _mint(msg.sender, 1e30);
    }
}

/// @dev Anyone may route a swap or a liquidity change through this. Liquidity is keyed to the caller,
/// as a public position manager does; to the pool manager the `sender` is always this contract.
contract Router is IUnlockCallback {
    IPoolManager public immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function deployToken() external returns (PLEAToken) {
        return new PLEAToken();
    }

    function deploy(bytes memory code, bytes32 salt) external returns (address deployed) {
        assembly ("memory-safe") {
            deployed := create2(0, add(code, 32), mload(code), salt)
        }
        require(deployed != address(0), "deploy failed");
    }

    function initialize(PoolKey memory key, uint160 price) external {
        manager.initialize(key, price);
    }

    function send(IERC20 token, address to, uint256 amount) external {
        token.transfer(to, amount);
    }

    function swap(PoolKey memory key, bool zeroForOne, uint256 amountIn) external {
        manager.unlock(abi.encode(true, msg.sender, key, zeroForOne, amountIn, int24(0), int24(0), int256(0)));
    }

    function modify(PoolKey memory key, int24 lower, int24 upper, int256 liquidity) external {
        manager.unlock(abi.encode(false, msg.sender, key, false, uint256(0), lower, upper, liquidity));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "not manager");
        (bool isSwap, address who, PoolKey memory key, bool z, uint256 amt, int24 lo, int24 hi, int256 liq) =
            abi.decode(data, (bool, address, PoolKey, bool, uint256, int24, int24, int256));
        BalanceDelta delta;
        if (isSwap) {
            delta = manager.swap(
                key,
                SwapParams({
                    zeroForOne: z,
                    amountSpecified: -int256(amt),
                    sqrtPriceLimitX96: z ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
                }),
                ""
            );
        } else {
            (delta,) = manager.modifyLiquidity(
                key,
                ModifyLiquidityParams({
                    tickLower: lo,
                    tickUpper: hi,
                    liquidityDelta: liq,
                    salt: bytes32(uint256(uint160(who)))
                }),
                ""
            );
        }
        _settle(key.currency0, delta.amount0(), who);
        _settle(key.currency1, delta.amount1(), who);
        return "";
    }

    function _settle(Currency currency, int128 amount, address who) private {
        if (amount < 0) {
            manager.sync(currency);
            IERC20(Currency.unwrap(currency)).transferFrom(who, address(manager), uint256(uint128(-amount)));
            manager.settle();
        } else if (amount > 0) {
            manager.take(currency, who, uint256(uint128(amount)));
        }
    }
}

abstract contract Fixture is Test {
    address internal owner = makeAddr("owner");
    address internal seller = makeAddr("seller");
    address internal stranger = makeAddr("stranger");
    address internal buyer = makeAddr("buyer");

    PoolManager internal manager;
    MockIMD internal imd;
    Router internal factory;
    PLEAToken internal token;
    PleaHook internal hook;
    PleaCourt internal court;
    PoolKey internal key;
    address[] internal judges;

    function setUp() public virtual {
        manager = new PoolManager(address(this));
        imd = new MockIMD();
        factory = new Router(manager);
        token = factory.deployToken();
        bytes memory code =
            abi.encodePacked(type(PleaHook).creationCode, abi.encode(manager, address(token), owner, address(factory)));
        uint160 flags = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_ADD_LIQUIDITY | HookFlags.BEFORE_SWAP;
        bytes32 hash = keccak256(code);
        bytes32 salt;
        for (uint256 i = 0; i < 500_000; i++) {
            address p = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(factory), bytes32(i), hash)))));
            if (HookFlags.matches(p, flags)) {
                salt = bytes32(i);
                break;
            }
        }
        hook = PleaHook(factory.deploy(code, salt));
        court = hook.court();
        (address c0, address c1) =
            address(token) < address(imd) ? (address(token), address(imd)) : (address(imd), address(token));
        key = PoolKey(Currency.wrap(c0), Currency.wrap(c1), 12_500, 60, IHooks(address(hook)));
        factory.initialize(key, 79228162514264337593543950336);

        imd.transfer(address(factory), 1e24);
        factory.send(IERC20(address(token)), address(this), 1e26);
        token.approve(address(factory), type(uint256).max);
        imd.approve(address(factory), type(uint256).max);
        factory.modify(key, TickMath.minUsableTick(60), TickMath.maxUsableTick(60), 1e21);

        factory.send(IERC20(address(token)), seller, 1e24);
        factory.send(IERC20(address(token)), stranger, 1e24);
        imd.transfer(buyer, 1e24);
        imd.transfer(stranger, 1e24);
        for (uint256 i = 0; i < 30; i++) {
            judges.push(makeAddr(string.concat("judge", vm.toString(i))));
        }
    }

    function installCabal() internal {
        vm.prank(owner);
        court.setJudges(judges);
    }

    function isSellZeroForOne() internal view returns (bool) {
        return Currency.unwrap(key.currency0) == address(token);
    }

    function vote(uint256 id, uint256 from, uint256 to, uint8 score, uint8 facts) internal {
        for (uint256 i = from; i < to; i++) {
            vm.prank(judges[i]);
            court.judge(id, score, facts);
        }
    }

    function plead(address who, uint256 amount) internal returns (uint256 id) {
        vm.prank(who);
        id = court.submitPlea("the facts: the sky is blue", amount);
    }
}

/// @dev Nothing stops a plea before the Cabal exists, and the launch cannot install it: `setJudges` is the
/// owner's, after the factory's transaction. Any wallet starts the clock in the first block, and installing
/// the panel does not stop it.
contract PleaBeforeCabalTest is Fixture {
    function test_pleaBeforeCabalMustNotStartTheClock() public {
        vm.prank(stranger);
        try court.submitPlea("first block", 1) {}
        catch {
            return; // refused until the panel exists: the gate holds
        }
        // The README's instruction: "set the judges ... within 33 hours of it".
        vm.warp(block.timestamp + 32 hours);
        installCabal();
        vm.warp(block.timestamp + 1 hours);
        assertFalse(court.tradesFreely(), "one stranger's plea before the Cabal existed freed trading forever");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PleaCourt} from "src/PleaCourt.sol";
import {IPleaCourt} from "src/interfaces/IPleaCourt.sol";

/// @dev Stands in for PleaHook: the court only needs `owner()` from it for administration.
contract HookStub {
    address public owner;

    constructor(address owner_) {
        owner = owner_;
    }
}

/// @notice A plea on which all 30 judges vote without 17 agreeing is stuck Pending forever: no judge can
/// vote again, the seller cannot appeal, and the Cabal cannot produce any verdict that would reset the
/// dead-man clock. 33 hours later the sell gate is gone for good although every judge did their job.
/// Fails on the current code (the plea is still Pending after 30 votes); passes once the court settles
/// a plea when the whole Cabal has voted.
contract DeadlockTest is Test {
    PleaCourt court;
    address owner = makeAddr("owner");
    address seller = makeAddr("seller");
    address[] judges;

    function setUp() public {
        HookStub hook = new HookStub(owner);
        court = new PleaCourt(address(hook));
        for (uint256 i = 0; i < 30; i++) {
            judges.push(makeAddr(string.concat("judge", vm.toString(i))));
        }
        vm.prank(owner);
        court.setJudges(judges);
    }

    function test_splitCabalCannotReachAVerdictAndTheDeadManFires() public {
        vm.prank(seller);
        uint256 id = court.submitPlea("borderline", 1e18);

        // 16 approve (45 + 26 = 71), 14 deny (44 + 26 = 70): a majority of neither side.
        for (uint256 i = 0; i < 16; i++) {
            vm.prank(judges[i]);
            court.judge(id, 45, 26);
        }
        for (uint256 i = 16; i < 30; i++) {
            vm.prank(judges[i]);
            court.judge(id, 44, 26);
        }

        // All 30 judges voted: the plea must have a verdict and must no longer count as pending.
        assertTrue(
            court.pleaStatus(id) != IPleaCourt.Status.Pending,
            "30 votes cast, 16 approve / 14 deny: the plea has no verdict and stays Pending"
        );
        assertEq(court.pendingCount(), 0, "an undecidable plea keeps the dead-man clock running");
        assertEq(court.deadManDeadline(), 0, "no plea is pending, so no deadline should run");

        // Nothing the Cabal can do resets the clock while this is the only plea; 33h later the gate is gone.
        vm.warp(block.timestamp + 33 hours);
        assertFalse(court.tradesFreely(), "the sell gate was lost although the whole Cabal voted");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {Test} from "forge-std/Test.sol";
import {PleaCourt} from "src/PleaCourt.sol";
import {PLEAToken} from "src/PLEAToken.sol";
import {IPleaCourt} from "src/interfaces/IPleaCourt.sol";

contract LeaderboardRemovalProof is Test {
    function owner() external view returns (address) { return address(this); }

    function test_removingWinnerMustPromoteNextEligibleSeller() public {
        PLEAToken pair = new PLEAToken();
        PleaCourt court = new PleaCourt(address(this));
        court.bind(address(pair));
        address[] memory judges = new address[](30);
        for (uint256 i; i < 30; ++i) judges[i] = makeAddr(string.concat("judge", vm.toString(i)));
        court.setJudges(judges);
        address[] memory players = new address[](26);
        for (uint256 i; i < 26; ++i) {
            players[i] = makeAddr(string.concat("player", vm.toString(i)));
            vm.prank(players[i]);
            uint256 id = court.submitPlea("facts", 1);
            for (uint256 j; j < 17; ++j) {
                vm.prank(judges[j]);
                court.judge(id, uint8(20 + i), 71);
            }
        }
        assertEq(court.leaderboard().length, 25);
        assertEq(court.seasonPoints(1, players[0]), 20);
        uint256 sale = court.authorizeSale(players[25], 1);
        pair.approve(address(court), 1 ether);
        uint256 oid = court.object(sale);
        for (uint256 j; j < 17; ++j) {
            vm.prank(judges[j]);
            court.ruleObjection(oid, true);
        }
        // 25 eligible positive-scoring sellers remain; the top 25 must include all of them.
        assertEq(court.leaderboard().length, 25, "eligible runner-up lost after winner struck");
        pair.transfer(address(court), 100 ether);
        vm.warp(court.seasonStart() + 30 days);
        court.endSeason();
        assertGt(court.claimable(players[0]), 0, "eligible 25th seller excluded from season prize");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {Test} from "forge-std/Test.sol";
import {PleaHook} from "src/PleaHook.sol";
import {PleaCourt} from "src/PleaCourt.sol";
import {PLEAToken} from "src/PLEAToken.sol";
import {IPleaCourt} from "src/interfaces/IPleaCourt.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract PartialFillProof is Test, IUnlockCallback {
    PoolManager internal manager;
    PoolKey internal key;
    PleaHook internal hook;
    PLEAToken internal token;
    PLEAToken internal pair;

    function test_saleAccountingMustChargeOnlyConsumedTokens() public {
        manager = new PoolManager(address(this));
        token = new PLEAToken();
        pair = new PLEAToken();
        bytes memory code = abi.encodePacked(type(PleaHook).creationCode,
            abi.encode(manager, address(token), address(this), address(this)));
        bytes32 hash = keccak256(code);
        for (uint256 salt; salt < 200_000; ++salt) {
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(salt), hash)))));
            if (uint160(predicted) & 0x3fff != 0x2880) continue;
            hook = new PleaHook{salt: bytes32(salt)}(manager, address(token), address(this), address(this));
            break;
        }
        require(address(hook) != address(0), "mining failed");
        bool zero = address(token) < address(pair);
        key = PoolKey(Currency.wrap(zero ? address(token) : address(pair)),
            Currency.wrap(zero ? address(pair) : address(token)), 12500, 60, IHooks(address(hook)));
        manager.initialize(key, 79228162514264337593543950336);
        manager.unlock(""); // Deliberately narrow, valid liquidity range: a partial fill is reachable.
        PleaCourt court = hook.court();
        address[] memory judges = new address[](30);
        for (uint256 i; i < 30; ++i) judges[i] = makeAddr(string.concat("judge", vm.toString(i)));
        court.setJudges(judges);
        uint256 requested = 1 ether;
        uint256 plea = court.submitPlea("sell within approved allowance", requested);
        for (uint256 i; i < 17; ++i) {
            vm.prank(judges[i]);
            court.judge(plea, 45, 26);
        }
        token.approve(address(hook), requested);
        uint256 beforeBalance = token.balanceOf(address(this));
        (uint256 sale, uint256 proceeds) = hook.sell(requested, 1);
        uint256 consumed = beforeBalance - token.balanceOf(address(this));
        assertGt(proceeds, 0);
        assertGt(consumed, 0);
        assertLt(consumed, requested, "fixture must exercise a real partial fill");
        assertEq(court.plea(plea).sold, consumed, "refunded tokens incorrectly spend the plea allowance");
        assertEq(court.sale(sale).amount, consumed, "objection record reports tokens never sold");
        (, uint256 remaining) = court.saleWindow(address(this));
        assertEq(remaining, requested - consumed, "partial fill prematurely closes the sale window");
    }

    function unlockCallback(bytes calldata) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (BalanceDelta d,) = manager.modifyLiquidity(key, ModifyLiquidityParams(-60, 60, 1e18, 0), "");
        pay(key.currency0, d.amount0());
        pay(key.currency1, d.amount1());
        return "";
    }

    function pay(Currency currency, int128 delta) internal {
        if (delta < 0) {
            manager.sync(currency);
            IERC20(Currency.unwrap(currency)).transfer(address(manager), uint256(uint128(-delta)));
            manager.settle();
        }
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PleaCourt} from "src/PleaCourt.sol";
import {IPleaCourt} from "src/interfaces/IPleaCourt.sol";

/// @dev Stands in for PleaHook: the court only needs `owner()` from it for administration.
contract HookStub {
    address public owner;

    constructor(address owner_) {
        owner = owner_;
    }
}

/// @notice A plea on which all 30 judges vote without 17 agreeing is stuck Pending forever: no judge can
/// vote again, the seller cannot appeal, and the Cabal cannot produce any verdict that would reset the
/// dead-man clock. 33 hours later the sell gate is gone for good although every judge did their job.
/// Fails on the current code (the plea is still Pending after 30 votes); passes once the court settles
/// a plea when the whole Cabal has voted.
contract DeadlockTest is Test {
    PleaCourt court;
    address owner = makeAddr("owner");
    address seller = makeAddr("seller");
    address[] judges;

    function setUp() public {
        HookStub hook = new HookStub(owner);
        court = new PleaCourt(address(hook));
        for (uint256 i = 0; i < 30; i++) {
            judges.push(makeAddr(string.concat("judge", vm.toString(i))));
        }
        vm.prank(owner);
        court.setJudges(judges);
    }

    function test_splitCabalCannotReachAVerdictAndTheDeadManFires() public {
        vm.prank(seller);
        uint256 id = court.submitPlea("borderline", 1e18);

        // 16 approve (45 + 26 = 71), 14 deny (44 + 26 = 70): a majority of neither side.
        for (uint256 i = 0; i < 16; i++) {
            vm.prank(judges[i]);
            court.judge(id, 45, 26);
        }
        for (uint256 i = 16; i < 30; i++) {
            vm.prank(judges[i]);
            court.judge(id, 44, 26);
        }

        // All 30 judges voted: the plea must have a verdict and must no longer count as pending.
        assertTrue(
            court.pleaStatus(id) != IPleaCourt.Status.Pending,
            "30 votes cast, 16 approve / 14 deny: the plea has no verdict and stays Pending"
        );
        assertEq(court.pendingCount(), 0, "an undecidable plea keeps the dead-man clock running");
        assertEq(court.deadManDeadline(), 0, "no plea is pending, so no deadline should run");

        // Nothing the Cabal can do resets the clock while this is the only plea; 33h later the gate is gone.
        vm.warp(block.timestamp + 33 hours);
        assertFalse(court.tradesFreely(), "the sell gate was lost although the whole Cabal voted");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PleaCourt} from "src/PleaCourt.sol";

/// @dev Stands in for PleaHook: the court only reads `owner()` from it.
contract HookStub {
    address public owner;

    constructor(address owner_) {
        owner = owner_;
    }
}

/// @notice Sellers who withdraw their pleas while the Cabal is voting stop every verdict from landing.
/// With overlapping pleas pendingCount never reaches zero, pendingSince never moves, and 33 hours after the
/// first plea the sell gate is gone forever although the Cabal cast 16 votes on every plea (one every 5 hours).
/// Fails on the current code; passes once a mid-vote withdrawal can no longer starve the Cabal of verdicts
/// (withdrawal refused once votes are cast, or judging activity / withdrawal resets the clock).
contract WithdrawDeadManTest is Test {
    PleaCourt court;
    address owner = makeAddr("owner");
    address[] judges;
    address[] wallets;

    function setUp() public {
        HookStub hook = new HookStub(owner);
        court = new PleaCourt(address(hook));
        for (uint256 i = 0; i < 30; i++) {
            judges.push(makeAddr(string.concat("judge", vm.toString(i))));
        }
        for (uint256 i = 0; i < 8; i++) {
            wallets.push(makeAddr(string.concat("wallet", vm.toString(i))));
        }
        vm.prank(owner);
        court.setJudges(judges);
    }

    function test_withdrawBeforeQuorumTripsDeadManOnActiveCabal() public {
        uint256 t0 = block.timestamp;
        vm.prank(wallets[0]);
        uint256 prev = court.submitPlea("case 0", 1e18);

        for (uint256 i = 1; i <= 6; i++) {
            vm.warp(t0 + i * 5 hours);
            // next attacker wallet keeps a plea pending so pendingSince never resets
            vm.prank(wallets[i]);
            uint256 next = court.submitPlea("case", 1e18);
            // the Cabal is alive: 16 approvals land on the previous plea
            for (uint256 j = 0; j < 16; j++) {
                vm.prank(judges[j]);
                court.judge(prev, 45, 26);
            }
            // its seller withdraws just before the 17th vote (refusal is an acceptable fix)
            vm.prank(wallets[i - 1]);
            try court.withdrawPlea(prev) {} catch {}
            vm.prank(judges[16]);
            try court.judge(prev, 45, 26) {} catch {}
            prev = next;
        }

        vm.warp(t0 + 33 hours);
        assertFalse(court.tradesFreely(), "Cabal voted throughout, yet withdrawals freed trading forever");
    }
}

// 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 {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PLEAToken} from "src/PLEAToken.sol";
import {PleaHook} from "src/PleaHook.sol";
import {PleaCourt} from "src/PleaCourt.sol";

contract ScratchIMD is ERC20 {
    constructor() ERC20("IMD", "IMD") {
        _mint(msg.sender, 1e30);
    }
}

/// @dev Stands in for the launch factory: opens the pool and seeds full-range liquidity.
contract ScratchFactory is IUnlockCallback {
    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function initialize(PoolKey memory key, uint160 price) external {
        manager.initialize(key, price);
    }

    function addLiquidity(PoolKey memory key, int256 liquidity) external {
        manager.unlock(abi.encode(key, liquidity));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "not manager");
        (PoolKey memory key, int256 liquidity) = abi.decode(data, (PoolKey, int256));
        (BalanceDelta delta,) = manager.modifyLiquidity(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(key.tickSpacing),
                tickUpper: TickMath.maxUsableTick(key.tickSpacing),
                liquidityDelta: liquidity,
                salt: 0
            }),
            ""
        );
        _pay(key.currency0, delta.amount0());
        _pay(key.currency1, delta.amount1());
        return "";
    }

    function _pay(Currency c, int128 amount) private {
        if (amount < 0) {
            manager.sync(c);
            IERC20(Currency.unwrap(c)).transfer(address(manager), uint256(uint128(-amount)));
            manager.settle();
        }
    }
}

/// @notice An upheld objection must void the seller's season points (README: "their season points are
/// voided"). When the season has ended between the verdict and the ruling, `endSeason` has already turned
/// those points into claimable IMD and `_strike` only zeroes the *next* season, so the struck seller keeps
/// the prize. The seller can force this: `endSeason` is permissionless.
contract StrikeAfterSeasonEndTest is Test {
    uint160 internal constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint160 internal constant FLAGS = (1 << 13) | (1 << 11) | (1 << 7);

    address internal owner = makeAddr("owner");
    address internal seller = makeAddr("seller");
    address internal objector = makeAddr("objector");

    PoolManager internal manager;
    ScratchIMD internal imd;
    ScratchFactory internal factory;
    PLEAToken internal token;
    PleaHook internal hook;
    PleaCourt internal court;
    PoolKey internal key;
    address[] internal judges;

    function setUp() public {
        manager = new PoolManager(address(this));
        imd = new ScratchIMD();
        factory = new ScratchFactory(manager);
        token = new PLEAToken();

        bytes memory initCode =
            abi.encodePacked(type(PleaHook).creationCode, abi.encode(manager, address(token), owner, address(factory)));
        bytes32 salt = _mine(initCode);
        hook = new PleaHook{salt: salt}(manager, address(token), owner, address(factory));
        court = hook.court();

        (address c0, address c1) =
            address(token) < address(imd) ? (address(token), address(imd)) : (address(imd), address(token));
        key = PoolKey({
            currency0: Currency.wrap(c0),
            currency1: Currency.wrap(c1),
            fee: 12_500,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        factory.initialize(key, SQRT_PRICE_1_1);
        token.transfer(address(factory), 1e24);
        imd.transfer(address(factory), 1e24);
        factory.addLiquidity(key, 1e21);

        token.transfer(seller, 1e22);
        imd.transfer(objector, 10e18);

        for (uint256 i = 0; i < 30; i++) {
            judges.push(makeAddr(string.concat("judge", vm.toString(i))));
        }
        vm.prank(owner);
        court.setJudges(judges);

        // The prize pot: 100 IMD held by the court that is nobody's yet.
        imd.transfer(address(court), 100e18);
    }

    function test_upheldObjectionDoesNotVoidPrizeAfterSeasonEnd() public {
        // The season is over but nobody has called endSeason yet.
        vm.warp(court.seasonStart() + court.SEASON_LENGTH());

        vm.prank(seller);
        uint256 pleaId = court.submitPlea("I only sell to pay my rent. Fact: rent is due.", 1e21);
        for (uint256 i = 0; i < 17; i++) {
            vm.prank(judges[i]);
            court.judge(pleaId, 45, 26);
        }
        assertEq(court.seasonPoints(1, seller), 45, "median 45 awarded to season 1");

        // The seller closes the season themselves: the points become claimable IMD at once.
        vm.prank(seller);
        try court.endSeason() {} catch {}

        // The seller sells inside the 7-minute window, and the sale is objected to and upheld by 17 judges.
        vm.startPrank(seller);
        token.approve(address(hook), 1e21);
        (uint256 saleId,) = hook.sell(1e21, 0);
        vm.stopPrank();

        vm.startPrank(objector);
        imd.approve(address(court), court.OBJECTION_BOND());
        uint256 objectionId = court.object(saleId);
        vm.stopPrank();
        for (uint256 i = 0; i < 17; i++) {
            vm.prank(judges[i]);
            court.ruleObjection(objectionId, true);
        }
        assertGt(court.bannedUntil(seller), block.timestamp, "seller is banned");

        // Give any fix that defers the season end a chance to settle it now.
        vm.warp(block.timestamp + 3 days);
        try court.endSeason() {} catch {}

        // Expected: a seller whose sale was struck gets no season prize. Actual: 100 IMD is claimable.
        assertEq(court.claimable(seller), 0, "struck seller keeps the season-1 prize");
    }

    function _mine(bytes memory initCode) internal view returns (bytes32) {
        bytes32 h = keccak256(initCode);
        for (uint256 i = 0; i < 1_000_000; i++) {
            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), h)))));
            if ((uint160(a) & ((1 << 14) - 1)) == FLAGS) return bytes32(i);
        }
        revert("no salt");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PleaCourt} from "src/PleaCourt.sol";
import {IPleaCourt} from "src/interfaces/IPleaCourt.sol";

/// @dev Stands in for PleaHook: the court only needs `owner()` from it for administration.
contract HookStub {
    address public owner;

    constructor(address owner_) {
        owner = owner_;
    }
}

/// @notice A judge who pleads is recused from their own plea, so at most 29 votes can ever land on it.
/// The hung-Cabal rule settles a plea only at 30 votes, so a 29-vote split (15 approve / 14 deny) leaves
/// the plea Pending forever: no judge can vote again, the seller cannot withdraw it (VotesCast), and
/// the dead-man clock runs out 33 hours later although every eligible judge voted.
/// Fails on the current code; passes once the hung-Cabal rule counts the judges who may vote.
contract JudgeSellerHangTest is Test {
    PleaCourt court;
    address owner = makeAddr("owner");
    address[] judges;

    function setUp() public {
        HookStub hook = new HookStub(owner);
        court = new PleaCourt(address(hook));
        for (uint256 i = 0; i < 30; i++) {
            judges.push(makeAddr(string.concat("judge", vm.toString(i))));
        }
        vm.prank(owner);
        court.setJudges(judges);
    }

    function test_judgeSellerPleaCannotBeSettledByTheRemaining29() public {
        address seller = judges[0];
        vm.prank(seller);
        uint256 id = court.submitPlea("a judge's own plea", 1e18);

        vm.prank(seller);
        vm.expectRevert(PleaCourt.Recused.selector);
        court.judge(id, 45, 26);

        // 15 approve (45 + 26 = 71), 14 deny (44 + 26 = 70): all 29 eligible judges voted.
        for (uint256 i = 1; i < 16; i++) {
            vm.prank(judges[i]);
            court.judge(id, 45, 26);
        }
        for (uint256 i = 16; i < 30; i++) {
            vm.prank(judges[i]);
            court.judge(id, 44, 26);
        }

        // Nobody can add a 30th vote and the seller cannot withdraw a scored plea.
        vm.prank(judges[1]);
        vm.expectRevert(PleaCourt.AlreadyVoted.selector);
        court.judge(id, 45, 26);
        vm.prank(seller);
        vm.expectRevert(PleaCourt.VotesCast.selector);
        court.withdrawPlea(id);

        assertTrue(
            court.pleaStatus(id) != IPleaCourt.Status.Pending,
            "29 votes cast, 15 approve / 14 deny, no 30th vote possible: the plea has no verdict"
        );
        assertEq(court.pendingCount(), 0, "an undecidable plea keeps the dead-man clock running");

        vm.warp(block.timestamp + 33 hours);
        assertFalse(court.tradesFreely(), "the sell gate was lost although every eligible judge voted");
    }
}