// 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 {JobsVault} from "src/JobsVault.sol";
import {Network} from "src/Network.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

contract Tkn is ERC20 {
    constructor() ERC20("T", "T") {}
    function mint(address to, uint256 a) external { _mint(to, a); }
}

contract FakeIntake {
    uint256 public jobs;
    function priceOf(bytes32, address) external pure returns (uint256) { return 1 ether; }
    function request(bytes32, bytes calldata, IIntake.Callback calldata, address asset, uint256 amount)
        external payable returns (bytes32)
    {
        IERC20(asset).transferFrom(msg.sender, address(this), amount);
        return keccak256(abi.encode(++jobs));
    }
}

/// One wallet's worth of tokens, passed along; each hop calls requestJob and hands the tokens on.
contract Hop {
    function run(JobsVault jv, IERC20 t, address next) external returns (bool ok) {
        try jv.requestJob("attacker job") {ok = true;} catch {}
        t.transfer(next, t.balanceOf(address(this)));
    }
}

contract JobsCycleTest is Test {
    function test_oneMillionTokensBuyOnlyOneJobPerDay() public {
        vm.chainId(4663);
        vm.etch(Network.IMD, address(new Tkn()).code);
        vm.etch(Network.INTAKE, address(new FakeIntake()).code);
        Tkn token = new Tkn();
        JobsVault jv = new JobsVault(address(this));
        jv.setToken(address(token));
        Tkn(Network.IMD).mint(address(jv), 10 ether); // one week of jobs budget: 10 jobs

        // The attacker holds (or flash-takes from the v4 PoolManager) exactly one threshold.
        uint256 threshold = jv.minimumHolding();
        Hop[] memory hops = new Hop[](10);
        for (uint256 i; i < 10; ++i) hops[i] = new Hop();
        token.mint(address(hops[0]), threshold);

        uint256 paid;
        for (uint256 i; i < 10; ++i) {
            address next = i + 1 < 10 ? address(hops[i + 1]) : address(this);
            if (hops[i].run(jv, token, next)) ++paid;
        }
        // Same block, same 1,000,000 tokens: the whole budget is spent on ten jobs.
        assertEq(token.balanceOf(address(this)), threshold, "tokens returned to the attacker");
        assertLe(paid, 1, "one holding bought more than one job in a day");
    }
}

// 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 {HolderRewards} from "src/HolderRewards.sol";
import {Network} from "src/Network.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

contract Tkn is ERC20 {
    constructor() ERC20("T", "T") {}
    function mint(address to, uint256 a) external { _mint(to, a); }
}

contract FakeFactory {
    function poolManager() external pure returns (address) { return address(0xBEEF); }
}

contract RecordingIntake {
    bytes32 public lastBodyHash;
    uint256 public askedAtBlock;
    function priceOf(bytes32, address) external pure returns (uint256) { return 1 ether; }
    function request(bytes32, bytes calldata body, IIntake.Callback calldata, address asset, uint256 amount)
        external payable returns (bytes32)
    {
        IERC20(asset).transferFrom(msg.sender, address(this), amount);
        lastBodyHash = keccak256(body);
        askedAtBlock = block.number;
        return keccak256(body);
    }
}

