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

import {Test} from "forge-std/Test.sol";
import {Weir} from "src/Weir.sol";
import {IIntake} from "src/interfaces/IIntake.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

/// @dev A token whose transfer to a blocked account returns false and moves nothing (legacy "false means
/// failure" semantics). transferFrom is honest, so the stream and the bond are created normally.
contract FalseReturnOnBlockToken is ERC20 {
    mapping(address => bool) public blocked;

    constructor() ERC20("T", "T") {}

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

    function setBlocked(address a, bool b) external {
        blocked[a] = b;
    }

    function transfer(address to, uint256 amount) public override returns (bool) {
        if (blocked[to]) return false;
        return super.transfer(to, amount);
    }
}

contract ProofIntake is IIntake {
    using SafeERC20 for IERC20;

    Callback public cb;
    uint256 public seq;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return 5e17;
    }

    function requestWithFailure(bytes32, bytes calldata, Callback calldata c, bytes4, address asset, uint256 amount)
        external
        payable
        returns (bytes32)
    {
        cb = c;
        IERC20(asset).safeTransferFrom(msg.sender, address(this), amount);
        return keccak256(abi.encode(address(this), ++seq));
    }

    function deliver(bytes32 id, OracleAttestation.Attestation memory a, bytes memory sig) external returns (bool ok) {
        (ok,) = cb.target.call{gas: 200_000}(abi.encodeWithSelector(cb.selector, id, a, sig));
    }
}

contract Proof_FalseReturnLocksRuled is Test {
    uint256 constant KEY = 0xfeed1234;
    address client = makeAddr("client");
    address recipient = makeAddr("recipient");
    FalseReturnOnBlockToken gate;
    FalseReturnOnBlockToken imd;
    FalseReturnOnBlockToken token;
    ProofIntake intake;
    Weir weir;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.roll(500);
        gate = new FalseReturnOnBlockToken();
        imd = new FalseReturnOnBlockToken();
        token = new FalseReturnOnBlockToken();
        intake = new ProofIntake();
        weir = new Weir(gate, imd, intake, vm.addr(KEY), 7 days, 10_000e18);
        address[2] memory users = [client, recipient];
        for (uint256 i; i < 2; ++i) {
            gate.mint(users[i], 10_000e18);
            token.mint(users[i], 1e30);
            imd.mint(users[i], 1e30);
            vm.startPrank(users[i]);
            token.approve(address(weir), type(uint256).max);
            imd.approve(address(weir), type(uint256).max);
            vm.stopPrank();
        }
    }

    /// @dev Recipient disputes, wins, and is then blocked by the token. enforce() must still complete and
    /// defer the bond to claimable, exactly as it does for a reverting transfer. Today it reverts with
    /// TransferMismatch forever: the stream is stuck in Ruled, where neither void, refund nor expireDispute
    /// is allowed, so the client's unearned principal and the recipient's bond are locked permanently.
    function test_falseReturningTransferIsDeferredNotFatal() public {
        vm.prank(client);
        uint256 id = weir.createStream(recipient, token, 1e6, 1_000e6, keccak256("terms"), "ipfs://terms", bytes32(0));
        vm.warp(vm.getBlockTimestamp() + 10);
        vm.prank(recipient);
        weir.dispute(id, "note");
        uint256 bond = weir.streams(id).bond;
        assertEq(bond, 50e6);

        OracleAttestation.Attestation memory a;
        a.requestId = keccak256("oracle uuid") & ~bytes32(uint256(type(uint128).max));
        a.chainId = block.chainid;
        a.questionHash = keccak256("q");
        a.answer = abi.encode(true);
        a.fromBlock = 400;
        a.toBlock = 500;
        a.panelSize = 5;
        a.quorum = 4;
        a.agreed = 4;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 7 days);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, weir.attestationDigest(a));
        assertTrue(intake.deliver(weir.streams(id).requestId, a, abi.encodePacked(r, s, v)));
        assertEq(uint256(weir.streams(id).state), uint256(Weir.State.Ruled));

        token.setBlocked(recipient, true);
        uint256 before = token.balanceOf(address(weir));
        weir.enforce(id); // reverts TransferMismatch on the current code
        assertEq(uint256(weir.streams(id).state), uint256(Weir.State.Active));
        assertEq(weir.streams(id).bond, 0);
        assertEq(weir.claimable(address(token), recipient), bond);
        assertEq(weir.unclaimed(address(token)), bond);
        assertEq(token.balanceOf(address(weir)), before);
        // the client is free again
        vm.prank(client);
        weir.void(id);
        // and the recipient collects once unblocked
        token.setBlocked(recipient, false);
        uint256 beforeRecipient = token.balanceOf(recipient);
        vm.prank(recipient);
        weir.claim(token);
        assertEq(token.balanceOf(recipient) - beforeRecipient, bond);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Weir} from "src/Weir.sol";
