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

import {Test} from "forge-std/Test.sol";
import {SwarmFeed} from "src/SwarmFeed.sol";
import {PriceFeed} from "src/PriceFeed.sol";

contract ConsumerDomainProof is Test {
    uint256 private constant SIGNER_KEY = 0xA11CE;
    bytes32 private constant QUESTION = keccak256("window-1");

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_000_000);
    }

    function testConsumerBoundServiceSignatureMustBeAccepted() public {
        SwarmFeed feed = _deployFeed();
        SwarmFeed.OracleAttestation memory a = _attestation();
        bytes32 consumerDomain = keccak256(abi.encode(
            keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
            keccak256("IdentityMD Oracle"), keccak256("1"), block.chainid, address(feed)
        ));
        feed.submitAttestation(a, _sign(feed, a, consumerDomain));
        (uint256 value, uint64 timestamp) = feed.latestValue();
        assertEq(value, 1 ether);
        assertEq(timestamp, block.timestamp);
    }

    function testSignatureAcceptedByOneConsumerMustNotReplayOnAnother() public {
        SwarmFeed first = _deployFeed();
        SwarmFeed second = _deployFeed();
        SwarmFeed.OracleAttestation memory a = _attestation();
        bytes memory signature = _sign(first, a, first.DOMAIN_SEPARATOR());
        first.submitAttestation(a, signature);
        vm.expectRevert(SwarmFeed.InvalidSignature.selector);
        second.submitAttestation(a, signature);
    }

    function _deployFeed() private returns (SwarmFeed) {
        // Keep this proof runnable across the prescribed 8-to-10-argument constructor repair.
        // In the old ABI the two literal 1s become duplicate reporter addresses, so it rejects.
        bytes memory bytecode = abi.encodePacked(type(PriceFeed).creationCode, abi.encode(
            vm.addr(SIGNER_KEY), address(this), uint256(1), uint8(1),
            address(this), address(0), address(0), uint8(1), uint256(3600), uint256(2000)
        ));
        address deployed;
        assembly ("memory-safe") { deployed := create(0, add(bytecode, 32), mload(bytecode)) }
        if (deployed == address(0)) {
            bytecode = abi.encodePacked(type(PriceFeed).creationCode, abi.encode(
                vm.addr(SIGNER_KEY), QUESTION, address(this), address(0), address(0),
                uint8(1), uint256(3600), uint256(2000)
            ));
            assembly ("memory-safe") { deployed := create(0, add(bytecode, 32), mload(bytecode)) }
        }
        require(deployed != address(0), "feed deployment failed");
        return SwarmFeed(deployed);
    }

    function _attestation() private view returns (SwarmFeed.OracleAttestation memory a) {
        a.requestId = keccak256("request-1");
        a.chainId = 1;
        a.questionHash = QUESTION;
        a.answerType = 1;
        a.answer = abi.encode(uint256(1 ether));
        a.figure = 1 ether;
        a.fromBlock = 100;
        a.toBlock = 101;
        a.blockHash = keccak256("block-101");
        a.panelJobId = keccak256("panel-1");
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 3600);
    }

    function _sign(SwarmFeed feed, SwarmFeed.OracleAttestation memory a, bytes32 domain)
        private view returns (bytes memory)
    {
        bytes32 structHash = keccak256(abi.encode(
            feed.ATTESTATION_TYPEHASH(), a.requestId, a.chainId, a.questionHash, a.answerType,
            keccak256(a.answer), a.figure, a.fromBlock, a.toBlock, a.blockHash, a.panelJobId,
            a.issuedAt, a.expiresAt
        ));
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, keccak256(abi.encodePacked("\x19\x01", domain, structHash)));
        return abi.encodePacked(r, s, v);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {SwarmFeed} from "src/SwarmFeed.sol";
import {PriceFeed} from "src/PriceFeed.sol";

