1use crate::secure_share::{
7 Id, SecureShare, SecureShareContent, SecureShareDeserializer, SecureShareSerializer,
8};
9use crate::{
10 error::ModelsError,
12 operation::{
13 compute_operations_hash, OperationId, OperationIdSerializer, OperationIdsDeserializer,
14 OperationIdsSerializer, SecureShareOperation,
15 },
16 };
18use massa_hash::Hash;
20use massa_serialization::{
21 Deserializer,
23 SerializeError,
24 Serializer,
25 };
28use massa_signature::{KeyPair, PublicKey, Signature};
29use nom::error::context;
32use nom::sequence::tuple;
34use nom::Parser;
35use nom::{
36 error::{ContextError, ParseError},
37 IResult,
38};
39use serde::{Deserialize, Serialize};
40use std::fmt::Formatter;
44use crate::block_header::{BlockHeader, BlockHeaderDeserializer, SecuredHeader};
47use crate::block_id::BlockId;
48
49#[derive(Debug, Clone, Serialize, Deserialize)]
51pub struct Block {
52 pub header: SecuredHeader,
54 pub operations: Vec<OperationId>,
56}
57
58#[derive(Debug, Clone, Serialize, Deserialize)]
60pub struct FilledBlock {
61 pub header: SecuredHeader,
63 pub operations: Vec<(OperationId, Option<SecureShareOperation>)>,
65}
66
67pub type SecureShareBlock = SecureShare<Block, BlockId>;
69
70impl SecureShareContent for Block {
75 fn verify_signature(
80 &self,
81 public_key: &PublicKey,
82 content_hash: &Hash,
83 signature: &Signature,
84 chain_id: u64,
85 ) -> Result<(), ModelsError> {
86 self.header
87 .content
88 .verify_signature(public_key, content_hash, signature, chain_id)
89 }
90
91 fn new_verifiable<SC: Serializer<Self>, U: Id>(
92 self,
93 content_serializer: SC,
94 _keypair: &KeyPair,
95 _chain_id: u64,
96 ) -> Result<SecureShare<Self, U>, ModelsError> {
97 let mut content_serialized = Vec::new();
98 content_serializer.serialize(&self, &mut content_serialized)?;
99 Ok(SecureShare {
100 signature: self.header.signature,
101 content_creator_pub_key: self.header.content_creator_pub_key,
102 content_creator_address: self.header.content_creator_address,
103 id: U::new(*self.header.id.get_hash()),
104 content: self,
105 serialized_data: content_serialized,
106 })
107 }
108
109 fn serialize(
110 _signature: &Signature,
111 _creator_public_key: &PublicKey,
112 serialized_content: &[u8],
113 buffer: &mut Vec<u8>,
114 ) -> Result<(), SerializeError> {
115 buffer.extend(serialized_content);
116 Ok(())
117 }
118
119 fn deserialize<
120 'a,
121 E: ParseError<&'a [u8]> + ContextError<&'a [u8]>,
122 DC: Deserializer<Self>,
123 U: Id,
124 >(
125 _content_serializer: Option<&dyn Serializer<Self>>,
126 _signature_deserializer: &massa_signature::SignatureDeserializer,
127 _creator_public_key_deserializer: &massa_signature::PublicKeyDeserializer,
128 content_deserializer: &DC,
129 buffer: &'a [u8],
130 _chain_id: u64,
131 ) -> IResult<&'a [u8], SecureShare<Self, U>, E> {
132 let (rest, content) = content_deserializer.deserialize(buffer)?;
133 Ok((
134 rest,
135 SecureShare {
136 signature: content.header.signature,
137 content_creator_pub_key: content.header.content_creator_pub_key,
138 content_creator_address: content.header.content_creator_address,
139 id: U::new(*content.header.id.get_hash()),
140 content,
141 serialized_data: buffer[..buffer.len() - rest.len()].to_vec(),
142 },
143 ))
144 }
145}
146pub struct BlockSerializer {
148 header_serializer: SecureShareSerializer,
149 op_ids_serializer: OperationIdsSerializer,
150}
151
152impl BlockSerializer {
153 pub fn new() -> Self {
155 BlockSerializer {
156 header_serializer: SecureShareSerializer::new(),
157 op_ids_serializer: OperationIdsSerializer::new(),
158 }
159 }
160}
161
162impl Default for BlockSerializer {
163 fn default() -> Self {
164 Self::new()
165 }
166}
167
168impl Serializer<Block> for BlockSerializer {
169 fn serialize(&self, value: &Block, buffer: &mut Vec<u8>) -> Result<(), SerializeError> {
234 self.header_serializer.serialize(&value.header, buffer)?;
235 self.op_ids_serializer
236 .serialize(&value.operations, buffer)?;
237 Ok(())
238 }
239}
240
241pub struct BlockDeserializerArgs {
243 pub thread_count: u8,
245 pub max_operations_per_block: u32,
247 pub endorsement_count: u32,
249 pub max_denunciations_per_block_header: u32,
251 pub last_start_period: Option<u64>,
253 pub chain_id: u64,
255}
256
257pub struct BlockDeserializer {
259 header_deserializer: SecureShareDeserializer<BlockHeader, BlockHeaderDeserializer>,
260 op_ids_deserializer: OperationIdsDeserializer,
261 op_id_serializer: OperationIdSerializer,
262}
263
264impl BlockDeserializer {
265 pub fn new(args: BlockDeserializerArgs) -> Self {
267 BlockDeserializer {
268 header_deserializer: SecureShareDeserializer::new(
269 BlockHeaderDeserializer::new(
270 args.thread_count,
271 args.endorsement_count,
272 args.max_denunciations_per_block_header,
273 args.last_start_period,
274 args.chain_id,
275 ),
276 args.chain_id,
277 ),
278 op_ids_deserializer: OperationIdsDeserializer::new(args.max_operations_per_block),
279 op_id_serializer: OperationIdSerializer::new(),
280 }
281 }
282}
283
284impl Deserializer<Block> for BlockDeserializer {
285 fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
375 &self,
376 buffer: &'a [u8],
377 ) -> IResult<&'a [u8], Block, E> {
378 let (rest, (header, operations)) = context(
379 "Failed Block deserialization",
380 tuple((
381 context("Failed header deserialization", |input| {
382 self.header_deserializer.deserialize(input)
383 }),
384 context("Failed operations deserialization", |input| {
385 self.op_ids_deserializer.deserialize(input)
386 }),
387 )),
388 )
389 .parse(buffer)?;
390
391 let computed_operations_hash = compute_operations_hash(&operations, &self.op_id_serializer);
392
393 if header.content.operation_merkle_root != computed_operations_hash {
394 return Err(nom::Err::Failure(ContextError::add_context(
395 rest,
396 "operation list hash does not match header operation_merkle_root",
397 ParseError::from_error_kind(rest, nom::error::ErrorKind::Verify),
398 )));
399 }
400
401 Ok((rest, Block { header, operations }))
402 }
403}
404
405impl SecureShareBlock {
406 pub fn bytes_count(&self) -> u64 {
408 self.serialized_data.len() as u64
409 }
410
411 pub fn contains_operation(&self, op: SecureShareOperation) -> bool {
413 self.content.operations.contains(&op.id)
414 }
415
416 pub fn get_fitness(&self) -> u64 {
418 self.content.header.get_fitness()
419 }
420}
421
422impl std::fmt::Display for Block {
423 fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
424 writeln!(f, "{}", self.header)?;
425 writeln!(
426 f,
427 "Operations: {}",
428 self.operations
429 .iter()
430 .map(|op| format!("{}", op))
431 .collect::<Vec<String>>()
432 .join(" ")
433 )?;
434 Ok(())
435 }
436}
437
438#[derive(Eq, PartialEq, Debug, Deserialize, Serialize)]
452pub enum BlockGraphStatus {
453 Incoming,
455 WaitingForSlot,
457 WaitingForDependencies,
459 ActiveInAlternativeCliques,
461 ActiveInBlockclique,
463 Final,
465 Discarded,
467 NotFound,
469}
470
471#[cfg(test)]
472mod test {
473 use super::*;
474 use crate::config::{CHAINID, MAX_DENUNCIATIONS_PER_BLOCK_HEADER};
475 use crate::{
476 block_header::BlockHeaderSerializer,
477 config::{ENDORSEMENT_COUNT, MAX_OPERATIONS_PER_BLOCK, THREAD_COUNT},
478 endorsement::Endorsement,
479 endorsement::EndorsementSerializer,
480 slot::Slot,
481 };
482 use massa_hash::Hash;
483 use massa_serialization::{DeserializeError, Deserializer, Serializer};
484 use massa_signature::KeyPair;
485 use serde_json::Value;
486 use serial_test::serial;
487 use std::str::FromStr;
488
489 fn empty_operations_merkle_root() -> Hash {
490 compute_operations_hash(&[], &OperationIdSerializer::new())
491 }
492
493 #[test]
494 #[serial]
495 fn test_block_serialization() {
496 let keypair =
497 KeyPair::from_str("S1bXjyPwrssNmG4oUG5SEqaUhQkVArQi7rzQDWpCprTSmEgZDGG").unwrap();
498 let parents = (0..THREAD_COUNT)
499 .map(|_i| {
500 BlockId::generate_from_hash(
501 Hash::from_bs58_check("bq1NsaCBAfseMKSjNBYLhpK7M5eeef2m277MYS2P2k424GaDf")
502 .unwrap(),
503 )
504 })
505 .collect();
506
507 let endo1 = Endorsement::new_verifiable(
508 Endorsement {
509 slot: Slot::new(1, 0),
510 index: 0,
511 endorsed_block: BlockId::generate_from_hash(
512 Hash::from_bs58_check("bq1NsaCBAfseMKSjNBYLhpK7M5eeef2m277MYS2P2k424GaDf")
513 .unwrap(),
514 ),
515 },
516 EndorsementSerializer::new(),
517 &keypair,
518 *CHAINID,
519 )
520 .unwrap();
521 let endo2 = Endorsement::new_verifiable(
522 Endorsement {
523 slot: Slot::new(1, 0),
524 index: ENDORSEMENT_COUNT - 1,
525 endorsed_block: BlockId::generate_from_hash(
526 Hash::from_bs58_check("bq1NsaCBAfseMKSjNBYLhpK7M5eeef2m277MYS2P2k424GaDf")
527 .unwrap(),
528 ),
529 },
530 EndorsementSerializer::new(),
531 &keypair,
532 *CHAINID,
533 )
534 .unwrap();
535
536 let orig_header = BlockHeader::new_verifiable(
538 BlockHeader {
539 current_version: 0,
540 announced_version: None,
541 slot: Slot::new(1, 0),
542 parents,
543 operation_merkle_root: empty_operations_merkle_root(),
544 endorsements: vec![endo1, endo2],
545 denunciations: Vec::new(), },
547 BlockHeaderSerializer::new(),
548 &keypair,
549 *CHAINID,
550 )
551 .unwrap();
552
553 let orig_block = Block {
555 header: orig_header.clone(),
556 operations: Default::default(),
557 };
558
559 let secured_block: SecureShareBlock = Block::new_verifiable(
561 orig_block.clone(),
562 BlockSerializer::new(),
563 &keypair,
564 *CHAINID,
565 )
566 .unwrap();
567 let mut ser_block = Vec::new();
568 SecureShareSerializer::new()
569 .serialize(&secured_block, &mut ser_block)
570 .unwrap();
571
572 let args = BlockDeserializerArgs {
574 thread_count: THREAD_COUNT,
575 max_operations_per_block: MAX_OPERATIONS_PER_BLOCK,
576 endorsement_count: ENDORSEMENT_COUNT,
577 max_denunciations_per_block_header: MAX_DENUNCIATIONS_PER_BLOCK_HEADER,
578 last_start_period: Some(0),
579 chain_id: *CHAINID,
580 };
581 let (rest, res_block): (&[u8], SecureShareBlock) =
582 SecureShareDeserializer::new(BlockDeserializer::new(args), *CHAINID)
583 .deserialize::<DeserializeError>(&ser_block)
584 .unwrap();
585
586 assert!(rest.is_empty());
587 assert_eq!(orig_block.header.id, res_block.content.header.id);
589 assert_eq!(orig_block.header.id, res_block.id);
590 assert_eq!(
591 orig_block.header.content.slot,
592 res_block.content.header.content.slot
593 );
594 assert_eq!(
595 orig_block.header.serialized_data,
596 res_block.content.header.serialized_data
597 );
598 assert_eq!(
599 orig_block.header.signature,
600 res_block.content.header.signature
601 );
602
603 assert_eq!(
604 orig_block.header.content.endorsements,
605 res_block.content.header.content.endorsements
606 );
607
608 assert_eq!(orig_block.header.signature, res_block.signature);
609 res_block.verify_signature(*CHAINID).unwrap();
610 for ed in orig_block.header.content.endorsements.iter() {
611 ed.verify_signature(*CHAINID).unwrap();
612 }
613
614 res_block
615 .content
616 .header
617 .assert_invariants(THREAD_COUNT, ENDORSEMENT_COUNT)
618 .unwrap();
619 }
620
621 #[test]
622 #[serial]
623 fn test_block_deserialization_merkle_root_mismatch() {
624 let keypair = KeyPair::generate(0).unwrap();
625 let parents: Vec<BlockId> = (0..THREAD_COUNT)
626 .map(|i| BlockId::generate_from_hash(Hash::compute_from(&[i])))
627 .collect();
628
629 let orig_header = BlockHeader::new_verifiable(
630 BlockHeader {
631 current_version: 0,
632 announced_version: None,
633 slot: Slot::new(1, 0),
634 parents,
635 operation_merkle_root: Hash::compute_from("mno".as_bytes()),
636 endorsements: vec![],
637 denunciations: Vec::new(),
638 },
639 BlockHeaderSerializer::new(),
640 &keypair,
641 *CHAINID,
642 )
643 .unwrap();
644
645 let orig_block = Block {
646 header: orig_header,
647 operations: Default::default(),
648 };
649
650 let secured_block: SecureShareBlock =
651 Block::new_verifiable(orig_block, BlockSerializer::new(), &keypair, *CHAINID).unwrap();
652 let mut ser_block = Vec::new();
653 SecureShareSerializer::new()
654 .serialize(&secured_block, &mut ser_block)
655 .unwrap();
656
657 let args = BlockDeserializerArgs {
658 thread_count: THREAD_COUNT,
659 max_operations_per_block: MAX_OPERATIONS_PER_BLOCK,
660 endorsement_count: ENDORSEMENT_COUNT,
661 max_denunciations_per_block_header: MAX_DENUNCIATIONS_PER_BLOCK_HEADER,
662 last_start_period: Some(0),
663 chain_id: *CHAINID,
664 };
665 let res: Result<(&[u8], SecureShareBlock), _> =
666 SecureShareDeserializer::new(BlockDeserializer::new(args), *CHAINID)
667 .deserialize::<DeserializeError>(&ser_block);
668
669 assert!(res.is_err());
670 }
671
672 #[test]
673 #[serial]
674 fn test_genesis_block_serialization() {
675 let keypair = KeyPair::generate(0).unwrap();
676 let parents: Vec<BlockId> = vec![];
677
678 let orig_header = BlockHeader::new_verifiable(
680 BlockHeader {
681 current_version: 0,
682 announced_version: None,
683 slot: Slot::new(0, 1),
684 parents,
685 operation_merkle_root: empty_operations_merkle_root(),
686 endorsements: vec![],
687 denunciations: vec![],
688 },
689 BlockHeaderSerializer::new(),
690 &keypair,
691 *CHAINID,
692 )
693 .unwrap();
694
695 let orig_block = Block {
697 header: orig_header,
698 operations: Default::default(),
699 };
700
701 let secured_block: SecureShareBlock = Block::new_verifiable(
703 orig_block.clone(),
704 BlockSerializer::new(),
705 &keypair,
706 *CHAINID,
707 )
708 .unwrap();
709 let mut ser_block = Vec::new();
710 SecureShareSerializer::new()
711 .serialize(&secured_block, &mut ser_block)
712 .unwrap();
713
714 let args = BlockDeserializerArgs {
716 thread_count: THREAD_COUNT,
717 max_operations_per_block: MAX_OPERATIONS_PER_BLOCK,
718 endorsement_count: ENDORSEMENT_COUNT,
719 max_denunciations_per_block_header: MAX_DENUNCIATIONS_PER_BLOCK_HEADER,
720 last_start_period: Some(0),
721 chain_id: *CHAINID,
722 };
723 let (rest, res_block): (&[u8], SecureShareBlock) =
724 SecureShareDeserializer::new(BlockDeserializer::new(args), *CHAINID)
725 .deserialize::<DeserializeError>(&ser_block)
726 .unwrap();
727
728 res_block
729 .content
730 .header
731 .assert_invariants(THREAD_COUNT, ENDORSEMENT_COUNT)
732 .unwrap();
733
734 assert!(rest.is_empty());
737 assert_eq!(orig_block.header.id, res_block.content.header.id);
738 assert_eq!(
740 orig_block.header.content.slot,
741 res_block.content.header.content.slot
742 );
743 assert_eq!(
744 orig_block.header.serialized_data,
745 res_block.content.header.serialized_data
746 );
747 assert_eq!(
748 orig_block.header.signature,
749 res_block.content.header.signature
750 );
751
752 assert_eq!(
753 orig_block.header.content.endorsements,
754 res_block.content.header.content.endorsements
755 );
756
757 assert_eq!(orig_block.header.signature, res_block.signature);
758 }
759
760 #[test]
761 #[serial]
762 fn test_invalid_genesis_block_serialization_with_endorsements() {
763 let keypair = KeyPair::generate(0).unwrap();
764 let parents: Vec<BlockId> = vec![];
765
766 let endorsement = Endorsement {
768 slot: Slot::new(0, 1),
769 index: 1,
770 endorsed_block: BlockId::generate_from_hash(Hash::compute_from(&[1])),
771 };
772
773 let orig_header = BlockHeader::new_verifiable(
775 BlockHeader {
776 current_version: 0,
777 announced_version: None,
778 slot: Slot::new(0, 1),
779 parents,
780 operation_merkle_root: empty_operations_merkle_root(),
781 endorsements: vec![Endorsement::new_verifiable(
782 endorsement,
783 EndorsementSerializer::new(),
784 &keypair,
785 *CHAINID,
786 )
787 .unwrap()],
788 denunciations: vec![],
789 },
790 BlockHeaderSerializer::new(),
791 &keypair,
792 *CHAINID,
793 )
794 .unwrap();
795
796 let orig_block = Block {
798 header: orig_header,
799 operations: Default::default(),
800 };
801
802 let secured_block: SecureShareBlock =
804 Block::new_verifiable(orig_block, BlockSerializer::new(), &keypair, *CHAINID).unwrap();
805 let mut ser_block = Vec::new();
806 SecureShareSerializer::new()
807 .serialize(&secured_block, &mut ser_block)
808 .unwrap();
809
810 let args = BlockDeserializerArgs {
812 thread_count: THREAD_COUNT,
813 max_operations_per_block: MAX_OPERATIONS_PER_BLOCK,
814 endorsement_count: ENDORSEMENT_COUNT,
815 max_denunciations_per_block_header: MAX_DENUNCIATIONS_PER_BLOCK_HEADER,
816 last_start_period: Some(0),
817 chain_id: *CHAINID,
818 };
819 let res: Result<(&[u8], SecureShareBlock), _> =
820 SecureShareDeserializer::new(BlockDeserializer::new(args), *CHAINID)
821 .deserialize::<DeserializeError>(&ser_block);
822
823 assert!(res.is_err());
826 }
830 #[test]
831 #[serial]
832 fn test_invalid_genesis_block_serialization_with_parents() {
833 let keypair = KeyPair::generate(0).unwrap();
834 let parents = (0..THREAD_COUNT)
835 .map(|i| BlockId::generate_from_hash(Hash::compute_from(&[i])))
836 .collect();
837
838 let orig_header = BlockHeader::new_verifiable(
840 BlockHeader {
841 current_version: 0,
842 announced_version: None,
843 slot: Slot::new(0, 1),
844 parents,
845 operation_merkle_root: empty_operations_merkle_root(),
846 endorsements: vec![],
847 denunciations: vec![],
848 },
849 BlockHeaderSerializer::new(),
850 &keypair,
851 *CHAINID,
852 )
853 .unwrap();
854
855 let orig_block = Block {
857 header: orig_header,
858 operations: Default::default(),
859 };
860
861 let secured_block: SecureShareBlock =
863 Block::new_verifiable(orig_block, BlockSerializer::new(), &keypair, *CHAINID).unwrap();
864 let mut ser_block = Vec::new();
865 SecureShareSerializer::new()
866 .serialize(&secured_block, &mut ser_block)
867 .unwrap();
868
869 let args = BlockDeserializerArgs {
871 thread_count: THREAD_COUNT,
872 max_operations_per_block: MAX_OPERATIONS_PER_BLOCK,
873 endorsement_count: ENDORSEMENT_COUNT,
874 max_denunciations_per_block_header: MAX_DENUNCIATIONS_PER_BLOCK_HEADER,
875 last_start_period: Some(0),
876 chain_id: *CHAINID,
877 };
878 let res: Result<(&[u8], SecureShareBlock), _> =
879 SecureShareDeserializer::new(BlockDeserializer::new(args), *CHAINID)
880 .deserialize::<DeserializeError>(&ser_block);
881
882 assert!(res.is_err());
885 }
886 #[test]
887 #[serial]
888 fn test_invalid_block_serialization_no_parents() {
889 let keypair = KeyPair::generate(0).unwrap();
890 let orig_header = BlockHeader::new_verifiable(
894 BlockHeader {
895 current_version: 0,
896 announced_version: None,
897 slot: Slot::new(1, 1),
898 parents: vec![],
899 operation_merkle_root: empty_operations_merkle_root(),
900 endorsements: vec![],
901 denunciations: vec![],
902 },
903 BlockHeaderSerializer::new(),
904 &keypair,
905 *CHAINID,
906 )
907 .unwrap();
908
909 let orig_block = Block {
911 header: orig_header,
912 operations: Default::default(),
913 };
914
915 let secured_block: SecureShareBlock =
917 Block::new_verifiable(orig_block, BlockSerializer::new(), &keypair, *CHAINID).unwrap();
918 let mut ser_block = Vec::new();
919 SecureShareSerializer::new()
920 .serialize(&secured_block, &mut ser_block)
921 .unwrap();
922
923 let args = BlockDeserializerArgs {
925 thread_count: THREAD_COUNT,
926 max_operations_per_block: MAX_OPERATIONS_PER_BLOCK,
927 endorsement_count: ENDORSEMENT_COUNT,
928 max_denunciations_per_block_header: MAX_DENUNCIATIONS_PER_BLOCK_HEADER,
929 last_start_period: Some(0),
930 chain_id: *CHAINID,
931 };
932 let res: Result<(&[u8], SecureShareBlock), _> =
933 SecureShareDeserializer::new(BlockDeserializer::new(args), *CHAINID)
934 .deserialize::<DeserializeError>(&ser_block);
935
936 assert!(res.is_err());
939 }
940 #[test]
941 #[serial]
942 fn test_invalid_block_serialization_obo_high_parent_count() {
943 let keypair = KeyPair::generate(0).unwrap();
944 let parents = (0..=THREAD_COUNT)
946 .map(|i| BlockId::generate_from_hash(Hash::compute_from(&[i])))
947 .collect();
948
949 let orig_header = BlockHeader::new_verifiable(
951 BlockHeader {
952 current_version: 0,
953 announced_version: None,
954 slot: Slot::new(1, 1),
955 parents,
956 operation_merkle_root: empty_operations_merkle_root(),
957 endorsements: vec![],
958 denunciations: vec![],
959 },
960 BlockHeaderSerializer::new(),
961 &keypair,
962 *CHAINID,
963 )
964 .unwrap();
965
966 let orig_block = Block {
968 header: orig_header,
969 operations: Default::default(),
970 };
971
972 let secured_block: SecureShareBlock =
974 Block::new_verifiable(orig_block, BlockSerializer::new(), &keypair, *CHAINID).unwrap();
975 let mut ser_block = Vec::new();
976 SecureShareSerializer::new()
977 .serialize(&secured_block, &mut ser_block)
978 .unwrap();
979
980 let args = BlockDeserializerArgs {
982 thread_count: THREAD_COUNT,
983 max_operations_per_block: MAX_OPERATIONS_PER_BLOCK,
984 endorsement_count: ENDORSEMENT_COUNT,
985 max_denunciations_per_block_header: MAX_DENUNCIATIONS_PER_BLOCK_HEADER,
986 last_start_period: Some(0),
987 chain_id: *CHAINID,
988 };
989 let res: Result<(&[u8], SecureShareBlock), _> =
990 SecureShareDeserializer::new(BlockDeserializer::new(args), *CHAINID)
991 .deserialize::<DeserializeError>(&ser_block);
992
993 assert!(res.is_err());
996 }
997
998 #[test]
999 #[serial]
1000 fn test_block_serialization_max_endo_count() {
1001 let keypair =
1002 KeyPair::from_str("S1bXjyPwrssNmG4oUG5SEqaUhQkVArQi7rzQDWpCprTSmEgZDGG").unwrap();
1003 let endorsed = BlockId::generate_from_hash(
1004 Hash::from_bs58_check("bq1NsaCBAfseMKSjNBYLhpK7M5eeef2m277MYS2P2k424GaDf").unwrap(),
1005 );
1006 let fillers =
1007 (1..THREAD_COUNT).map(|i| BlockId::generate_from_hash(Hash::compute_from(&[i])));
1008 let parents = std::iter::once(endorsed).chain(fillers).collect();
1009
1010 let endorsements = (0..ENDORSEMENT_COUNT)
1011 .map(|i| {
1012 Endorsement::new_verifiable(
1013 Endorsement {
1014 slot: Slot::new(1, 0),
1015 index: i,
1016 endorsed_block: BlockId::generate_from_hash(
1017 Hash::from_bs58_check(
1018 "bq1NsaCBAfseMKSjNBYLhpK7M5eeef2m277MYS2P2k424GaDf",
1019 )
1020 .unwrap(),
1021 ),
1022 },
1023 EndorsementSerializer::new(),
1024 &keypair,
1025 *CHAINID,
1026 )
1027 .unwrap()
1028 })
1029 .collect();
1030 let orig_header = BlockHeader::new_verifiable(
1032 BlockHeader {
1033 current_version: 0,
1034 announced_version: None,
1035 slot: Slot::new(1, 0),
1036 parents,
1037 operation_merkle_root: empty_operations_merkle_root(),
1038 endorsements,
1039 denunciations: vec![],
1040 },
1041 BlockHeaderSerializer::new(),
1042 &keypair,
1043 *CHAINID,
1044 )
1045 .unwrap();
1046
1047 let orig_block = Block {
1049 header: orig_header,
1050 operations: Default::default(),
1051 };
1052
1053 let secured_block: SecureShareBlock =
1055 Block::new_verifiable(orig_block, BlockSerializer::new(), &keypair, *CHAINID).unwrap();
1056 let mut ser_block = Vec::new();
1057 SecureShareSerializer::new()
1058 .serialize(&secured_block, &mut ser_block)
1059 .unwrap();
1060
1061 let args = BlockDeserializerArgs {
1063 thread_count: THREAD_COUNT,
1064 max_operations_per_block: MAX_OPERATIONS_PER_BLOCK,
1065 endorsement_count: ENDORSEMENT_COUNT,
1066 max_denunciations_per_block_header: MAX_DENUNCIATIONS_PER_BLOCK_HEADER,
1067 last_start_period: Some(0),
1068 chain_id: *CHAINID,
1069 };
1070 let (_, res): (&[u8], SecureShareBlock) =
1071 SecureShareDeserializer::new(BlockDeserializer::new(args), *CHAINID)
1072 .deserialize::<DeserializeError>(&ser_block)
1073 .unwrap();
1074
1075 res.content
1076 .header
1077 .assert_invariants(THREAD_COUNT, ENDORSEMENT_COUNT)
1078 .unwrap();
1079 }
1080 #[test]
1081 #[serial]
1082 fn test_invalid_block_serialization_obo_low_parent_count() {
1083 let keypair = KeyPair::generate(0).unwrap();
1084 let parents = (1..THREAD_COUNT)
1086 .map(|i| BlockId::generate_from_hash(Hash::compute_from(&[i])))
1087 .collect();
1088
1089 let orig_header = BlockHeader::new_verifiable(
1091 BlockHeader {
1092 current_version: 0,
1093 announced_version: None,
1094 slot: Slot::new(1, 1),
1095 parents,
1096 operation_merkle_root: empty_operations_merkle_root(),
1097 endorsements: vec![],
1098 denunciations: vec![],
1099 },
1100 BlockHeaderSerializer::new(),
1101 &keypair,
1102 *CHAINID,
1103 )
1104 .unwrap();
1105
1106 let orig_block = Block {
1108 header: orig_header,
1109 operations: Default::default(),
1110 };
1111
1112 let secured_block: SecureShareBlock =
1114 Block::new_verifiable(orig_block, BlockSerializer::new(), &keypair, *CHAINID).unwrap();
1115 let mut ser_block = Vec::new();
1116 SecureShareSerializer::new()
1117 .serialize(&secured_block, &mut ser_block)
1118 .unwrap();
1119
1120 let args = BlockDeserializerArgs {
1122 thread_count: THREAD_COUNT,
1123 max_operations_per_block: MAX_OPERATIONS_PER_BLOCK,
1124 endorsement_count: ENDORSEMENT_COUNT,
1125 max_denunciations_per_block_header: MAX_DENUNCIATIONS_PER_BLOCK_HEADER,
1126 last_start_period: Some(0),
1127 chain_id: *CHAINID,
1128 };
1129 let res: Result<(&[u8], SecureShareBlock), _> =
1130 SecureShareDeserializer::new(BlockDeserializer::new(args), *CHAINID)
1131 .deserialize::<DeserializeError>(&ser_block);
1132
1133 assert!(res.is_err());
1136 }
1137 #[test]
1138 #[serial]
1139 fn test_invalid_block_serialization_obo_high_endo_count() {
1140 let keypair = KeyPair::generate(0).unwrap();
1141 let parents = (0..THREAD_COUNT)
1143 .map(|i| BlockId::generate_from_hash(Hash::compute_from(&[i])))
1144 .collect();
1145
1146 let endorsements = (0..=ENDORSEMENT_COUNT)
1147 .map(|i| {
1148 Endorsement::new_verifiable(
1149 Endorsement {
1150 slot: Slot::new(0, 1),
1151 index: i,
1152 endorsed_block: BlockId::generate_from_hash(Hash::compute_from(&[i as u8])),
1153 },
1154 EndorsementSerializer::new(),
1155 &keypair,
1156 *CHAINID,
1157 )
1158 .unwrap()
1159 })
1160 .collect();
1161 let orig_header = BlockHeader::new_verifiable(
1163 BlockHeader {
1164 current_version: 0,
1165 announced_version: None,
1166 slot: Slot::new(1, 1),
1167 parents,
1168 operation_merkle_root: empty_operations_merkle_root(),
1169 endorsements,
1170 denunciations: vec![],
1171 },
1172 BlockHeaderSerializer::new(),
1173 &keypair,
1174 *CHAINID,
1175 )
1176 .unwrap();
1177
1178 let orig_block = Block {
1180 header: orig_header,
1181 operations: Default::default(),
1182 };
1183
1184 let secured_block: SecureShareBlock =
1186 Block::new_verifiable(orig_block, BlockSerializer::new(), &keypair, *CHAINID).unwrap();
1187 let mut ser_block = Vec::new();
1188 SecureShareSerializer::new()
1189 .serialize(&secured_block, &mut ser_block)
1190 .unwrap();
1191
1192 let args = BlockDeserializerArgs {
1194 thread_count: THREAD_COUNT,
1195 max_operations_per_block: MAX_OPERATIONS_PER_BLOCK,
1196 endorsement_count: ENDORSEMENT_COUNT,
1197 max_denunciations_per_block_header: MAX_DENUNCIATIONS_PER_BLOCK_HEADER,
1198 last_start_period: Some(0),
1199 chain_id: *CHAINID,
1200 };
1201 let res: Result<(&[u8], SecureShareBlock), _> =
1202 SecureShareDeserializer::new(BlockDeserializer::new(args), *CHAINID)
1203 .deserialize::<DeserializeError>(&ser_block);
1204
1205 assert!(res.is_err());
1208 }
1209 #[test]
1210 #[serial]
1211 fn test_invalid_endorsement_idx() {
1212 let keypair =
1213 KeyPair::from_str("S1bXjyPwrssNmG4oUG5SEqaUhQkVArQi7rzQDWpCprTSmEgZDGG").unwrap();
1214 let parents = (0..THREAD_COUNT)
1215 .map(|_i| {
1216 BlockId::generate_from_hash(
1217 Hash::from_bs58_check("bq1NsaCBAfseMKSjNBYLhpK7M5eeef2m277MYS2P2k424GaDf")
1218 .unwrap(),
1219 )
1220 })
1221 .collect();
1222
1223 let endo1 = Endorsement::new_verifiable(
1224 Endorsement {
1225 slot: Slot::new(1, 0),
1226 index: ENDORSEMENT_COUNT,
1227 endorsed_block: BlockId::generate_from_hash(
1228 Hash::from_bs58_check("bq1NsaCBAfseMKSjNBYLhpK7M5eeef2m277MYS2P2k424GaDf")
1229 .unwrap(),
1230 ),
1231 },
1232 EndorsementSerializer::new(),
1233 &keypair,
1234 *CHAINID,
1235 )
1236 .unwrap();
1237
1238 let orig_header = BlockHeader::new_verifiable(
1240 BlockHeader {
1241 current_version: 0,
1242 announced_version: None,
1243 slot: Slot::new(1, 0),
1244 parents,
1245 operation_merkle_root: empty_operations_merkle_root(),
1246 endorsements: vec![endo1],
1247 denunciations: vec![],
1248 },
1249 BlockHeaderSerializer::new(),
1250 &keypair,
1251 *CHAINID,
1252 )
1253 .unwrap();
1254
1255 let orig_block = Block {
1257 header: orig_header,
1258 operations: Default::default(),
1259 };
1260
1261 let secured_block: SecureShareBlock =
1263 Block::new_verifiable(orig_block, BlockSerializer::new(), &keypair, *CHAINID).unwrap();
1264 let mut ser_block = Vec::new();
1265 SecureShareSerializer::new()
1266 .serialize(&secured_block, &mut ser_block)
1267 .unwrap();
1268
1269 let args = BlockDeserializerArgs {
1271 thread_count: THREAD_COUNT,
1272 max_operations_per_block: MAX_OPERATIONS_PER_BLOCK,
1273 endorsement_count: ENDORSEMENT_COUNT,
1274 max_denunciations_per_block_header: MAX_DENUNCIATIONS_PER_BLOCK_HEADER,
1275 last_start_period: Some(0),
1276 chain_id: *CHAINID,
1277 };
1278 let res: Result<(&[u8], SecureShareBlock), _> =
1279 SecureShareDeserializer::new(BlockDeserializer::new(args), *CHAINID)
1280 .deserialize::<DeserializeError>(&ser_block);
1281 assert!(res.is_err());
1284 }
1285 #[test]
1286 #[serial]
1287 fn test_invalid_dupe_endo_idx() {
1288 let keypair =
1289 KeyPair::from_str("S1bXjyPwrssNmG4oUG5SEqaUhQkVArQi7rzQDWpCprTSmEgZDGG").unwrap();
1290 let parents = (0..THREAD_COUNT)
1291 .map(|_i| {
1292 BlockId::generate_from_hash(
1293 Hash::from_bs58_check("bq1NsaCBAfseMKSjNBYLhpK7M5eeef2m277MYS2P2k424GaDf")
1294 .unwrap(),
1295 )
1296 })
1297 .collect();
1298
1299 let endo1 = Endorsement::new_verifiable(
1300 Endorsement {
1301 slot: Slot::new(1, 0),
1302 index: 0,
1303 endorsed_block: BlockId::generate_from_hash(
1304 Hash::from_bs58_check("bq1NsaCBAfseMKSjNBYLhpK7M5eeef2m277MYS2P2k424GaDf")
1305 .unwrap(),
1306 ),
1307 },
1308 EndorsementSerializer::new(),
1309 &keypair,
1310 *CHAINID,
1311 )
1312 .unwrap();
1313 let endo2 = Endorsement::new_verifiable(
1314 Endorsement {
1315 slot: Slot::new(1, 0),
1316 index: 0,
1317 endorsed_block: BlockId::generate_from_hash(
1318 Hash::from_bs58_check("bq1NsaCBAfseMKSjNBYLhpK7M5eeef2m277MYS2P2k424GaDf")
1319 .unwrap(),
1320 ),
1321 },
1322 EndorsementSerializer::new(),
1323 &keypair,
1324 *CHAINID,
1325 )
1326 .unwrap();
1327
1328 let orig_header = BlockHeader::new_verifiable(
1330 BlockHeader {
1331 current_version: 0,
1332 announced_version: None,
1333 slot: Slot::new(1, 0),
1334 parents,
1335 operation_merkle_root: empty_operations_merkle_root(),
1336 endorsements: vec![endo1, endo2],
1337 denunciations: vec![],
1338 },
1339 BlockHeaderSerializer::new(),
1340 &keypair,
1341 *CHAINID,
1342 )
1343 .unwrap();
1344
1345 let orig_block = Block {
1347 header: orig_header,
1348 operations: Default::default(),
1349 };
1350
1351 let secured_block: SecureShareBlock =
1353 Block::new_verifiable(orig_block, BlockSerializer::new(), &keypair, *CHAINID).unwrap();
1354 let mut ser_block = Vec::new();
1355 SecureShareSerializer::new()
1356 .serialize(&secured_block, &mut ser_block)
1357 .unwrap();
1358
1359 let args = BlockDeserializerArgs {
1361 thread_count: THREAD_COUNT,
1362 max_operations_per_block: MAX_OPERATIONS_PER_BLOCK,
1363 endorsement_count: ENDORSEMENT_COUNT,
1364 max_denunciations_per_block_header: MAX_DENUNCIATIONS_PER_BLOCK_HEADER,
1365 last_start_period: Some(0),
1366 chain_id: *CHAINID,
1367 };
1368 let res: Result<(&[u8], SecureShareBlock), _> =
1369 SecureShareDeserializer::new(BlockDeserializer::new(args), *CHAINID)
1370 .deserialize::<DeserializeError>(&ser_block);
1371
1372 assert!(res.is_err());
1375 }
1376
1377 #[test]
1378 #[serial]
1379 fn test_block_serde() {
1380 let keypair =
1381 KeyPair::from_str("S1bXjyPwrssNmG4oUG5SEqaUhQkVArQi7rzQDWpCprTSmEgZDGG").unwrap();
1382 let parents = (0..THREAD_COUNT)
1383 .map(|_i| {
1384 BlockId::generate_from_hash(
1385 Hash::from_bs58_check("bq1NsaCBAfseMKSjNBYLhpK7M5eeef2m277MYS2P2k424GaDf")
1386 .unwrap(),
1387 )
1388 })
1389 .collect();
1390
1391 let endo1 = Endorsement::new_verifiable(
1392 Endorsement {
1393 slot: Slot::new(1, 0),
1394 index: 0,
1395 endorsed_block: BlockId::generate_from_hash(
1396 Hash::from_bs58_check("bq1NsaCBAfseMKSjNBYLhpK7M5eeef2m277MYS2P2k424GaDf")
1397 .unwrap(),
1398 ),
1399 },
1400 EndorsementSerializer::new(),
1401 &keypair,
1402 *CHAINID,
1403 )
1404 .unwrap();
1405 let endo2 = Endorsement::new_verifiable(
1406 Endorsement {
1407 slot: Slot::new(1, 0),
1408 index: ENDORSEMENT_COUNT - 1,
1409 endorsed_block: BlockId::generate_from_hash(
1410 Hash::from_bs58_check("bq1NsaCBAfseMKSjNBYLhpK7M5eeef2m277MYS2P2k424GaDf")
1411 .unwrap(),
1412 ),
1413 },
1414 EndorsementSerializer::new(),
1415 &keypair,
1416 *CHAINID,
1417 )
1418 .unwrap();
1419
1420 let orig_header = BlockHeader::new_verifiable(
1422 BlockHeader {
1423 current_version: 0,
1424 announced_version: None,
1425 slot: Slot::new(1, 0),
1426 parents,
1427 operation_merkle_root: empty_operations_merkle_root(),
1428 endorsements: vec![endo1, endo2],
1429 denunciations: Vec::new(), },
1431 BlockHeaderSerializer::new(),
1432 &keypair,
1433 *CHAINID,
1434 )
1435 .unwrap();
1436
1437 let orig_block = Block {
1439 header: orig_header.clone(),
1440 operations: Default::default(),
1441 };
1442
1443 let serialized_block = serde_json::to_string(&orig_block).unwrap();
1444 let res_block: Value = serde_json::from_str(&serialized_block).unwrap();
1445 assert_eq!(orig_block.header.id.to_string(), res_block["header"]["id"]);
1447 assert_eq!(
1448 orig_block.header.signature.to_string(),
1449 res_block["header"]["signature"]
1450 );
1451 }
1452}