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

import {Test} from "forge-std/Test.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {ParameterizedVault} from "src/ParameterizedVault.sol";
import {ImdUSD} from "src/ImdUSD.sol";
import {MockIMD} from "src/MockIMD.sol";
import {TreasuryFactory} from "src/TreasuryFactory.sol";
import {ISwarmFeed} from "src/interfaces/ISwarmFeed.sol";
import {APPROVED_OPERATOR, CHAINLINK_ETH_USD, TREASURY_FACTORY} from "src/DeploymentConfig.sol";

contract DFeed is ISwarmFeed {
    uint256 public constant maxAge = 1 days;
    uint256 public value;

    constructor(uint256 v) {
        value = v;
    }

    function set(uint256 v) external {
        value = v;
    }

    function latestValue() external view returns (uint256, uint64) {
        return (value, uint64(block.timestamp));
    }

    function isStale() external pure returns (bool) {
        return false;
    }
}

contract DMirror is ISwarmFeed {
    ISwarmFeed private immutable p;

    constructor(ISwarmFeed p_) {
        p = p_;
    }

    function latestValue() external view returns (uint256, uint64) {
        return p.latestValue();
    }

    function isStale() external view returns (bool) {
        return p.isStale();
    }

    function maxAge() external view returns (uint256) {
        return p.maxAge();
    }
}

contract DAggregator {
    function decimals() external pure returns (uint8) {
        return 8;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, 2000e8, block.timestamp, block.timestamp, 1);
    }
}

/// @notice D1's REDEMPTION half needs no work minting, yet its fix (the lagged backing) is gated on
/// `wage() != 0` and so is off at launch (WAGE_WAD = 0). After a price fall leaves backing below par,
/// capital brought in ONE transaction earlier (same block, no interest, no price exposure) lifts
/// backingPerUnit to 1.0 and the next transaction redeems the Treasury's reserve at par.
/// Each top-level call below is its own transaction (isolate), so transient storage clears between them.
contract DormantRedemptionLagTest is Test {
    address private constant HONEST = address(0x40E);
    address private constant ATTACKER = address(0xBAD);
    MockIMD private imd;
    ParameterizedVault private vault;
    ImdUSD private stable;
    DFeed private primary;

    function setUp() public {
        if (TREASURY_FACTORY.code.length == 0) vm.etch(TREASURY_FACTORY, address(new TreasuryFactory()).code);
        vm.etch(CHAINLINK_ETH_USD, address(new DAggregator()).code);
        vm.warp(1_000_000);
        imd = new MockIMD();
        primary = new DFeed(uint256(1 ether) * 1e18 / 2000 ether); // $1 per IMD
        vault = new ParameterizedVault(
            address(imd), address(0), address(0), address(primary), address(new DFeed(0.85 ether)), address(new DMirror(primary))
        );
        stable = vault.stablecoin();
        assertEq(vault.parameters().wage(), 0, "launch configuration: lag dormant");
        vm.startPrank(APPROVED_OPERATOR);
        imd.mint(HONEST, 200 ether);
        imd.mint(ATTACKER, 1_000 ether);
        imd.mint(address(vault.treasury()), 10 ether); // the Treasury's reserve (liquidation cuts, dust)
        vm.stopPrank();
        vm.prank(HONEST);
        imd.approve(address(vault), type(uint256).max);
        vm.prank(ATTACKER);
        imd.approve(address(vault), type(uint256).max);
        vm.prank(HONEST);
        vault.lock(200 ether);
        vm.prank(HONEST);
        vault.draw(100 ether);
        vm.warp(block.timestamp + 1 days);
        vm.roll(block.number + 7_200);
        // IMD falls 70%; the honest position is underwater and not yet liquidated (grace).
        primary.set(uint256(0.3 ether) * 1e18 / 2000 ether);
    }

    /// forge-config: default.isolate = true
    function test_freshCapitalOneTransactionOldDoesNotLiftTheReservePayoutAtLaunch() public {
        uint256 before = vault.backingPerUnit();
        assertLt(before, 0.7e18, "backing is ~0.64 after the fall");

        // Transaction 1: real capital, in the same block.
        vm.prank(ATTACKER);
        vault.lock(1_000 ether);
        vm.prank(ATTACKER);
        vault.draw(100 ether);

        // Transaction 2, same block: redeem 3 imdUSD; the Treasury's reserve alone funds it.
        uint256 feeBps = vault.redemptionFeeBps(3 ether);
        uint256 reserveBefore = imd.balanceOf(address(vault.treasury()));
        vm.prank(ATTACKER);
        uint256 gemOut = vault.cash(3 ether, 0, address(0));
        assertEq(reserveBefore - imd.balanceOf(address(vault.treasury())), gemOut, "paid from the reserve");

        // What D1's fix promises: the payout scale is the backing that stood before this capital arrived.
        uint256 price = uint256(0.3 ether); // USD per IMD, as the vault reads it
        uint256 fair = Math.mulDiv(3 ether, Math.mulDiv(before, 10_000 - feeBps, 10_000), price);
        emit log_named_decimal_uint("reserve IMD paid", gemOut, 18);
        emit log_named_decimal_uint("at the pre-existing backing", fair, 18);
        assertLe(gemOut, fair + 1e9, "fresh capital must not let a redemption take the reserve at par");

        // Transaction 3: unwind. Only 3 imdUSD of the 100 drawn stays owed; the rest of the capital leaves.
        vm.prank(ATTACKER);
        vault.wipe(97 ether);
        vm.prank(ATTACKER);
        vault.free(950 ether);
    }
}