contract QuestionGateProof is Test {
    uint256 private constant SIGNER_KEY = 0xA11CE;
    bytes32 private constant QUESTION = keccak256("window-1");
    SwarmFeed private feed;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_000_000);
        feed = _deployFeed();
    }

    function testNextPinnedWindowMustBeAccepted() public {
        SwarmFeed.OracleAttestation memory a = _attestation();
        feed.submitAttestation(a, _sign(a));
        vm.warp(block.timestamp + 1);
        a.requestId = keccak256("request-2");
        a.questionHash = keccak256("window-2");
        a.fromBlock = 102;
        a.toBlock = 103;
        a.blockHash = keccak256("block-103");
        a.figure = 1.1 ether;
        a.answer = abi.encode(a.figure);
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 3600);
        feed.submitAttestation(a, _sign(a));
        (uint256 value, uint64 timestamp) = feed.latestValue();
        assertEq(value, 1.1 ether);
        assertEq(timestamp, block.timestamp);
    }

    function testNonzeroRelayerMustRejectAnUnauthorizedCaller() public {
        SwarmFeed.OracleAttestation memory a = _attestation();
        bytes memory signature = _sign(a);
        vm.expectRevert();
        vm.prank(address(0xBAD));
        feed.submitAttestation(a, signature);
    }

    function testConfiguredDataChainMustRejectAnotherChain() public {
        SwarmFeed.OracleAttestation memory a = _attestation();
        a.chainId = 11155111;
        bytes memory signature = _sign(a);
        vm.expectRevert();
        feed.submitAttestation(a, signature);
    }

    function testConfiguredAnswerTypeMustRejectAnotherType() public {
        SwarmFeed.OracleAttestation memory a = _attestation();
        a.answerType = 2;
        bytes memory signature = _sign(a);
        vm.expectRevert();
        feed.submitAttestation(a, signature);
    }

    function _deployFeed() private returns (SwarmFeed) {
        // New ABI first; the old ABI sees duplicate reporter addresses and rejects this encoding.
        bytes memory bytecode = abi.encodePacked(type(PriceFeed).creationCode, abi.encode(
            vm.addr(SIGNER_KEY), address(this), uint256(1), uint8(1),
            address(this), address(0), address(0), uint8(1), uint256(3600), uint256(2000)
        ));
        address deployed;
        assembly ("memory-safe") { deployed := create(0, add(bytecode, 32), mload(bytecode)) }
        if (deployed == address(0)) {
            bytecode = abi.encodePacked(type(PriceFeed).creationCode, abi.encode(
                vm.addr(SIGNER_KEY), QUESTION, address(this), address(0), address(0),
                uint8(1), uint256(3600), uint256(2000)
            ));
            assembly ("memory-safe") { deployed := create(0, add(bytecode, 32), mload(bytecode)) }
        }
        require(deployed != address(0), "feed deployment failed");
        return SwarmFeed(deployed);
    }

    function _attestation() private view returns (SwarmFeed.OracleAttestation memory a) {
        a.requestId = keccak256("request-1");
        a.chainId = 1;
        a.questionHash = QUESTION;
        a.answerType = 1;
        a.answer = abi.encode(uint256(1 ether));
        a.figure = 1 ether;
        a.fromBlock = 100;
        a.toBlock = 101;
        a.blockHash = keccak256("block-101");
        a.panelJobId = keccak256("panel-1");
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 3600);
    }

    function _sign(SwarmFeed.OracleAttestation memory a) private view returns (bytes memory) {
        bytes32 structHash = keccak256(abi.encode(
            feed.ATTESTATION_TYPEHASH(), a.requestId, a.chainId, a.questionHash, a.answerType,
            keccak256(a.answer), a.figure, a.fromBlock, a.toBlock, a.blockHash, a.panelJobId,
            a.issuedAt, a.expiresAt
        ));
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY,
            keccak256(abi.encodePacked("\x19\x01", feed.DOMAIN_SEPARATOR(), structHash)));
        return abi.encodePacked(r, s, v);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {CDPVault} from "src/CDPVault.sol";
import {MockIMD} from "src/MockIMD.sol";
import {CompToken} from "src/CompToken.sol";

