ssi-data-integrity 0.3.0

Verifiable Credentials Data Model v1.1 for the `ssi` library.
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use serde::{Deserialize, Serialize};
use ssi_claims_core::ResolverProvider;
use ssi_core::JsonPointerBuf;
use ssi_data_integrity_core::{
    suite::{CryptographicSuiteSelect, SelectionError, SelectiveCryptographicSuite},
    DataIntegrity, ProofRef,
};
use ssi_json_ld::{Expandable, ExpandedDocument, JsonLdLoaderProvider, JsonLdNodeObject};
use ssi_rdf::LexicalInterpretation;
use ssi_verification_methods::{AnyMethod, VerificationMethodResolver};

use crate::AnySuite;

#[derive(Debug, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct AnySelectionOptions {
    pub selective_pointers: Vec<JsonPointerBuf>,
    pub presentation_header: Option<Vec<u8>>,
}

#[cfg(all(feature = "w3c", feature = "bbs"))]
impl From<AnySelectionOptions> for ssi_data_integrity_suites::bbs_2023::DeriveOptions {
    fn from(value: AnySelectionOptions) -> Self {
        Self {
            selective_pointers: value.selective_pointers,
            presentation_header: value.presentation_header,
            feature_option: Default::default(),
        }
    }
}

#[cfg(all(feature = "w3c", feature = "secp256r1"))]
impl From<AnySelectionOptions> for ssi_data_integrity_suites::ecdsa_sd_2023::DeriveOptions {
    fn from(value: AnySelectionOptions) -> Self {
        Self {
            selective_pointers: value.selective_pointers,
        }
    }
}

impl SelectiveCryptographicSuite for AnySuite {
    type SelectionOptions = AnySelectionOptions;
}

impl<T, P> CryptographicSuiteSelect<T, P> for AnySuite
where
    T: Serialize + JsonLdNodeObject + Expandable,
    T::Expanded<LexicalInterpretation, ()>: Into<ExpandedDocument>,
    P: JsonLdLoaderProvider + ResolverProvider,
    P::Resolver: VerificationMethodResolver<Method = AnyMethod>,
{
    #[allow(unused_variables)]
    async fn select(
        &self,
        unsecured_document: &T,
        proof: ProofRef<'_, Self>,
        params: P,
        options: Self::SelectionOptions,
    ) -> Result<DataIntegrity<ssi_json_ld::syntax::Object, Self>, SelectionError> {
        let params = crate::AnyVerifier {
            resolver: crate::AnyResolver::<_, ssi_verification_methods::Multikey>::new(
                params.resolver(),
            ),
            json_ld_loader: params.loader(),
            eip712_loader: (),
        };

        match self {
            #[cfg(all(feature = "w3c", feature = "secp256r1"))]
            Self::EcdsaSd2023 => {
                let DataIntegrity { claims, proofs } = ssi_data_integrity_suites::EcdsaSd2023
                    .select(
                        unsecured_document,
                        crate::Project::project_proof(proof),
                        params,
                        options.into(),
                    )
                    .await?;

                Ok(DataIntegrity {
                    claims,
                    proofs: proofs
                        .into_iter()
                        .map(|p| {
                            p.map_type(
                                |_| Self::EcdsaSd2023,
                                crate::AnySuiteVerificationMethod::EcdsaSd2023,
                                |_| crate::AnyProofOptions::EcdsaSd2023(()),
                                crate::AnySignature::EcdsaSd2023,
                            )
                        })
                        .collect(),
                })
            }
            #[cfg(all(feature = "w3c", feature = "bbs"))]
            Self::Bbs2023 => {
                let DataIntegrity { claims, proofs } = ssi_data_integrity_suites::Bbs2023
                    .select(
                        unsecured_document,
                        crate::Project::project_proof(proof),
                        params,
                        options.into(),
                    )
                    .await?;

                Ok(DataIntegrity {
                    claims,
                    proofs: proofs
                        .into_iter()
                        .map(|p| {
                            p.map_type(
                                |_| Self::Bbs2023,
                                crate::AnySuiteVerificationMethod::Bbs2023,
                                |_| crate::AnyProofOptions::Bbs2023(()),
                                crate::AnySignature::Bbs2023,
                            )
                        })
                        .collect(),
                })
            }
            _ => Err(SelectionError::NonSelectiveSuite),
        }
    }
}