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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {PLEA} from "src/PLEA.sol";
import {CabalGate} from "src/CabalGate.sol";
import {PleaHook} from "src/PleaHook.sol";
import {PleaDistributor} from "src/PleaDistributor.sol";
import {PleaLaunch} from "src/PleaLaunch.sol";
import {Addresses} from "src/libraries/Addresses.sol";

contract ScratchAsset is ERC20 {
    constructor() ERC20("Test IMD", "TestIMD") {}
}

/// @notice The dead-man clock starts in CabalGate's constructor, while pleading is impossible
/// (submitSell reverts NotReady until the pool is seeded). Anyone can kill the Cabal before launch.
contract DeadmanBeforeSeedTest is Test {
    uint256 constant START = 1791775740;
    PLEA token;
    CabalGate gate;
    PleaDistributor distributor;
    PleaLaunch launch;

    function setUp() public {
        vm.chainId(11155111);
        // Deploy 40 hours before START, as a launch two days ahead of the latest opening would.
        vm.warp(START - 40 hours);
        token = new PLEA(address(this));
        gate = new CabalGate(address(token));
        distributor = new PleaDistributor(address(token), address(this));
        launch = new PleaLaunch(address(token), address(gate), address(distributor), START);

        PoolManager implementation = new PoolManager(address(this));
        bytes memory runtime = address(implementation).code;
        bytes32 original = bytes32(uint256(uint160(address(implementation))));
        bytes32 target = bytes32(uint256(uint160(Addresses.MANAGER)));
        for (uint256 i; i + 32 <= runtime.length; ++i) {
            bytes32 word;
            assembly ("memory-safe") { word := mload(add(add(runtime, 32), i)) }
            if (word == original) {
                assembly ("memory-safe") { mstore(add(add(runtime, 32), i), target) }
            }
        }
        vm.etch(Addresses.MANAGER, runtime);
        vm.etch(Addresses.IMD, address(new ScratchAsset()).code);

        bytes memory initcode = bytes.concat(type(PleaHook).creationCode, abi.encode(address(token), address(gate), address(this)));
        bytes32 hash = keccak256(initcode);
        bytes32 salt;
        for (uint256 i;; ++i) {
            salt = bytes32(i);
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(launch), salt, hash)))));
            if (uint160(predicted) & Addresses.HOOK_MASK == Addresses.HOOK_FLAGS) break;
        }
        launch.deployHook(salt, initcode);
    }

    /// @dev Nobody could have pleaded yet (not seeded), so no verdict was ever possible: the
    /// Cabal must still be alive. On the current code killCabal succeeds 33h after deployment.
    function testKillCabalBeforeSeedMustRevert() public {
        vm.warp(START - 40 hours + 33 hours);
        vm.prank(address(0xBAD));
        vm.expectRevert(); // any revert: the Cabal must still be alive
        gate.killCabal();
        assertFalse(token.cabalDead());
    }

    /// @dev Seeding at START (allowed by the brief) must give the oracle its full 33h from the
    /// moment pleading becomes possible. On the current code the Cabal can be killed in the
    /// very same block as the public seed.
    function testKillCabalRightAfterSeedAtStartMustRevert() public {
        vm.warp(START);
        vm.prank(address(0xA11CE));
        launch.seed();
        assertGt(PleaHook(launch.hook()).seededAt(), 0);
        vm.prank(address(0xBAD));
        vm.expectRevert(); // any revert: the Cabal must still be alive
        gate.killCabal();
        assertFalse(token.cabalDead());
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {PLEA} from "src/PLEA.sol";
import {CabalGate} from "src/CabalGate.sol";
import {PleaHook} from "src/PleaHook.sol";
import {PleaDistributor} from "src/PleaDistributor.sol";
import {PleaLaunch} from "src/PleaLaunch.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";
import {Addresses} from "src/libraries/Addresses.sol";

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

contract ScratchStacker {
    function credit(address, uint256) external pure returns (uint256) { revert("paused"); }
}

contract ScratchIntake is IIntake {
    struct Request { address payer; address callbackTarget; bytes4 callbackSelector; bool completed; }
    mapping(bytes32 => Request) public requests;
    uint256 private nonce;
    function request(bytes32, bytes calldata, Callback calldata callback, address asset, uint256 amount)
        external payable returns (bytes32 id)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        id = keccak256(abi.encode(msg.sender, ++nonce));
        requests[id] = Request(msg.sender, callback.target, callback.selector, false);
    }
    function complete(bytes32 id) external { requests[id].completed = true; }
    function deliver(bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata sig) external returns (bool ok) {
        Request storage r = requests[id];
        r.completed = true;
        (ok,) = r.callbackTarget.call{gas: 200_000}(abi.encodeWithSelector(r.callbackSelector, id, a, sig));
    }
}

contract ScratchSigner {
    address public immutable signer;
    constructor(address s) { signer = s; }
    function isValidSignature(bytes32 digest, bytes calldata sig) external view returns (bytes4) {
        return ECDSA.recover(digest, sig) == signer ? bytes4(0x1626ba7e) : bytes4(0xffffffff);
    }
}

