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

import {Test} from "forge-std/Test.sol";
interface IERC20Like { function transferFrom(address from, address to, uint256 amount) external returns (bool); }
import {PlantOrganism} from "src/PlantOrganism.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

contract ProofToken2 {
    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;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[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;
        return true;
    }
}

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

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

contract ProofIntake2 is IIntake {
    uint256 public sequence;
    bytes32 public lastId;
    Callback public callback;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return 0.5 ether;
    }

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

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

/// @notice The heartbeat caller fixes the day's only move candidate. Parking into an empty cell,
/// asking, and unparking in one transaction points the candidate at a cell with no stake, so the
/// holders' real candidate (above 5% of supply and above the location) is never read that day.
contract SnapshotEmptyCellTest is Test {
    uint256 internal constant KEY = 0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d;
    uint32 internal constant LISBON = 10223579;
    uint32 internal constant PORTO = (164 << 16) | uint32(uint16(int16(-35)));
    uint32 internal constant DECOY = (100 << 16) | uint32(uint16(int16(-20)));
    uint32 internal constant START = 20000;

    address internal alice = address(0xa11ce);
    address internal bob = address(0xb0b);
    address internal mallory = address(0xbad);
    address internal lender = address(0x9001);

    ProofToken2 internal imd;
    ProofToken2 internal plant;
    ProofIntake2 internal intake;
    PlantOrganism internal organism;
    uint256 internal serial;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(uint256(START) * 1 days + 123);
        imd = new ProofToken2();
        plant = new ProofToken2();
        intake = new ProofIntake2();
        plant.mint(alice, 300 ether);
        plant.mint(bob, 300 ether);
        plant.mint(lender, 400 ether);
        organism = new PlantOrganism(
            address(imd), address(intake), bytes32("oracle.request@oracle-1"), vm.addr(KEY), LISBON, address(this)
        );
        organism.bind(address(new ProofHook2(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(mallory);
        plant.approve(address(organism), type(uint256).max);
    }

    function _nextEnded() internal {
        uint256 time = uint256(organism.lastSettledDay() + 2) * 1 days;
        if (vm.getBlockTimestamp() < time) vm.warp(time);
    }

    function _deliver() internal {
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("uuid", ++serial));
        a.chainId = 4663;
        a.questionHash = keccak256("doc");
        a.answerType = 2;
        a.answer = abi.encode(bytes32(uint256(1) | (uint256(1) << 48) | (uint256(organism.lastSettledDay() + 1) << 96)));
        a.panelJobId = keccak256("panel");
        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));
        assertTrue(intake.deliver(intake.lastId(), a, abi.encodePacked(r, s, v)), "callback failed");
    }

    function test_emptyCellSnapshotBlocksTheHoldersMove() public {
        vm.prank(alice);
        organism.park(LISBON, 100 ether);
        _nextEnded();
        organism.settle(); // birth: Lisbon
        assertEq(organism.location(), LISBON);

        // Bob wants Porto: 200 parked there, above Lisbon's 100 and above 5% of the 1000 supply.
        vm.prank(bob);
        organism.park(PORTO, 200 ether);
        assertEq(organism.challenger(), PORTO);

        // Day ends. In one transaction mallory borrows 201 PLANT, parks into a decoy cell (now the
        // challenger), asks the oracle (candidate snapshotted = DECOY), unparks and repays.
        _nextEnded();
        vm.prank(lender);
        plant.transfer(mallory, 201 ether);
        vm.startPrank(mallory);
        organism.park(DECOY, 201 ether);
        organism.heartbeat();
        organism.unpark(DECOY, 201 ether);
        plant.transfer(lender, 201 ether);
        vm.stopPrank();
        (, , uint32 snapshot,,,,,,) = organism.pending();
        assertEq(snapshot, DECOY);
        assertEq(organism.parkedTotal(DECOY), 0);

        // Anyone repairs the live challenger, but the day's READ only looks at the snapshot.
        organism.challenge(PORTO);
        assertEq(organism.challenger(), PORTO);

        _deliver();
        organism.settle();
        // Expected: Porto (200 > 100, >= 50). Actual: Lisbon; the day's vote was spent on an empty cell.
        assertEq(organism.location(), PORTO, "holders' candidate was never read");
    }
}

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

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