// 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 {OracleAsker} from "src/OracleAsker.sol";
import {SwarmFeed} from "src/SwarmFeed.sol";
import {SwarmRelay} from "src/SwarmRelay.sol";
import {MockIMD} from "src/MockIMD.sol";
import {IIntake} from "src/interfaces/IIntake.sol";
import {APPROVED_OPERATOR, ATTESTATION_RELAYER, INTAKE, ORACLE_ACTION} from "src/DeploymentConfig.sol";

/// @dev A feed bound to a question exactly the way PriceFeed/NhiFeed/SpotFeed are: a pinned prefix, the
/// signed window spliced in, NhiFeed's span bounds, relayed only through SwarmRelay, data chain 1.
contract BoundNhiFeed is SwarmFeed {
    constructor(address attester_) SwarmFeed(attester_, ATTESTATION_RELAYER, 1, 3, 1 days, 2_000) {}

    function questionPolicy() internal pure override returns (bytes memory, uint64, uint64) {
        return ('{"q":"network health","window":{"fromBlock":', 150, 1_200);
    }
}

/// @dev The Intake's request side: takes the price and records the body it was asked to answer.
contract RecordingIntake {
    mapping(bytes32 => bytes) public bodyOf;
    uint256 public nonce;

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

    function request(bytes32, bytes calldata body, IIntake.Callback calldata, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        IERC20(asset).transferFrom(msg.sender, address(this), amount);
        id = keccak256(abi.encode(++nonce));
        bodyOf[id] = body;
    }
}