contract AppealNoVerdictClearsDenialWaitTest is Test {
    uint256 constant START = 1791775740;
    uint256 constant SIGN_KEY = 0x12345;
    address constant ALICE = address(0xA11CE);
    address constant BOB = address(0xB0B);
    PLEA token;
    CabalGate gate;
    PleaDistributor distributor;
    PleaLaunch launch;
    PleaHook hook;
    ScratchAsset imd;
    ScratchAsset feeToken;
    ScratchIntake intake;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(START - 1 days);
        token = new PLEA(address(this));
        gate = new CabalGate(address(token));
        distributor = new PleaDistributor(address(token), address(this));
        launch = new PleaLaunch(address(token), address(gate), address(distributor), START);

        PoolManager implementation = new PoolManager(address(this));
        bytes memory runtime = address(implementation).code;
        bytes32 original = bytes32(uint256(uint160(address(implementation))));
        bytes32 target = bytes32(uint256(uint160(Addresses.MANAGER)));
        for (uint256 i; i + 32 <= runtime.length; ++i) {
            bytes32 word;
            assembly ("memory-safe") { word := mload(add(add(runtime, 32), i)) }
            if (word == original) {
                assembly ("memory-safe") { mstore(add(add(runtime, 32), i), target) }
            }
        }
        vm.etch(Addresses.MANAGER, runtime);
        ScratchAsset asset = new ScratchAsset();
        vm.etch(Addresses.IMD, address(asset).code);
        vm.etch(Addresses.ORACLE_ASSET, address(asset).code);
        imd = ScratchAsset(Addresses.IMD);
        feeToken = ScratchAsset(Addresses.ORACLE_ASSET);
        vm.etch(Addresses.STACKER, address(new ScratchStacker()).code);
        vm.etch(Addresses.INTAKE, address(new ScratchIntake()).code);
        intake = ScratchIntake(Addresses.INTAKE);
        vm.etch(Addresses.SIGNER, address(new ScratchSigner(vm.addr(SIGN_KEY))).code);

        bytes memory initcode = bytes.concat(type(PleaHook).creationCode, abi.encode(address(token), address(gate), address(this)));
        bytes32 hash = keccak256(initcode);
        bytes32 salt;
        for (uint256 i;; ++i) {
            salt = bytes32(i);
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(launch), salt, hash)))));
            if (uint160(predicted) & Addresses.HOOK_MASK == Addresses.HOOK_FLAGS) break;
        }
        launch.deployHook(salt, initcode);
        hook = PleaHook(launch.hook());
        launch.seed();
        _fund(ALICE);
        _fund(BOB);
        vm.warp(hook.seededAt() + 90 minutes);
        vm.roll(block.number + 1);
    }

    function _fund(address who) internal {
        imd.mint(who, 100_000 ether);
        feeToken.mint(who, 10 ether);
        vm.startPrank(who);
        imd.approve(address(gate), type(uint256).max);
        feeToken.approve(address(gate), type(uint256).max);
        token.approve(address(gate), type(uint256).max);
        vm.stopPrank();
    }

    function _buy(address who, uint256 amount) internal returns (uint256) {
        uint160 limit = hook.plea0() ? TickMath.MAX_SQRT_PRICE - 1 : TickMath.MIN_SQRT_PRICE + 1;
        vm.prank(who);
        return gate.buy(amount, 1, limit);
    }

    function _verdict(uint256 id, bool yes) internal {
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("uuid", id));
        a.chainId = 1;
        a.answer = abi.encode(yes);
        a.panelSize = 30;
        a.quorum = 17;
        a.agreed = 17;
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 1 hours);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGN_KEY, gate.attestationDigest(a));
        bool ok = intake.deliver(gate.pleas(id).intakeId, a, abi.encodePacked(r, s, v));
        assertTrue(ok, "callback failed");
    }

    /// An appeal that gets no verdict erases the 4h wait imposed by the denial.
    function testAppealNoVerdictClearsDenialWait() public {
        uint256 balance = _buy(ALICE, 10 ether);
        vm.prank(ALICE);
        uint256 id = gate.submitSell(balance / 10, "Rent is due.");
        _verdict(id, false);
        uint256 denialWaitEnds = gate.nextAllowedAt(ALICE);
        assertEq(denialWaitEnds, block.timestamp + 4 hours);
        vm.prank(ALICE);
        gate.appeal(id, balance / 10, "Please reconsider.");
        // The oracle never answers the appeal: 20 minutes pass.
        vm.warp(block.timestamp + 20 minutes);
        assertLt(block.timestamp, denialWaitEnds);
        vm.prank(ALICE);
        vm.expectRevert(CabalGate.Cooldown.selector); // expected: still inside the denial wait
        gate.submitSell(balance / 10, "Fresh plea, no wait.");
    }

    /// Lead A': same, via intake.completed (refused / disagreed) one block later.
    function testAppealCompletedWithoutVerdictClearsDenialWait() public {
        uint256 balance = _buy(ALICE, 10 ether);
        vm.prank(ALICE);
        uint256 id = gate.submitSell(balance / 10, "Rent is due.");
        _verdict(id, false);
        vm.prank(ALICE);
        uint256 appealId = gate.appeal(id, balance / 10, "Please reconsider.");
        intake.complete(gate.pleas(appealId).intakeId);
        vm.warp(block.timestamp + 12);
        vm.prank(ALICE);
        vm.expectRevert(CabalGate.Cooldown.selector);
        gate.submitSell(balance / 10, "Fresh plea, no wait.");
    }

}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {Test} from "forge-std/Test.sol";
import {PLEA} from "src/PLEA.sol";
import {CabalGate} from "src/CabalGate.sol";
import {PleaDistributor} from "src/PleaDistributor.sol";
import {PleaLaunch} from "src/PleaLaunch.sol";
import {PleaHook} from "src/PleaHook.sol";
import {Addresses} from "src/libraries/Addresses.sol";