contract FMToken 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;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[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;
        return true;
    }
}

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

    constructor(address o, address p) {
        organism = o;
        plant = p;
    }
}

contract FMIntake is IIntake {
    uint256 public sequence;
    bytes32 public lastId;
    Callback public callback;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return 0.5 ether;
    }

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

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

/// @dev Stands in for a flash borrower: the PLANT that casts the vote is parked and unparked inside one call.
contract Relocator {
    PlantOrganism immutable organism;

    constructor(PlantOrganism o, IERC20 p) {
        organism = o;
        p.approve(address(o), type(uint256).max);
    }

    function dustPark(uint32 cell) external {
        organism.park(cell, 1);
    }

    function relocate(uint32 cell, uint256 amount) external {
        organism.park(cell, amount);
        organism.settle();
        organism.unpark(cell, amount);
    }

    function claim() external {
        organism.claim();
    }
}

contract FlashMoveTest is Test {
    uint256 constant KEY = 0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d;
    uint32 constant LISBON = 10223579;
    uint32 constant OTHER = (156 << 16) | 65500;
    uint32 constant START = 20000;
    address alice = address(0xa11ce);
    address keeper = address(0xbee);
    FMToken imd;
    FMToken plant;
    FMIntake intake;
    PlantOrganism organism;
    Relocator eve;
    uint256 serial;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(uint256(START) * 1 days + 123);
        imd = new FMToken();
        plant = new FMToken();
        intake = new FMIntake();
        organism = new PlantOrganism(
            address(imd), address(intake), bytes32("oracle.request@oracle-1"), vm.addr(KEY), LISBON, address(this)
        );
        plant.mint(alice, 900 ether);
        eve = new Relocator(organism, plant);
        plant.mint(address(eve), 100 ether + 1); // 1 wei of lasting stake plus capital used only inside relocate()
        organism.bind(address(new FMHook(address(organism), address(plant))));
        imd.mint(address(organism), 1000 ether);
        vm.prank(alice);
        plant.approve(address(organism), type(uint256).max);
        // Birth: alice is the only gardener, at Lisbon.
        vm.prank(alice);
        organism.park(LISBON, 100 ether);
        _nextEnded();
        organism.settle();
        assertEq(organism.location(), LISBON);
        // Eve's 1 wei at OTHER becomes the standing challenger and is reward-active one settle later.
        eve.dustPark(OTHER);
        assertEq(organism.challenger(), OTHER);
        _askAndDeliver(0);
        organism.settle(); // no move: 1 wei is below alice's 100 ether
        assertEq(organism.location(), LISBON);
    }

    function _nextEnded() internal {
        uint256 time = uint256(organism.lastSettledDay() + 2) * 1 days;
        if (vm.getBlockTimestamp() < time) vm.warp(time);
    }

    function _askAndDeliver(uint24 sun) internal {
        _nextEnded();
        vm.prank(keeper);
        bytes32 id = organism.heartbeat();
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("uuid", ++serial));
        a.chainId = 4663;
        a.answerType = 2;
        a.answer = abi.encode(bytes32(uint256(sun) | 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));
        assertTrue(intake.deliver(id, a, abi.encodePacked(r, s, v)));
    }

    /// Runs park -> settle -> unpark in one transaction. A fix may make that sequence revert or make the
    /// settle inside it not move the plant; either way the plant must still be at Lisbon afterwards.
    function _attemptAtomicRelocation() internal {
        uint32 before = organism.lastSettledDay();
        try eve.relocate(OTHER, 100 ether) {} catch {}
        if (organism.lastSettledDay() == before) organism.settle();
    }

    /// The vote that moves the plant is cast and withdrawn inside one transaction.
    function test_atomicParkSettleUnparkMustNotMoveThePlant() public {
        _askAndDeliver(0); // the day's word is stored; settle() is open to anyone
        uint256 eveBefore = plant.balanceOf(address(eve));
        _attemptAtomicRelocation();
        assertEq(plant.balanceOf(address(eve)), eveBefore, "capital fully withdrawn");
        assertEq(organism.parkedTotal(OTHER), 1, "only the dust remains at OTHER");
        assertEq(organism.location(), LISBON, "plant moved by capital that left in the same transaction");
    }

    /// After the zero-commitment move, the next sunny day's whole gardener pool goes to 1 wei of PLANT and
    /// the only real gardener (alice, 100 ether) earns nothing.
    function test_nextPoolMustGoToTheRealGardenerNotTheDustStake() public {
        _askAndDeliver(0);
        _attemptAtomicRelocation();
        _askAndDeliver(0xffffff); // a sunny day
        organism.settle();
        eve.claim();
        vm.prank(alice);
        organism.claim();
        emit log_named_uint("IMD paid to the 1 wei stake", imd.balanceOf(address(eve)));
        emit log_named_uint("IMD paid to alice's 100 ether stake", imd.balanceOf(alice));
        assertEq(imd.balanceOf(address(eve)), 0, "dust stake captured the pool");
        assertGt(imd.balanceOf(alice), 0, "the committed gardener earned nothing");
    }
}

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

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