contract WindowDepthTest is Test {
    function test_oracleWindowIsAtLeastFiveBlocksBehindTheAsk() public {
        vm.chainId(4663);
        vm.roll(12_345); // Foundry answers ArbSys.arbBlockNumber() with block.number on 4663
        vm.etch(Network.IMD, address(new Tkn()).code);
        vm.etch(Network.INTAKE, address(new RecordingIntake()).code);
        vm.etch(Network.FACTORY, address(new FakeFactory()).code);
        Tkn token = new Tkn();
        HolderRewards rewards = new HolderRewards(address(this), address(0x1111), address(0x2222));
        rewards.setToken(address(token));

        Tkn(Network.IMD).mint(address(rewards), 100 ether);
        rewards.notifyDeposit(); // what SIMDVault.distribute() does after its transfer
        assertTrue(rewards.epoch(1).requestId != bytes32(0), "oracle was asked");

        RecordingIntake intake = RecordingIntake(Network.INTAKE);
        bytes memory sent = rewards.oracleBody(1);
        assertEq(keccak256(sent), intake.lastBodyHash(), "the body the Intake received");
        assertEq(intake.askedAtBlock(), 12_345);
        string memory body = string(sent);
        uint256 toBlock = vm.parseJsonUint(body, ".window.toBlock");
        uint256 head = rewards.snapshotHead();
        // oracle-consumer: the window's last block must be >= 5 deep when the plane reads the ask
        // ("close it a few blocks behind the head (the example uses eight)").
        assertLe(toBlock + 5, head, "window closes at the asking block itself (depth 0)");
    }
}

// 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 {SIMDVault} from "src/SIMDVault.sol";
import {HolderRewards} from "src/HolderRewards.sol";
import {Network} from "src/Network.sol";
import {IIntake} from "src/interfaces/IIntake.sol";
import {IHookFactory, PoolKey} from "src/interfaces/IHookFactory.sol";

contract ProofToken is ERC20 {
    constructor() ERC20("Proof", "P") {}

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

/// @dev Minimal Intake: fixed price, exact pull, optional outage.
contract ProofIntake is IIntake {
    uint256 public price = 0.5 ether;
    bool public down;
    uint256 public nonce;

    function setDown(bool value) external {
        down = value;
    }

    function setPrice(uint256 value) external {
        price = value;
    }

    function priceOf(bytes32, address) external view returns (uint256) {
        return price;
    }

    function request(bytes32, bytes calldata, Callback calldata, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(!down, "intake down");
        require(amount == price, "wrong price");
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount), "payment failed");
        id = keccak256(abi.encode(msg.sender, ++nonce));
    }
}

contract ProofFactory is IHookFactory {
    PoolKey internal key;
    address internal requester;
    address public poolManager;

    function set(PoolKey calldata key_, address requester_) external {
        key = key_;
        requester = requester_;
        poolManager = address(0xBEEF);
    }

    function positionOf(uint64) external view returns (PoolKey memory, int24, int24, address) {
        return (key, -60, 60, requester);
    }

    function claimFees(uint64) external {}
}