/// @dev The dead-man clock starts in CabalGate's constructor, not at seed or at the first plea.
/// With START = 1791775740 (2026-10-12 03:29 UTC) about two days after deployment, anyone can kill the
/// Cabal after deployHook and before the launch even opens, permanently removing the sell gate.
contract DeadmanBeforeSeedTest is Test {
    uint256 constant START = 1791775740;

    function testCabalCannotBeKilledBeforeAnyVerdictWasPossible() public {
        vm.chainId(11155111);
        vm.warp(START - 2 days);
        PLEA token = new PLEA(address(this));
        CabalGate gate = new CabalGate(address(token));
        PleaDistributor distributor = new PleaDistributor(address(token), address(this));
        PleaLaunch launch = new PleaLaunch(address(token), address(gate), address(distributor), START);

        // Anyone deploys the committed hook right after launch (no pool needed yet).
        bytes memory initcode = bytes.concat(type(PleaHook).creationCode, abi.encode(address(token), address(gate), address(this)));
        bytes32 salt;
        for (uint256 i;; ++i) {
            salt = bytes32(i);
            if (uint160(launch.predictHook(salt)) & Addresses.HOOK_MASK == Addresses.HOOK_FLAGS) break;
        }
        launch.deployHook(salt, initcode);
        assertEq(token.gate(), address(gate));

        // 33 hours after deployment, still before START: pool not seeded, no plea could ever have existed.
        vm.warp(START - 2 days + 33 hours);
        assertLt(block.timestamp, START);
        assertFalse(launch.seeded());

        // Any revert is acceptable (CabalStillAlive, or NotReady if the fix requires a seeded pool);
        // what must not happen is a successful kill.
        vm.prank(address(0xBEEF));
        vm.expectRevert();
        gate.killCabal();
        assertFalse(token.cabalDead(), "Cabal killed before the launch opened");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {PLEA} from "src/PLEA.sol";
import {CabalGate} from "src/CabalGate.sol";
import {PleaHook} from "src/PleaHook.sol";
import {PleaDistributor} from "src/PleaDistributor.sol";
import {PleaLaunch} from "src/PleaLaunch.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";
import {Addresses} from "src/libraries/Addresses.sol";

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

/// @dev Minimal stacker: pulls the cashback and hands it to the trader, returns non-zero shares.
contract ScratchStacker {
    function credit(address trader, uint256 amount) external returns (uint256) {
        require(IERC20(Addresses.IMD).transferFrom(msg.sender, trader, amount));
        return 1;
    }
}

contract ScratchSigner {
    function isValidSignature(bytes32, bytes calldata) external pure returns (bytes4) { return 0x1626ba7e; }
}

contract ScratchIntake is IIntake {
    struct Request { address payer; address callbackTarget; bytes4 callbackSelector; bool completed; }
    mapping(bytes32 => Request) public requests;
    uint256 private nonce;
    function request(bytes32, bytes calldata, Callback calldata callback, address asset, uint256 amount)
        external payable returns (bytes32 id)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        id = keccak256(abi.encode(msg.sender, ++nonce));
        requests[id] = Request(msg.sender, callback.target, callback.selector, false);
    }
    function completeWithoutVerdict(bytes32 id) external { requests[id].completed = true; }
    function deliver(bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata sig) external returns (bool ok) {
        Request storage r = requests[id];
        r.completed = true;
        (ok,) = r.callbackTarget.call{gas: 200_000}(abi.encodeWithSelector(r.callbackSelector, id, a, sig));
    }
}

/// @dev _noVerdict() zeroes nextAllowedAt. After a denial, an appeal that ends without a verdict therefore
/// lets the seller submit a brand-new plea immediately instead of waiting out the 4 hour denial cooldown.
contract CooldownBypassTest is Test {
    uint256 constant START = 1791775740;
    address constant ALICE = address(0xA11CE);
    PLEA token;
    CabalGate gate;
    PleaDistributor distributor;
    PleaLaunch launch;
    PleaHook hook;
    ScratchAsset imd;
    ScratchAsset feeToken;
    ScratchIntake intake;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(START - 1 days);
        token = new PLEA(address(this));
        gate = new CabalGate(address(token));
        distributor = new PleaDistributor(address(token), address(this));
        launch = new PleaLaunch(address(token), address(gate), address(distributor), START);
        PoolManager implementation = new PoolManager(address(this));
        bytes memory runtime = address(implementation).code;
        bytes32 original = bytes32(uint256(uint160(address(implementation))));
        bytes32 target = bytes32(uint256(uint160(Addresses.MANAGER)));
        for (uint256 i; i + 32 <= runtime.length; ++i) {
            bytes32 word;
            assembly ("memory-safe") { word := mload(add(add(runtime, 32), i)) }
            if (word == original) {
                assembly ("memory-safe") { mstore(add(add(runtime, 32), i), target) }
            }
        }
        vm.etch(Addresses.MANAGER, runtime);
        ScratchAsset asset = new ScratchAsset();
        vm.etch(Addresses.IMD, address(asset).code);
        vm.etch(Addresses.ORACLE_ASSET, address(asset).code);
        imd = ScratchAsset(Addresses.IMD);
        feeToken = ScratchAsset(Addresses.ORACLE_ASSET);
        vm.etch(Addresses.STACKER, address(new ScratchStacker()).code);
        vm.etch(Addresses.INTAKE, address(new ScratchIntake()).code);
        intake = ScratchIntake(Addresses.INTAKE);
        vm.etch(Addresses.SIGNER, address(new ScratchSigner()).code);
        bytes memory code = bytes.concat(type(PleaHook).creationCode, abi.encode(address(token), address(gate), address(this)));
        bytes32 salt;
        for (uint256 i;; ++i) {
            salt = bytes32(i);
            if (uint160(launch.predictHook(salt)) & Addresses.HOOK_MASK == Addresses.HOOK_FLAGS) break;
        }
        launch.deployHook(salt, code);
        hook = PleaHook(launch.hook());
        launch.seed();
        imd.mint(ALICE, 100_000 ether);
        feeToken.mint(ALICE, 10 ether);
        vm.startPrank(ALICE);
        imd.approve(address(gate), type(uint256).max);
        feeToken.approve(address(gate), type(uint256).max);
        token.approve(address(gate), type(uint256).max);
        vm.stopPrank();
        vm.warp(hook.seededAt() + 90 minutes);
        vm.roll(block.number + 1);
    }

    function _verdict(uint256 id, bool yes) internal {
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("uuid", id));
        a.chainId = 1;
        a.answer = abi.encode(yes);
        a.panelSize = 30;
        a.quorum = 17;
        a.agreed = 17;
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 1 hours);
        bytes memory sig = new bytes(65);
        assertTrue(intake.deliver(gate.pleas(id).intakeId, a, sig), "callback failed");
    }

    function testNoVerdictAppealDoesNotEraseDenialCooldown() public {
        uint160 limit = hook.plea0() ? TickMath.MAX_SQRT_PRICE - 1 : TickMath.MIN_SQRT_PRICE + 1;
        vm.prank(ALICE);
        uint256 balance = gate.buy(10 ether, 1, limit);
        vm.prank(ALICE);
        uint256 id = gate.submitSell(balance / 10, "My rent is due; the rest stays with the Cabal.");
        _verdict(id, false);
        uint256 deniedAt = block.timestamp;
        assertEq(gate.nextAllowedAt(ALICE), deniedAt + 4 hours);

        // Appeal at once; the appeal gets no verdict (refused or split panel: intake completes without callback).
        vm.prank(ALICE);
        uint256 appealId = gate.appeal(id, balance / 10, "Please reconsider my rent.");
        intake.completeWithoutVerdict(gate.pleas(appealId).intakeId);
        vm.prank(ALICE);
        gate.clearNoVerdict();
        assertEq(uint256(gate.pleas(appealId).status), uint256(CabalGate.Status.NoVerdict));

        // One minute after the denial the seller must still be inside the 4 hour wait.
        vm.warp(deniedAt + 1 minutes);
        vm.prank(ALICE);
        vm.expectRevert(CabalGate.Cooldown.selector);
        gate.submitSell(balance / 10, "A fresh plea long before the 4h wait ended.");
    }
}

