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

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

contract ProofToken is IERC20 {
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
        totalSupply += amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        emit Transfer(msg.sender, to, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        emit Transfer(from, to, amount);
        return true;
    }
}

contract ProofHook {
    address public immutable organism;
    address public immutable plant;

    constructor(address organism_, address plant_) {
        organism = organism_;
        plant = plant_;
    }
}

/// @dev An intake that takes the fee and never answers.
contract SilentIntake is IIntake {
    uint256 public price = 0.5 ether;
    uint256 public sequence;

    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(msg.value == 0 && amount == price, "price");
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount), "pull");
        id = keccak256(abi.encode(address(this), ++sequence));
    }
}

/// @notice A request the oracle never answers is cleared after 24 hours; that clear must count as a strike
/// like an incomplete result, so three silent requests settle the day empty (with a READ) instead of
/// leaving `lastSettledDay` frozen until the 30-day death clock kills the plant.
contract SilentOracleProofTest is Test {
    PlantOrganism internal organism;
    ProofToken internal imd;
    ProofToken internal plant;
    SilentIntake internal intake;

    function _heartbeat() internal {
        // Tolerate the bounded-advance signature as well as the current one.
        (bool ok,) = address(organism).call(abi.encodeWithSignature("heartbeat(uint256)", type(uint256).max));
        if (!ok) (ok,) = address(organism).call(abi.encodeWithSignature("heartbeat()"));
        require(ok, "heartbeat failed");
    }

    function test_threeUnansweredRequestsSettleTheDayEmpty() public {
        vm.chainId(4663);
        vm.warp(uint256(20000) * 1 days + 123);
        imd = new ProofToken();
        plant = new ProofToken();
        intake = new SilentIntake();
        organism = new PlantOrganism(
            address(imd), address(intake), bytes32("oracle.request@oracle-1"), vm.addr(0xA11CE), 10223579, address(this)
        );
        plant.mint(address(this), 1000 ether);
        organism.bind(address(new ProofHook(address(organism), address(plant))));
        imd.mint(address(organism), 1000 ether);

        // Reach a located plant on the code as it is (three empty settles fall back to the fallback cell);
        // a plant that already has a location from deployment skips this loop.
        for (uint256 i; i < 3 && organism.location() == 0; ++i) {
            vm.warp(uint256(organism.lastSettledDay() + 2) * 1 days);
            organism.settle();
        }
        assertTrue(organism.location() != 0, "plant has no location");

        vm.warp(uint256(organism.lastSettledDay() + 2) * 1 days);
        uint32 silentDay = organism.lastSettledDay() + 1;
        for (uint256 i; i < 3; ++i) {
            _heartbeat();
            vm.warp(vm.getBlockTimestamp() + 1 days); // 24 h without an answer
            organism.clearPending();
            if (i < 2) vm.warp(organism.retryAt());
        }
        // If the implementation settles the day on the next explicit settle rather than inside the third clear,
        // give it that chance; on the code as it is this call reverts with NoResult.
        if (organism.lastSettledDay() == silentDay - 1) {
            (bool settled,) = address(organism).call(abi.encodeWithSignature("settle()"));
            settled;
        }

        assertFalse(organism.isDead(), "silent oracle must not be a death sentence within a few days");
        assertEq(organism.lastSettledDay(), silentDay, "three unanswered requests did not settle the day empty");
        assertEq(organism.water(), 50, "an empty day has no weather");
    }
}

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

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

contract ProofToken is IERC20 {
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
        totalSupply += amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        emit Transfer(msg.sender, to, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        emit Transfer(from, to, amount);
        return true;
    }
}

contract ProofHook {
    address public immutable organism;
    address public immutable plant;

    constructor(address organism_, address plant_) {
        organism = organism_;
        plant = plant_;
    }
}

contract ProofIntake is IIntake {
    uint256 public price = 0.5 ether;
    uint256 public sequence;
    bytes32 public lastId;
    Callback public callback;

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

    function request(bytes32, bytes calldata, Callback calldata cb, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(msg.value == 0 && amount == price, "price");
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount), "pull");
        callback = cb;
        id = keccak256(abi.encode(address(this), ++sequence));
        lastId = id;
    }

    function deliver(OracleAttestation.Attestation calldata a, bytes calldata sig) external returns (bool ok) {
        (ok,) = callback.target.call{gas: 200000}(abi.encodeWithSelector(callback.selector, lastId, a, sig));
    }
}

