massa_models/
block.rs

1//! Copyright (c) 2022 MASSA LABS <info@massa.net>
2
3// use crate::config::THREAD_COUNT;
4// use crate::endorsement::{EndorsementId, EndorsementSerializer, EndorsementSerializerLW};
5// use crate::prehash::PreHashed;
6use crate::secure_share::{
7    Id, SecureShare, SecureShareContent, SecureShareDeserializer, SecureShareSerializer,
8};
9use crate::{
10    // endorsement::{Endorsement, EndorsementDeserializerLW, SecureShareEndorsement},
11    error::ModelsError,
12    operation::{
13        compute_operations_hash, OperationId, OperationIdSerializer, OperationIdsDeserializer,
14        OperationIdsSerializer, SecureShareOperation,
15    },
16    // slot::{Slot, SlotDeserializer, SlotSerializer},
17};
18// use massa_hash::{Hash, HashDeserializer};
19use massa_hash::Hash;
20use massa_serialization::{
21    // DeserializeError,
22    Deserializer,
23    SerializeError,
24    Serializer,
25    // U32VarIntDeserializer,
26    // U32VarIntSerializer, U64VarIntDeserializer, U64VarIntSerializer,
27};
28use massa_signature::{KeyPair, PublicKey, Signature};
29// use nom::branch::alt;
30// use nom::bytes::complete::tag;
31use nom::error::context;
32// use nom::multi::{count, length_count};
33use nom::sequence::tuple;
34use nom::Parser;
35use nom::{
36    error::{ContextError, ParseError},
37    IResult,
38};
39use serde::{Deserialize, Serialize};
40// use serde_with::{DeserializeFromStr, SerializeDisplay};
41// use std::collections::HashSet;
42// use std::convert::TryInto;
43use std::fmt::Formatter;
44// use std::ops::Bound::{Excluded, Included};
45// use std::str::FromStr;
46use crate::block_header::{BlockHeader, BlockHeaderDeserializer, SecuredHeader};
47use crate::block_id::BlockId;
48
49/// block
50#[derive(Debug, Clone, Serialize, Deserialize)]
51pub struct Block {
52    /// signed header
53    pub header: SecuredHeader,
54    /// operations ids
55    pub operations: Vec<OperationId>,
56}
57
58/// filled block
59#[derive(Debug, Clone, Serialize, Deserialize)]
60pub struct FilledBlock {
61    /// signed header
62    pub header: SecuredHeader,
63    /// operations
64    pub operations: Vec<(OperationId, Option<SecureShareOperation>)>,
65}
66
67/// Block with associated meta-data and interfaces allowing trust of data in untrusted network
68pub type SecureShareBlock = SecureShare<Block, BlockId>;
69
70/// Blocks are not signed at the block level: authentication lives in the nested
71/// [`SecuredHeader`]. The outer [`SecureShareBlock`] copies the header's signature,
72/// creator key, and id for transport convenience, while `serialized_data` holds
73/// the full block bytes (header + operation ids).
74impl SecureShareContent for Block {
75    /// Delegates to the nested signed header signing domain.
76    ///
77    /// Outer auth fields are copies of the header's; the default
78    /// [`SecureShareContent::verify_signature`] would verify against the wrong domain.
79    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}
146/// Serializer for `Block`
147pub struct BlockSerializer {
148    header_serializer: SecureShareSerializer,
149    op_ids_serializer: OperationIdsSerializer,
150}
151
152impl BlockSerializer {
153    /// Creates a new `BlockSerializer`
154    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    /// ## Example:
170    /// ```rust
171    /// use massa_models::{block::{Block, BlockSerializer}, config::THREAD_COUNT, slot::Slot, endorsement::{Endorsement, EndorsementSerializer}, secure_share::SecureShareContent, prehash::PreHashSet};
172    /// use massa_models::block_header::{BlockHeader, BlockHeaderSerializer};
173    /// use massa_models::block_id::{BlockId};
174    /// use massa_hash::Hash;
175    /// use massa_models::config::CHAINID;
176    /// use massa_signature::KeyPair;
177    /// use massa_models::operation::{compute_operations_hash, OperationIdSerializer};
178    /// use massa_serialization::Serializer;
179    /// let keypair = KeyPair::generate(0).unwrap();
180    /// let parents = (0..THREAD_COUNT)
181    ///     .map(|i| BlockId::generate_from_hash(Hash::compute_from(&[i])))
182    ///     .collect();
183    ///
184    /// // create block header
185    /// let orig_header = BlockHeader::new_verifiable(
186    ///     BlockHeader {
187    ///         current_version: 0,
188    ///         announced_version: None,
189    ///         slot: Slot::new(1, 1),
190    ///         parents,
191    ///         operation_merkle_root: compute_operations_hash(&[], &OperationIdSerializer::new()),
192    ///         endorsements: vec![
193    ///             Endorsement::new_verifiable(
194    ///                 Endorsement {
195    ///                     slot: Slot::new(1, 1),
196    ///                     index: 1,
197    ///                     endorsed_block: BlockId::generate_from_hash(Hash::compute_from("blk1".as_bytes())),
198    ///                 },
199    ///                 EndorsementSerializer::new(),
200    ///                 &keypair,
201    ///                 *CHAINID
202    ///             )
203    ///             .unwrap(),
204    ///             Endorsement::new_verifiable(
205    ///                 Endorsement {
206    ///                     slot: Slot::new(4, 0),
207    ///                     index: 3,
208    ///                     endorsed_block: BlockId::generate_from_hash(Hash::compute_from("blk2".as_bytes())),
209    ///                 },
210    ///                 EndorsementSerializer::new(),
211    ///                 &keypair,
212    ///                 *CHAINID
213    ///             )
214    ///             .unwrap(),
215    ///         ],
216    ///         denunciations: Vec::new(),
217    ///     },
218    ///     BlockHeaderSerializer::new(),
219    ///     &keypair,
220    ///     *CHAINID
221    /// )
222    /// .unwrap();
223    ///
224    /// // create block
225    /// let orig_block = Block {
226    ///     header: orig_header,
227    ///     operations: Vec::new(),
228    /// };
229    ///
230    /// let mut buffer = Vec::new();
231    /// BlockSerializer::new().serialize(&orig_block, &mut buffer).unwrap();
232    /// ```
233    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
241/// Parameters for the deserializer of a block
242pub struct BlockDeserializerArgs {
243    /// Number of threads in Massa
244    pub thread_count: u8,
245    /// Maximum of operations in a block
246    pub max_operations_per_block: u32,
247    /// Number of endorsements in a block
248    pub endorsement_count: u32,
249    /// Max denunciations in a block
250    pub max_denunciations_per_block_header: u32,
251    /// If Some(lsp), this will through if trying to deserialize a block with a period before the genesis blocks
252    pub last_start_period: Option<u64>,
253    /// chain id
254    pub chain_id: u64,
255}
256
257/// Deserializer for `Block`
258pub struct BlockDeserializer {
259    header_deserializer: SecureShareDeserializer<BlockHeader, BlockHeaderDeserializer>,
260    op_ids_deserializer: OperationIdsDeserializer,
261    op_id_serializer: OperationIdSerializer,
262}
263
264impl BlockDeserializer {
265    /// Creates a new `BlockDeserializer`
266    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    /// ## Example:
286    /// ```rust
287    /// use massa_models::{block::{Block, BlockSerializer, BlockDeserializer, BlockDeserializerArgs}, config::THREAD_COUNT, slot::Slot, endorsement::{Endorsement, EndorsementSerializer}, secure_share::SecureShareContent, prehash::PreHashSet};
288    /// use massa_models::block_id::BlockId;
289    /// use massa_models::block_header::{BlockHeader, BlockHeaderSerializer};
290    /// use massa_hash::Hash;
291    /// use massa_models::config::CHAINID;
292    /// use massa_signature::KeyPair;
293    /// use massa_models::operation::{compute_operations_hash, OperationIdSerializer};
294    /// use massa_serialization::{Serializer, Deserializer, DeserializeError};
295    /// let keypair = KeyPair::generate(0).unwrap();
296    /// let parents: Vec<BlockId> = (0..THREAD_COUNT)
297    ///     .map(|i| BlockId::generate_from_hash(Hash::compute_from(&[i])))
298    ///     .collect();
299    ///
300    /// // create block header
301    /// let orig_header = BlockHeader::new_verifiable(
302    ///     BlockHeader {
303    ///         current_version: 0,
304    ///         announced_version: None,
305    ///         slot: Slot::new(1, 1),
306    ///         parents: parents.clone(),
307    ///         operation_merkle_root: compute_operations_hash(&[], &OperationIdSerializer::new()),
308    ///         endorsements: vec![
309    ///             Endorsement::new_verifiable(
310    ///                 Endorsement {
311    ///                     slot: Slot::new(1, 1),
312    ///                     index: 0,
313    ///                     endorsed_block: parents[1].clone(),
314    ///                 },
315    ///                 EndorsementSerializer::new(),
316    ///                 &keypair,
317    ///                 *CHAINID
318    ///             )
319    ///             .unwrap(),
320    ///             Endorsement::new_verifiable(
321    ///                 Endorsement {
322    ///                     slot: Slot::new(1, 1),
323    ///                     index: 1,
324    ///                     endorsed_block: parents[1].clone(),
325    ///                 },
326    ///                 EndorsementSerializer::new(),
327    ///                 &keypair,
328    ///                 *CHAINID
329    ///             )
330    ///             .unwrap(),
331    ///         ],
332    ///         denunciations: Vec::new(),
333    ///     },
334    ///     BlockHeaderSerializer::new(),
335    ///     &keypair,
336    ///     *CHAINID
337    /// )
338    /// .unwrap();
339    ///
340    /// // create block
341    /// let orig_block = Block {
342    ///     header: orig_header,
343    ///     operations: Vec::new(),
344    /// };
345    ///
346    /// let mut buffer = Vec::new();
347    /// BlockSerializer::new().serialize(&orig_block, &mut buffer).unwrap();
348    /// let args = BlockDeserializerArgs {
349    ///     thread_count: THREAD_COUNT,
350    ///     max_operations_per_block: 100,
351    ///     endorsement_count: 9,
352    ///     max_denunciations_per_block_header: 10,
353    ///     last_start_period: Some(0),
354    ///     chain_id: *CHAINID
355    /// };
356    /// let (rest, res_block) = BlockDeserializer::new(args).deserialize::<DeserializeError>(&mut buffer).unwrap();
357    ///
358    /// assert!(rest.is_empty());
359    /// // check equality
360    /// assert_eq!(orig_block.header.id, res_block.header.id);
361    /// assert_eq!(
362    ///     orig_block.header.content.slot,
363    ///     res_block.header.content.slot
364    /// );
365    /// assert_eq!(
366    ///     orig_block.header.serialized_data,
367    ///     res_block.header.serialized_data
368    /// );
369    /// assert_eq!(
370    ///     orig_block.header.signature,
371    ///     res_block.header.signature
372    /// );
373    /// ```
374    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    /// size in bytes of the whole block
407    pub fn bytes_count(&self) -> u64 {
408        self.serialized_data.len() as u64
409    }
410
411    /// true if given operation is included in the block
412    pub fn contains_operation(&self, op: SecureShareOperation) -> bool {
413        self.content.operations.contains(&op.id)
414    }
415
416    /// returns the fitness of the block
417    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// NOTE: TODO
439// impl Signable<BlockId> for BlockHeader {
440//     fn get_signature_message(&self) -> Result<Hash, ModelsError> {
441//         let hash = self.compute_hash()?;
442//         let mut res = [0u8; SLOT_KEY_SIZE + BLOCK_ID_SIZE_BYTES];
443//         res[..SLOT_KEY_SIZE].copy_from_slice(&self.slot.to_bytes_key());
444//         res[SLOT_KEY_SIZE..].copy_from_slice(hash.to_bytes());
445//         // rehash for safety
446//         Ok(Hash::compute_from(&res))
447//     }
448// }
449
450/// Block status within the graph
451#[derive(Eq, PartialEq, Debug, Deserialize, Serialize)]
452pub enum BlockGraphStatus {
453    /// received but not yet graph-processed
454    Incoming,
455    /// waiting for its slot
456    WaitingForSlot,
457    /// waiting for a missing dependency
458    WaitingForDependencies,
459    /// active in alternative cliques
460    ActiveInAlternativeCliques,
461    /// active in blockclique
462    ActiveInBlockclique,
463    /// forever applies
464    Final,
465    /// discarded for any reason
466    Discarded,
467    /// not found in graph
468    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        // create block header
537        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(), // FIXME
546            },
547            BlockHeaderSerializer::new(),
548            &keypair,
549            *CHAINID,
550        )
551        .unwrap();
552
553        // create block
554        let orig_block = Block {
555            header: orig_header.clone(),
556            operations: Default::default(),
557        };
558
559        // serialize block
560        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        // deserialize
573        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        // check equality
588        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        // create block header
679        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        // create block
696        let orig_block = Block {
697            header: orig_header,
698            operations: Default::default(),
699        };
700
701        // serialize block
702        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        // deserialize
715        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        // check equality
735
736        assert!(rest.is_empty());
737        assert_eq!(orig_block.header.id, res_block.content.header.id);
738        // assert_eq!(orig_block.header.id, res_block.id);
739        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        // Genesis block do not have any parents and thus cannot embed endorsements
767        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        // create block header
774        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        // create block
797        let orig_block = Block {
798            header: orig_header,
799            operations: Default::default(),
800        };
801
802        // serialize block
803        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        // deserialize
811        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        // TODO: Catch an failed deser being a fail, instead of a recoverable error
824        // TODO: assert that the error variant/context/etc. matches the expected failure
825        assert!(res.is_err());
826        // let nom::Err::Failure(_) = res.unwrap_err() else {
827        //     panic!("Deserialisation with invalid endorsements should be total fail");
828        // };
829    }
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        // create block header
839        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        // create block
856        let orig_block = Block {
857            header: orig_header,
858            operations: Default::default(),
859        };
860
861        // serialize block
862        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        // deserialize
870        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        // TODO: Catch an failed deser being a fail, instead of a recoverable error
883        // TODO: assert that the error variant/context/etc. matches the expected failure
884        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        // Non genesis block must have THREAD_COUNT parents
891
892        // create block header
893        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        // create block
910        let orig_block = Block {
911            header: orig_header,
912            operations: Default::default(),
913        };
914
915        // serialize block
916        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        // deserialize
924        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        // TODO: Catch an failed deser being a fail, instead of a recoverable error
937        // TODO: assert that the error variant/context/etc. matches the expected failure
938        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        // Non genesis block must have THREAD_COUNT parents
945        let parents = (0..=THREAD_COUNT)
946            .map(|i| BlockId::generate_from_hash(Hash::compute_from(&[i])))
947            .collect();
948
949        // create block header
950        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        // create block
967        let orig_block = Block {
968            header: orig_header,
969            operations: Default::default(),
970        };
971
972        // serialize block
973        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        // deserialize
981        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        // TODO: Catch an failed deser being a fail, instead of a recoverable error
994        // TODO: assert that the error variant/context/etc. matches the expected failure
995        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        // create block header
1031        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        // create block
1048        let orig_block = Block {
1049            header: orig_header,
1050            operations: Default::default(),
1051        };
1052
1053        // serialize block
1054        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        // deserialize
1062        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        // Non genesis block must have THREAD_COUNT parents
1085        let parents = (1..THREAD_COUNT)
1086            .map(|i| BlockId::generate_from_hash(Hash::compute_from(&[i])))
1087            .collect();
1088
1089        // create block header
1090        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        // create block
1107        let orig_block = Block {
1108            header: orig_header,
1109            operations: Default::default(),
1110        };
1111
1112        // serialize block
1113        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        // deserialize
1121        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        // TODO: Catch an failed deser being a fail, instead of a recoverable error
1134        // TODO: assert that the error variant/context/etc. matches the expected failure
1135        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        // Non genesis block must have THREAD_COUNT parents
1142        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        // create block header
1162        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        // create block
1179        let orig_block = Block {
1180            header: orig_header,
1181            operations: Default::default(),
1182        };
1183
1184        // serialize block
1185        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        // deserialize
1193        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        // TODO: Catch an failed deser being a fail, instead of a recoverable error
1206        // TODO: see issue #3400
1207        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        // create block header
1239        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        // create block
1256        let orig_block = Block {
1257            header: orig_header,
1258            operations: Default::default(),
1259        };
1260
1261        // serialize block
1262        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        // deserialize
1270        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        // TODO: Catch an failed deser being a fail, instead of a recoverable error
1282        // TODO: assert that the error variant/context/etc. matches the expected failure
1283        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        // create block header
1329        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        // create block
1346        let orig_block = Block {
1347            header: orig_header,
1348            operations: Default::default(),
1349        };
1350
1351        // serialize block
1352        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        // deserialize
1360        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        // TODO: Catch an failed deser being a fail, instead of a recoverable error
1373        // TODO: assert that the error variant/context/etc. matches the expected failure
1374        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        // create block header
1421        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(), // FIXME
1430            },
1431            BlockHeaderSerializer::new(),
1432            &keypair,
1433            *CHAINID,
1434        )
1435        .unwrap();
1436
1437        // create block
1438        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        // check equality
1446        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}