contract SharedHalfPriceFeed {
    function latestValue() external view returns (uint256 value, uint64 updatedAt) {
        return (0.5 ether, uint64(block.timestamp));
    }

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

contract SharedFeedProof is Test {
    function testConstructorMustRejectSharedPriceAndNhiFeed() public {
        MockIMD imd = new MockIMD();
        CompToken comp = new CompToken(address(0));
        SharedHalfPriceFeed sharedFeed = new SharedHalfPriceFeed();
        vm.expectRevert(CDPVault.InvalidFeed.selector);
        new CDPVault(address(imd), address(comp), address(0), address(sharedFeed), address(sharedFeed));
    }
}

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

import {Test} from "forge-std/Test.sol";
import {SwarmFeed} from "src/SwarmFeed.sol";
import {PriceFeed} from "src/PriceFeed.sol";
import {NhiFeed} from "src/NhiFeed.sol";

contract AttestationDomainFindingTest is Test {
    uint256 private constant SIGNER_KEY = 0x12345;
    bytes32 private constant WINDOW = keccak256("pinned block window");
    SwarmFeed private price;
    SwarmFeed private nhi;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(10 days);
        price = _deploy("src/PriceFeed.sol:PriceFeed");
        nhi = _deploy("src/NhiFeed.sol:NhiFeed");
    }

    function test_PriceFeedAcceptsItsConsumerDomainSignature() public {
        _assertConsumerSignatureAccepted(price);
    }

    function test_NhiFeedAcceptsItsConsumerDomainSignature() public {
        _assertConsumerSignatureAccepted(nhi);
    }

    function test_SignatureAcceptedByPriceFeedCannotReplayOnNhiFeed() public {
        SwarmFeed.OracleAttestation memory a = _attestation();
        // Isolate replay from the separate consumer-domain acceptance test above.
        bytes memory signature = _sign(a, price.DOMAIN_SEPARATOR());
        price.submitAttestation(a, signature);
        assertTrue(price.usedRequests(a.requestId));
        vm.expectRevert(SwarmFeed.InvalidSignature.selector);
        nhi.submitAttestation(a, signature);
        assertFalse(nhi.usedRequests(a.requestId));
        assertTrue(nhi.isStale());
    }

    function _assertConsumerSignatureAccepted(SwarmFeed feed) private {
        bytes32 domain = keccak256(
            abi.encode(
                keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                keccak256("IdentityMD Oracle"), keccak256("1"), block.chainid, address(feed)
            )
        );
        SwarmFeed.OracleAttestation memory a = _attestation();
        feed.submitAttestation(a, _sign(a, domain));
        (uint256 value, uint64 updatedAt) = feed.latestValue();
        assertEq(value, a.figure);
        assertEq(updatedAt, a.issuedAt);
        assertTrue(feed.usedRequests(a.requestId));
    }

    function _deploy(string memory artifact) private returns (SwarmFeed) {
        bytes memory code = vm.getCode(artifact);
        // Try the approved constructor first, then the current legacy constructor. The proof
        // remains runnable when the policy fix replaces questionHash with three policy words.
        address deployed = _create(bytes.concat(code, abi.encode(
            vm.addr(SIGNER_KEY), address(0), uint256(1), uint8(1),
            address(this), address(0), address(0), uint8(1), uint256(1 hours), uint256(1000)
        )));
        if (deployed == address(0)) {
            deployed = _create(bytes.concat(code, abi.encode(
                vm.addr(SIGNER_KEY), WINDOW, address(this), address(0), address(0),
                uint8(1), uint256(1 hours), uint256(1000)
            )));
        }
        require(deployed != address(0), "feed fixture deployment failed");
        return SwarmFeed(deployed);
    }

    function _create(bytes memory code) private returns (address deployed) {
        assembly ("memory-safe") {
            deployed := create(0, add(code, 32), mload(code))
        }
    }

    function _attestation() private view returns (SwarmFeed.OracleAttestation memory a) {
        a.requestId = keccak256("request 1");
        a.chainId = 1;
        a.questionHash = WINDOW;
        a.answerType = 1;
        a.answer = abi.encode(uint256(1 ether));
        a.figure = 1 ether;
        a.fromBlock = 100;
        a.toBlock = 200;
        a.blockHash = keccak256("block");
        a.panelJobId = keccak256("panel");
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 1 hours);
    }

    function _sign(SwarmFeed.OracleAttestation memory a, bytes32 domain) private pure returns (bytes memory) {
        bytes32 body = keccak256(bytes.concat(
            abi.encode(
                keccak256("OracleAttestation(bytes32 requestId,uint256 chainId,bytes32 questionHash,uint8 answerType,bytes answer,uint256 figure,uint64 fromBlock,uint64 toBlock,bytes32 blockHash,bytes32 panelJobId,uint64 issuedAt,uint64 expiresAt)"),
                a.requestId, a.chainId, a.questionHash, a.answerType, keccak256(a.answer), a.figure
            ),
            abi.encode(a.fromBlock, a.toBlock, a.blockHash, a.panelJobId, a.issuedAt, a.expiresAt)
        ));
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, keccak256(abi.encodePacked("\x19\x01", domain, body)));
        return abi.encodePacked(r, s, v);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {SwarmFeed} from "src/SwarmFeed.sol";
import {PriceFeed} from "src/PriceFeed.sol";