/// @notice The 5% relocation threshold must be measured against PLANT that can still vote, i.e.
/// `totalSupply() - burned`. On the code as it is `_read` uses `PLANT.totalSupply()`, so once 96% of the
/// supply has been redeemed the remaining 4% can never move the plant, even when it is 100% of what is left.
contract ThresholdProofTest is Test {
    uint256 internal constant KEY = 0xA11CE;
    uint32 internal constant OTHER = (156 << 16) | 65500;
    address internal alice = address(0xa11ce);
    address internal bob = address(0xb0b);
    address internal carol = address(0xca201);
    PlantOrganism internal organism;
    ProofToken internal imd;
    ProofToken internal plant;
    ProofIntake internal intake;
    uint256 internal serial;

    function _heartbeat() internal {
        (bool ok,) = address(organism).call(abi.encodeWithSignature("heartbeat(uint256)", type(uint256).max));
        if (!ok) (ok,) = address(organism).call(abi.encodeWithSignature("heartbeat()"));
        require(ok, "heartbeat failed");
    }

    /// @dev One complete, weatherless day: ask, deliver a signed `complete` word with empty masks, settle.
    function _emptyWeatherDay() internal {
        vm.warp(uint256(organism.lastSettledDay() + 2) * 1 days);
        _heartbeat();
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("threshold proof", ++serial));
        a.chainId = 4663;
        a.answerType = 2;
        a.answer = abi.encode(bytes32(uint256(1) << 48 | uint256(organism.lastSettledDay() + 1) << 96));
        a.panelSize = 15;
        a.quorum = 10;
        a.agreed = 12;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 1 days);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, organism.attestationDigest(a));
        require(intake.deliver(a, abi.encodePacked(r, s, v)), "delivery rejected");
        organism.settle();
    }

    function test_remainingSupplyCanStillMoveThePlantAfterRedemptions() public {
        vm.chainId(4663);
        vm.warp(uint256(20000) * 1 days + 123);
        imd = new ProofToken();
        plant = new ProofToken();
        intake = new ProofIntake();
        organism = new PlantOrganism(
            address(imd), address(intake), bytes32("oracle.request@oracle-1"), vm.addr(KEY), 10223579, address(this)
        );
        plant.mint(alice, 600 ether);
        plant.mint(bob, 300 ether);
        plant.mint(carol, 100 ether);
        organism.bind(address(new ProofHook(address(organism), address(plant))));
        imd.mint(address(organism), 1000 ether);
        vm.prank(alice);
        plant.approve(address(organism), type(uint256).max);
        vm.prank(bob);
        plant.approve(address(organism), type(uint256).max);
        vm.prank(carol);
        plant.approve(address(organism), type(uint256).max);

        // Reach a located plant on the code as it is (three empty settles fall back to the fallback cell);
        // a plant that already has a location from deployment skips this loop.
        for (uint256 i; i < 3 && organism.location() == 0; ++i) {
            vm.warp(uint256(organism.lastSettledDay() + 2) * 1 days);
            organism.settle();
        }
        uint32 home = organism.location();
        assertTrue(home != 0 && home != OTHER, "plant has no location");

        // 96% of the supply leaves for good; 40 PLANT is everything that can still vote.
        vm.prank(alice);
        organism.redeem(600 ether);
        vm.prank(bob);
        organism.redeem(300 ether);
        vm.prank(carol);
        organism.redeem(60 ether);
        assertEq(plant.totalSupply() - organism.burned(), 40 ether);

        vm.prank(carol);
        organism.park(OTHER, 40 ether);
        _emptyWeatherDay(); // the deposit is retained across one successful settle and now votes
        organism.challenge(OTHER);
        assertEq(organism.votingStake(OTHER), 40 ether);
        assertEq(organism.votingStake(home), 0);
        _emptyWeatherDay(); // READ: 40 of 40 remaining PLANT, against a current cell with no stake at all
        assertEq(organism.location(), OTHER, "100% of the remaining supply could not move the plant");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IERC1271} from "@openzeppelin/contracts/interfaces/IERC1271.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {PlantOrganism} from "src/PlantOrganism.sol";

/// @dev The protocol's documented rotation story: a registry that answers ERC-1271 for the keys it lists.
contract SignerRegistry is IERC1271 {
    mapping(address => bool) public listed;

    constructor(address key) {
        listed[key] = true;
    }

    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4) {
        (address recovered, ECDSA.RecoverError err,) = ECDSA.tryRecover(hash, signature);
        return err == ECDSA.RecoverError.NoError && listed[recovered] ? IERC1271.isValidSignature.selector : bytes4(0);
    }
}

contract ProofIntake {
    function priceOf(bytes32, address) external pure returns (uint256) {
        return 0;
    }
}

/// @notice The oracle signer may be an ERC-1271 contract. On the code as it is, the constructor refuses any
/// signer with code (`signer_.code.length != 0` -> InvalidConfiguration), so a launch whose signer is the
/// protocol's registry contract cannot deploy at all.
contract ContractSignerProofTest is Test {
    function test_constructorAcceptsAnErc1271SignerContract() public {
        vm.chainId(4663);
        vm.warp(uint256(20000) * 1 days + 123);
        SignerRegistry registry = new SignerRegistry(vm.addr(0xA11CE));
        address imd = address(new ProofIntake()); // any contract address works for the token argument here
        PlantOrganism organism = new PlantOrganism(
            imd, address(new ProofIntake()), bytes32("oracle.request@oracle-1"), address(registry), 10223579, address(this)
        );
        assertEq(organism.oracleSigner(), address(registry));
    }
}