contract FMToken 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;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[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;
        return true;
    }
}

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

    constructor(address o, address p) {
        organism = o;
        plant = p;
    }
}

contract FMIntake is IIntake {
    uint256 public sequence;
    bytes32 public lastId;
    Callback public callback;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return 0.5 ether;
    }

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

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

/// @dev Stands in for a flash borrower: the PLANT that casts the vote is parked and unparked inside one call.
contract Relocator {
    PlantOrganism immutable organism;

    constructor(PlantOrganism o, IERC20 p) {
        organism = o;
        p.approve(address(o), type(uint256).max);
    }

    function dustPark(uint32 cell) external {
        organism.park(cell, 1);
    }

    function relocate(uint32 cell, uint256 amount) external {
        organism.park(cell, amount);
        organism.settle();
        organism.unpark(cell, amount);
    }

    function claim() external {
        organism.claim();
    }
}

contract FlashMoveTest is Test {
    uint256 constant KEY = 0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d;
    uint32 constant LISBON = 10223579;
    uint32 constant OTHER = (156 << 16) | 65500;
    uint32 constant START = 20000;
    address alice = address(0xa11ce);
    address keeper = address(0xbee);
    FMToken imd;
    FMToken plant;
    FMIntake intake;
    PlantOrganism organism;
    Relocator eve;
    uint256 serial;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(uint256(START) * 1 days + 123);
        imd = new FMToken();
        plant = new FMToken();
        intake = new FMIntake();
        organism = new PlantOrganism(
            address(imd), address(intake), bytes32("oracle.request@oracle-1"), vm.addr(KEY), LISBON, address(this)
        );
        plant.mint(alice, 900 ether);
        eve = new Relocator(organism, plant);
        plant.mint(address(eve), 100 ether + 1); // 1 wei of lasting stake plus capital used only inside relocate()
        organism.bind(address(new FMHook(address(organism), address(plant))));
        imd.mint(address(organism), 1000 ether);
        vm.prank(alice);
        plant.approve(address(organism), type(uint256).max);
        // Birth: alice is the only gardener, at Lisbon.
        vm.prank(alice);
        organism.park(LISBON, 100 ether);
        _nextEnded();
        organism.settle();
        assertEq(organism.location(), LISBON);
        // Eve's 1 wei at OTHER becomes the standing challenger and is reward-active one settle later.
        eve.dustPark(OTHER);
        assertEq(organism.challenger(), OTHER);
        _askAndDeliver(0);
        organism.settle(); // no move: 1 wei is below alice's 100 ether
        assertEq(organism.location(), LISBON);
    }

    function _nextEnded() internal {
        uint256 time = uint256(organism.lastSettledDay() + 2) * 1 days;
        if (vm.getBlockTimestamp() < time) vm.warp(time);
    }

    function _askAndDeliver(uint24 sun) internal {
        _nextEnded();
        vm.prank(keeper);
        bytes32 id = organism.heartbeat();
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("uuid", ++serial));
        a.chainId = 4663;
        a.answerType = 2;
        a.answer = abi.encode(bytes32(uint256(sun) | 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));
        assertTrue(intake.deliver(id, a, abi.encodePacked(r, s, v)));
    }

    /// Runs park -> settle -> unpark in one transaction. A fix may make that sequence revert or make the
    /// settle inside it not move the plant; either way the plant must still be at Lisbon afterwards.
    function _attemptAtomicRelocation() internal {
        uint32 before = organism.lastSettledDay();
        try eve.relocate(OTHER, 100 ether) {} catch {}
        if (organism.lastSettledDay() == before) organism.settle();
    }

    /// The vote that moves the plant is cast and withdrawn inside one transaction.
    function test_atomicParkSettleUnparkMustNotMoveThePlant() public {
        _askAndDeliver(0); // the day's word is stored; settle() is open to anyone
        uint256 eveBefore = plant.balanceOf(address(eve));
        _attemptAtomicRelocation();
        assertEq(plant.balanceOf(address(eve)), eveBefore, "capital fully withdrawn");
        assertEq(organism.parkedTotal(OTHER), 1, "only the dust remains at OTHER");
        assertEq(organism.location(), LISBON, "plant moved by capital that left in the same transaction");
    }

    /// After the zero-commitment move, the next sunny day's whole gardener pool goes to 1 wei of PLANT and
    /// the only real gardener (alice, 100 ether) earns nothing.
    function test_nextPoolMustGoToTheRealGardenerNotTheDustStake() public {
        _askAndDeliver(0);
        _attemptAtomicRelocation();
        _askAndDeliver(0xffffff); // a sunny day
        organism.settle();
        eve.claim();
        vm.prank(alice);
        organism.claim();
        emit log_named_uint("IMD paid to the 1 wei stake", imd.balanceOf(address(eve)));
        emit log_named_uint("IMD paid to alice's 100 ether stake", imd.balanceOf(alice));
        assertEq(imd.balanceOf(address(eve)), 0, "dust stake captured the pool");
        assertGt(imd.balanceOf(alice), 0, "the committed gardener earned nothing");
    }
}

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

