inherence-verifier 0.1.0

Reference verifier for Inherence receipts (verification protocol v1).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

//! Failure codes (SPEC §8 controlled vocabulary).

use thiserror::Error;

#[derive(Debug, Error, Clone, PartialEq, Eq)]
pub enum VerifyError {
    #[error("schema_violation: {0}")]
    SchemaViolation(String),

    #[error("signature_invalid: {0}")]
    SignatureInvalid(String),

    #[error("wrong_signer")]
    WrongSigner,

    #[error("expired")]
    Expired,

    #[error("not_yet_valid")]
    NotYetValid,

    #[error("wrong_issuer: {0}")]
    WrongIssuer(String),

    #[error("wrong_audience: {0}")]
    WrongAudience(String),

    #[error("contract_hash_mismatch")]
    ContractHashMismatch,

    #[error("principal_signature_invalid:{0}")]
    PrincipalSignatureInvalid(&'static str), // "principal" | "agent"

    #[error("state_invalid: {0}")]
    StateInvalid(String),

    #[error("decision_bit_mismatch")]
    DecisionBitMismatch,

    #[error("unknown_vk: {0}")]
    UnknownVk(String),

    #[error("internal_inconsistency: {0}")]
    InternalInconsistency(String),

    #[error("proof_invalid: {0}")]
    ProofInvalid(String),
}

impl VerifyError {
    /// Returns the canonical SPEC §8 code string (without context).
    /// Used by fixture-replay tests that compare against
    /// `expected_verdict = "INVALID: <code>"`.
    pub fn code(&self) -> String {
        match self {
            VerifyError::SchemaViolation(_) => "schema_violation".into(),
            VerifyError::SignatureInvalid(_) => "signature_invalid".into(),
            VerifyError::WrongSigner => "wrong_signer".into(),
            VerifyError::Expired => "expired".into(),
            VerifyError::NotYetValid => "not_yet_valid".into(),
            VerifyError::WrongIssuer(_) => "wrong_issuer".into(),
            VerifyError::WrongAudience(_) => "wrong_audience".into(),
            VerifyError::ContractHashMismatch => "internal_inconsistency".into(),
            VerifyError::PrincipalSignatureInvalid(role) => format!("principal_signature_invalid:{}", role),
            VerifyError::StateInvalid(_) => "state_invalid".into(),
            VerifyError::DecisionBitMismatch => "decision_bit_mismatch".into(),
            VerifyError::UnknownVk(_) => "unknown_vk".into(),
            VerifyError::InternalInconsistency(_) => "internal_inconsistency".into(),
            VerifyError::ProofInvalid(_) => "proof_invalid".into(),
        }
    }
}