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#[derive(Debug, Clone, Serialize, Deserialize)]
30pub struct BlockHeader {
31 pub current_version: u32,
33 pub announced_version: Option<u32>,
35 pub slot: Slot,
37 pub parents: Vec<BlockId>,
39 pub operation_merkle_root: Hash,
41 pub endorsements: Vec<SecureShareEndorsement>,
43 pub denunciations: Vec<Denunciation>,
45}
46
47#[cfg(any(test, feature = "test-exports"))]
49impl BlockHeader {
50 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 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
99pub type SecuredHeader = SecureShare<BlockHeader, BlockId>;
101
102impl SecureShareContent for BlockHeader {
103 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 pub fn get_fitness(&self) -> u64 {
123 (self.content.endorsements.len() as u64) + 1
124 }
125 #[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
140pub 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 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 fn serialize(&self, value: &BlockHeader, buffer: &mut Vec<u8>) -> Result<(), SerializeError> {
224 self.u32_serializer
226 .serialize(&value.current_version, buffer)?;
227 self.opt_serializer
228 .serialize(&value.announced_version, buffer)?;
229
230 self.slot_serializer.serialize(&value.slot, buffer)?;
232
233 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 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
275pub 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 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 #[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 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 #[cfg(any(test, feature = "test-exports"))]
474 res.assert_invariants(self.thread_count, self.endorsement_count)
475 .unwrap();
476
477 let (rest2, _) = tag(&[0, 0])(rest)?;
480 return Ok((rest2, res));
481 }
482
483 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 #[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#[derive(Debug)]
602pub struct BlockHeaderDenunciationData {
603 slot: Slot,
604 chain_id: u64,
606}
607
608impl BlockHeaderDenunciationData {
609 pub fn new(slot: Slot, chain_id: u64) -> Self {
611 Self { slot, chain_id }
612 }
613
614 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 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 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 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 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}