uts-core 0.1.0-alpha.0

Core types and traits for Univeral Timestamps in Rust
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

use crate::{
    codec::v1::{Attestation, PendingAttestation, RawAttestation},
    error::DecodeError,
};

#[cfg(feature = "eas-verifier")]
mod eas;
#[cfg(feature = "eas-verifier")]
pub use eas::EASVerifier;

#[derive(Debug, thiserror::Error)]
pub enum VerifyError {
    /// The raw attestation lacks a value, so it cannot be verified.
    #[error("raw attestation lacks a value")]
    NoValue,
    /// The attestation is still pending and cannot be verified yet.
    #[error("attestation is still pending and cannot be verified yet")]
    Pending,
    /// The attestation is not the expected type
    /// (e.g. a Bitcoin attestation was expected but an Ethereum attestation was found).
    #[error("attestation is not the expected type")]
    BadAttestationTag,
    /// An error occurred while decoding the attestation.
    #[error("error decoding attestation: {0}")]
    Decode(DecodeError),
    /// An error occurred while verifying the eas attestation.
    #[cfg(feature = "eas-verifier")]
    #[error("error verifying eas attestation: {0}")]
    EAS(#[from] eas::EASVerifierError),
}

pub trait AttestationVerifier<P>
where
    P: for<'a> Attestation<'a> + Send,
    Self: Send + Sync,
{
    type Output;

    fn verify_raw(
        &self,
        raw: &RawAttestation,
    ) -> impl Future<Output = Result<Self::Output, VerifyError>> + Send {
        async {
            if raw.tag == PendingAttestation::TAG {
                return Err(VerifyError::Pending);
            }

            let Some(value) = raw.value.get() else {
                return Err(VerifyError::NoValue);
            };

            match P::from_raw(raw) {
                Ok(attestation) => self.verify(&attestation, value).await,
                Err(DecodeError::BadAttestationTag) => Err(VerifyError::BadAttestationTag),
                Err(e) => Err(VerifyError::Decode(e)),
            }
        }
    }

    fn verify(
        &self,
        attestation: &P,
        value: &[u8],
    ) -> impl Future<Output = Result<Self::Output, VerifyError>> + Send;
}