import {Test} from "forge-std/Test.sol";
interface IERC20Like { function transferFrom(address from, address to, uint256 amount) external returns (bool); }
import {PlantOrganism} from "src/PlantOrganism.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

contract ProofToken2 {
    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;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[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;
        return true;
    }
}

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

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

contract ProofIntake2 is IIntake {
    uint256 public sequence;
    bytes32 public lastId;
    Callback public callback;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return 0.5 ether;
    }

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

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

/// @notice The heartbeat caller fixes the day's only move candidate. Parking into an empty cell,
/// asking, and unparking in one transaction points the candidate at a cell with no stake, so the
/// holders' real candidate (above 5% of supply and above the location) is never read that day.
contract SnapshotEmptyCellTest is Test {
    uint256 internal constant KEY = 0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d;
    uint32 internal constant LISBON = 10223579;
    uint32 internal constant PORTO = (164 << 16) | uint32(uint16(int16(-35)));
    uint32 internal constant DECOY = (100 << 16) | uint32(uint16(int16(-20)));
    uint32 internal constant START = 20000;

    address internal alice = address(0xa11ce);
    address internal bob = address(0xb0b);
    address internal mallory = address(0xbad);
    address internal lender = address(0x9001);

    ProofToken2 internal imd;
    ProofToken2 internal plant;
    ProofIntake2 internal intake;
    PlantOrganism internal organism;
    uint256 internal serial;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(uint256(START) * 1 days + 123);
        imd = new ProofToken2();
        plant = new ProofToken2();
        intake = new ProofIntake2();
        plant.mint(alice, 300 ether);
        plant.mint(bob, 300 ether);
        plant.mint(lender, 400 ether);
        organism = new PlantOrganism(
            address(imd), address(intake), bytes32("oracle.request@oracle-1"), vm.addr(KEY), LISBON, address(this)
        );
        organism.bind(address(new ProofHook2(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(mallory);
        plant.approve(address(organism), type(uint256).max);
    }

    function _nextEnded() internal {
        uint256 time = uint256(organism.lastSettledDay() + 2) * 1 days;
        if (vm.getBlockTimestamp() < time) vm.warp(time);
    }

    function _deliver() internal {
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("uuid", ++serial));
        a.chainId = 4663;
        a.questionHash = keccak256("doc");
        a.answerType = 2;
        a.answer = abi.encode(bytes32(uint256(1) | (uint256(1) << 48) | (uint256(organism.lastSettledDay() + 1) << 96)));
        a.panelJobId = keccak256("panel");
        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));
        assertTrue(intake.deliver(intake.lastId(), a, abi.encodePacked(r, s, v)), "callback failed");
    }

    function test_emptyCellSnapshotBlocksTheHoldersMove() public {
        vm.prank(alice);
        organism.park(LISBON, 100 ether);
        _nextEnded();
        organism.settle(); // birth: Lisbon
        assertEq(organism.location(), LISBON);

        // Bob wants Porto: 200 parked there, above Lisbon's 100 and above 5% of the 1000 supply.
        vm.prank(bob);
        organism.park(PORTO, 200 ether);
        assertEq(organism.challenger(), PORTO);

        // Day ends. In one transaction mallory borrows 201 PLANT, parks into a decoy cell (now the
        // challenger), asks the oracle (candidate snapshotted = DECOY), unparks and repays.
        _nextEnded();
        vm.prank(lender);
        plant.transfer(mallory, 201 ether);
        vm.startPrank(mallory);
        organism.park(DECOY, 201 ether);
        organism.heartbeat();
        organism.unpark(DECOY, 201 ether);
        plant.transfer(lender, 201 ether);
        vm.stopPrank();
        (, , uint32 snapshot,,,,,,) = organism.pending();
        assertEq(snapshot, DECOY);
        assertEq(organism.parkedTotal(DECOY), 0);

        // Anyone repairs the live challenger, but the day's READ only looks at the snapshot.
        organism.challenge(PORTO);
        assertEq(organism.challenger(), PORTO);

        _deliver();
        organism.settle();
        // Expected: Porto (200 > 100, >= 50). Actual: Lisbon; the day's vote was spent on an empty cell.
        assertEq(organism.location(), PORTO, "holders' candidate was never read");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PlantOrganism} from "src/PlantOrganism.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

