ssi-data-integrity 0.4.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
126
127
128
129
130
131
132
133
134
135
136
137
138

use std::borrow::Cow;

use ssi_claims_core::MessageSignatureError;
use ssi_verification_methods::{protocol, SignatureProtocol};

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum AnyProtocol {
    None,
    Base58Btc,
    Base58BtcMultibase,
    EthereumWallet,
    #[cfg(feature = "tezos")]
    TezosWallet,
}

impl SignatureProtocol<ssi_crypto::Algorithm> for AnyProtocol {
    fn prepare_message<'b>(&self, bytes: &'b [u8]) -> Cow<'b, [u8]> {
        match self {
            Self::None => SignatureProtocol::<ssi_jwk::Algorithm>::prepare_message(&(), bytes),
            Self::Base58Btc => SignatureProtocol::<ssi_jwk::Algorithm>::prepare_message(
                &protocol::Base58Btc,
                bytes,
            ),
            Self::Base58BtcMultibase => SignatureProtocol::<ssi_jwk::Algorithm>::prepare_message(
                &protocol::Base58BtcMultibase,
                bytes,
            ),
            Self::EthereumWallet => SignatureProtocol::<ssi_jwk::Algorithm>::prepare_message(
                &protocol::EthereumWallet,
                bytes,
            ),
            #[cfg(feature = "tezos")]
            Self::TezosWallet => {
                SignatureProtocol::<ssi_crypto::algorithm::AnyBlake2b>::prepare_message(
                    &ssi_data_integrity_suites::tezos::TezosWallet,
                    bytes,
                )
            }
        }
    }

    fn encode_signature(
        &self,
        algorithm: ssi_crypto::Algorithm,
        signature: Vec<u8>,
    ) -> Result<Vec<u8>, MessageSignatureError> {
        match self {
            Self::None => SignatureProtocol::<ssi_crypto::Algorithm>::encode_signature(
                &(),
                algorithm,
                signature,
            ),
            Self::Base58Btc => SignatureProtocol::<ssi_crypto::Algorithm>::encode_signature(
                &protocol::Base58Btc,
                algorithm,
                signature,
            ),
            Self::Base58BtcMultibase => {
                SignatureProtocol::<ssi_crypto::Algorithm>::encode_signature(
                    &protocol::Base58BtcMultibase,
                    algorithm,
                    signature,
                )
            }
            Self::EthereumWallet => SignatureProtocol::<ssi_crypto::Algorithm>::encode_signature(
                &protocol::EthereumWallet,
                algorithm,
                signature,
            ),
            #[cfg(feature = "tezos")]
            Self::TezosWallet => {
                let algorithm: ssi_crypto::algorithm::AnyBlake2b = algorithm.try_into()?;
                ssi_data_integrity_suites::tezos::TezosWallet.encode_signature(algorithm, signature)
            }
        }
    }

    fn decode_signature<'s>(
        &self,
        encoded_signature: &'s [u8],
    ) -> Result<Cow<'s, [u8]>, protocol::InvalidProtocolSignature> {
        match self {
            Self::None => {
                SignatureProtocol::<ssi_jwk::Algorithm>::decode_signature(&(), encoded_signature)
            }
            Self::Base58Btc => SignatureProtocol::<ssi_jwk::Algorithm>::decode_signature(
                &protocol::Base58Btc,
                encoded_signature,
            ),
            Self::Base58BtcMultibase => SignatureProtocol::<ssi_jwk::Algorithm>::decode_signature(
                &protocol::Base58BtcMultibase,
                encoded_signature,
            ),
            Self::EthereumWallet => SignatureProtocol::<ssi_jwk::Algorithm>::decode_signature(
                &protocol::EthereumWallet,
                encoded_signature,
            ),
            #[cfg(feature = "tezos")]
            Self::TezosWallet => {
                SignatureProtocol::<ssi_crypto::algorithm::AnyBlake2b>::decode_signature(
                    &ssi_data_integrity_suites::tezos::TezosWallet,
                    encoded_signature,
                )
            }
        }
    }
}

impl From<()> for AnyProtocol {
    fn from(_value: ()) -> Self {
        Self::None
    }
}

impl From<protocol::Base58Btc> for AnyProtocol {
    fn from(_value: protocol::Base58Btc) -> Self {
        Self::Base58Btc
    }
}

impl From<protocol::Base58BtcMultibase> for AnyProtocol {
    fn from(_value: protocol::Base58BtcMultibase) -> Self {
        Self::Base58BtcMultibase
    }
}

impl From<protocol::EthereumWallet> for AnyProtocol {
    fn from(_value: protocol::EthereumWallet) -> Self {
        Self::EthereumWallet
    }
}

#[cfg(feature = "tezos")]
impl From<ssi_data_integrity_suites::tezos::TezosWallet> for AnyProtocol {
    fn from(_value: ssi_data_integrity_suites::tezos::TezosWallet) -> Self {
        Self::TezosWallet
    }
}