/// @notice Fails on the current code: a retry whose replacement request fails still deletes the
/// pending request, so the epoch is left with no request at all and the oracle's answer to the
/// original request is refused. Passes once a failed retry leaves the pending id in place.
contract RetryDropsPendingRequestTest is Test {
    uint64 constant LAUNCH = 3077;
    SIMDVault vault;
    HolderRewards rewards;
    ProofToken imd;
    ProofToken token;
    ProofIntake intake;
    ProofFactory factory;

    function setUp() public {
        vm.chainId(4663);
        vm.roll(10_000);
        vm.warp(1_800_000_000);
        vm.etch(Network.IMD, address(new ProofToken()).code);
        vm.etch(Network.INTAKE, address(new ProofIntake()).code);
        vm.etch(Network.FACTORY, address(new ProofFactory()).code);
        imd = ProofToken(Network.IMD);
        intake = ProofIntake(Network.INTAKE);
        factory = ProofFactory(Network.FACTORY);
        // etch copies code, not storage: re-set the defaults that the constructors wrote
        intake.setPrice(0.5 ether);
        token = new ProofToken();
        vault = new SIMDVault();
        rewards = vault.holderRewards();
        factory.set(PoolKey(address(token), Network.IMD, 12_500, 60, address(0xCAFE)), address(vault));
        vm.prank(Network.DEV);
        vault.bindLaunch(LAUNCH, address(token));
    }

    function _deposit(uint256 amount) internal returns (uint256 id) {
        imd.mint(address(rewards), amount);
        vm.prank(address(vault));
        rewards.notifyDeposit();
        return rewards.currentEpoch();
    }

    /// Intake outage during the retry: the pending request A must survive.
    function test_failedRetryKeepsPendingRequest() public {
        uint256 id = _deposit(10 ether);
        bytes32 pending = rewards.epoch(id).requestId;
        assertTrue(pending != bytes32(0), "first request must succeed");
        assertEq(rewards.requestEpoch(pending), id);

        intake.setDown(true);
        vm.warp(1_800_000_000 + 1 days);
        vm.prank(makeAddr("anyone"));
        rewards.retryOracle(id);

        // Expected: the replacement failed, so the original request is still the epoch's request.
        assertEq(rewards.epoch(id).requestId, pending, "pending request id was dropped by a failed retry");
        assertEq(rewards.requestEpoch(pending), id, "requestEpoch mapping for the pending id was deleted");
    }

    /// price >= pot boundary: the second retry can never ask again, yet still deletes request B,
    /// so the epoch becomes permanently unanswerable and its pot later moves to another snapshot.
    function test_retryAtPriceBoundaryLeavesEpochUnanswerable() public {
        // 1.4 IMD: pot 0.9 after request A; retry -> pot 0.4 with request B; price 0.5 >= 0.4 blocks a third ask.
        uint256 start = 1_800_000_000;
        uint256 id = _deposit(1.4 ether);
        vm.warp(start + 1 days);
        rewards.retryOracle(id);
        bytes32 requestB = rewards.epoch(id).requestId;
        assertTrue(requestB != bytes32(0));
        assertEq(rewards.epoch(id).pot, 0.4 ether);

        vm.warp(start + 2 days);
        vm.prank(makeAddr("griefer"));
        rewards.retryOracle(id); // submitOracle reverts CannotRequest (0.5 >= 0.4) and is caught

        assertEq(rewards.epoch(id).requestId, requestB, "request B dropped although no replacement was made");
        assertEq(rewards.requestEpoch(requestB), id);
    }
}

// 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 {SIMDVault} from "src/SIMDVault.sol";
import {HolderRewards} from "src/HolderRewards.sol";
import {Network} from "src/Network.sol";
import {IIntake} from "src/interfaces/IIntake.sol";
import {IHookFactory, PoolKey} from "src/interfaces/IHookFactory.sol";

contract ProofToken is ERC20 {
    constructor() ERC20("Proof", "P") {}

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

/// @dev Minimal Intake: fixed price, exact pull, optional outage.
contract ProofIntake is IIntake {
    uint256 public price = 0.5 ether;
    bool public down;
    uint256 public nonce;

    function setDown(bool value) external {
        down = value;
    }

    function setPrice(uint256 value) external {
        price = value;
    }

    function priceOf(bytes32, address) external view returns (uint256) {
        return price;
    }

    function request(bytes32, bytes calldata, Callback calldata, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(!down, "intake down");
        require(amount == price, "wrong price");
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount), "payment failed");
        id = keccak256(abi.encode(msg.sender, ++nonce));
    }
}

contract ProofFactory is IHookFactory {
    PoolKey internal key;
    address internal requester;
    address public poolManager;

    function set(PoolKey calldata key_, address requester_) external {
        key = key_;
        requester = requester_;
        poolManager = address(0xBEEF);
    }

    function positionOf(uint64) external view returns (PoolKey memory, int24, int24, address) {
        return (key, -60, 60, requester);
    }

    function claimFees(uint64) external {}
}

