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