massa_models/
endorsement.rs

1// Copyright (c) 2022 MASSA LABS <info@massa.net>
2
3use crate::block_id::{BlockIdDeserializer, BlockIdSerializer};
4use crate::prehash::PreHashed;
5use crate::secure_share::{Id, SecureShare, SecureShareContent};
6use crate::slot::{Slot, SlotDeserializer, SlotSerializer};
7use crate::{block_id::BlockId, error::ModelsError};
8use massa_hash::{Hash, HashDeserializer};
9use massa_serialization::{
10    DeserializeError, Deserializer, SerializeError, Serializer, U32VarIntDeserializer,
11    U32VarIntSerializer, U64VarIntDeserializer, U64VarIntSerializer,
12};
13use massa_signature::PublicKey;
14use nom::error::{context, ErrorKind};
15use nom::sequence::tuple;
16use nom::Parser;
17use nom::{
18    error::{ContextError, ParseError},
19    IResult,
20};
21use serde::{Deserialize, Serialize};
22use serde_with::{DeserializeFromStr, SerializeDisplay};
23use std::fmt::Formatter;
24use std::ops::Bound::{Excluded, Included};
25use std::{fmt::Display, str::FromStr};
26use transition::Versioned;
27
28/// Endorsement ID size in bytes
29pub const ENDORSEMENT_ID_SIZE_BYTES: usize = massa_hash::HASH_SIZE_BYTES;
30
31/// endorsement id
32#[allow(missing_docs)]
33#[transition::versioned(versions("0"))]
34#[derive(
35    Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash, SerializeDisplay, DeserializeFromStr,
36)]
37pub struct EndorsementId(Hash);
38
39const ENDORSEMENTID_PREFIX: char = 'E';
40const ENDORSEMENTID_VERSION: u64 = 0;
41
42impl PreHashed for EndorsementId {}
43
44impl Id for EndorsementId {
45    fn new(hash: Hash) -> Self {
46        EndorsementId::EndorsementIdV0(EndorsementIdV0(hash))
47    }
48
49    fn get_hash(&self) -> &Hash {
50        match self {
51            EndorsementId::EndorsementIdV0(endorsement_id) => endorsement_id.get_hash(),
52        }
53    }
54}
55
56#[transition::impl_version(versions("0"))]
57impl EndorsementId {
58    fn get_hash(&self) -> &Hash {
59        &self.0
60    }
61}
62
63impl std::fmt::Display for EndorsementId {
64    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
65        match self {
66            EndorsementId::EndorsementIdV0(id) => write!(f, "{}", id),
67        }
68    }
69}
70
71#[transition::impl_version(versions("0"))]
72impl std::fmt::Display for EndorsementId {
73    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
74        let u64_serializer = U64VarIntSerializer::new();
75        // might want to allocate the vector with capacity in order to avoid re-allocation
76        let mut bytes: Vec<u8> = Vec::new();
77        u64_serializer
78            .serialize(&ENDORSEMENTID_VERSION, &mut bytes)
79            .map_err(|_| std::fmt::Error)?;
80        bytes.extend(self.0.to_bytes());
81        write!(
82            f,
83            "{}{}",
84            ENDORSEMENTID_PREFIX,
85            bs58::encode(bytes).with_check().into_string()
86        )
87    }
88}
89
90impl std::fmt::Debug for EndorsementId {
91    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
92        write!(f, "{}", self)
93    }
94}
95
96impl FromStr for EndorsementId {
97    type Err = ModelsError;
98    /// ## Example
99    /// ```rust
100    /// # use massa_hash::Hash;
101    /// # use std::str::FromStr;
102    /// # use massa_models::endorsement::EndorsementId;
103    /// # use crate::massa_models::secure_share::Id;
104    /// # let endo_id = EndorsementId::new(Hash::compute_from("endo_id".as_bytes()));
105    /// let ser = endo_id.to_string();
106    /// let res_endo_id = EndorsementId::from_str(&ser).unwrap();
107    /// assert_eq!(endo_id, res_endo_id);
108    /// ```
109    fn from_str(s: &str) -> Result<Self, Self::Err> {
110        let mut chars = s.chars();
111        match chars.next() {
112            Some(prefix) if prefix == ENDORSEMENTID_PREFIX => {
113                let data = chars.collect::<String>();
114                let decoded_bs58_check = bs58::decode(data)
115                    .with_check(None)
116                    .into_vec()
117                    .map_err(|_| ModelsError::EndorsementIdParseError)?;
118                let endorsement_id_deserializer = EndorsementIdDeserializer::new();
119                let (rest, endorsement_id) = endorsement_id_deserializer
120                    .deserialize::<DeserializeError>(&decoded_bs58_check[..])
121                    .map_err(|_| ModelsError::EndorsementIdParseError)?;
122                if rest.is_empty() {
123                    Ok(endorsement_id)
124                } else {
125                    Err(ModelsError::EndorsementIdParseError)
126                }
127            }
128            _ => Err(ModelsError::EndorsementIdParseError),
129        }
130    }
131}
132
133#[transition::impl_version(versions("0"))]
134impl FromStr for EndorsementId {
135    type Err = ModelsError;
136    fn from_str(s: &str) -> Result<Self, Self::Err> {
137        let mut chars = s.chars();
138        match chars.next() {
139            Some(prefix) if prefix == ENDORSEMENTID_PREFIX => {
140                let data = chars.collect::<String>();
141                let decoded_bs58_check = bs58::decode(data)
142                    .with_check(None)
143                    .into_vec()
144                    .map_err(|_| ModelsError::EndorsementIdParseError)?;
145                let endorsement_id_deserializer = EndorsementIdDeserializer::new();
146                let (rest, endorsement_id) = endorsement_id_deserializer
147                    .deserialize::<DeserializeError>(&decoded_bs58_check[..])
148                    .map_err(|_| ModelsError::EndorsementIdParseError)?;
149                if rest.is_empty() {
150                    Ok(endorsement_id)
151                } else {
152                    Err(ModelsError::EndorsementIdParseError)
153                }
154            }
155            _ => Err(ModelsError::EndorsementIdParseError),
156        }
157    }
158}
159
160struct EndorsementIdDeserializer {
161    version_deserializer: U64VarIntDeserializer,
162    hash_deserializer: HashDeserializer,
163}
164
165impl EndorsementIdDeserializer {
166    pub fn new() -> Self {
167        Self {
168            version_deserializer: U64VarIntDeserializer::new(Included(0), Included(u64::MAX)),
169            hash_deserializer: HashDeserializer::new(),
170        }
171    }
172}
173
174impl Deserializer<EndorsementId> for EndorsementIdDeserializer {
175    fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
176        &self,
177        buffer: &'a [u8],
178    ) -> IResult<&'a [u8], EndorsementId, E> {
179        // Verify that we at least have a version and something else
180        if buffer.len() < 2 {
181            return Err(nom::Err::Error(E::from_error_kind(buffer, ErrorKind::Eof)));
182        }
183        let (rest, endorsement_id_version) = self
184            .version_deserializer
185            .deserialize(buffer)
186            .map_err(|_: nom::Err<E>| {
187                nom::Err::Error(E::from_error_kind(buffer, ErrorKind::Eof))
188            })?;
189        match endorsement_id_version {
190            <EndorsementId!["0"]>::VERSION => {
191                let (rest, endorsement_id) = self.deserialize(rest)?;
192                Ok((rest, EndorsementIdVariant!["0"](endorsement_id)))
193            }
194            _ => Err(nom::Err::Error(E::from_error_kind(buffer, ErrorKind::Eof))),
195        }
196    }
197}
198
199#[transition::impl_version(versions("0"), structures("EndorsementId"))]
200impl Deserializer<EndorsementId> for EndorsementIdDeserializer {
201    fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
202        &self,
203        buffer: &'a [u8],
204    ) -> IResult<&'a [u8], EndorsementId, E> {
205        context("Failed OperationId deserialization", |input| {
206            self.hash_deserializer.deserialize(input)
207        })
208        .map(EndorsementId)
209        .parse(buffer)
210    }
211}
212impl Display for Endorsement {
213    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
214        writeln!(
215            f,
216            "Endorsed block: {} at slot {}",
217            self.endorsed_block, self.slot
218        )?;
219        writeln!(f, "Index: {}", self.index)?;
220        Ok(())
221    }
222}
223
224/// an endorsement, as sent in the network
225#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
226pub struct Endorsement {
227    /// Slot in which the endorsement can be included
228    pub slot: Slot,
229    /// Endorsement index inside the including block
230    pub index: u32,
231    /// Hash of endorsed block.
232    /// This is the parent in thread `self.slot.thread` of the block in which the endorsement is included
233    pub endorsed_block: BlockId,
234}
235
236#[cfg(any(test, feature = "test-exports"))]
237impl SecureShareEndorsement {
238    // TODO: gh-issue #3398
239    /// Used under testing conditions to validate an instance of Self
240    pub fn check_invariants(&self) -> Result<(), Box<dyn std::error::Error>> {
241        if let Err(e) = self.verify_signature(*crate::config::CHAINID) {
242            return Err(e.into());
243        }
244        if self.content.slot.thread >= crate::config::THREAD_COUNT {
245            Err("Endorsement slot on non-existent thread".into())
246        } else if self.content.index >= crate::config::ENDORSEMENT_COUNT {
247            Err("Endorsement index out of range".into())
248        } else {
249            Ok(())
250        }
251    }
252}
253
254/// Wrapped endorsement
255pub type SecureShareEndorsement = SecureShare<Endorsement, EndorsementId>;
256
257impl SecureShareContent for Endorsement {
258    /// Compute the signed hash. `chain_id` is folded into it, so the same endorsement
259    /// signed on two different chains produces two different signed hashes. This
260    /// prevents cross-chain replay of endorsements as denunciations (F90 / PDF #11).
261    fn compute_signed_hash(
262        &self,
263        public_key: &PublicKey,
264        content_hash: &Hash,
265        chain_id: u64,
266    ) -> Hash {
267        let mut signed_data: Vec<u8> = Vec::new();
268        signed_data.extend(public_key.to_bytes());
269        signed_data
270            .extend(EndorsementDenunciationData::new(self.slot, self.index, chain_id).to_bytes());
271        signed_data.extend(content_hash.to_bytes());
272        Hash::compute_from(&signed_data)
273    }
274}
275
276/// Serializer for `Endorsement`
277#[derive(Clone)]
278pub struct EndorsementSerializer {
279    slot_serializer: SlotSerializer,
280    u32_serializer: U32VarIntSerializer,
281    block_id_serializer: BlockIdSerializer,
282}
283
284impl EndorsementSerializer {
285    /// Creates a new `EndorsementSerializer`
286    pub fn new() -> Self {
287        EndorsementSerializer {
288            slot_serializer: SlotSerializer::new(),
289            u32_serializer: U32VarIntSerializer::new(),
290            block_id_serializer: BlockIdSerializer::new(),
291        }
292    }
293}
294
295impl Default for EndorsementSerializer {
296    fn default() -> Self {
297        Self::new()
298    }
299}
300
301impl Serializer<Endorsement> for EndorsementSerializer {
302    /// ## Example:
303    /// ```rust
304    /// use massa_models::{slot::Slot, block_id::BlockId, endorsement::{Endorsement, EndorsementSerializer}};
305    /// use massa_serialization::Serializer;
306    /// use massa_hash::Hash;
307    ///
308    /// let endorsement = Endorsement {
309    ///   slot: Slot::new(1, 2),
310    ///   index: 0,
311    ///   endorsed_block: BlockId::generate_from_hash(Hash::compute_from("test".as_bytes()))
312    /// };
313    /// let mut buffer = Vec::new();
314    /// EndorsementSerializer::new().serialize(&endorsement, &mut buffer).unwrap();
315    /// ```
316    fn serialize(&self, value: &Endorsement, buffer: &mut Vec<u8>) -> Result<(), SerializeError> {
317        self.slot_serializer.serialize(&value.slot, buffer)?;
318        self.u32_serializer.serialize(&value.index, buffer)?;
319        self.block_id_serializer
320            .serialize(&value.endorsed_block, buffer)?;
321        Ok(())
322    }
323}
324
325/// Deserializer for `Endorsement`
326pub struct EndorsementDeserializer {
327    slot_deserializer: SlotDeserializer,
328    index_deserializer: U32VarIntDeserializer,
329    block_id_deserializer: BlockIdDeserializer,
330}
331
332impl EndorsementDeserializer {
333    /// Creates a new `EndorsementDeserializer`
334    pub fn new(thread_count: u8, endorsement_count: u32) -> Self {
335        EndorsementDeserializer {
336            slot_deserializer: SlotDeserializer::new(
337                (Included(0), Included(u64::MAX)),
338                (Included(0), Excluded(thread_count)),
339            ),
340            index_deserializer: U32VarIntDeserializer::new(
341                Included(0),
342                Excluded(endorsement_count),
343            ),
344            block_id_deserializer: BlockIdDeserializer::new(),
345        }
346    }
347}
348
349impl Deserializer<Endorsement> for EndorsementDeserializer {
350    /// ## Example:
351    /// ```rust
352    /// use massa_models::{slot::Slot, block_id::BlockId, endorsement::{Endorsement, EndorsementSerializer, EndorsementDeserializer}};
353    /// use massa_serialization::{Serializer, Deserializer, DeserializeError};
354    /// use massa_hash::Hash;
355    ///
356    /// let endorsement = Endorsement {
357    ///   slot: Slot::new(1, 2),
358    ///   index: 0,
359    ///   endorsed_block: BlockId::generate_from_hash(Hash::compute_from("test".as_bytes()))
360    /// };
361    /// let mut buffer = Vec::new();
362    /// EndorsementSerializer::new().serialize(&endorsement, &mut buffer).unwrap();
363    /// let (rest, deserialized) = EndorsementDeserializer::new(32, 10).deserialize::<DeserializeError>(&buffer).unwrap();
364    /// assert_eq!(rest.len(), 0);
365    /// assert_eq!(deserialized.slot, endorsement.slot);
366    /// assert_eq!(deserialized.index, endorsement.index);
367    /// assert_eq!(deserialized.endorsed_block, endorsement.endorsed_block);
368    /// ```
369    fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
370        &self,
371        buffer: &'a [u8],
372    ) -> IResult<&'a [u8], Endorsement, E> {
373        context(
374            "Failed endorsement deserialization",
375            tuple((
376                context("Failed slot deserialization", |input| {
377                    self.slot_deserializer.deserialize(input)
378                }),
379                context("Failed index deserialization", |input| {
380                    self.index_deserializer.deserialize(input)
381                }),
382                context("Failed endorsed_block deserialization", |input| {
383                    self.block_id_deserializer.deserialize(input)
384                }),
385            )),
386        )
387        .map(|(slot, index, endorsed_block)| Endorsement {
388            slot,
389            index,
390            endorsed_block,
391        })
392        .parse(buffer)
393    }
394}
395
396/// Lightweight Serializer for `Endorsement`
397/// When included in a `BlockHeader`, we want to serialize only the index (optimization)
398pub struct EndorsementSerializerLW {
399    // slot_serializer: SlotSerializer,
400    u32_serializer: U32VarIntSerializer,
401}
402
403impl EndorsementSerializerLW {
404    /// Creates a new `EndorsementSerializerLW`
405    pub fn new() -> Self {
406        EndorsementSerializerLW {
407            u32_serializer: U32VarIntSerializer::new(),
408        }
409    }
410}
411
412impl Default for EndorsementSerializerLW {
413    fn default() -> Self {
414        Self::new()
415    }
416}
417
418impl Serializer<Endorsement> for EndorsementSerializerLW {
419    /// ## Example:
420    /// ```rust
421    /// use massa_models::{slot::Slot, block_id::BlockId, endorsement::{Endorsement, EndorsementSerializerLW}};
422    /// use massa_serialization::Serializer;
423    /// use massa_hash::Hash;
424    ///
425    /// let endorsement = Endorsement {
426    ///   slot: Slot::new(1, 2),
427    ///   index: 0,
428    ///   endorsed_block: BlockId::generate_from_hash(Hash::compute_from("test".as_bytes()))
429    /// };
430    /// let mut buffer = Vec::new();
431    /// EndorsementSerializerLW::new().serialize(&endorsement, &mut buffer).unwrap();
432    /// ```
433    fn serialize(&self, value: &Endorsement, buffer: &mut Vec<u8>) -> Result<(), SerializeError> {
434        self.u32_serializer.serialize(&value.index, buffer)?;
435        Ok(())
436    }
437}
438
439/// Lightweight Deserializer for `Endorsement`
440pub struct EndorsementDeserializerLW {
441    index_deserializer: U32VarIntDeserializer,
442    slot: Slot,
443    endorsed_block: BlockId,
444}
445
446impl EndorsementDeserializerLW {
447    /// Creates a new `EndorsementDeserializerLW`
448    pub const fn new(endorsement_count: u32, slot: Slot, endorsed_block: BlockId) -> Self {
449        EndorsementDeserializerLW {
450            index_deserializer: U32VarIntDeserializer::new(
451                Included(0),
452                Excluded(endorsement_count),
453            ),
454            slot,
455            endorsed_block,
456        }
457    }
458}
459
460impl Deserializer<Endorsement> for EndorsementDeserializerLW {
461    /// ## Example:
462    /// ```rust
463    /// use massa_models::{slot::Slot, block_id::BlockId, endorsement::{Endorsement, EndorsementSerializerLW, EndorsementDeserializerLW}};
464    /// use massa_serialization::{Serializer, Deserializer, DeserializeError};
465    /// use massa_hash::Hash;
466    ///
467    /// let slot = Slot::new(1, 2);
468    /// let endorsed_block = BlockId::generate_from_hash(Hash::compute_from("test".as_bytes()));
469    /// let endorsement = Endorsement {
470    ///   slot: slot,
471    ///   index: 0,
472    ///   endorsed_block: endorsed_block
473    /// };
474    /// let mut buffer = Vec::new();
475    /// EndorsementSerializerLW::new().serialize(&endorsement, &mut buffer).unwrap();
476    /// let (rest, deserialized) = EndorsementDeserializerLW::new(10, slot, endorsed_block).deserialize::<DeserializeError>(&buffer).unwrap();
477    /// assert_eq!(rest.len(), 0);
478    /// assert_eq!(deserialized.index, endorsement.index);
479    /// ```
480    fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
481        &self,
482        buffer: &'a [u8],
483    ) -> IResult<&'a [u8], Endorsement, E> {
484        context("Failed index deserialization", |input| {
485            self.index_deserializer.deserialize(input)
486        })
487        .map(|index| Endorsement {
488            slot: self.slot,
489            index,
490            endorsed_block: self.endorsed_block,
491        })
492        .parse(buffer)
493    }
494}
495
496/// A denunciation data for endorsement
497#[derive(Debug)]
498pub struct EndorsementDenunciationData {
499    slot: Slot,
500    index: u32,
501    /// chain the message is signed on
502    chain_id: u64,
503}
504
505impl EndorsementDenunciationData {
506    /// Create a new denunciation data for endorsement
507    pub fn new(slot: Slot, index: u32, chain_id: u64) -> Self {
508        Self {
509            slot,
510            index,
511            chain_id,
512        }
513    }
514
515    /// Get byte array
516    pub fn to_bytes(&self) -> Vec<u8> {
517        let mut buf = Vec::new();
518        buf.extend(self.slot.to_bytes_key());
519        buf.extend(self.index.to_le_bytes());
520        buf.extend(self.chain_id.to_be_bytes());
521        buf
522    }
523}
524
525#[cfg(test)]
526mod tests {
527    use crate::secure_share::{SecureShareContent, SecureShareDeserializer, SecureShareSerializer};
528    use massa_signature::verify_signature_batch;
529    use serde_json::Value;
530
531    use super::*;
532    use crate::config::CHAINID;
533    use massa_serialization::DeserializeError;
534    use massa_signature::KeyPair;
535    use serial_test::serial;
536
537    #[test]
538    #[serial]
539    fn test_endorsement_serialization() {
540        let sender_keypair = KeyPair::generate(0).unwrap();
541        let content = Endorsement {
542            slot: Slot::new(10, 1),
543            index: 0,
544            endorsed_block: BlockId::generate_from_hash(Hash::compute_from("blk".as_bytes())),
545        };
546        let endorsement: SecureShareEndorsement = Endorsement::new_verifiable(
547            content,
548            EndorsementSerializer::new(),
549            &sender_keypair,
550            *CHAINID,
551        )
552        .unwrap();
553
554        let mut ser_endorsement: Vec<u8> = Vec::new();
555        let serializer = SecureShareSerializer::new();
556        serializer
557            .serialize(&endorsement, &mut ser_endorsement)
558            .unwrap();
559        let (_, res_endorsement): (&[u8], SecureShareEndorsement) =
560            SecureShareDeserializer::new(EndorsementDeserializer::new(32, 1), *CHAINID)
561                .deserialize::<DeserializeError>(&ser_endorsement)
562                .unwrap();
563        assert_eq!(res_endorsement, endorsement);
564    }
565
566    #[test]
567    #[serial]
568    fn test_endorsement_lightweight_serialization() {
569        let sender_keypair = KeyPair::generate(0).unwrap();
570        let content = Endorsement {
571            slot: Slot::new(10, 1),
572            index: 0,
573            endorsed_block: BlockId::generate_from_hash(Hash::compute_from("blk".as_bytes())),
574        };
575        let endorsement: SecureShareEndorsement = Endorsement::new_verifiable(
576            content,
577            EndorsementSerializerLW::new(),
578            &sender_keypair,
579            *CHAINID,
580        )
581        .unwrap();
582
583        let mut ser_endorsement: Vec<u8> = Vec::new();
584        let serializer = SecureShareSerializer::new();
585        serializer
586            .serialize(&endorsement, &mut ser_endorsement)
587            .unwrap();
588
589        let parent = BlockId::generate_from_hash(Hash::compute_from("blk".as_bytes()));
590
591        let (_, res_endorsement): (&[u8], SecureShareEndorsement) = SecureShareDeserializer::new(
592            EndorsementDeserializerLW::new(1, Slot::new(10, 1), parent),
593            *CHAINID,
594        )
595        .deserialize::<DeserializeError>(&ser_endorsement)
596        .unwrap();
597        // Test only endorsement index as with the lw ser. we only process this field
598        assert_eq!(res_endorsement.content.index, endorsement.content.index);
599    }
600
601    #[test]
602    fn test_verify_sig_batch() {
603        // test verify_signature_batch as we override SecureShareEndorsements compute_hash
604
605        let sender_keypair = KeyPair::generate(0).unwrap();
606        let content_1 = Endorsement {
607            slot: Slot::new(10, 1),
608            index: 0,
609            endorsed_block: BlockId::generate_from_hash(Hash::compute_from("blk1".as_bytes())),
610        };
611        let s_endorsement_1: SecureShareEndorsement = Endorsement::new_verifiable(
612            content_1,
613            EndorsementSerializer::new(),
614            &sender_keypair,
615            *CHAINID,
616        )
617        .unwrap();
618        let mut serialized = vec![];
619        SecureShareSerializer::new()
620            .serialize(&s_endorsement_1, &mut serialized)
621            .unwrap();
622        let (_, s_endorsement_1): (&[u8], SecureShare<Endorsement, EndorsementId>) =
623            SecureShareDeserializer::new(EndorsementDeserializer::new(32, 32), *CHAINID)
624                .deserialize::<DeserializeError>(&serialized)
625                .unwrap();
626        let sender_keypair = KeyPair::generate(0).unwrap();
627        let content_2 = Endorsement {
628            slot: Slot::new(2, 5),
629            index: 0,
630            endorsed_block: BlockId::generate_from_hash(Hash::compute_from("blk2".as_bytes())),
631        };
632        let s_endorsement_2: SecureShareEndorsement = Endorsement::new_verifiable(
633            content_2,
634            EndorsementSerializerLW::new(),
635            &sender_keypair,
636            *CHAINID,
637        )
638        .unwrap();
639
640        // Test with batch len == 1 (no // verif)
641        let batch_1 = [(
642            s_endorsement_1.compute_signed_hash(*CHAINID),
643            s_endorsement_1.signature,
644            s_endorsement_1.content_creator_pub_key,
645        )];
646        verify_signature_batch(&batch_1).unwrap();
647
648        // Test with batch len > 1 (// verif)
649        let batch_2 = [
650            (
651                s_endorsement_1.compute_signed_hash(*CHAINID),
652                s_endorsement_1.signature,
653                s_endorsement_1.content_creator_pub_key,
654            ),
655            (
656                s_endorsement_2.compute_signed_hash(*CHAINID),
657                s_endorsement_2.signature,
658                s_endorsement_2.content_creator_pub_key,
659            ),
660        ];
661        verify_signature_batch(&batch_2).unwrap();
662    }
663
664    #[test]
665    #[serial]
666    fn test_endorsement_id() {
667        let expected_endorsement_id =
668            EndorsementId::from_str("E12Uy7hrAUHpmHQTWu68p17v7VtZJ6syBTWEJH6jwMTWJB6fdSc7")
669                .unwrap();
670        let actual_endorsement_id = EndorsementId::new(Hash::compute_from("edm".as_bytes()));
671
672        assert_eq!(actual_endorsement_id, expected_endorsement_id);
673    }
674
675    #[test]
676    #[serial]
677    fn test_endorsement_id_errors() {
678        let actual_error = EndorsementId::from_str("SomeInvalidEndorsementId")
679            .unwrap_err()
680            .to_string();
681        let expected_error = "endorsement id parsing error".to_string();
682
683        assert_eq!(actual_error, expected_error);
684    }
685
686    #[test]
687    #[serial]
688    fn test_endorsement_serde() {
689        let orig_endorsement = Endorsement {
690            slot: Slot::new(10, 1),
691            index: 0,
692            endorsed_block: BlockId::generate_from_hash(Hash::compute_from("blk".as_bytes())),
693        };
694        let serialized_endorsement = serde_json::to_string(&orig_endorsement).unwrap();
695        let res_endorsement: Value = serde_json::from_str(&serialized_endorsement).unwrap();
696        // check equality
697        assert_eq!(
698            orig_endorsement.slot.period,
699            res_endorsement["slot"]["period"]
700        );
701        assert_eq!(
702            orig_endorsement.slot.thread,
703            res_endorsement["slot"]["thread"]
704        );
705        assert_eq!(orig_endorsement.index, res_endorsement["index"]);
706        assert_eq!(
707            orig_endorsement.endorsed_block.to_string(),
708            res_endorsement["endorsed_block"]
709        );
710    }
711}