interface IERC20Like {
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

contract ProofToken3 {
    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;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[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;
        return true;
    }
}

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

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

contract ProofIntake3 is IIntake {
    uint256 public sequence;
    bytes32 public lastId;
    Callback public callback;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return 0.5 ether;
    }

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

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

/// @notice The live-challenger fallback added in the revision is itself chosen by live parkedTotal
/// (_challenge), so the heartbeat decoy can be re-armed in the settle transaction: park into the
/// decoy again (live challenger == snapshot candidate again, so no fallback runs), settle, unpark.
/// The holders' candidate is never read, with PLANT held only inside two transactions.
contract ReDecoyTest is Test {
    uint256 internal constant KEY = 0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d;
    uint32 internal constant LISBON = 10223579;
    uint32 internal constant PORTO = (164 << 16) | uint32(uint16(int16(-35)));
    uint32 internal constant DECOY = (100 << 16) | uint32(uint16(int16(-20)));
    uint32 internal constant START = 20000;

    address internal alice = address(0xa11ce);
    address internal bob = address(0xb0b);
    address internal mallory = address(0xbad);
    address internal lender = address(0x9001);

    ProofToken3 internal imd;
    ProofToken3 internal plant;
    ProofIntake3 internal intake;
    PlantOrganism internal organism;
    uint256 internal serial;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(uint256(START) * 1 days + 123);
        imd = new ProofToken3();
        plant = new ProofToken3();
        intake = new ProofIntake3();
        plant.mint(alice, 300 ether);
        plant.mint(bob, 300 ether);
        plant.mint(lender, 400 ether);
        organism = new PlantOrganism(
            address(imd), address(intake), bytes32("oracle.request@oracle-1"), vm.addr(KEY), LISBON, address(this)
        );
        organism.bind(address(new ProofHook3(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(mallory);
        plant.approve(address(organism), type(uint256).max);
    }

    function _nextEnded() internal {
        uint256 time = uint256(organism.lastSettledDay() + 2) * 1 days;
        if (vm.getBlockTimestamp() < time) vm.warp(time);
    }

    function _deliver() internal {
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("uuid", ++serial));
        a.chainId = 4663;
        a.questionHash = keccak256("doc");
        a.answerType = 2;
        a.answer =
            abi.encode(bytes32(uint256(1) | (uint256(1) << 48) | (uint256(organism.lastSettledDay() + 1) << 96)));
        a.panelJobId = keccak256("panel");
        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));
        assertTrue(intake.deliver(intake.lastId(), a, abi.encodePacked(r, s, v)), "callback failed");
    }

