nym-credentials 1.20.4

Crate for using Nym's zknym credentials
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
139
140
141
142
143
144
145
146
147
148

// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
// SPDX-License-Identifier: Apache-2.0

use crate::ecash::bandwidth::serialiser::keys::EpochVerificationKey;
use crate::ecash::bandwidth::serialiser::signatures::{
    AggregatedCoinIndicesSignatures, AggregatedExpirationDateSignatures,
};
use crate::ecash::bandwidth::{
    issued::IssuedTicketBook,
    serialiser::{VersionSerialised, VersionedSerialise},
};
use crate::Error;
use serde::de::DeserializeOwned;
use serde::{Deserialize, Serialize};
use zeroize::{Zeroize, ZeroizeOnDrop};

pub struct DecodedImportableTicketBook {
    pub ticketbook: IssuedTicketBook,

    pub expiration_date_signatures: Option<AggregatedExpirationDateSignatures>,

    pub coin_index_signatures: Option<AggregatedCoinIndicesSignatures>,

    pub master_verification_key: Option<EpochVerificationKey>,
}

#[derive(Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
pub struct ImportableTicketBook {
    pub serialised_ticketbook: VersionSerialised<IssuedTicketBook>,

    #[zeroize(skip)]
    pub serialised_expiration_date_signatures:
        Option<VersionSerialised<AggregatedExpirationDateSignatures>>,

    #[zeroize(skip)]
    pub serialised_coin_index_signatures:
        Option<VersionSerialised<AggregatedCoinIndicesSignatures>>,

    #[zeroize(skip)]
    pub serialised_master_verification_key: Option<VersionSerialised<EpochVerificationKey>>,
}

impl From<IssuedTicketBook> for ImportableTicketBook {
    fn from(ticketbook: IssuedTicketBook) -> Self {
        ImportableTicketBook {
            serialised_ticketbook: ticketbook.pack(),
            serialised_expiration_date_signatures: None,
            serialised_coin_index_signatures: None,
            serialised_master_verification_key: None,
        }
    }
}

impl ImportableTicketBook {
    pub fn with_expiration_date_signatures(
        mut self,
        signatures: &AggregatedExpirationDateSignatures,
    ) -> Self {
        self.serialised_expiration_date_signatures = Some(signatures.pack());
        self
    }

    pub fn with_coin_index_signatures(
        mut self,
        signatures: &AggregatedCoinIndicesSignatures,
    ) -> Self {
        self.serialised_coin_index_signatures = Some(signatures.pack());
        self
    }

    pub fn with_master_verification_key(mut self, key: &EpochVerificationKey) -> Self {
        self.serialised_master_verification_key = Some(key.pack());
        self
    }

    pub fn with_maybe_expiration_date_signatures(
        self,
        signatures: &Option<AggregatedExpirationDateSignatures>,
    ) -> Self {
        if let Some(sigs) = signatures {
            self.with_expiration_date_signatures(sigs)
        } else {
            self
        }
    }

    pub fn with_maybe_coin_index_signatures(
        self,
        signatures: &Option<AggregatedCoinIndicesSignatures>,
    ) -> Self {
        if let Some(sigs) = signatures {
            self.with_coin_index_signatures(sigs)
        } else {
            self
        }
    }

    pub fn with_maybe_master_verification_key(self, key: &Option<EpochVerificationKey>) -> Self {
        if let Some(sigs) = key {
            self.with_master_verification_key(sigs)
        } else {
            self
        }
    }

    pub fn finalize_export(self) -> VersionSerialised<Self> {
        self.pack()
    }

    pub fn try_unpack_full(&self) -> Result<DecodedImportableTicketBook, Error> {
        Ok(DecodedImportableTicketBook {
            ticketbook: self.serialised_ticketbook.try_unpack()?,
            expiration_date_signatures: self
                .serialised_expiration_date_signatures
                .as_ref()
                .map(|sigs| sigs.try_unpack())
                .transpose()?,
            coin_index_signatures: self
                .serialised_coin_index_signatures
                .as_ref()
                .map(|sigs| sigs.try_unpack())
                .transpose()?,
            master_verification_key: self
                .serialised_master_verification_key
                .as_ref()
                .map(|key| key.try_unpack())
                .transpose()?,
        })
    }
}

impl VersionedSerialise for ImportableTicketBook {
    const CURRENT_SERIALISATION_REVISION: u8 = 1;

    fn try_unpack(b: &[u8], revision: impl Into<Option<u8>>) -> Result<Self, Error>
    where
        Self: DeserializeOwned,
    {
        let revision = revision
            .into()
            .unwrap_or(<Self as VersionedSerialise>::CURRENT_SERIALISATION_REVISION);

        match revision {
            1 => Self::try_unpack_current(b),
            _ => Err(Error::UnknownSerializationRevision { revision }),
        }
    }
}