// 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/PoolManager.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {PLEA} from "src/PLEA.sol";
import {CabalGate} from "src/CabalGate.sol";
import {PleaHook} from "src/PleaHook.sol";
import {PleaDistributor} from "src/PleaDistributor.sol";
import {PleaLaunch} from "src/PleaLaunch.sol";
import {Addresses} from "src/libraries/Addresses.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

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

/// Minimal intake: pulls the fee and records the request. No callbacks are needed for this proof.
contract ProofIntake is IIntake {
    struct Request { address payer; address callbackTarget; bytes4 callbackSelector; bool completed; }
    mapping(bytes32 => Request) public requests;
    uint256 private nonce;
    function request(bytes32, bytes calldata, Callback calldata callback, address asset, uint256 amount)
        external payable returns (bytes32 id)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        id = keccak256(abi.encode(msg.sender, ++nonce));
        requests[id] = Request(msg.sender, callback.target, callback.selector, false);
    }
}

/// Minimal stacker: takes the cashback like the real one would.
contract ProofStacker {
    function credit(address, uint256 imdAmount) external returns (uint256) {
        require(IERC20(Addresses.IMD).transferFrom(msg.sender, address(this), imdAmount));
        return imdAmount;
    }
}

/// A plea's stored fact score must equal the score against the current hour's checkpoint.
/// On the current code the gate never refreshes the checkpoint before scoring, so a seller who
/// skips `checkpoint()` is scored against a 25-hour-stale price (42 here) while the latest
/// checkpoint gives 32. Fails now; passes once `_submit` calls `hook().checkpoint()` first.
contract StaleCheckpointScoreTest is Test {
    uint256 constant START = 1791775740;
    address constant ALICE = address(0xA11CE);
    address constant BOB = address(0xB0B);
    PLEA token;
    CabalGate gate;
    PleaDistributor distributor;
    PleaLaunch launch;
    PleaHook hook;
    ProofAsset imd;
    ProofAsset feeToken;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(START - 1 days);
        token = new PLEA(address(this));
        gate = new CabalGate(address(token));
        distributor = new PleaDistributor(address(token), address(this));
        launch = new PleaLaunch(address(token), address(gate), address(distributor), START);
        PoolManager implementation = new PoolManager(address(this));
        bytes memory runtime = address(implementation).code;
        bytes32 original = bytes32(uint256(uint160(address(implementation))));
        bytes32 target = bytes32(uint256(uint160(Addresses.MANAGER)));
        for (uint256 i; i + 32 <= runtime.length; ++i) {
            bytes32 word;
            assembly ("memory-safe") { word := mload(add(add(runtime, 32), i)) }
            if (word == original) {
                assembly ("memory-safe") { mstore(add(add(runtime, 32), i), target) }
            }
        }
        vm.etch(Addresses.MANAGER, runtime);
        ProofAsset asset = new ProofAsset();
        vm.etch(Addresses.IMD, address(asset).code);
        vm.etch(Addresses.ORACLE_ASSET, address(asset).code);
        imd = ProofAsset(Addresses.IMD);
        feeToken = ProofAsset(Addresses.ORACLE_ASSET);
        ProofIntake intakeImplementation = new ProofIntake();
        vm.etch(Addresses.INTAKE, address(intakeImplementation).code);
        ProofStacker stackerImplementation = new ProofStacker();
        vm.etch(Addresses.STACKER, address(stackerImplementation).code);
        bytes memory code = abi.encodePacked(type(PleaHook).creationCode, abi.encode(address(token), address(gate), address(this)));
        bytes32 hash = keccak256(code);
        bytes32 salt;
        for (uint256 i;; ++i) {
            salt = bytes32(i);
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(launch), salt, hash)))));
            if (uint160(predicted) & Addresses.HOOK_MASK == Addresses.HOOK_FLAGS) break;
        }
        launch.deployHook(salt, code);
        hook = PleaHook(launch.hook());
        launch.seed();
        _fund(ALICE);
        _fund(BOB);
        vm.warp(hook.seededAt() + 90 minutes);
        vm.roll(vm.getBlockNumber() + 1);
    }

    function _fund(address who) internal {
        imd.mint(who, 1_000_000 ether);
        feeToken.mint(who, 10 ether);
        vm.startPrank(who);
        imd.approve(address(gate), type(uint256).max);
        feeToken.approve(address(gate), type(uint256).max);
        token.approve(address(gate), type(uint256).max);
        vm.stopPrank();
    }

    function _buy(address who, uint256 amount) internal returns (uint256) {
        uint160 limit = hook.plea0() ? TickMath.MAX_SQRT_PRICE - 1 : TickMath.MIN_SQRT_PRICE + 1;
        vm.prank(who);
        return gate.buy(amount, 1, limit);
    }

    function testPleaIsScoredAgainstCurrentHourCheckpoint() public {
        uint256 bal = _buy(ALICE, 100 ether);
        // Another trader moves the price in a later block.
        vm.roll(vm.getBlockNumber() + 1);
        vm.warp(vm.getBlockTimestamp() + 1);
        _buy(BOB, 20_000 ether);
        // A day of silence: nobody trades, nobody calls checkpoint().
        vm.warp(vm.getBlockTimestamp() + 1 days + 1);
        vm.roll(vm.getBlockNumber() + 1);
        uint256 amount = bal / 10;
        if (amount > 2_500_000 ether) amount = 2_500_000 ether;
        vm.prank(ALICE);
        uint256 id = gate.submitSell(amount, "Rent is due; the rest stays with the Cabal.");
        uint256 stored = gate.pleas(id).score;
        // What the score is once the current hour's checkpoint exists.
        hook.checkpoint();
        uint256 current = gate.factScore(ALICE, amount);
        assertEq(stored, current, "plea scored against a stale checkpoint");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {PLEA} from "src/PLEA.sol";
import {CabalGate} from "src/CabalGate.sol";
import {PleaHook} from "src/PleaHook.sol";
import {PleaDistributor} from "src/PleaDistributor.sol";
import {PleaLaunch} from "src/PleaLaunch.sol";
import {Addresses} from "src/libraries/Addresses.sol";

contract ScratchAsset is ERC20 {
    constructor() ERC20("Test IMD", "TestIMD") {}
}

/// @notice The dead-man clock starts in CabalGate's constructor, while pleading is impossible
/// (submitSell reverts NotReady until the pool is seeded). Anyone can kill the Cabal before launch.
contract DeadmanBeforeSeedTest is Test {
    uint256 constant START = 1791775740;
    PLEA token;
    CabalGate gate;
    PleaDistributor distributor;
    PleaLaunch launch;

    function setUp() public {
        vm.chainId(11155111);
        // Deploy 40 hours before START, as a launch two days ahead of the latest opening would.
        vm.warp(START - 40 hours);
        token = new PLEA(address(this));
        gate = new CabalGate(address(token));
        distributor = new PleaDistributor(address(token), address(this));
        launch = new PleaLaunch(address(token), address(gate), address(distributor), START);

        PoolManager implementation = new PoolManager(address(this));
        bytes memory runtime = address(implementation).code;
        bytes32 original = bytes32(uint256(uint160(address(implementation))));
        bytes32 target = bytes32(uint256(uint160(Addresses.MANAGER)));
        for (uint256 i; i + 32 <= runtime.length; ++i) {
            bytes32 word;
            assembly ("memory-safe") { word := mload(add(add(runtime, 32), i)) }
            if (word == original) {
                assembly ("memory-safe") { mstore(add(add(runtime, 32), i), target) }
            }
        }
        vm.etch(Addresses.MANAGER, runtime);
        vm.etch(Addresses.IMD, address(new ScratchAsset()).code);

        bytes memory initcode = bytes.concat(type(PleaHook).creationCode, abi.encode(address(token), address(gate), address(this)));
        bytes32 hash = keccak256(initcode);
        bytes32 salt;
        for (uint256 i;; ++i) {
            salt = bytes32(i);
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(launch), salt, hash)))));
            if (uint160(predicted) & Addresses.HOOK_MASK == Addresses.HOOK_FLAGS) break;
        }
        launch.deployHook(salt, initcode);
    }

    /// @dev Nobody could have pleaded yet (not seeded), so no verdict was ever possible: the
    /// Cabal must still be alive. On the current code killCabal succeeds 33h after deployment.
    function testKillCabalBeforeSeedMustRevert() public {
        vm.warp(START - 40 hours + 33 hours);
        vm.prank(address(0xBAD));
        vm.expectRevert(); // any revert: the Cabal must still be alive
        gate.killCabal();
        assertFalse(token.cabalDead());
    }

    /// @dev Seeding at START (allowed by the brief) must give the oracle its full 33h from the
    /// moment pleading becomes possible. On the current code the Cabal can be killed in the
    /// very same block as the public seed.
    function testKillCabalRightAfterSeedAtStartMustRevert() public {
        vm.warp(START);
        vm.prank(address(0xA11CE));
        launch.seed();
        assertGt(PleaHook(launch.hook()).seededAt(), 0);
        vm.prank(address(0xBAD));
        vm.expectRevert(); // any revert: the Cabal must still be alive
        gate.killCabal();
        assertFalse(token.cabalDead());
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {PLEA} from "src/PLEA.sol";
import {CabalGate} from "src/CabalGate.sol";
import {PleaHook} from "src/PleaHook.sol";
import {PleaDistributor} from "src/PleaDistributor.sol";
import {PleaLaunch} from "src/PleaLaunch.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";
import {Addresses} from "src/libraries/Addresses.sol";

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

contract ScratchStacker {
    function credit(address, uint256) external pure returns (uint256) { revert("paused"); }
}

contract ScratchIntake is IIntake {
    struct Request { address payer; address callbackTarget; bytes4 callbackSelector; bool completed; }
    mapping(bytes32 => Request) public requests;
    uint256 private nonce;
    function request(bytes32, bytes calldata, Callback calldata callback, address asset, uint256 amount)
        external payable returns (bytes32 id)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        id = keccak256(abi.encode(msg.sender, ++nonce));
        requests[id] = Request(msg.sender, callback.target, callback.selector, false);
    }
    function complete(bytes32 id) external { requests[id].completed = true; }
    function deliver(bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata sig) external returns (bool ok) {
        Request storage r = requests[id];
        r.completed = true;
        (ok,) = r.callbackTarget.call{gas: 200_000}(abi.encodeWithSelector(r.callbackSelector, id, a, sig));
    }
}