contract AttestationPolicyFindingTest is Test {
    uint256 private constant SIGNER_KEY = 0x12345;
    bytes32 private constant WINDOW_ONE = keccak256("pinned window one");
    SwarmFeed private feed;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(10 days);
        bytes memory creationCode = vm.getCode("src/PriceFeed.sol:PriceFeed");
        address attester = vm.addr(SIGNER_KEY);
        // Try the approved constructor first. The legacy constructor rejects these words
        // because it reads the zero reporter slot as quorum. Retrying its old signature
        // keeps this proof executable both before and after the required interface change.
        address deployed = _create(bytes.concat(creationCode, abi.encode(
            attester, address(this), uint256(1), uint8(1), address(this),
            address(0), address(0), uint8(1), uint256(1 hours), uint256(1000)
        )));
        if (deployed == address(0)) {
            deployed = _create(bytes.concat(creationCode, abi.encode(
                attester, WINDOW_ONE, address(this), address(0), address(0),
                uint8(1), uint256(1 hours), uint256(1000)
            )));
        }
        require(deployed != address(0), "feed deployment failed");
        feed = SwarmFeed(deployed);
    }

    function test_successivePinnedWindowsMustBothBeAccepted() public {
        SwarmFeed.OracleAttestation memory a = _attestation();
        feed.submitAttestation(a, _sign(a));
        assertTrue(feed.usedRequests(a.requestId));
        vm.warp(block.timestamp + 1);
        a = _attestation();
        a.requestId = keccak256("request two");
        a.questionHash = keccak256("pinned window two");
        a.fromBlock = 201;
        a.toBlock = 300;
        a.figure = 1.05 ether;
        feed.submitAttestation(a, _sign(a));
        (uint256 value, uint64 updatedAt) = feed.latestValue();
        assertEq(value, a.figure);
        assertEq(updatedAt, a.issuedAt);
        assertTrue(feed.usedRequests(a.requestId));
    }

    function test_signedWrongPayloadChainMustBeRejected() public {
        SwarmFeed.OracleAttestation memory a = _attestation();
        a.chainId = 2;
        bytes memory signature = _sign(a);
        vm.expectRevert();
        feed.submitAttestation(a, signature);
        _assertUnchanged(a.requestId);
    }

    function test_signedWrongAnswerTypeMustBeRejected() public {
        SwarmFeed.OracleAttestation memory a = _attestation();
        a.answerType = 2;
        bytes memory signature = _sign(a);
        vm.expectRevert();
        feed.submitAttestation(a, signature);
        _assertUnchanged(a.requestId);
    }

    function test_unauthorizedRelayerMustNotSeedFeed() public {
        SwarmFeed.OracleAttestation memory a = _attestation();
        bytes memory signature = _sign(a);
        vm.prank(address(0xBAD));
        vm.expectRevert();
        feed.submitAttestation(a, signature);
        _assertUnchanged(a.requestId);
    }

    function _assertUnchanged(bytes32 requestId) private view {
        assertFalse(feed.usedRequests(requestId));
        assertTrue(feed.isStale());
        (uint256 value, uint64 updatedAt) = feed.latestValue();
        assertEq(value, 0);
        assertEq(updatedAt, 0);
        assertEq(feed.round(), 1);
    }

    function _create(bytes memory code) private returns (address deployed) {
        assembly ("memory-safe") {
            deployed := create(0, add(code, 32), mload(code))
        }
    }

    function _attestation() private view returns (SwarmFeed.OracleAttestation memory a) {
        a.requestId = keccak256("request one");
        a.chainId = 1;
        a.questionHash = WINDOW_ONE;
        a.answerType = 1;
        a.answer = bytes("one");
        a.figure = 1 ether;
        a.fromBlock = 100;
        a.toBlock = 200;
        a.blockHash = keccak256("block");
        a.panelJobId = keccak256("panel");
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 1 hours);
    }

    function _sign(SwarmFeed.OracleAttestation memory a) private view returns (bytes memory) {
        bytes32 body = keccak256(bytes.concat(
            abi.encode(
                feed.ATTESTATION_TYPEHASH(), a.requestId, a.chainId, a.questionHash,
                a.answerType, keccak256(a.answer), a.figure
            ),
            abi.encode(a.fromBlock, a.toBlock, a.blockHash, a.panelJobId, a.issuedAt, a.expiresAt)
        ));
        // Isolate the attestation policy from the separately reported domain defect.
        bytes32 digest = keccak256(abi.encodePacked("\x19\x01", feed.DOMAIN_SEPARATOR(), body));
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, digest);
        return abi.encodePacked(r, s, v);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {CDPVault} from "src/CDPVault.sol";
import {CompToken} from "src/CompToken.sol";
import {MockIMD} from "src/MockIMD.sol";
import {ISwarmFeed} from "src/interfaces/ISwarmFeed.sol";

contract SharedFeedFixture is ISwarmFeed {
    function latestValue() external view returns (uint256 value, uint64 updatedAt) {
        return (0.5e18, uint64(block.timestamp));
    }

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

    function maxAge() external pure returns (uint256) {
        return 86400;
    }
}

contract SharedFeedFindingTest is Test {
    function test_ConstructorRejectsSameFeedForPriceAndNhi() public {
        MockIMD imd = new MockIMD();
        CompToken comp = new CompToken(address(0));
        SharedFeedFixture sharedFeed = new SharedFeedFixture();

        // These immutable inputs must represent independent price and network-health channels.
        vm.expectRevert(CDPVault.InvalidFeed.selector);
        new CDPVault(address(imd), address(comp), address(0), address(sharedFeed), address(sharedFeed));
    }
}