Function bodies 7 total

def prove_command(
    input_path: str,
    output_path: str,
    log_path: str | None,
    proof_out_path: str,
    store_path: str,
) -> None:
    """Generate a verifiable proof for a computation."""
    input_data = json.loads(Path(input_path).read_text())
    output_data = json.loads(Path(output_path).read_text())
    computation_log = (
        Path(log_path).read_text() if log_path else ""
    )

    generator = ProofGenerator()
    proof = generator.generate_proof(
        input_data=input_data,
        output_data=output_data,
        computation_log=computation_log,
        metadata={"input_file": input_path, "output_file": output_path},
    )

    # Save proof JSON
    Path(proof_out_path).write_text(
        proof.model_dump_json(indent=2), encoding="utf-8"
    )

    # Persist to store
    store = ProofStore()
    _load_proof_store(store, store_path)
    store.save(proof)
    _save_proof_store(store, store_path)

    click.echo(f"Proof generated: {proof.proof_id}")
    clic

def verify_command(
    proof_path: str,
    input_path: str,
    output_path: str,
    log_path: str | None,
) -> None:
    """Verify a proof against original input/output data."""
    proof = ComputationProof.model_validate(
        json.loads(Path(proof_path).read_text())
    )
    input_data = json.loads(Path(input_path).read_text())
    output_data = json.loads(Path(output_path).read_text())
    computation_log = (
        Path(log_path).read_text() if log_path else ""
    )

    verifier = ProofVerifier()
    result = verifier.verify(
        proof=proof,
        input_data=input_data,
        output_data=output_data,
        computation_log=computation_log,
    )

    if result.valid:
        click.echo(f"VALID   Proof {proof.proof_id}")
        click.echo(f"        {result.details}")
    else:
        click.echo(f"INVALID Proof {proof.proof_id}", err=True)
        click.echo(result.details, err=True)
        sys.exit(1)

def list_command(store_path: str) -> None:
    """List all proofs in the store."""
    store = ProofStore()
    _load_proof_store(store, store_path)
    proofs = store.list_proofs()
    if not proofs:
        click.echo("No proofs found.")
        return
    for proof in proofs:
        click.echo(
            f"{proof.proof_id}  {proof.timestamp.isoformat()[:19]}  "
            f"chain={proof.chain_hash[:16]}..."
        )

def _canonical_json(data: dict[str, Any]) -> bytes:
    """
    Produce a deterministic JSON byte-string for *data*.

    Keys are sorted; non-ASCII characters are preserved.
    """
    return json.dumps(data, sort_keys=True, ensure_ascii=False).encode("utf-8")

    def generate_proof(
        self,
        input_data: dict[str, Any],
        output_data: dict[str, Any],
        computation_log: str,
        metadata: dict[str, Any] | None = None,
    ) -> ComputationProof:
        """
        Generate a verifiable proof for a computation.

        Args:
            input_data: The input payload (will be canonicalized).
            output_data: The output payload (will be canonicalized).
            computation_log: Free-text log of the computation steps.
            metadata: Optional key-value annotations stored in the proof.

        Returns:
            A ``ComputationProof`` with SHA-256 hashes and a chain hash.
        """
        input_hash = _sha256(_canonical_json(input_data))
        output_hash = _sha256(_canonical_json(output_data))
        computation_hash = _sha256(computation_log.encode("utf-8"))

        # Chain: bind all three hashes together
        chain_input = (input_hash + output_hash + computation_hash).encode(
         

    def verify(
        self,
        proof: ComputationProof,
        input_data: dict[str, Any],
        output_data: dict[str, Any],
        computation_log: str = "",
    ) -> VerificationResult:
        """
        Recompute the expected hashes and compare against the stored proof.

        Returns a ``VerificationResult`` with ``valid=True`` only when all
        hashes match exactly.
        """
        expected_input_hash = _sha256(_canonical_json(input_data))
        expected_output_hash = _sha256(_canonical_json(output_data))
        expected_computation_hash = _sha256(
            computation_log.encode("utf-8")
        )
        expected_chain_hash = _sha256(
            (
                expected_input_hash
                + expected_output_hash
                + expected_computation_hash
            ).encode("ascii")
        )

        failures: list[str] = []
        if proof.input_hash != expected_input_hash:
            failures.append(
                f"input_hash mis

    def get(self, proof_id: str) -> ComputationProof:
        """Retrieve a proof by ID."""
        proof = self._proofs.get(proof_id)
        if proof is None:
            raise KeyError(f"No proof found with id {proof_id!r}.")
        return proof