contract ScratchSigner {
    address public immutable signer;
    constructor(address s) { signer = s; }
    function isValidSignature(bytes32 digest, bytes calldata sig) external view returns (bytes4) {
        return ECDSA.recover(digest, sig) == signer ? bytes4(0x1626ba7e) : bytes4(0xffffffff);
    }
}

contract AppealNoVerdictClearsDenialWaitTest is Test {
    uint256 constant START = 1791775740;
    uint256 constant SIGN_KEY = 0x12345;
    address constant ALICE = address(0xA11CE);
    address constant BOB = address(0xB0B);
    PLEA token;
    CabalGate gate;
    PleaDistributor distributor;
    PleaLaunch launch;
    PleaHook hook;
    ScratchAsset imd;
    ScratchAsset feeToken;
    ScratchIntake intake;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(START - 1 days);
        token = new PLEA(address(this));
        gate = new CabalGate(address(token));
        distributor = new PleaDistributor(address(token), address(this));
        launch = new PleaLaunch(address(token), address(gate), address(distributor), START);

        PoolManager implementation = new PoolManager(address(this));
        bytes memory runtime = address(implementation).code;
        bytes32 original = bytes32(uint256(uint160(address(implementation))));
        bytes32 target = bytes32(uint256(uint160(Addresses.MANAGER)));
        for (uint256 i; i + 32 <= runtime.length; ++i) {
            bytes32 word;
            assembly ("memory-safe") { word := mload(add(add(runtime, 32), i)) }
            if (word == original) {
                assembly ("memory-safe") { mstore(add(add(runtime, 32), i), target) }
            }
        }
        vm.etch(Addresses.MANAGER, runtime);
        ScratchAsset asset = new ScratchAsset();
        vm.etch(Addresses.IMD, address(asset).code);
        vm.etch(Addresses.ORACLE_ASSET, address(asset).code);
        imd = ScratchAsset(Addresses.IMD);
        feeToken = ScratchAsset(Addresses.ORACLE_ASSET);
        vm.etch(Addresses.STACKER, address(new ScratchStacker()).code);
        vm.etch(Addresses.INTAKE, address(new ScratchIntake()).code);
        intake = ScratchIntake(Addresses.INTAKE);
        vm.etch(Addresses.SIGNER, address(new ScratchSigner(vm.addr(SIGN_KEY))).code);

        bytes memory initcode = bytes.concat(type(PleaHook).creationCode, abi.encode(address(token), address(gate), address(this)));
        bytes32 hash = keccak256(initcode);
        bytes32 salt;
        for (uint256 i;; ++i) {
            salt = bytes32(i);
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(launch), salt, hash)))));
            if (uint160(predicted) & Addresses.HOOK_MASK == Addresses.HOOK_FLAGS) break;
        }
        launch.deployHook(salt, initcode);
        hook = PleaHook(launch.hook());
        launch.seed();
        _fund(ALICE);
        _fund(BOB);
        vm.warp(hook.seededAt() + 90 minutes);
        vm.roll(block.number + 1);
    }

    function _fund(address who) internal {
        imd.mint(who, 100_000 ether);
        feeToken.mint(who, 10 ether);
        vm.startPrank(who);
        imd.approve(address(gate), type(uint256).max);
        feeToken.approve(address(gate), type(uint256).max);
        token.approve(address(gate), type(uint256).max);
        vm.stopPrank();
    }

    function _buy(address who, uint256 amount) internal returns (uint256) {
        uint160 limit = hook.plea0() ? TickMath.MAX_SQRT_PRICE - 1 : TickMath.MIN_SQRT_PRICE + 1;
        vm.prank(who);
        return gate.buy(amount, 1, limit);
    }

    function _verdict(uint256 id, bool yes) internal {
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("uuid", id));
        a.chainId = 1;
        a.answer = abi.encode(yes);
        a.panelSize = 30;
        a.quorum = 17;
        a.agreed = 17;
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 1 hours);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGN_KEY, gate.attestationDigest(a));
        bool ok = intake.deliver(gate.pleas(id).intakeId, a, abi.encodePacked(r, s, v));
        assertTrue(ok, "callback failed");
    }

    /// An appeal that gets no verdict erases the 4h wait imposed by the denial.
    function testAppealNoVerdictClearsDenialWait() public {
        uint256 balance = _buy(ALICE, 10 ether);
        vm.prank(ALICE);
        uint256 id = gate.submitSell(balance / 10, "Rent is due.");
        _verdict(id, false);
        uint256 denialWaitEnds = gate.nextAllowedAt(ALICE);
        assertEq(denialWaitEnds, block.timestamp + 4 hours);
        vm.prank(ALICE);
        gate.appeal(id, balance / 10, "Please reconsider.");
        // The oracle never answers the appeal: 20 minutes pass.
        vm.warp(block.timestamp + 20 minutes);
        assertLt(block.timestamp, denialWaitEnds);
        vm.prank(ALICE);
        vm.expectRevert(CabalGate.Cooldown.selector); // expected: still inside the denial wait
        gate.submitSell(balance / 10, "Fresh plea, no wait.");
    }

    /// Lead A': same, via intake.completed (refused / disagreed) one block later.
    function testAppealCompletedWithoutVerdictClearsDenialWait() public {
        uint256 balance = _buy(ALICE, 10 ether);
        vm.prank(ALICE);
        uint256 id = gate.submitSell(balance / 10, "Rent is due.");
        _verdict(id, false);
        vm.prank(ALICE);
        uint256 appealId = gate.appeal(id, balance / 10, "Please reconsider.");
        intake.complete(gate.pleas(appealId).intakeId);
        vm.warp(block.timestamp + 12);
        vm.prank(ALICE);
        vm.expectRevert(CabalGate.Cooldown.selector);
        gate.submitSell(balance / 10, "Fresh plea, no wait.");
    }

}

