massa_models/
block_header.rs

1use crate::block_id::{BlockId, BlockIdDeserializer, BlockIdSerializer};
2use crate::denunciation::{Denunciation, DenunciationDeserializer, DenunciationSerializer};
3use crate::endorsement::{
4    Endorsement, EndorsementDeserializerLW, EndorsementId, EndorsementSerializer,
5    EndorsementSerializerLW, SecureShareEndorsement,
6};
7use crate::secure_share::{
8    SecureShare, SecureShareContent, SecureShareDeserializer, SecureShareSerializer,
9};
10use crate::slot::{Slot, SlotDeserializer, SlotSerializer};
11use massa_hash::{Hash, HashDeserializer};
12use massa_serialization::{
13    Deserializer, OptionDeserializer, OptionSerializer, SerializeError, Serializer,
14    U32VarIntDeserializer, U32VarIntSerializer,
15};
16use massa_signature::PublicKey;
17use nom::branch::alt;
18use nom::bytes::complete::tag;
19use nom::error::{context, ContextError, ParseError};
20use nom::multi::{count, length_count};
21use nom::sequence::{preceded, tuple};
22use nom::{IResult, Parser};
23use serde::{Deserialize, Serialize};
24use std::collections::Bound::{Excluded, Included};
25use std::collections::HashSet;
26use std::fmt::Formatter;
27
28/// block header
29#[derive(Debug, Clone, Serialize, Deserialize)]
30pub struct BlockHeader {
31    /// current network version
32    pub current_version: u32,
33    /// announced network version
34    pub announced_version: Option<u32>,
35    /// slot
36    pub slot: Slot,
37    /// parents
38    pub parents: Vec<BlockId>,
39    /// all operations hash
40    pub operation_merkle_root: Hash,
41    /// endorsements
42    pub endorsements: Vec<SecureShareEndorsement>,
43    /// denunciations
44    pub denunciations: Vec<Denunciation>,
45}
46
47// TODO: gh-issue #3398
48#[cfg(any(test, feature = "test-exports"))]
49impl BlockHeader {
50    /// This is an intentional duplication of invariant checks. In production code,
51    /// these checks are dispersed throughout the deserialization process. This test-only function
52    /// allows all the checks to be in one place.
53    fn assert_invariants(
54        &self,
55        thread_count: u8,
56        endorsement_count: u32,
57    ) -> Result<(), Box<dyn std::error::Error>> {
58        if self.slot.period == 0 {
59            if !self.parents.is_empty() {
60                return Err("Invariant broken: genesis block with parent(s)".into());
61            }
62            if !self.endorsements.is_empty() {
63                return Err("Invariant broken: genesis block with endorsement(s)".into());
64            }
65        } else {
66            if self.parents.len() != thread_count as usize {
67                return Err(
68                    "Invariant broken: non-genesis block with incorrect number of parents".into(),
69                );
70            }
71            if self.endorsements.len() > endorsement_count as usize {
72                return Err("Invariant broken: endorsement count too high".into());
73            }
74
75            let parent_id = self.parents[self.slot.thread as usize];
76            for endo in self.endorsements.iter() {
77                if endo.content.endorsed_block != parent_id {
78                    return Err("Invariant broken: endorsement doesn't match parent".into());
79                }
80            }
81        }
82
83        // assert that the endorsement indexes are all unique...
84        let mut set = HashSet::new();
85        for endo in self.endorsements.iter() {
86            if !set.insert(endo.content.index) {
87                return Err("Endorsement duplicate index found".into());
88            }
89        }
90
91        for de in self.denunciations.iter() {
92            de.check_invariants()?;
93        }
94
95        Ok(())
96    }
97}
98
99/// BlockHeader wrapped up alongside verification data
100pub type SecuredHeader = SecureShare<BlockHeader, BlockId>;
101
102impl SecureShareContent for BlockHeader {
103    /// Compute the signed hash. `chain_id` is folded into it, so the same block header
104    /// signed on two different chains produces two different signed hashes. This
105    /// prevents cross-chain replay of block headers as denunciations (F90 / PDF #11).
106    fn compute_signed_hash(
107        &self,
108        public_key: &PublicKey,
109        content_hash: &Hash,
110        chain_id: u64,
111    ) -> Hash {
112        let mut signed_data: Vec<u8> = Vec::new();
113        signed_data.extend(public_key.to_bytes());
114        signed_data.extend(BlockHeaderDenunciationData::new(self.slot, chain_id).to_bytes());
115        signed_data.extend(content_hash.to_bytes());
116        Hash::compute_from(&signed_data)
117    }
118}
119
120impl SecuredHeader {
121    /// gets the header fitness
122    pub fn get_fitness(&self) -> u64 {
123        (self.content.endorsements.len() as u64) + 1
124    }
125    // TODO: gh-issue #3398
126    #[allow(dead_code)]
127    #[cfg(any(test, feature = "test-exports"))]
128    pub(crate) fn assert_invariants(
129        &self,
130        thread_count: u8,
131        endorsement_count: u32,
132    ) -> Result<(), Box<dyn std::error::Error>> {
133        self.content
134            .assert_invariants(thread_count, endorsement_count)?;
135        self.verify_signature(*crate::config::CHAINID)
136            .map_err(|er| format!("{}", er).into())
137    }
138}
139
140/// Serializer for `BlockHeader`
141pub struct BlockHeaderSerializer {
142    slot_serializer: SlotSerializer,
143    endorsement_serializer: SecureShareSerializer,
144    endorsement_content_serializer: EndorsementSerializerLW,
145    denunciation_serializer: DenunciationSerializer,
146    u32_serializer: U32VarIntSerializer,
147    opt_serializer: OptionSerializer<u32, U32VarIntSerializer>,
148    block_id_serializer: BlockIdSerializer,
149}
150
151impl BlockHeaderSerializer {
152    /// Creates a new `BlockHeaderSerializer`
153    pub fn new() -> Self {
154        Self {
155            slot_serializer: SlotSerializer::new(),
156            endorsement_serializer: SecureShareSerializer::new(),
157            u32_serializer: U32VarIntSerializer::new(),
158            opt_serializer: OptionSerializer::new(U32VarIntSerializer),
159            endorsement_content_serializer: EndorsementSerializerLW::new(),
160            denunciation_serializer: DenunciationSerializer::new(),
161            block_id_serializer: BlockIdSerializer::new(),
162        }
163    }
164}
165
166impl Default for BlockHeaderSerializer {
167    fn default() -> Self {
168        Self::new()
169    }
170}
171
172impl Serializer<BlockHeader> for BlockHeaderSerializer {
173    /// ## Example:
174    /// ```rust
175    /// use massa_models::{block_id::BlockId, block_header::BlockHeader, block_header::BlockHeaderSerializer};
176    /// use massa_models::endorsement::{Endorsement, EndorsementSerializer};
177    /// use massa_models::secure_share::SecureShareContent;
178    /// use massa_models::{config::THREAD_COUNT, slot::Slot};
179    /// use massa_hash::Hash;
180    /// use massa_models::config::CHAINID;
181    /// use massa_signature::KeyPair;
182    /// use massa_serialization::Serializer;
183    ///
184    /// let keypair = KeyPair::generate(0).unwrap();
185    /// let parents = (0..THREAD_COUNT)
186    ///   .map(|i| BlockId::generate_from_hash(Hash::compute_from(&[i])))
187    ///   .collect();
188    /// let header = BlockHeader {
189    ///   current_version: 0,
190    ///   announced_version: None,
191    ///   slot: Slot::new(1, 1),
192    ///   parents,
193    ///   operation_merkle_root: Hash::compute_from("mno".as_bytes()),
194    ///   endorsements: vec![
195    ///     Endorsement::new_verifiable(
196    ///        Endorsement {
197    ///          slot: Slot::new(1, 1),
198    ///          index: 1,
199    ///          endorsed_block: BlockId::generate_from_hash(Hash::compute_from("blk1".as_bytes())),
200    ///        },
201    ///     EndorsementSerializer::new(),
202    ///     &keypair,
203    ///     *CHAINID
204    ///     )
205    ///     .unwrap(),
206    ///     Endorsement::new_verifiable(
207    ///       Endorsement {
208    ///         slot: Slot::new(4, 0),
209    ///         index: 3,
210    ///         endorsed_block: BlockId::generate_from_hash(Hash::compute_from("blk2".as_bytes())),
211    ///       },
212    ///     EndorsementSerializer::new(),
213    ///     &keypair,
214    ///     *CHAINID
215    ///     )
216    ///     .unwrap(),
217    ///    ],
218    ///   denunciations: vec![],
219    /// };
220    /// let mut buffer = vec![];
221    /// BlockHeaderSerializer::new().serialize(&header, &mut buffer).unwrap();
222    /// ```
223    fn serialize(&self, value: &BlockHeader, buffer: &mut Vec<u8>) -> Result<(), SerializeError> {
224        // network versions
225        self.u32_serializer
226            .serialize(&value.current_version, buffer)?;
227        self.opt_serializer
228            .serialize(&value.announced_version, buffer)?;
229
230        // slot
231        self.slot_serializer.serialize(&value.slot, buffer)?;
232
233        // parents (note: there should be none if slot period=0)
234        if value.parents.is_empty() {
235            buffer.push(0);
236        } else {
237            buffer.push(1);
238        }
239        for parent_h in value.parents.iter() {
240            self.block_id_serializer.serialize(parent_h, buffer)?;
241        }
242
243        // operations merkle root
244        buffer.extend(value.operation_merkle_root.to_bytes());
245
246        self.u32_serializer.serialize(
247            &value.endorsements.len().try_into().map_err(|err| {
248                SerializeError::GeneralError(format!("too many endorsements: {}", err))
249            })?,
250            buffer,
251        )?;
252
253        for endorsement in value.endorsements.iter() {
254            self.endorsement_serializer.serialize_with(
255                &self.endorsement_content_serializer,
256                endorsement,
257                buffer,
258            )?;
259        }
260        self.u32_serializer.serialize(
261            &value.denunciations.len().try_into().map_err(|err| {
262                SerializeError::GeneralError(format!("too many denunciations: {}", err))
263            })?,
264            buffer,
265        )?;
266        for denunciation in value.denunciations.iter() {
267            self.denunciation_serializer
268                .serialize(denunciation, buffer)?;
269        }
270
271        Ok(())
272    }
273}
274
275/// Deserializer for `BlockHeader`
276pub struct BlockHeaderDeserializer {
277    slot_deserializer: SlotDeserializer,
278    endorsement_serializer: EndorsementSerializer,
279    endorsement_len_deserializer: U32VarIntDeserializer,
280    hash_deserializer: HashDeserializer,
281    thread_count: u8,
282    endorsement_count: u32,
283    last_start_period: Option<u64>,
284    denunciation_len_deserializer: U32VarIntDeserializer,
285    denunciation_deserializer: DenunciationDeserializer,
286    network_versions_deserializer: U32VarIntDeserializer,
287    opt_deserializer: OptionDeserializer<u32, U32VarIntDeserializer>,
288    block_id_deserializer: BlockIdDeserializer,
289    chain_id: u64,
290}
291
292impl BlockHeaderDeserializer {
293    /// Creates a new `BlockHeaderDeserializer`
294    /// If last_start_period is Some(lsp), then the deserializer will check for valid (non)-genesis blocks
295    pub fn new(
296        thread_count: u8,
297        endorsement_count: u32,
298        max_denunciations_in_block_header: u32,
299        last_start_period: Option<u64>,
300        chain_id: u64,
301    ) -> Self {
302        Self {
303            slot_deserializer: SlotDeserializer::new(
304                (Included(0), Included(u64::MAX)),
305                (Included(0), Excluded(thread_count)),
306            ),
307            endorsement_serializer: EndorsementSerializer::new(),
308            endorsement_len_deserializer: U32VarIntDeserializer::new(
309                Included(0),
310                Included(endorsement_count),
311            ),
312            hash_deserializer: HashDeserializer::new(),
313            denunciation_len_deserializer: U32VarIntDeserializer::new(
314                Included(0),
315                Included(max_denunciations_in_block_header),
316            ),
317            network_versions_deserializer: U32VarIntDeserializer::new(
318                Included(0),
319                Included(u32::MAX),
320            ),
321            opt_deserializer: OptionDeserializer::new(U32VarIntDeserializer::new(
322                Included(0),
323                Included(u32::MAX),
324            )),
325            denunciation_deserializer: DenunciationDeserializer::new(
326                thread_count,
327                endorsement_count,
328            ),
329            block_id_deserializer: BlockIdDeserializer::new(),
330            thread_count,
331            endorsement_count,
332            last_start_period,
333            chain_id,
334        }
335    }
336}
337
338impl Deserializer<BlockHeader> for BlockHeaderDeserializer {
339    /// ## Example:
340    /// ```rust
341    /// use massa_models::block_header::{BlockHeader, BlockHeaderDeserializer, BlockHeaderSerializer};
342    /// use massa_models::block_id::{BlockId};
343    /// use massa_models::{config::THREAD_COUNT, slot::Slot, secure_share::SecureShareContent};
344    /// use massa_models::endorsement::{Endorsement, EndorsementSerializer};
345    /// use massa_hash::Hash;
346    /// use massa_models::config::CHAINID;
347    /// use massa_signature::KeyPair;
348    /// use massa_serialization::{Serializer, Deserializer, DeserializeError};
349    ///
350    /// let keypair = KeyPair::generate(0).unwrap();
351    /// let parents: Vec<BlockId> = (0..THREAD_COUNT)
352    ///   .map(|i| BlockId::generate_from_hash(Hash::compute_from(&[i])))
353    ///   .collect();
354    /// let header = BlockHeader {
355    ///   current_version: 0,
356    ///   announced_version: None,
357    ///   slot: Slot::new(1, 1),
358    ///   parents: parents.clone(),
359    ///   operation_merkle_root: Hash::compute_from("mno".as_bytes()),
360    ///   endorsements: vec![
361    ///     Endorsement::new_verifiable(
362    ///        Endorsement {
363    ///          slot: Slot::new(1, 1),
364    ///          index: 0,
365    ///          endorsed_block: parents[1].clone(),
366    ///        },
367    ///     EndorsementSerializer::new(),
368    ///     &keypair,
369    ///     *CHAINID
370    ///     )
371    ///     .unwrap(),
372    ///     Endorsement::new_verifiable(
373    ///       Endorsement {
374    ///         slot: Slot::new(1, 1),
375    ///         index: 1,
376    ///         endorsed_block: parents[1].clone(),
377    ///       },
378    ///     EndorsementSerializer::new(),
379    ///     &keypair,
380    ///     *CHAINID
381    ///     )
382    ///     .unwrap(),
383    ///    ],
384    ///    denunciations: vec![],
385    /// };
386    /// let mut buffer = vec![];
387    /// BlockHeaderSerializer::new().serialize(&header, &mut buffer).unwrap();
388    /// let (rest, deserialized_header) = BlockHeaderDeserializer::new(32, 9, 10, Some(0), 77).deserialize::<DeserializeError>(&buffer).unwrap();
389    /// assert_eq!(rest.len(), 0);
390    /// let mut buffer2 = Vec::new();
391    /// BlockHeaderSerializer::new().serialize(&deserialized_header, &mut buffer2).unwrap();
392    /// assert_eq!(buffer, buffer2);
393    /// ```
394    #[allow(clippy::type_complexity)]
395    fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
396        &self,
397        buffer: &'a [u8],
398    ) -> IResult<&'a [u8], BlockHeader, E> {
399        let (rest, (current_version, announced_version, slot, parents, operation_merkle_root)): (
400            &[u8],
401            (u32, Option<u32>, Slot, Vec<BlockId>, Hash),
402        ) = context("Failed BlockHeader deserialization", |input| {
403            let (rest, (current_version, announced_version, slot, parents)) = tuple((
404                context("Failed current_version deserialization", |input| {
405                    self.network_versions_deserializer.deserialize(input)
406                }),
407                context("Failed announced_version deserialization", |input| {
408                    self.opt_deserializer.deserialize(input)
409                }),
410                context("Failed slot deserialization", |input| {
411                    self.slot_deserializer.deserialize(input)
412                }),
413                context(
414                    "Failed parents deserialization",
415                    alt((
416                        preceded(tag(&[0]), |input| Ok((input, Vec::new()))),
417                        preceded(
418                            tag(&[1]),
419                            count(
420                                context("Failed block_id deserialization", |input| {
421                                    self.block_id_deserializer.deserialize(input)
422                                }),
423                                self.thread_count as usize,
424                            ),
425                        ),
426                    )),
427                ),
428            ))
429            .parse(input)?;
430
431            // validate the parent/slot invariants before moving on to other fields
432            if let Some(last_start_period) = self.last_start_period {
433                if slot.period == last_start_period && !parents.is_empty() {
434                    return Err(nom::Err::Failure(ContextError::add_context(
435                        rest,
436                        "Genesis block cannot contain parents",
437                        ParseError::from_error_kind(rest, nom::error::ErrorKind::Fail),
438                    )));
439                } else if slot.period != last_start_period
440                    && parents.len() != self.thread_count as usize
441                {
442                    return Err(nom::Err::Failure(ContextError::add_context(
443                        rest,
444                        "Non-genesis block must have same numbers of parents as threads count",
445                        ParseError::from_error_kind(rest, nom::error::ErrorKind::Fail),
446                    )));
447                }
448            }
449
450            let (rest, merkle) = context("Failed operation_merkle_root", |input| {
451                self.hash_deserializer.deserialize(input)
452            })
453            .parse(rest)?;
454            Ok((
455                rest,
456                (current_version, announced_version, slot, parents, merkle),
457            ))
458        })
459        .parse(buffer)?;
460
461        if parents.is_empty() {
462            let res = BlockHeader {
463                current_version,
464                announced_version,
465                slot,
466                parents,
467                operation_merkle_root,
468                endorsements: Vec::new(),
469                denunciations: Vec::new(),
470            };
471
472            // TODO: gh-issue #3398
473            #[cfg(any(test, feature = "test-exports"))]
474            res.assert_invariants(self.thread_count, self.endorsement_count)
475                .unwrap();
476
477            // As we have 0 endorsements & 0 denunciations, rest = [0, 0] (length 0 & length 0)
478            // As we want to return an empty "res" we use nom tag
479            let (rest2, _) = tag(&[0, 0])(rest)?;
480            return Ok((rest2, res));
481        }
482
483        // Now deser the endorsements (which were light-weight serialized)
484        let endorsement_deserializer = SecureShareDeserializer::new(
485            EndorsementDeserializerLW::new(
486                self.endorsement_count,
487                slot,
488                parents[slot.thread as usize],
489            ),
490            self.chain_id,
491        );
492
493        let parent_id = parents[slot.thread as usize];
494        let (rest, endorsements): (&[u8], Vec<SecureShare<Endorsement, EndorsementId>>) = context(
495            "Failed endorsements deserialization",
496            length_count::<&[u8], SecureShare<Endorsement, EndorsementId>, u32, E, _, _>(
497                context("Failed length deserialization", |input| {
498                    self.endorsement_len_deserializer.deserialize(input)
499                }),
500                context("Failed endorsement deserialization", |input| {
501                    let (rest, endo) = endorsement_deserializer
502                        .deserialize_with(&self.endorsement_serializer, input)?;
503
504                    if endo.content.endorsed_block != parent_id {
505                        return Err(nom::Err::Failure(ContextError::add_context(
506                            rest,
507                            "Endorsement does not match block parents",
508                            ParseError::from_error_kind(rest, nom::error::ErrorKind::Fail),
509                        )));
510                    }
511
512                    Ok((rest, endo))
513                }),
514            ),
515        )
516        .parse(rest)?;
517
518        let mut set = HashSet::new();
519        for end in endorsements.iter() {
520            if !set.insert(end.content.index) {
521                return Err(nom::Err::Failure(ContextError::add_context(
522                    rest,
523                    "Duplicate endorsement index found",
524                    ParseError::from_error_kind(rest, nom::error::ErrorKind::Fail),
525                )));
526            }
527        }
528
529        let (rest, denunciations): (&[u8], Vec<Denunciation>) = context(
530            "Failed denunciations deserialization",
531            length_count::<&[u8], Denunciation, u32, E, _, _>(
532                context("Failed length deserialization", |input| {
533                    let (res, count) = self.denunciation_len_deserializer.deserialize(input)?;
534                    IResult::Ok((res, count))
535                }),
536                context("Failed denunciation deserialization", |input| {
537                    self.denunciation_deserializer.deserialize(input)
538                }),
539            ),
540        )
541        .parse(rest)?;
542
543        let header = BlockHeader {
544            current_version,
545            announced_version,
546            slot,
547            parents,
548            operation_merkle_root,
549            endorsements,
550            denunciations,
551        };
552
553        // TODO: gh-issue #3398
554        #[cfg(any(test, feature = "test-exports"))]
555        header
556            .assert_invariants(self.thread_count, self.endorsement_count)
557            .unwrap();
558
559        Ok((rest, header))
560    }
561}
562
563impl std::fmt::Display for BlockHeader {
564    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
565        writeln!(
566            f,
567            "\t(period: {}, thread: {})",
568            self.slot.period, self.slot.thread,
569        )?;
570        writeln!(f, "\tMerkle root: {}", self.operation_merkle_root,)?;
571        writeln!(f, "\tParents: ")?;
572        for id in self.parents.iter() {
573            let str_id = id.to_string();
574            writeln!(f, "\t\t{}", str_id)?;
575        }
576        if self.parents.is_empty() {
577            writeln!(f, "No parents found: This is a genesis header")?;
578        }
579        writeln!(f, "\tEndorsements:")?;
580        for ed in self.endorsements.iter() {
581            writeln!(f, "\t\t-----")?;
582            writeln!(f, "\t\tId: {}", ed.id)?;
583            writeln!(f, "\t\tIndex: {}", ed.content.index)?;
584            writeln!(f, "\t\tEndorsed slot: {}", ed.content.slot)?;
585            writeln!(
586                f,
587                "\t\tEndorser's public key: {}",
588                ed.content_creator_pub_key
589            )?;
590            writeln!(f, "\t\tEndorsed block: {}", ed.content.endorsed_block)?;
591            writeln!(f, "\t\tSignature: {}", ed.signature)?;
592        }
593        if self.endorsements.is_empty() {
594            writeln!(f, "\tNo endorsements found")?;
595        }
596        Ok(())
597    }
598}
599
600/// A denunciation data for block header
601#[derive(Debug)]
602pub struct BlockHeaderDenunciationData {
603    slot: Slot,
604    /// chain the message is signed on
605    chain_id: u64,
606}
607
608impl BlockHeaderDenunciationData {
609    /// Create a new DenunciationData for block header
610    pub fn new(slot: Slot, chain_id: u64) -> Self {
611        Self { slot, chain_id }
612    }
613
614    /// Get byte array
615    pub fn to_bytes(&self) -> Vec<u8> {
616        let mut buf = Vec::new();
617        buf.extend(self.slot.to_bytes_key());
618        buf.extend(self.chain_id.to_be_bytes());
619        buf
620    }
621}
622
623#[cfg(test)]
624mod test {
625    use super::*;
626    use massa_serialization::DeserializeError;
627    use serde_json::Value;
628
629    use crate::config::{
630        CHAINID, ENDORSEMENT_COUNT, MAX_DENUNCIATIONS_PER_BLOCK_HEADER, THREAD_COUNT,
631    };
632
633    use crate::test_exports::{
634        gen_block_headers_for_denunciation, gen_endorsements_for_denunciation,
635    };
636    use massa_signature::{verify_signature_batch, KeyPair};
637
638    // Only for testing purpose
639    impl PartialEq for BlockHeader {
640        fn eq(&self, other: &Self) -> bool {
641            self.slot == other.slot
642                && self.parents == other.parents
643                && self.operation_merkle_root == other.operation_merkle_root
644                && self.endorsements == other.endorsements
645                && self.denunciations == other.denunciations
646        }
647    }
648
649    #[test]
650    fn test_block_header_ser_der() {
651        let keypair = KeyPair::generate(0).unwrap();
652
653        let slot = Slot::new(7, 1);
654        let parents_1: Vec<BlockId> = (0..THREAD_COUNT)
655            .map(|i| BlockId::generate_from_hash(Hash::compute_from(&[i])))
656            .collect();
657
658        let endorsement_1 = Endorsement {
659            slot,
660            index: 1,
661            endorsed_block: parents_1[1],
662        };
663
664        assert_eq!(parents_1[1], endorsement_1.endorsed_block);
665
666        let s_endorsement_1: SecureShareEndorsement = Endorsement::new_verifiable(
667            endorsement_1,
668            EndorsementSerializer::new(),
669            &keypair,
670            *CHAINID,
671        )
672        .unwrap();
673
674        let (slot_a, _, s_header_1, s_header_2, _) = gen_block_headers_for_denunciation(None, None);
675        assert!(slot_a < slot);
676        let de_a = Denunciation::try_from((&s_header_1, &s_header_2, *CHAINID)).unwrap();
677        let (slot_b, _, s_endo_1, s_endo_2, _) = gen_endorsements_for_denunciation(None, None);
678        assert!(slot_b < slot);
679        let de_b = Denunciation::try_from((&s_endo_1, &s_endo_2, *CHAINID)).unwrap();
680
681        let block_header_1 = BlockHeader {
682            current_version: 0,
683            announced_version: None,
684            slot,
685            parents: parents_1,
686            operation_merkle_root: Hash::compute_from("mno".as_bytes()),
687            endorsements: vec![s_endorsement_1],
688            denunciations: vec![de_a, de_b],
689        };
690
691        let mut buffer = Vec::new();
692        let ser = BlockHeaderSerializer::new();
693        ser.serialize(&block_header_1, &mut buffer).unwrap();
694        let der = BlockHeaderDeserializer::new(
695            THREAD_COUNT,
696            ENDORSEMENT_COUNT,
697            MAX_DENUNCIATIONS_PER_BLOCK_HEADER,
698            None,
699            *CHAINID,
700        );
701
702        let (rem, block_header_der) = der.deserialize::<DeserializeError>(&buffer).unwrap();
703
704        assert!(rem.is_empty());
705        assert_eq!(block_header_1, block_header_der);
706    }
707
708    #[test]
709    fn test_block_header_no_parents_ser_der() {
710        let slot = Slot::new(0, 1);
711        let block_header_1 = BlockHeader {
712            current_version: 0,
713            announced_version: None,
714            slot,
715            parents: vec![],
716            operation_merkle_root: Hash::compute_from("mno".as_bytes()),
717            endorsements: vec![],
718            denunciations: vec![],
719        };
720
721        let mut buffer = Vec::new();
722        let ser = BlockHeaderSerializer::new();
723        ser.serialize(&block_header_1, &mut buffer).unwrap();
724        let der = BlockHeaderDeserializer::new(
725            THREAD_COUNT,
726            ENDORSEMENT_COUNT,
727            MAX_DENUNCIATIONS_PER_BLOCK_HEADER,
728            None,
729            *CHAINID,
730        );
731
732        let (rem, block_header_der) = der.deserialize::<DeserializeError>(&buffer).unwrap();
733
734        assert!(rem.is_empty());
735        assert_eq!(block_header_1, block_header_der);
736    }
737
738    #[test]
739    fn test_verify_sig_batch() {
740        let (_slot, _keypair, secured_header_1, secured_header_2, secured_header_3) =
741            gen_block_headers_for_denunciation(None, None);
742
743        // Test with batch len == 1 (no // verif)
744        let batch_1 = [(
745            secured_header_1.compute_signed_hash(*CHAINID),
746            secured_header_1.signature,
747            secured_header_1.content_creator_pub_key,
748        )];
749        verify_signature_batch(&batch_1).unwrap();
750
751        // Test with batch len > 1 (// verif)
752        let batch_2 = [
753            (
754                secured_header_1.compute_signed_hash(*CHAINID),
755                secured_header_1.signature,
756                secured_header_1.content_creator_pub_key,
757            ),
758            (
759                secured_header_2.compute_signed_hash(*CHAINID),
760                secured_header_2.signature,
761                secured_header_2.content_creator_pub_key,
762            ),
763            (
764                secured_header_3.compute_signed_hash(*CHAINID),
765                secured_header_3.signature,
766                secured_header_3.content_creator_pub_key,
767            ),
768        ];
769        verify_signature_batch(&batch_2).unwrap();
770    }
771
772    #[test]
773    fn test_block_header_serde() {
774        let keypair = KeyPair::generate(0).unwrap();
775
776        let slot = Slot::new(7, 1);
777        let parents_1: Vec<BlockId> = (0..THREAD_COUNT)
778            .map(|i| BlockId::generate_from_hash(Hash::compute_from(&[i])))
779            .collect();
780
781        let endorsement_1 = Endorsement {
782            slot,
783            index: 1,
784            endorsed_block: parents_1[1],
785        };
786
787        assert_eq!(parents_1[1], endorsement_1.endorsed_block);
788
789        let s_endorsement_1: SecureShareEndorsement = Endorsement::new_verifiable(
790            endorsement_1,
791            EndorsementSerializer::new(),
792            &keypair,
793            *CHAINID,
794        )
795        .unwrap();
796
797        let (slot_a, _, s_header_1, s_header_2, _) = gen_block_headers_for_denunciation(None, None);
798        assert!(slot_a < slot);
799        let de_a = Denunciation::try_from((&s_header_1, &s_header_2, *CHAINID)).unwrap();
800        let (slot_b, _, s_endo_1, s_endo_2, _) = gen_endorsements_for_denunciation(None, None);
801        assert!(slot_b < slot);
802        let de_b = Denunciation::try_from((&s_endo_1, &s_endo_2, *CHAINID)).unwrap();
803
804        let block_header_1 = BlockHeader {
805            current_version: 0,
806            announced_version: None,
807            slot,
808            parents: parents_1,
809            operation_merkle_root: Hash::compute_from("mno".as_bytes()),
810            endorsements: vec![s_endorsement_1],
811            denunciations: vec![de_a, de_b],
812        };
813
814        let serialized_block_header = serde_json::to_string(&block_header_1).unwrap();
815        let res_block_header: Value = serde_json::from_str(&serialized_block_header).unwrap();
816        // check equality
817        assert_eq!(
818            block_header_1.current_version,
819            res_block_header["current_version"]
820        );
821        assert_eq!(
822            block_header_1.slot.period,
823            res_block_header["slot"]["period"]
824        );
825        assert_eq!(
826            block_header_1.slot.thread,
827            res_block_header["slot"]["thread"]
828        );
829    }
830}