/// @notice Fails on the current code: a retry whose replacement request fails still deletes the
/// pending request, so the epoch is left with no request at all and the oracle's answer to the
/// original request is refused. Passes once a failed retry leaves the pending id in place.
contract RetryDropsPendingRequestTest is Test {
    uint64 constant LAUNCH = 3077;
    SIMDVault vault;
    HolderRewards rewards;
    ProofToken imd;
    ProofToken token;
    ProofIntake intake;
    ProofFactory factory;

    function setUp() public {
        vm.chainId(4663);
        vm.roll(10_000);
        vm.warp(1_800_000_000);
        vm.etch(Network.IMD, address(new ProofToken()).code);
        vm.etch(Network.INTAKE, address(new ProofIntake()).code);
        vm.etch(Network.FACTORY, address(new ProofFactory()).code);
        imd = ProofToken(Network.IMD);
        intake = ProofIntake(Network.INTAKE);
        factory = ProofFactory(Network.FACTORY);
        // etch copies code, not storage: re-set the defaults that the constructors wrote
        intake.setPrice(0.5 ether);
        token = new ProofToken();
        vault = new SIMDVault();
        rewards = vault.holderRewards();
        factory.set(PoolKey(address(token), Network.IMD, 12_500, 60, address(0xCAFE)), address(vault));
        vm.prank(Network.DEV);
        vault.bindLaunch(LAUNCH, address(token));
    }

    function _deposit(uint256 amount) internal returns (uint256 id) {
        imd.mint(address(rewards), amount);
        vm.prank(address(vault));
        rewards.notifyDeposit();
        return rewards.currentEpoch();
    }

    /// Intake outage during the retry: the pending request A must survive.
    function test_failedRetryKeepsPendingRequest() public {
        uint256 id = _deposit(10 ether);
        bytes32 pending = rewards.epoch(id).requestId;
        assertTrue(pending != bytes32(0), "first request must succeed");
        assertEq(rewards.requestEpoch(pending), id);

        intake.setDown(true);
        vm.warp(1_800_000_000 + 1 days);
        vm.prank(makeAddr("anyone"));
        rewards.retryOracle(id);

        // Expected: the replacement failed, so the original request is still the epoch's request.
        assertEq(rewards.epoch(id).requestId, pending, "pending request id was dropped by a failed retry");
        assertEq(rewards.requestEpoch(pending), id, "requestEpoch mapping for the pending id was deleted");
    }

    /// price >= pot boundary: the second retry can never ask again, yet still deletes request B,
    /// so the epoch becomes permanently unanswerable and its pot later moves to another snapshot.
    function test_retryAtPriceBoundaryLeavesEpochUnanswerable() public {
        // 1.4 IMD: pot 0.9 after request A; retry -> pot 0.4 with request B; price 0.5 >= 0.4 blocks a third ask.
        uint256 start = 1_800_000_000;
        uint256 id = _deposit(1.4 ether);
        vm.warp(start + 1 days);
        rewards.retryOracle(id);
        bytes32 requestB = rewards.epoch(id).requestId;
        assertTrue(requestB != bytes32(0));
        assertEq(rewards.epoch(id).pot, 0.4 ether);

        vm.warp(start + 2 days);
        vm.prank(makeAddr("griefer"));
        rewards.retryOracle(id); // submitOracle reverts CannotRequest (0.5 >= 0.4) and is caught

        assertEq(rewards.epoch(id).requestId, requestB, "request B dropped although no replacement was made");
        assertEq(rewards.requestEpoch(requestB), id);
    }
}

// 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 {HolderRewards} from "src/HolderRewards.sol";
import {Network} from "src/Network.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

contract Tkn is ERC20 {
    constructor() ERC20("T", "T") {}
    function mint(address to, uint256 a) external { _mint(to, a); }
}

contract FakeFactory {
    function poolManager() external pure returns (address) { return address(0xBEEF); }
}

contract RecordingIntake {
    bytes32 public lastBodyHash;
    uint256 public askedAtBlock;
    function priceOf(bytes32, address) external pure returns (uint256) { return 1 ether; }
    function request(bytes32, bytes calldata body, IIntake.Callback calldata, address asset, uint256 amount)
        external payable returns (bytes32)
    {
        IERC20(asset).transferFrom(msg.sender, address(this), amount);
        lastBodyHash = keccak256(body);
        askedAtBlock = block.number;
        return keccak256(body);
    }
}