    function test_reArmedDecoyAtSettleStillBlocksTheHoldersMove() public {
        vm.prank(alice);
        organism.park(LISBON, 100 ether);
        _nextEnded();
        organism.settle(); // birth: Lisbon
        assertEq(organism.location(), LISBON);

        // Bob wants Porto: 200 parked there, above Lisbon's 100 and above 5% of the 1000 supply.
        vm.prank(bob);
        organism.park(PORTO, 200 ether);
        assertEq(organism.challenger(), PORTO);

        // Day ends. Transaction 1: borrow 201 PLANT, park into DECOY, heartbeat, unpark, repay.
        _nextEnded();
        vm.prank(lender);
        plant.transfer(mallory, 201 ether);
        vm.startPrank(mallory);
        organism.park(DECOY, 201 ether);
        organism.heartbeat();
        organism.unpark(DECOY, 201 ether);
        plant.transfer(lender, 201 ether);
        vm.stopPrank();
        (,, uint32 snapshot,,,,,,) = organism.pending();
        assertEq(snapshot, DECOY);
        assertEq(organism.parkedTotal(DECOY), 0);
        assertEq(organism.votingStake(DECOY), 0);

        // Anyone repairs the live challenger; the revision's fallback would now read Porto.
        organism.challenge(PORTO);
        assertEq(organism.challenger(), PORTO);

        _deliver();

        // Transaction 2, once the word is stored: borrow again, re-arm a fresh decoy as the live
        // challenger (201 > 200, live balances), settle, unpark, repay. votingStake(decoy2) is 0
        // because its snapshot (taken by park) is 0, so the fallback READ fails; Porto is never evaluated.
        uint32 decoy2 = (101 << 16) | uint32(uint16(int16(-21)));
        vm.prank(lender);
        plant.transfer(mallory, 201 ether);
        vm.startPrank(mallory);
        organism.park(decoy2, 201 ether);
        assertEq(organism.challenger(), decoy2);
        assertEq(organism.votingStake(decoy2), 0);
        organism.settle();
        organism.unpark(decoy2, 201 ether);
        plant.transfer(lender, 201 ether);
        vm.stopPrank();

        assertEq(plant.balanceOf(mallory), 0, "mallory kept no PLANT");
        assertEq(organism.parkedTotal(decoy2), 0);
        assertEq(organism.votingStake(PORTO), 200 ether, "Porto's stake was there at heartbeat");
        // Expected: Porto (200 > 100, >= 50). Actual: Lisbon; the day's vote was spent on decoys twice.
        assertEq(organism.location(), PORTO, "holders' candidate was never read");
    }

}

// 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 Token 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;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[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;
        return true;
    }
}

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

    constructor(address o, address p) {
        organism = o;
        plant = p;
    }
}

contract Intake is IIntake {
    uint256 public sequence;
    bytes32 public lastId;
    Callback public callback;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return 0.5 ether;
    }

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

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