// 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/PoolManager.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {PLEA} from "src/PLEA.sol";
import {CabalGate} from "src/CabalGate.sol";
import {PleaHook} from "src/PleaHook.sol";
import {PleaDistributor} from "src/PleaDistributor.sol";
import {PleaLaunch} from "src/PleaLaunch.sol";
import {Addresses} from "src/libraries/Addresses.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

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

/// Minimal intake: pulls the fee and records the request. No callbacks are needed for this proof.
contract ProofIntake is IIntake {
    struct Request { address payer; address callbackTarget; bytes4 callbackSelector; bool completed; }
    mapping(bytes32 => Request) public requests;
    uint256 private nonce;
    function request(bytes32, bytes calldata, Callback calldata callback, address asset, uint256 amount)
        external payable returns (bytes32 id)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        id = keccak256(abi.encode(msg.sender, ++nonce));
        requests[id] = Request(msg.sender, callback.target, callback.selector, false);
    }
}

/// Minimal stacker: takes the cashback like the real one would.
contract ProofStacker {
    function credit(address, uint256 imdAmount) external returns (uint256) {
        require(IERC20(Addresses.IMD).transferFrom(msg.sender, address(this), imdAmount));
        return imdAmount;
    }
}

/// A plea's stored fact score must equal the score against the current hour's checkpoint.
/// On the current code the gate never refreshes the checkpoint before scoring, so a seller who
/// skips `checkpoint()` is scored against a 25-hour-stale price (42 here) while the latest
/// checkpoint gives 32. Fails now; passes once `_submit` calls `hook().checkpoint()` first.
contract StaleCheckpointScoreTest is Test {
    uint256 constant START = 1791775740;
    address constant ALICE = address(0xA11CE);
    address constant BOB = address(0xB0B);
    PLEA token;
    CabalGate gate;
    PleaDistributor distributor;
    PleaLaunch launch;
    PleaHook hook;
    ProofAsset imd;
    ProofAsset feeToken;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(START - 1 days);
        token = new PLEA(address(this));
        gate = new CabalGate(address(token));
        distributor = new PleaDistributor(address(token), address(this));
        launch = new PleaLaunch(address(token), address(gate), address(distributor), START);
        PoolManager implementation = new PoolManager(address(this));
        bytes memory runtime = address(implementation).code;
        bytes32 original = bytes32(uint256(uint160(address(implementation))));
        bytes32 target = bytes32(uint256(uint160(Addresses.MANAGER)));
        for (uint256 i; i + 32 <= runtime.length; ++i) {
            bytes32 word;
            assembly ("memory-safe") { word := mload(add(add(runtime, 32), i)) }
            if (word == original) {
                assembly ("memory-safe") { mstore(add(add(runtime, 32), i), target) }
            }
        }
        vm.etch(Addresses.MANAGER, runtime);
        ProofAsset asset = new ProofAsset();
        vm.etch(Addresses.IMD, address(asset).code);
        vm.etch(Addresses.ORACLE_ASSET, address(asset).code);
        imd = ProofAsset(Addresses.IMD);
        feeToken = ProofAsset(Addresses.ORACLE_ASSET);
        ProofIntake intakeImplementation = new ProofIntake();
        vm.etch(Addresses.INTAKE, address(intakeImplementation).code);
        ProofStacker stackerImplementation = new ProofStacker();
        vm.etch(Addresses.STACKER, address(stackerImplementation).code);
        bytes memory code = abi.encodePacked(type(PleaHook).creationCode, abi.encode(address(token), address(gate), address(this)));
        bytes32 hash = keccak256(code);
        bytes32 salt;
        for (uint256 i;; ++i) {
            salt = bytes32(i);
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(launch), salt, hash)))));
            if (uint160(predicted) & Addresses.HOOK_MASK == Addresses.HOOK_FLAGS) break;
        }
        launch.deployHook(salt, code);
        hook = PleaHook(launch.hook());
        launch.seed();
        _fund(ALICE);
        _fund(BOB);
        vm.warp(hook.seededAt() + 90 minutes);
        vm.roll(vm.getBlockNumber() + 1);
    }

    function _fund(address who) internal {
        imd.mint(who, 1_000_000 ether);
        feeToken.mint(who, 10 ether);
        vm.startPrank(who);
        imd.approve(address(gate), type(uint256).max);
        feeToken.approve(address(gate), type(uint256).max);
        token.approve(address(gate), type(uint256).max);
        vm.stopPrank();
    }

    function _buy(address who, uint256 amount) internal returns (uint256) {
        uint160 limit = hook.plea0() ? TickMath.MAX_SQRT_PRICE - 1 : TickMath.MIN_SQRT_PRICE + 1;
        vm.prank(who);
        return gate.buy(amount, 1, limit);
    }

    function testPleaIsScoredAgainstCurrentHourCheckpoint() public {
        uint256 bal = _buy(ALICE, 100 ether);
        // Another trader moves the price in a later block.
        vm.roll(vm.getBlockNumber() + 1);
        vm.warp(vm.getBlockTimestamp() + 1);
        _buy(BOB, 20_000 ether);
        // A day of silence: nobody trades, nobody calls checkpoint().
        vm.warp(vm.getBlockTimestamp() + 1 days + 1);
        vm.roll(vm.getBlockNumber() + 1);
        uint256 amount = bal / 10;
        if (amount > 2_500_000 ether) amount = 2_500_000 ether;
        vm.prank(ALICE);
        uint256 id = gate.submitSell(amount, "Rent is due; the rest stays with the Cabal.");
        uint256 stored = gate.pleas(id).score;
        // What the score is once the current hour's checkpoint exists.
        hook.checkpoint();
        uint256 current = gate.factScore(ALICE, amount);
        assertEq(stored, current, "plea scored against a stale checkpoint");
    }
}