/// @notice OracleAsker pins each feed's request body by hash for its whole life, and a request body
/// pins the question's block window (oracle/nhi-composite-quote.json: "window":{"fromBlock":26099000,
/// "toBlock":26100000}; the attester "signs windows the buyer pins", docs/AUDIT-ORACLE-2026-10-05.md).
/// A bound feed accepts a window only if toBlock advances and (F1) closed within maxAge/12 blocks. So
/// every Treasury-paid `ask` after the first buys an attestation the feed must refuse, and F4's
/// try/catch swallows the refusal: the keep-alive feed stays near-stale and is re-asked (and paid for)
/// every ASK_MIN_INTERVAL until the daily budget is gone.
contract AskerPinnedWindowTest is Test {
    uint256 private constant KEY = 0xA11CE;
    bytes private constant BODY = '{"q":"network health","window":{"fromBlock":26099000,"toBlock":26100000}}';
    MockIMD private imd;
    BoundNhiFeed private feed;
    OracleAsker private asker;

    function setUp() public {
        vm.chainId(1);
        vm.roll(26_100_050);
        vm.warp(1_791_000_000);
        vm.etch(ATTESTATION_RELAYER, address(new SwarmRelay()).code);
        vm.etch(INTAKE, address(new RecordingIntake()).code);
        imd = new MockIMD();
        feed = new BoundNhiFeed(vm.addr(KEY));
        address[] memory feeds = new address[](1);
        feeds[0] = address(feed);
        bytes32[] memory hashes = new bytes32[](1);
        hashes[0] = keccak256(BODY);
        bool[] memory tracks = new bool[](1);
        bool[] memory keepAlive = new bool[](1);
        keepAlive[0] = true; // NHI: the Treasury keeps it alive
        asker = new OracleAsker(IERC20(address(imd)), feeds, hashes, tracks, keepAlive);
        vm.prank(APPROVED_OPERATOR);
        imd.mint(address(asker), 10 ether); // one day's budget, as fundOracle tops it up
    }

    /// @dev The swarm answers the window written in the body it was sold.
    function _answer(bytes32 id, uint256 figure) private {
        bytes memory body = RecordingIntake(INTAKE).bodyOf(id);
        uint64 from = _number(body, '"fromBlock":');
        uint64 to = _number(body, '"toBlock":');
        SwarmFeed.OracleAttestation memory a = SwarmFeed.OracleAttestation({
            requestId: id,
            chainId: 1,
            questionHash: feed.expectedQuestionHash(from, to),
            answerType: 3,
            answer: abi.encode(figure),
            figure: figure,
            fromBlock: from,
            toBlock: to,
            blockHash: bytes32(0),
            panelJobId: bytes32(0),
            panelSize: 25,
            quorum: 15,
            agreed: 25,
            issuedAt: uint64(block.timestamp),
            expiresAt: uint64(block.timestamp + 1 hours)
        });
        bytes32 structHash = keccak256(
            bytes.concat(
                abi.encode(
                    feed.ATTESTATION_TYPEHASH(), a.requestId, a.chainId, a.questionHash, a.answerType,
                    keccak256(a.answer), a.figure, a.fromBlock
                ),
                abi.encode(a.toBlock, a.blockHash, a.panelJobId, a.panelSize, a.quorum, a.agreed, a.issuedAt, a.expiresAt)
            )
        );
        (uint8 v, bytes32 r, bytes32 s) =
            vm.sign(KEY, keccak256(abi.encodePacked("\x19\x01", feed.DOMAIN_SEPARATOR(), structHash)));
        vm.prank(INTAKE);
        asker.onOracleResult(id, a, abi.encodePacked(r, s, v));
    }

    function _number(bytes memory body, bytes memory key) private pure returns (uint64 n) {
        for (uint256 i; i + key.length <= body.length; ++i) {
            bool hit = true;
            for (uint256 j; j < key.length; ++j) {
                if (body[i + j] != key[j]) {
                    hit = false;
                    break;
                }
            }
            if (!hit) continue;
            for (uint256 k = i + key.length; k < body.length && body[k] >= "0" && body[k] <= "9"; ++k) {
                n = n * 10 + uint8(body[k]) - 48;
            }
            return n;
        }
    }

    function test_theTreasuryPaidAskerKeepsAKeepAliveFeedAlive() public {
        bytes32 first = asker.ask(address(feed), BODY);
        _answer(first, 0.9 ether);
        (uint256 value,) = feed.latestValue();
        assertEq(value, 0.9 ether, "the first purchase lands");

        // 20 hours later the feed is near stale (75% of maxAge) and the Treasury buys its next update.
        vm.warp(block.timestamp + 20 hours);
        vm.roll(block.number + 6_000);
        uint256 spentBefore = imd.balanceOf(address(asker));
        bytes32 second = asker.ask(address(feed), BODY);
        _answer(second, 0.88 ether);
        assertLt(imd.balanceOf(address(asker)), spentBefore, "the Treasury paid for it");
        (value,) = feed.latestValue();
        assertEq(value, 0.88 ether, "and the paid-for update reached the feed");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {ParameterizedVault} from "src/ParameterizedVault.sol";
import {ImdUSD} from "src/ImdUSD.sol";
import {MockIMD} from "src/MockIMD.sol";
import {MockWorkOracle} from "src/MockWorkOracle.sol";
import {TreasuryFactory} from "src/TreasuryFactory.sol";
import {ISwarmFeed} from "src/interfaces/ISwarmFeed.sol";
import {Parameters} from "src/Parameters.sol";
import {APPROVED_OPERATOR, CHAINLINK_ETH_USD, TREASURY_FACTORY} from "src/DeploymentConfig.sol";

contract WFeed is ISwarmFeed {
    uint256 public constant maxAge = 1 days;
    uint256 private value;

    constructor(uint256 v) {
        value = v;
    }

    function latestValue() external view returns (uint256, uint64) {
        return (value, uint64(block.timestamp));
    }

    function isStale() external pure returns (bool) {
        return false;
    }
}

contract WMirror is ISwarmFeed {
    ISwarmFeed private immutable p;

    constructor(ISwarmFeed p_) {
        p = p_;
    }

    function latestValue() external view returns (uint256, uint64) {
        return p.latestValue();
    }

    function isStale() external view returns (bool) {
        return p.isStale();
    }

    function maxAge() external view returns (uint256) {
        return p.maxAge();
    }
}

contract WAggregator {
    function decimals() external pure returns (uint8) {
        return 8;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, 2000e8, block.timestamp, block.timestamp, 1);
    }
}

/// @notice BACKING_WARMUP is documented as a LINEAR one-day warm-up ("an increase is credited linearly
/// over BACKING_WARMUP"; "Full credit costs real capital held ... for the whole warm-up"). `_approach`
/// instead closes elapsed/WARMUP of the REMAINING gap at every checkpoint, and every lock/draw/wipe by
/// anyone is a checkpoint. With any activity the credit is exponential (time constant one day): after a
/// full day held, 1000 imdUSD of debt is credited as ~640, not 1000.
contract LagWarmupTest is Test {
    address private constant WORKER = address(0xCA);
    address private constant POKER = address(0x90CE);
    MockIMD private imd;
    ParameterizedVault private vault;

    function setUp() public {
        if (TREASURY_FACTORY.code.length == 0) vm.etch(TREASURY_FACTORY, address(new TreasuryFactory()).code);
        vm.etch(CHAINLINK_ETH_USD, address(new WAggregator()).code);
        vm.warp(1_000_000);
        imd = new MockIMD();
        WFeed primary = new WFeed(uint256(1 ether) * 1e18 / 2000 ether); // $1 per IMD
        WFeed health = new WFeed(0.85 ether);
        vault = new ParameterizedVault(
            address(imd), address(0), address(0), address(primary), address(health), address(new WMirror(primary))
        );
        vm.startPrank(APPROVED_OPERATOR);
        imd.mint(WORKER, 2_000 ether);
        imd.mint(POKER, 1 ether);
        vm.stopPrank();
        vm.prank(WORKER);
        imd.approve(address(vault), type(uint256).max);
        vm.prank(POKER);
        imd.approve(address(vault), type(uint256).max);
        // Minting from work switched on through governance, as the runbook describes.
        Parameters params = vault.parameters();
        vm.prank(APPROVED_OPERATOR);
        params.proposeWage(0.01 ether);
        vm.warp(block.timestamp + params.TIMELOCK());
        params.applyPending();
    }

    function test_debtHeldForTheWholeWarmupIsCreditedInFullDespiteOtherActivity() public {
        vm.startPrank(WORKER);
        vault.lock(2_000 ether);
        vault.draw(1_000 ether);
        vm.stopPrank();
        // An unrelated account locks one wei every hour for the day (any lock/draw/wipe/bite/cash does the same).
        for (uint256 i; i < 24; ++i) {
            vm.warp(block.timestamp + 1 hours);
            vm.prank(POKER);
            vault.lock(1);
        }
        (uint256 lagDebt,) = vault.laggedNow();
        // Documented: held one full BACKING_WARMUP, the debt counts in full (earnLine 250, as in
        // test/LaggedBacking.t.sol's undisturbed case). Actual: ~1000 * (1 - (23/24)^24) = ~640.
        assertApproxEqAbs(lagDebt, 1_000 ether, 1 ether, "a day held is full credit");
        assertApproxEqAbs(vault.earnLine(), 250 ether, 0.5 ether, "a day held earns full credit");
    }
}

// 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 {ParameterizedVault} from "src/ParameterizedVault.sol";
import {MockIMD} from "src/MockIMD.sol";
import {TreasuryFactory} from "src/TreasuryFactory.sol";
import {Treasury} from "src/Treasury.sol";
import {ISwarmFeed} from "src/interfaces/ISwarmFeed.sol";
import {Parameters} from "src/Parameters.sol";
import {APPROVED_OPERATOR, CHAINLINK_ETH_USD, TREASURY_FACTORY} from "src/DeploymentConfig.sol";

contract SFeed is ISwarmFeed {
    uint256 public constant maxAge = 1 days;
    uint256 public value;

    constructor(uint256 v) {
        value = v;
    }

    function set(uint256 v) external {
        value = v;
    }

    function latestValue() external view returns (uint256, uint64) {
        return (value, uint64(block.timestamp));
    }

    function isStale() external pure returns (bool) {
        return false;
    }
}

contract SMirror is ISwarmFeed {
    ISwarmFeed private immutable p;

    constructor(ISwarmFeed p_) {
        p = p_;
    }

    function latestValue() external view returns (uint256, uint64) {
        return p.latestValue();
    }

    function isStale() external view returns (bool) {
        return p.isStale();
    }

    function maxAge() external view returns (uint256) {
        return p.maxAge();
    }
}

contract SAggregator {
    function decimals() external pure returns (uint8) {
        return 8;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, 2000e8, block.timestamp, block.timestamp, 1);
    }
}