contract WindowDepthTest is Test {
    function test_oracleWindowIsAtLeastFiveBlocksBehindTheAsk() public {
        vm.chainId(4663);
        vm.roll(12_345); // Foundry answers ArbSys.arbBlockNumber() with block.number on 4663
        vm.etch(Network.IMD, address(new Tkn()).code);
        vm.etch(Network.INTAKE, address(new RecordingIntake()).code);
        vm.etch(Network.FACTORY, address(new FakeFactory()).code);
        Tkn token = new Tkn();
        HolderRewards rewards = new HolderRewards(address(this), address(0x1111), address(0x2222));
        rewards.setToken(address(token));

        Tkn(Network.IMD).mint(address(rewards), 100 ether);
        rewards.notifyDeposit(); // what SIMDVault.distribute() does after its transfer
        assertTrue(rewards.epoch(1).requestId != bytes32(0), "oracle was asked");

        RecordingIntake intake = RecordingIntake(Network.INTAKE);
        bytes memory sent = rewards.oracleBody(1);
        assertEq(keccak256(sent), intake.lastBodyHash(), "the body the Intake received");
        assertEq(intake.askedAtBlock(), 12_345);
        string memory body = string(sent);
        uint256 toBlock = vm.parseJsonUint(body, ".window.toBlock");
        uint256 head = rewards.snapshotHead();
        // oracle-consumer: the window's last block must be >= 5 deep when the plane reads the ask
        // ("close it a few blocks behind the head (the example uses eight)").
        assertLe(toBlock + 5, head, "window closes at the asking block itself (depth 0)");
    }
}

// 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 {JobsVault} from "src/JobsVault.sol";
import {Network} from "src/Network.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

contract Tkn is ERC20 {
    constructor() ERC20("T", "T") {}
    function mint(address to, uint256 a) external { _mint(to, a); }
}

contract FakeIntake {
    uint256 public jobs;
    function priceOf(bytes32, address) external pure returns (uint256) { return 1 ether; }
    function request(bytes32, bytes calldata, IIntake.Callback calldata, address asset, uint256 amount)
        external payable returns (bytes32)
    {
        IERC20(asset).transferFrom(msg.sender, address(this), amount);
        return keccak256(abi.encode(++jobs));
    }
}

/// One wallet's worth of tokens, passed along; each hop calls requestJob and hands the tokens on.
contract Hop {
    function run(JobsVault jv, IERC20 t, address next) external returns (bool ok) {
        try jv.requestJob("attacker job") {ok = true;} catch {}
        t.transfer(next, t.balanceOf(address(this)));
    }
}

contract JobsCycleTest is Test {
    function test_oneMillionTokensBuyOnlyOneJobPerDay() public {
        vm.chainId(4663);
        vm.etch(Network.IMD, address(new Tkn()).code);
        vm.etch(Network.INTAKE, address(new FakeIntake()).code);
        Tkn token = new Tkn();
        JobsVault jv = new JobsVault(address(this));
        jv.setToken(address(token));
        Tkn(Network.IMD).mint(address(jv), 10 ether); // one week of jobs budget: 10 jobs

        // The attacker holds (or flash-takes from the v4 PoolManager) exactly one threshold.
        uint256 threshold = jv.minimumHolding();
        Hop[] memory hops = new Hop[](10);
        for (uint256 i; i < 10; ++i) hops[i] = new Hop();
        token.mint(address(hops[0]), threshold);

        uint256 paid;
        for (uint256 i; i < 10; ++i) {
            address next = i + 1 < 10 ? address(hops[i + 1]) : address(this);
            if (hops[i].run(jv, token, next)) ++paid;
        }
        // Same block, same 1,000,000 tokens: the whole budget is spent on ten jobs.
        assertEq(token.balanceOf(address(this)), threshold, "tokens returned to the attacker");
        assertLe(paid, 1, "one holding bought more than one job in a day");
    }
}