// 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/PoolManager.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {Currency} from "v4-core/types/Currency.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {PLEA} from "src/PLEA.sol";
import {CabalGate} from "src/CabalGate.sol";
import {PleaHook} from "src/PleaHook.sol";
import {PleaDistributor} from "src/PleaDistributor.sol";
import {PleaLaunch} from "src/PleaLaunch.sol";
import {Addresses} from "src/libraries/Addresses.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

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

contract ProofIntake is IIntake {
    struct Request { address payer; address callbackTarget; bytes4 callbackSelector; bool completed; }
    mapping(bytes32 => Request) public requests;
    uint256 private nonce;
    function request(bytes32, bytes calldata, Callback calldata callback, address asset, uint256 amount)
        external payable returns (bytes32 id)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        id = keccak256(abi.encode(msg.sender, ++nonce));
        requests[id] = Request(msg.sender, callback.target, callback.selector, false);
    }
}

contract ProofStacker {
    function credit(address, uint256 imdAmount) external returns (uint256) {
        require(IERC20(Addresses.IMD).transferFrom(msg.sender, address(this), imdAmount));
        return imdAmount;
    }
}

/// A third-party router that prepays its own TestIMD and names somebody else as the trader.
contract GiftRouter {
    IPoolManager constant manager = IPoolManager(Addresses.MANAGER);
    PleaHook hook;
    address victim;
    uint256 amount;

    function gift(PleaHook h, address v, uint256 a) external {
        hook = h;
        victim = v;
        amount = a;
        manager.unlock("");
    }

    function unlockCallback(bytes calldata) external returns (bytes memory) {
        require(msg.sender == address(manager));
        manager.sync(Currency.wrap(Addresses.IMD));
        require(IERC20(Addresses.IMD).transfer(address(manager), amount));
        manager.settle();
        uint160 limit = hook.plea0() ? TickMath.MAX_SQRT_PRICE - 1 : TickMath.MIN_SQRT_PRICE + 1;
        manager.swap(hook.poolKey(), IPoolManager.SwapParams(!hook.plea0(), -int256(amount), limit), abi.encode(victim));
        return "";
    }
}