contract SToken is ERC20 {
    constructor() ERC20("R", "R") {}

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

/// @notice F9 promised that a listed source answering an extreme value "counts for nothing" instead of
/// taking earnLine, backingPerUnit and cash down. The fix only guards the single product's overflow; a
/// value that FITS in 256 bits but sits near the top is still returned and then overflows the checked
/// additions that consume it (earnLine's `reserveValue() + ...`, `_redemptionReserveBacking`'s
/// `others + ...`, `_backingPerUnit`'s `backing += ...`).
contract ReserveSaturationTest is Test {
    address private constant BORROWER = address(0xBA);
    MockIMD private imd;
    ParameterizedVault private vault;
    SFeed private assetPrice;
    SToken private asset;

    function setUp() public {
        if (TREASURY_FACTORY.code.length == 0) vm.etch(TREASURY_FACTORY, address(new TreasuryFactory()).code);
        vm.etch(CHAINLINK_ETH_USD, address(new SAggregator()).code);
        vm.warp(1_000_000);
        imd = new MockIMD();
        SFeed primary = new SFeed(uint256(1 ether) * 1e18 / 2000 ether); // $1 per IMD
        vault = new ParameterizedVault(
            address(imd), address(0), address(0), address(primary), address(new SFeed(0.85 ether)), address(new SMirror(primary))
        );
        asset = new SToken();
        assetPrice = new SFeed(1 ether);
        Parameters params = vault.parameters();
        vm.prank(APPROVED_OPERATOR);
        params.proposeReserveAsset(IERC20(address(asset)), ISwarmFeed(address(assetPrice)), 10_000);
        vm.warp(block.timestamp + params.TIMELOCK());
        params.applyPending();
        asset.mint(address(vault.treasury()), 1 ether); // one whole token in the reserve
        vm.prank(APPROVED_OPERATOR);
        imd.mint(BORROWER, 2_000 ether);
        vm.startPrank(BORROWER);
        imd.approve(address(vault), type(uint256).max);
        vault.lock(2_000 ether);
        vault.draw(1_000 ether);
        vm.stopPrank();
        vm.warp(block.timestamp + 1);
    }

    function test_cashAlone() public {
        assetPrice.set(type(uint256).max);
        vm.prank(BORROWER);
        vault.cash(10 ether, 0, BORROWER);
    }

    function test_backingAlone() public {
        assetPrice.set(type(uint256).max);
        vault.backingPerUnit();
    }

    function test_anExtremeListedPriceStillRevertsTheConsumers() public {
        // The listed source starts answering an absurd but representable figure.
        assetPrice.set(type(uint256).max);
        Treasury treasury = vault.treasury();
        assertEq(treasury.reserveValueOf(IERC20(address(asset))), type(uint256).max, "returned, not treated as unpriced");
        // F9's promise: none of these revert because of a bad listed source.
        vault.earnLine();
        vault.backingPerUnit();
        vm.prank(BORROWER);
        vault.cash(10 ether, 0, BORROWER);
    }
}