import {IIntake} from "src/interfaces/IIntake.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

contract CooldownToken is ERC20 {
    constructor() ERC20("T", "T") {}

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

contract CooldownIntake is IIntake {
    using SafeERC20 for IERC20;

    Callback public cb;
    bytes4 public failSelector;
    uint256 public seq;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return 5e17;
    }

    function requestWithFailure(bytes32, bytes calldata, Callback calldata c, bytes4 f, address asset, uint256 amount)
        external
        payable
        returns (bytes32)
    {
        cb = c;
        failSelector = f;
        IERC20(asset).safeTransferFrom(msg.sender, address(this), amount);
        return keccak256(abi.encode(address(this), ++seq));
    }

    function failRequest(bytes32 id) external returns (bool ok) {
        (ok,) = cb.target.call{gas: 200_000}(
            abi.encodeWithSelector(failSelector, id, uint8(1), bytes32("body_refused"), uint16(0), uint16(0), bytes(""))
        );
    }
}

contract Proof_RedisputeCooldown is Test {
    uint256 constant KEY = 0xfeed1234;
    address client = makeAddr("client");
    address recipient = makeAddr("recipient");
    CooldownToken gate;
    CooldownToken imd;
    CooldownToken token;
    CooldownIntake intake;
    Weir weir;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.roll(500);
        gate = new CooldownToken();
        imd = new CooldownToken();
        token = new CooldownToken();
        intake = new CooldownIntake();
        weir = new Weir(gate, imd, intake, vm.addr(KEY), 7 days, 10_000e18);
        address[2] memory users = [client, recipient];
        for (uint256 i; i < 2; ++i) {
            gate.mint(users[i], 10_000e18);
            token.mint(users[i], 1e30);
            imd.mint(users[i], 1e30);
            vm.startPrank(users[i]);
            token.approve(address(weir), type(uint256).max);
            imd.approve(address(weir), type(uint256).max);
            vm.stopPrank();
        }
    }

    /// @dev The recipient's dispute puts the stream in Disputed, where the client can neither void nor refund.
    /// When the request fails (a refused body comes back in minutes), the same party re-disputes in the very
    /// next transaction and locks the client's unearned principal again, for 0.5 IMD per cycle or for free
    /// while the court fund has money. The second dispute by the same party must be refused until
    /// disputeTimeout has passed since its last dispute ended; the other party may still dispute at once.
    function test_sameParty_cannotRedisputeImmediatelyAfterFailure() public {
        vm.prank(client);
        uint256 id = weir.createStream(recipient, token, 1e6, 1_000e6, keccak256("terms"), "ipfs://terms", bytes32(0));
        vm.warp(vm.getBlockTimestamp() + 10);
        vm.prank(recipient);
        weir.dispute(id, "note");
        vm.prank(client);
        vm.expectRevert(abi.encodeWithSelector(Weir.WrongState.selector, Weir.State.Disputed));
        weir.void(id);
        assertTrue(intake.failRequest(weir.streams(id).requestId));
        assertEq(uint256(weir.streams(id).state), uint256(Weir.State.Active));

        // Same party, same block: must be refused on a fixed contract (CooldownActive). Succeeds today.
        vm.prank(recipient);
        vm.expectRevert();
        weir.dispute(id, "note");
        assertEq(uint256(weir.streams(id).state), uint256(Weir.State.Active));

        // The client is not on cooldown and may still act, including disputing.
        vm.prank(client);
        weir.dispute(id, "client's own dispute");
        assertEq(uint256(weir.streams(id).state), uint256(Weir.State.Disputed));
    }
}