# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-discovery-invariants-prevent-price-oracle-manipulation-in-agent-to-agent-trades.md
# Remnant Warrant:    https://corpusfetch.com/c/what-discovery-invariants-prevent-price-oracle-manipulation-in-agent-to-agent-trades.warrant.json
# Markdown SHA-256:   d72b896bade1f673a7b62113acdaddd65af6a370a10e3dc638eee9ccb5cb6e98
# Code AST SHA-256:   102d3104825e94ad8278bbd63dfd9a8784cff4facbed4c8719412ca7bad54d44
# Verified Classes:   OracleVerdict, OraclePrice, OraclePolicy, OracleManifest, PriceOracleGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class OracleVerdict(Enum):
    PRICE_TRUSTED = auto()
    SINGLE_SOURCE_RISK = auto()
    DEVIATION_EXCEEDED = auto()
    STALE_PRICE = auto()

@dataclass(frozen=True)
class OraclePrice:
    source_id: str
    price: float
    timestamp_epoch: float
    liquidity_depth_score: float

@dataclass(frozen=True)
class OraclePolicy:
    min_independent_sources: int
    max_deviation_pct: float
    max_staleness_sec: float
    current_epoch: float

@dataclass(frozen=True)
class OracleManifest:
    verdict: OracleVerdict
    directive: str
    manifest_digest: str

class PriceOracleGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_prices(
        cls, prices: tuple[OraclePrice, ...], policy: OraclePolicy
    ) -> OracleManifest:
        
        # Gate 1: Sufficient independent sources
        if len(prices) < policy.min_independent_sources:
            return OracleManifest(
                verdict=OracleVerdict.SINGLE_SOURCE_RISK,
                directive=f"HALT: {len(prices)} sources < minimum {policy.min_independent_sources}.",
                manifest_digest=cls._hash(f"INSUFFICIENT:{len(prices)}")
            )

        # Gate 2: Freshness
        for p in prices:
            age = policy.current_epoch - p.timestamp_epoch
            if age > policy.max_staleness_sec:
                return OracleManifest(
                    verdict=OracleVerdict.STALE_PRICE,
                    directive=f"HALT: Source {p.source_id} is {age:.0f}s stale.",
                    manifest_digest=cls._hash(f"STALE:{p.source_id}")
                )

        # Gate 3: Deviation
        price_values = [p.price for p in prices]
        mean_price = sum(price_values) / len(price_values)
        for p in prices:
            deviation_pct = abs(p.price - mean_price) / mean_price * 100
            if deviation_pct > policy.max_deviation_pct:
                return OracleManifest(
                    verdict=OracleVerdict.DEVIATION_EXCEEDED,
                    directive=f"HALT: Source {p.source_id} deviates {deviation_pct:.2f}% > {policy.max_deviation_pct:.2f}%.",
                    manifest_digest=cls._hash(f"DEVIATION:{p.source_id}")
                )

        # Gate 4: Trusted
        digest = cls._hash(json.dumps({
            "sources": tuple(sorted(p.source_id for p in prices)),
            "mean": f"{mean_price:.6f}",
            "sources_count": str(len(prices))
        }, sort_keys=True))
        
        return OracleManifest(
            verdict=OracleVerdict.PRICE_TRUSTED,
            directive=f"PROCEED: {len(prices)} sources agree within {policy.max_deviation_pct:.2f}%.",
            manifest_digest=digest
        )