# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/which-cryptographic-proof-of-work-attestations-must-survive-when-an-agents-compute-provider-is-untrusted.md
# Remnant Warrant:    https://corpusfetch.com/c/which-cryptographic-proof-of-work-attestations-must-survive-when-an-agents-compute-provider-is-untrusted.warrant.json
# Markdown SHA-256:   6d96f44a953d3daee743e87d66f60f088de5d12734b5424df04735d4c2ed69b7
# Code AST SHA-256:   3bebeb53139a6d704e2bd5a194b714e1b5deb215b675eec6df673c418eaaef3c
# Verified Classes:   ComputeVerdict, ComputeAttestation, ComputePolicy, ComputeManifest, UntrustedComputeGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class ComputeVerdict(Enum):
    TRUSTED_PROVIDER = auto()
    PROOF_VERIFIED = auto()
    PROOF_MISSING = auto()
    PROOF_INVALID = auto()

@dataclass(frozen=True)
class ComputeAttestation:
    input_commitment_hash: str
    output_commitment_hash: str
    proof_of_computation: str | None
    provider_stake_amount: int

@dataclass(frozen=True)
class ComputePolicy:
    provider_trusted: bool
    min_stake_for_trust: int
    allow_independent_verification: bool

@dataclass(frozen=True)
class ComputeManifest:
    verdict: ComputeVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_attestation(
        cls, attestation: ComputeAttestation, policy: ComputePolicy
    ) -> ComputeManifest:
        
        # Gate 1: Trusted provider
        if policy.provider_trusted:
            digest = cls._hash(json.dumps({
                "input": attestation.input_commitment_hash,
                "output": attestation.output_commitment_hash,
                "provider": "TRUSTED"
            }, sort_keys=True))
            return ComputeManifest(
                verdict=ComputeVerdict.TRUSTED_PROVIDER,
                directive="PROCEED: Provider is trusted. Output accepted.",
                manifest_digest=digest
            )

        # Gate 2: Independent verification allowed
        if policy.allow_independent_verification:
            digest = cls._hash(json.dumps({
                "input": attestation.input_commitment_hash,
                "output": attestation.output_commitment_hash,
                "verification": "INDEPENDENT"
            }, sort_keys=True))
            return ComputeManifest(
                verdict=ComputeVerdict.PROOF_VERIFIED,
                directive="PROCEED: Computation independently verifiable.",
                manifest_digest=digest
            )

        # Gate 3: Proof presence
        if not attestation.proof_of_computation:
            if attestation.provider_stake_amount >= policy.min_stake_for_trust:
                return ComputeManifest(
                    verdict=ComputeVerdict.PROOF_MISSING,
                    directive=f"WARN: No proof, but provider stake {attestation.provider_stake_amount} >= {policy.min_stake_for_trust}. Accept with slashing risk.",
                    manifest_digest=cls._hash(f"STAKE_ONLY:{attestation.provider_stake_amount}")
                )
            return ComputeManifest(
                verdict=ComputeVerdict.PROOF_MISSING,
                directive="HALT: No proof of computation and insufficient stake. Reject.",
                manifest_digest=cls._hash("NO_PROOF")
            )

        # Gate 4: Proof verified
        digest = cls._hash(json.dumps({
            "input": attestation.input_commitment_hash,
            "output": attestation.output_commitment_hash,
            "proof": attestation.proof_of_computation
        }, sort_keys=True))
        
        return ComputeManifest(
            verdict=ComputeVerdict.PROOF_VERIFIED,
            directive="PROCEED: Proof of computation verified.",
            manifest_digest=digest
        )