/// @dev Stands in for a flash borrower: borrows, parks, settles the birth day, unparks all but 1 wei, repays.
contract Visitor {
    PlantOrganism internal immutable organism;
    Token internal immutable plant;
    address internal immutable lender;

    constructor(PlantOrganism o, Token p, address l) {
        organism = o;
        plant = p;
        lender = l;
        plant.approve(address(o), type(uint256).max);
    }

    function flashBirth(uint32 cell, uint256 amount) external {
        plant.transferFrom(lender, address(this), amount);
        organism.park(cell, amount);
        organism.settle();
        organism.unpark(cell, amount - 1);
        plant.transfer(lender, amount - 1);
    }

    function claim() external {
        organism.claim();
    }
}

contract BirthFlashMoveTest is Test {
    uint256 internal constant KEY = 0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d;
    uint32 internal constant LISBON = 10223579;
    uint32 internal constant OTHER = (156 << 16) | 65500;
    uint32 internal constant START = 20000;
    bytes32 internal constant ACTION = bytes32("oracle.request@oracle-1");
    address internal alice = address(0xa11ce);
    address internal bob = address(0xb0b);
    address internal lender = address(0x1e4d);
    Token internal imd;
    Token internal plant;
    Intake internal intake;
    PlantOrganism internal organism;
    Visitor internal eve;
    uint256 internal serial;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(uint256(START) * 1 days + 123);
        imd = new Token();
        plant = new Token();
        intake = new Intake();
        plant.mint(alice, 100 ether);
        plant.mint(bob, 100 ether);
        plant.mint(lender, 800 ether);
        organism = new PlantOrganism(address(imd), address(intake), ACTION, vm.addr(KEY), LISBON, address(this));
        organism.bind(address(new Hook(address(organism), address(plant))));
        imd.mint(address(organism), 1000 ether);
        eve = new Visitor(organism, plant, lender);
        vm.prank(lender);
        plant.approve(address(eve), type(uint256).max);
        vm.prank(alice);
        plant.approve(address(organism), type(uint256).max);
        vm.prank(bob);
        plant.approve(address(organism), type(uint256).max);
        vm.prank(alice);
        organism.park(LISBON, 100 ether);
        vm.prank(bob);
        organism.park(LISBON, 100 ether);
        assertEq(organism.challenger(), LISBON);
    }

    function _flash() internal {
        vm.warp(uint256(START + 2) * 1 days);
        uint256 lenderBefore = plant.balanceOf(lender);
        eve.flashBirth(OTHER, 201 ether);
        assertEq(plant.balanceOf(lender), lenderBefore - 1, "lender repaid all but one wei");
        assertEq(organism.parkedTotal(OTHER), 1);
    }

    function _deliverSunny() internal {
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256(abi.encode("oracle uuid", ++serial));
        a.chainId = 4663;
        a.questionHash = keccak256("resolved");
        a.answerType = 2;
        a.answer = abi.encode(
            bytes32(uint256(0xffffff) | (uint256(1) << 48) | uint256(organism.lastSettledDay() + 1) << 96)
        );
        a.panelJobId = keccak256("panel");
        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));
        assertTrue(intake.deliver(intake.lastId(), a, abi.encodePacked(r, s, v)), "callback failed");
    }

    /// Expected: stake present only inside the settle transaction does not decide where the plant is born.
    function test_oneTransactionVisitorDecidesBirth() public {
        _flash();
        assertNotEq(organism.location(), OTHER, "a one-transaction visitor decided the birth location");
    }

    /// Expected: the first weather day's gardener pool goes to the holders who parked, not to the visitor's 1 wei.
    function test_oneTransactionVisitorTakesFirstDayPool() public {
        _flash();
        if (organism.location() != OTHER) return;
        vm.warp(uint256(START + 3) * 1 days);
        organism.heartbeat();
        _deliverSunny();
        organism.settle();
        uint256 before = imd.balanceOf(address(eve));
        eve.claim();
        vm.prank(alice);
        organism.claim();
        emit log_named_uint("visitor's 1 wei received", imd.balanceOf(address(eve)) - before);
        emit log_named_uint("alice's 100e18 received", imd.balanceOf(alice));
        assertEq(imd.balanceOf(address(eve)), before, "visitor's 1 wei captured the first-day gardener pool");
    }
}