/// A holder's buy-time and cost-basis ledger must only move through that holder's own trades.
/// On the current code any PoolManager caller that prepays input may name any wallet in hookData,
/// and afterSwap rewrites that wallet's averageBuyTime/costBasis. Fails now; passes once buys from
/// a sender other than the gate are refused (or hookData is ignored for them).
contract HookDataTraderTest is Test {
    uint256 constant START = 1791775740;
    address constant ALICE = address(0xA11CE);
    address constant BOB = address(0xB0B);
    PLEA token;
    CabalGate gate;
    PleaDistributor distributor;
    PleaLaunch launch;
    PleaHook hook;
    ProofAsset imd;
    ProofAsset feeToken;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(START - 1 days);
        token = new PLEA(address(this));
        gate = new CabalGate(address(token));
        distributor = new PleaDistributor(address(token), address(this));
        launch = new PleaLaunch(address(token), address(gate), address(distributor), START);
        PoolManager implementation = new PoolManager(address(this));
        bytes memory runtime = address(implementation).code;
        bytes32 original = bytes32(uint256(uint160(address(implementation))));
        bytes32 target = bytes32(uint256(uint160(Addresses.MANAGER)));
        for (uint256 i; i + 32 <= runtime.length; ++i) {
            bytes32 word;
            assembly ("memory-safe") { word := mload(add(add(runtime, 32), i)) }
            if (word == original) {
                assembly ("memory-safe") { mstore(add(add(runtime, 32), i), target) }
            }
        }
        vm.etch(Addresses.MANAGER, runtime);
        ProofAsset asset = new ProofAsset();
        vm.etch(Addresses.IMD, address(asset).code);
        vm.etch(Addresses.ORACLE_ASSET, address(asset).code);
        imd = ProofAsset(Addresses.IMD);
        feeToken = ProofAsset(Addresses.ORACLE_ASSET);
        vm.etch(Addresses.INTAKE, address(new ProofIntake()).code);
        vm.etch(Addresses.STACKER, address(new ProofStacker()).code);
        bytes memory code = abi.encodePacked(type(PleaHook).creationCode, abi.encode(address(token), address(gate), address(this)));
        bytes32 hash = keccak256(code);
        bytes32 salt;
        for (uint256 i;; ++i) {
            salt = bytes32(i);
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(launch), salt, hash)))));
            if (uint160(predicted) & Addresses.HOOK_MASK == Addresses.HOOK_FLAGS) break;
        }
        launch.deployHook(salt, code);
        hook = PleaHook(launch.hook());
        launch.seed();
        imd.mint(ALICE, 1_000 ether);
        feeToken.mint(ALICE, 10 ether);
        vm.startPrank(ALICE);
        imd.approve(address(gate), type(uint256).max);
        feeToken.approve(address(gate), type(uint256).max);
        token.approve(address(gate), type(uint256).max);
        vm.stopPrank();
        vm.warp(hook.seededAt() + 90 minutes);
        vm.roll(vm.getBlockNumber() + 1);
    }

    function testThirdPartyCannotMoveHoldersLedger() public {
        uint160 limit = hook.plea0() ? TickMath.MAX_SQRT_PRICE - 1 : TickMath.MIN_SQRT_PRICE + 1;
        vm.prank(ALICE);
        uint256 balance = gate.buy(10 ether, 1, limit);
        uint256 avgBefore = hook.averageBuyTime(ALICE);
        uint256 basisBefore = hook.costBasis(ALICE);
        // ALICE has held for just over seven days: 14 hold points.
        vm.warp(avgBefore + 7 days + 30 minutes);
        vm.roll(vm.getBlockNumber() + 1);
        uint256 scoreBefore = gate.factScore(ALICE, balance * 15 / 100);

        GiftRouter router = new GiftRouter();
        imd.mint(address(router), 1 ether);
        vm.prank(BOB);
        // Whether the gift is refused or accepted, ALICE's ledger must not move.
        (bool ok,) = address(router).call(abi.encodeCall(GiftRouter.gift, (hook, ALICE, 0.05 ether)));
        ok; // ignored on purpose

        assertEq(hook.averageBuyTime(ALICE), avgBefore, "third party moved ALICE's average buy time");
        assertEq(hook.costBasis(ALICE), basisBefore, "third party moved ALICE's cost basis");
        assertEq(gate.factScore(ALICE, token.balanceOf(ALICE) * 15 / 100), scoreBefore, "fact score changed");
    }
}