massa_models/

denunciation.rs

//! Copyright (c) 2022 MASSA LABS <info@massa.net>

//! Denunciation intro
//!
//! Currently, nothing prevents a user from producing multiple blocks (for the same Slot) or endorsing a block multiple times.
//! If an invalid Denunciation will just be ignored, a valid Denunciation will slash some locked rolls.
//! Note that this proposal aims at dissuading 'rational' users from causing damage but does help against 'byzantine' actors
//! that just want to disturb or break the blockclique (at any cost).
//!
//! Denunciation structure
//!
//! A denunciation embeds some information such as
//! Slot, the slot from the block header or the endorsements (+ index)
//! A public key: the public key of the secure share endorsement or secured header
//! 2 Hashes & 2 Signatures
//!
//! All of this constitutes a proof (and is verifiable) that a user produced multiple (at least 2) blocks or endorsements
//!
//! Denunciation creation
//!
//! Denunciations are created in a Denunciation pool, receiving new blocks & block headers & endorsements from various places.
//! The denunciation pool is also responsible of returning a list of denunciations to insert into a new block header.
//! After execution, the denunciation is kept for some time inside `executed_denunciations`
//! in order to prevent multiple executions. Note that this structure is part of the final state hash and thus is bootstrapped.
//!
//! Denunciation execution
//!
//! When a Denunciation is proven valid, we then need to ensure that the user has sufficient funds. If we cannot deduct the funds on node
//! balance or staked rolls, we will use 'locked' rolls` (or Deferred credits).
//! Selling a roll will lock it for some time (== 4 cycles). Note that it restricts the time,
//! a denunciation can be produced (A constant value will be defined for this).
//!
//! Punishment model
//!
//! A valid denunciation slashes locked rolls only. It does not forfeit slot rewards
//! (`EndorsementCreatorReward`, `EndorsementTargetReward`, `BlockCreatorReward`) for the
//! denouncing block. A validator denounced in a block may still receive those rewards in the
//! same slot. That is intentional: excluding denounced addresses from same-slot rewards would
//! make the effective penalty depend on whether they were also selected by draws for that slot,
//! which is not a coherent punishment model.

#![allow(missing_docs)]

use std::cmp::Ordering;
use std::ops::Bound::{Excluded, Included};

use nom::{
    error::{context, ContextError, ParseError},
    sequence::tuple,
    IResult, Parser,
};
use num_enum::{IntoPrimitive, TryFromPrimitive};
use serde::{Deserialize, Serialize};
use thiserror::Error;

use crate::block_header::{BlockHeaderDenunciationData, SecuredHeader};
use crate::endorsement::{EndorsementDenunciationData, SecureShareEndorsement};
use crate::slot::{Slot, SlotDeserializer, SlotSerializer};

use crate::secure_share::Id;
use massa_hash::{Hash, HashDeserializer, HashSerializer};
use massa_serialization::{
    Deserializer, SerializeError, Serializer, U32VarIntDeserializer, U32VarIntSerializer,
};
use massa_signature::{
    MassaSignatureError, PublicKey, PublicKeyDeserializer, Signature, SignatureDeserializer,
};
use variant_count::VariantCount;

/// A Variant of Denunciation enum for endorsement
#[allow(dead_code)]
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EndorsementDenunciation {
    public_key: PublicKey,
    slot: Slot,
    index: u32,
    hash_1: Hash,
    hash_2: Hash,
    signature_1: Signature,
    signature_2: Signature,
}

impl EndorsementDenunciation {
    /// Rebuild full hash of SecureShareEndorsement from given arguments.
    ///
    /// `sig_chain_id` selects the signed-hash layout: `None` reproduces the legacy
    /// (chain-agnostic) layout, `Some(chain_id)` reproduces the chain-scoped layout
    /// used post MIP-0002 `Execution` v2 activation. It must match the layout used to
    /// sign the endorsement.
    fn compute_hash_for_sig_verif(
        public_key: &PublicKey,
        slot: &Slot,
        index: &u32,
        content_hash: &Hash,
        sig_chain_id: Option<u64>,
    ) -> Hash {
        let mut hash_data = Vec::new();
        // Public key
        hash_data.extend(public_key.to_bytes());
        // Ser slot & index (+ optional chain id)
        let denunciation_data = EndorsementDenunciationData::new(*slot, *index, sig_chain_id);
        hash_data.extend(&denunciation_data.to_bytes());
        // Add content hash
        hash_data.extend(content_hash.to_bytes());
        Hash::compute_from(&hash_data)
    }

    // Getters (for GRPC From)
    pub fn get_public_key(&self) -> &PublicKey {
        &self.public_key
    }
    pub fn get_slot(&self) -> &Slot {
        &self.slot
    }
    pub fn get_index(&self) -> &u32 {
        &self.index
    }
    pub fn get_hash_1(&self) -> &Hash {
        &self.hash_1
    }
    pub fn get_hash_2(&self) -> &Hash {
        &self.hash_2
    }
    pub fn get_signature_1(&self) -> &Signature {
        &self.signature_1
    }
    pub fn get_signature_2(&self) -> &Signature {
        &self.signature_2
    }
}

/// A Variant of Denunciation enum for block header
#[allow(dead_code)]
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BlockHeaderDenunciation {
    public_key: PublicKey,
    slot: Slot,
    hash_1: Hash,
    hash_2: Hash,
    signature_1: Signature,
    signature_2: Signature,
}

impl BlockHeaderDenunciation {
    /// Rebuild full hash of SecuredHeader from given arguments.
    ///
    /// `sig_chain_id` selects the signed-hash layout: `None` reproduces the legacy
    /// (chain-agnostic) layout, `Some(chain_id)` reproduces the chain-scoped layout
    /// used post MIP-0002 `Execution` v2 activation. It must match the layout used to
    /// sign the block header.
    fn compute_hash_for_sig_verif(
        public_key: &PublicKey,
        slot: &Slot,
        content_hash: &Hash,
        sig_chain_id: Option<u64>,
    ) -> Hash {
        let mut hash_data = Vec::new();
        // Public key
        hash_data.extend(public_key.to_bytes());
        // Ser slot (+ optional chain id)
        let de_data = BlockHeaderDenunciationData::new(*slot, sig_chain_id);
        hash_data.extend(de_data.to_bytes());
        // Add content hash
        hash_data.extend(content_hash.to_bytes());
        Hash::compute_from(&hash_data)
    }

    // Getters (for GRPC From)
    pub fn get_public_key(&self) -> &PublicKey {
        &self.public_key
    }
    pub fn get_slot(&self) -> &Slot {
        &self.slot
    }
    pub fn get_hash_1(&self) -> &Hash {
        &self.hash_1
    }
    pub fn get_hash_2(&self) -> &Hash {
        &self.hash_2
    }
    pub fn get_signature_1(&self) -> &Signature {
        &self.signature_1
    }
    pub fn get_signature_2(&self) -> &Signature {
        &self.signature_2
    }
}

/// A denunciation enum
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[allow(missing_docs)]
pub enum Denunciation {
    Endorsement(EndorsementDenunciation),
    BlockHeader(BlockHeaderDenunciation),
}

#[allow(dead_code)]
impl Denunciation {
    /// Check if it is a Denunciation of several endorsements
    pub fn is_for_endorsement(&self) -> bool {
        matches!(self, Denunciation::Endorsement(_))
    }

    /// Check if it is a Denunciation of several block headers
    pub fn is_for_block_header(&self) -> bool {
        matches!(self, Denunciation::BlockHeader(_))
    }

    /// Check if it is a Denunciation for this endorsement
    ///
    /// `sig_chain_id` selects the signed-hash layout used to reconstruct the
    /// signature hash (see [`EndorsementDenunciation::compute_hash_for_sig_verif`]).
    pub fn is_also_for_endorsement(
        &self,
        s_endorsement: &SecureShareEndorsement,
        sig_chain_id: Option<u64>,
    ) -> Result<bool, DenunciationError> {
        match self {
            Denunciation::BlockHeader(_) => Ok(false),
            Denunciation::Endorsement(endo_de) => {
                let content_hash = s_endorsement.id.get_hash();

                let hash = EndorsementDenunciation::compute_hash_for_sig_verif(
                    &endo_de.public_key,
                    &endo_de.slot,
                    &endo_de.index,
                    content_hash,
                    sig_chain_id,
                );

                Ok(endo_de.slot == s_endorsement.content.slot
                    && endo_de.index == s_endorsement.content.index
                    && endo_de.public_key == s_endorsement.content_creator_pub_key
                    && endo_de.hash_1 != *content_hash
                    && endo_de.hash_2 != *content_hash
                    && endo_de
                        .public_key
                        .verify_signature(&hash, &s_endorsement.signature)
                        .is_ok())
            }
        }
    }

    /// Check if it is a Denunciation for this block header
    ///
    /// `sig_chain_id` selects the signed-hash layout used to reconstruct the
    /// signature hash (see [`BlockHeaderDenunciation::compute_hash_for_sig_verif`]).
    pub fn is_also_for_block_header(
        &self,
        s_block_header: &SecuredHeader,
        sig_chain_id: Option<u64>,
    ) -> Result<bool, DenunciationError> {
        match self {
            Denunciation::Endorsement(_) => Ok(false),
            Denunciation::BlockHeader(endo_bh) => {
                let content_hash = s_block_header.id.get_hash();

                let hash = BlockHeaderDenunciation::compute_hash_for_sig_verif(
                    &endo_bh.public_key,
                    &endo_bh.slot,
                    content_hash,
                    sig_chain_id,
                );

                Ok(endo_bh.slot == s_block_header.content.slot
                    && endo_bh.public_key == s_block_header.content_creator_pub_key
                    && endo_bh.hash_1 != *content_hash
                    && endo_bh.hash_2 != *content_hash
                    && endo_bh
                        .public_key
                        .verify_signature(&hash, &s_block_header.signature)
                        .is_ok())
            }
        }
    }

    /// Check if Denunciation is valid using the legacy (chain-agnostic) signed-hash
    /// layout. Kept for backward compatibility with tests / pre-activation data.
    /// Production code should use [`Self::is_valid_with_chain`] with the
    /// `sig_chain_id` derived from the denounced slot's network-agreed active
    /// version.
    pub fn is_valid(&self) -> bool {
        self.is_valid_with_chain(None)
    }

    /// Check if Denunciation is valid, reconstructing signatures with the
    /// chain-scoped signed-hash layout selected by `sig_chain_id` (`None` = legacy,
    /// `Some(chain_id)` = chain-scoped).
    ///
    /// This is the chain-aware variant that prevents cross-chain replay of
    /// endorsements / block headers as denunciations (F90 / PDF #11): when
    /// `sig_chain_id` is `Some(local_chain_id)`, a denunciation combining two
    /// messages signed on different chains no longer verifies, because the second
    /// message's signature was produced over a hash folding in a different chain id.
    pub fn is_valid_with_chain(&self, sig_chain_id: Option<u64>) -> bool {
        let (signature_1, signature_2, hash_1, hash_2, public_key) = match self {
            Denunciation::Endorsement(de) => {
                let hash_1 = EndorsementDenunciation::compute_hash_for_sig_verif(
                    &de.public_key,
                    &de.slot,
                    &de.index,
                    &de.hash_1,
                    sig_chain_id,
                );
                let hash_2 = EndorsementDenunciation::compute_hash_for_sig_verif(
                    &de.public_key,
                    &de.slot,
                    &de.index,
                    &de.hash_2,
                    sig_chain_id,
                );

                (
                    de.signature_1,
                    de.signature_2,
                    hash_1,
                    hash_2,
                    de.public_key,
                )
            }
            Denunciation::BlockHeader(de) => {
                let hash_1 = BlockHeaderDenunciation::compute_hash_for_sig_verif(
                    &de.public_key,
                    &de.slot,
                    &de.hash_1,
                    sig_chain_id,
                );
                let hash_2 = BlockHeaderDenunciation::compute_hash_for_sig_verif(
                    &de.public_key,
                    &de.slot,
                    &de.hash_2,
                    sig_chain_id,
                );

                (
                    de.signature_1,
                    de.signature_2,
                    hash_1,
                    hash_2,
                    de.public_key,
                )
            }
        };

        hash_1 != hash_2
            && public_key.verify_signature(&hash_1, &signature_1).is_ok()
            && public_key.verify_signature(&hash_2, &signature_2).is_ok()
    }

    /// Get Denunciation slot ref
    pub fn get_slot(&self) -> &Slot {
        match self {
            Denunciation::Endorsement(de) => &de.slot,
            Denunciation::BlockHeader(de) => &de.slot,
        }
    }

    /// Get field: index (return None for a block header denunciation)
    pub fn get_index(&self) -> Option<&u32> {
        match self {
            Denunciation::BlockHeader(_) => None,
            Denunciation::Endorsement(de) => Some(&de.index),
        }
    }

    /// Get Denunciation public key ref
    pub fn get_public_key(&self) -> &PublicKey {
        match self {
            Denunciation::Endorsement(de) => &de.public_key,
            Denunciation::BlockHeader(de) => &de.public_key,
        }
    }

    /// Check if denunciation has expired given a slot period
    /// Note that slot_period can be:
    /// * A final slot period (for example in order to cleanup denunciation pool caches)
    /// * A block slot period (in execution (execute_denunciation(...)))
    pub fn is_expired(
        denunciation_slot_period: &u64,
        slot_period: &u64,
        denunciation_expire_periods: &u64,
    ) -> bool {
        slot_period.checked_sub(*denunciation_slot_period) > Some(*denunciation_expire_periods)
    }
}

/// Create a new Denunciation from 2 SecureShareEndorsement (legacy, chain-agnostic
/// signed-hash layout). Kept for backward compatibility with tests and
/// pre-activation data. Production code should use the chain-aware tuple variant.
impl TryFrom<(&SecureShareEndorsement, &SecureShareEndorsement)> for Denunciation {
    type Error = DenunciationError;

    fn try_from(
        (s_e1, s_e2): (&SecureShareEndorsement, &SecureShareEndorsement),
    ) -> Result<Self, Self::Error> {
        Denunciation::try_from((s_e1, s_e2, None))
    }
}

/// Create a new Denunciation from 2 SecureShareEndorsement using the chain-scoped
/// signed-hash layout selected by `sig_chain_id` (`None` = legacy, `Some(chain_id)`
/// = chain-scoped). The same `sig_chain_id` must be used to sign the endorsements
/// and to verify the resulting denunciation.
impl
    TryFrom<(
        &SecureShareEndorsement,
        &SecureShareEndorsement,
        Option<u64>,
    )> for Denunciation
{
    type Error = DenunciationError;

    fn try_from(
        (s_e1, s_e2, sig_chain_id): (
            &SecureShareEndorsement,
            &SecureShareEndorsement,
            Option<u64>,
        ),
    ) -> Result<Self, Self::Error> {
        // In order to create a Denunciation, there should be the same
        // slot, index & public key
        if s_e1.content.slot != s_e2.content.slot
            || s_e1.content.index != s_e2.content.index
            || s_e1.content_creator_pub_key != s_e2.content_creator_pub_key
            || s_e1.id == s_e2.id
        {
            return Err(DenunciationError::InvalidInput(format!(
                "Not the same slot, index or public key or same hash for {:?} & {:?}",
                s_e1, s_e2
            )));
        }

        // Check sig of s_e1 with s_e1.public_key, s_e1.slot, s_e1.index
        let s_e1_hash_content = s_e1.id.get_hash();
        let s_e1_hash = EndorsementDenunciation::compute_hash_for_sig_verif(
            &s_e1.content_creator_pub_key,
            &s_e1.content.slot,
            &s_e1.content.index,
            s_e1_hash_content,
            sig_chain_id,
        );
        // Check sig of s_e2 but with s_e1.public_key, s_e1.slot, s_e1.index
        let s_e2_hash_content = s_e2.id.get_hash();
        let s_e2_hash = EndorsementDenunciation::compute_hash_for_sig_verif(
            &s_e1.content_creator_pub_key,
            &s_e1.content.slot,
            &s_e1.content.index,
            s_e2_hash_content,
            sig_chain_id,
        );

        s_e1.content_creator_pub_key
            .verify_signature(&s_e1_hash, &s_e1.signature)?;
        s_e1.content_creator_pub_key
            .verify_signature(&s_e2_hash, &s_e2.signature)?;

        Ok(Denunciation::Endorsement(EndorsementDenunciation {
            public_key: s_e1.content_creator_pub_key,
            slot: s_e1.content.slot,
            index: s_e1.content.index,
            signature_1: s_e1.signature,
            signature_2: s_e2.signature,
            hash_1: *s_e1_hash_content,
            hash_2: *s_e2_hash_content,
        }))
    }
}

/// Create a new Denunciation from 2 SecureHeader (legacy, chain-agnostic signed-hash
/// layout). Kept for backward compatibility with tests and pre-activation data.
/// Production code should use the chain-aware tuple variant.
impl TryFrom<(&SecuredHeader, &SecuredHeader)> for Denunciation {
    type Error = DenunciationError;

    fn try_from((s_bh1, s_bh2): (&SecuredHeader, &SecuredHeader)) -> Result<Self, Self::Error> {
        Denunciation::try_from((s_bh1, s_bh2, None))
    }
}

/// Create a new Denunciation from 2 SecureHeader using the chain-scoped signed-hash
/// layout selected by `sig_chain_id` (`None` = legacy, `Some(chain_id)` =
/// chain-scoped).
impl TryFrom<(&SecuredHeader, &SecuredHeader, Option<u64>)> for Denunciation {
    type Error = DenunciationError;

    fn try_from(
        (s_bh1, s_bh2, sig_chain_id): (&SecuredHeader, &SecuredHeader, Option<u64>),
    ) -> Result<Self, Self::Error> {
        // Cannot use the same block header twice
        // In order to create a Denunciation, there should be the same slot & public key
        if s_bh1.content.slot != s_bh2.content.slot
            || s_bh1.content_creator_pub_key != s_bh2.content_creator_pub_key
            || s_bh1.id == s_bh2.id
        {
            return Err(DenunciationError::InvalidInput(format!(
                "Not the same slot or public key or same hash for {:?} & {:?}",
                s_bh1, s_bh2
            )));
        }

        // Check sig of s_bh2 but with s_bh1.public_key, s_bh1.slot, s_bh1.index
        let s_bh1_hash_content = s_bh1.id.get_hash();
        let s_bh1_hash = BlockHeaderDenunciation::compute_hash_for_sig_verif(
            &s_bh1.content_creator_pub_key,
            &s_bh1.content.slot,
            s_bh1_hash_content,
            sig_chain_id,
        );
        let s_bh2_hash_content = s_bh2.id.get_hash();
        let s_bh2_hash = BlockHeaderDenunciation::compute_hash_for_sig_verif(
            &s_bh1.content_creator_pub_key,
            &s_bh1.content.slot,
            s_bh2_hash_content,
            sig_chain_id,
        );

        s_bh1
            .content_creator_pub_key
            .verify_signature(&s_bh1_hash, &s_bh1.signature)?;
        s_bh1
            .content_creator_pub_key
            .verify_signature(&s_bh2_hash, &s_bh2.signature)?;

        Ok(Denunciation::BlockHeader(BlockHeaderDenunciation {
            public_key: s_bh1.content_creator_pub_key,
            slot: s_bh1.content.slot,
            signature_1: s_bh1.signature,
            signature_2: s_bh2.signature,
            hash_1: *s_bh1_hash_content,
            hash_2: *s_bh2_hash_content,
        }))
    }
}

#[allow(missing_docs)]
#[derive(IntoPrimitive, Debug, TryFromPrimitive, VariantCount)]
#[repr(u32)]
pub enum DenunciationTypeId {
    BlockHeader = 0,
    Endorsement = 1,
}

impl From<&Denunciation> for DenunciationTypeId {
    fn from(value: &Denunciation) -> Self {
        match value {
            Denunciation::Endorsement(_) => DenunciationTypeId::Endorsement,
            Denunciation::BlockHeader(_) => DenunciationTypeId::BlockHeader,
        }
    }
}

/// Denunciation error
#[allow(missing_docs)]
#[derive(Error, Debug)]
pub enum DenunciationError {
    #[error("Invalid endorsements or block headers, cannot create denunciation: {0}")]
    InvalidInput(String),
    #[error("signature error: {0}")]
    Signature(#[from] MassaSignatureError),
    #[error("serialization error: {0}")]
    Serialization(#[from] SerializeError),
}

// Serialization / Deserialization

/// Serializer for `EndorsementDenunciation`
struct EndorsementDenunciationSerializer {
    slot_serializer: SlotSerializer,
    u32_serializer: U32VarIntSerializer,
    hash_serializer: HashSerializer,
}

impl EndorsementDenunciationSerializer {
    /// Creates a new `EndorsementDenunciationSerializer`
    const fn new() -> Self {
        Self {
            slot_serializer: SlotSerializer::new(),
            u32_serializer: U32VarIntSerializer::new(),
            hash_serializer: HashSerializer::new(),
        }
    }
}

impl Default for EndorsementDenunciationSerializer {
    fn default() -> Self {
        Self::new()
    }
}

impl Serializer<EndorsementDenunciation> for EndorsementDenunciationSerializer {
    fn serialize(
        &self,
        value: &EndorsementDenunciation,
        buffer: &mut Vec<u8>,
    ) -> Result<(), SerializeError> {
        buffer.extend(value.public_key.to_bytes());
        self.slot_serializer.serialize(&value.slot, buffer)?;
        self.u32_serializer.serialize(&value.index, buffer)?;
        self.hash_serializer.serialize(&value.hash_1, buffer)?;
        self.hash_serializer.serialize(&value.hash_2, buffer)?;
        buffer.extend(value.signature_1.to_bytes());
        buffer.extend(value.signature_2.to_bytes());
        Ok(())
    }
}

/// Deserializer for `EndorsementDenunciation`
struct EndorsementDenunciationDeserializer {
    slot_deserializer: SlotDeserializer,
    index_deserializer: U32VarIntDeserializer,
    hash_deserializer: HashDeserializer,
    pubkey_deserializer: PublicKeyDeserializer,
    signature_deserializer: SignatureDeserializer,
}

impl EndorsementDenunciationDeserializer {
    /// Creates a new `EndorsementDeserializer`
    const fn new(thread_count: u8, endorsement_count: u32) -> Self {
        EndorsementDenunciationDeserializer {
            slot_deserializer: SlotDeserializer::new(
                (Included(0), Included(u64::MAX)),
                (Included(0), Excluded(thread_count)),
            ),
            index_deserializer: U32VarIntDeserializer::new(
                Included(0),
                Excluded(endorsement_count),
            ),
            hash_deserializer: HashDeserializer::new(),
            pubkey_deserializer: PublicKeyDeserializer::new(),
            signature_deserializer: SignatureDeserializer::new(),
        }
    }
}

impl Deserializer<EndorsementDenunciation> for EndorsementDenunciationDeserializer {
    fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
        &self,
        buffer: &'a [u8],
    ) -> IResult<&'a [u8], EndorsementDenunciation, E> {
        context(
            "Failed Endorsement Denunciation deserialization",
            tuple((
                context("Failed public key deserialization", |input| {
                    self.pubkey_deserializer.deserialize(input)
                }),
                context("Failed slot deserialization", |input| {
                    self.slot_deserializer.deserialize(input)
                }),
                context("Failed slot deserialization", |input| {
                    self.index_deserializer.deserialize(input)
                }),
                context("Failed hash 1 deserialization", |input| {
                    self.hash_deserializer.deserialize(input)
                }),
                context("Failed hash 2 deserialization", |input| {
                    self.hash_deserializer.deserialize(input)
                }),
                context("Failed signature 1 deserialization", |input| {
                    self.signature_deserializer.deserialize(input)
                }),
                context("Failed signature 2 deserialization", |input| {
                    self.signature_deserializer.deserialize(input)
                }),
            )),
        )
        .map(
            |(public_key, slot, index, hash_1, hash_2, signature_1, signature_2)| {
                EndorsementDenunciation {
                    public_key,
                    slot,
                    index,
                    hash_1,
                    hash_2,
                    signature_1,
                    signature_2,
                }
            },
        )
        .parse(buffer)
    }
}

/// Serializer for `BlockHeaderDenunciation`
struct BlockHeaderDenunciationSerializer {
    slot_serializer: SlotSerializer,
    hash_serializer: HashSerializer,
}

impl BlockHeaderDenunciationSerializer {
    /// Creates a new `BlockHeaderDenunciationSerializer`
    const fn new() -> Self {
        Self {
            slot_serializer: SlotSerializer::new(),
            hash_serializer: HashSerializer::new(),
        }
    }
}

impl Default for BlockHeaderDenunciationSerializer {
    fn default() -> Self {
        Self::new()
    }
}

impl Serializer<BlockHeaderDenunciation> for BlockHeaderDenunciationSerializer {
    fn serialize(
        &self,
        value: &BlockHeaderDenunciation,
        buffer: &mut Vec<u8>,
    ) -> Result<(), SerializeError> {
        buffer.extend(value.public_key.to_bytes());
        self.slot_serializer.serialize(&value.slot, buffer)?;
        self.hash_serializer.serialize(&value.hash_1, buffer)?;
        self.hash_serializer.serialize(&value.hash_2, buffer)?;
        buffer.extend(value.signature_1.to_bytes());
        buffer.extend(value.signature_2.to_bytes());
        Ok(())
    }
}

/// Deserializer for `BlockHeaderDenunciation`
struct BlockHeaderDenunciationDeserializer {
    slot_deserializer: SlotDeserializer,
    hash_deserializer: HashDeserializer,
    pubkey_deserializer: PublicKeyDeserializer,
    signature_deserializer: SignatureDeserializer,
}

impl BlockHeaderDenunciationDeserializer {
    /// Creates a new `BlockHeaderDenunciationDeserializer`
    pub const fn new(thread_count: u8) -> Self {
        Self {
            slot_deserializer: SlotDeserializer::new(
                (Included(0), Included(u64::MAX)),
                (Included(0), Excluded(thread_count)),
            ),
            hash_deserializer: HashDeserializer::new(),
            pubkey_deserializer: PublicKeyDeserializer::new(),
            signature_deserializer: SignatureDeserializer::new(),
        }
    }
}

impl Deserializer<BlockHeaderDenunciation> for BlockHeaderDenunciationDeserializer {
    fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
        &self,
        buffer: &'a [u8],
    ) -> IResult<&'a [u8], BlockHeaderDenunciation, E> {
        context(
            "Failed BlockHeader Denunciation deserialization",
            tuple((
                context("Failed public key deserialization", |input| {
                    self.pubkey_deserializer.deserialize(input)
                }),
                context("Failed slot deserialization", |input| {
                    self.slot_deserializer.deserialize(input)
                }),
                context("Failed hash 1 deserialization", |input| {
                    self.hash_deserializer.deserialize(input)
                }),
                context("Failed hash 2 deserialization", |input| {
                    self.hash_deserializer.deserialize(input)
                }),
                context("Failed signature 1 deserialization", |input| {
                    self.signature_deserializer.deserialize(input)
                }),
                context("Failed signature 2 deserialization", |input| {
                    self.signature_deserializer.deserialize(input)
                }),
            )),
        )
        .map(
            |(public_key, slot, hash_1, hash_2, signature_1, signature_2)| {
                BlockHeaderDenunciation {
                    public_key,
                    slot,
                    hash_1,
                    hash_2,
                    signature_1,
                    signature_2,
                }
            },
        )
        .parse(buffer)
    }
}

/// Serializer for `Denunciation`
pub struct DenunciationSerializer {
    endo_de_serializer: EndorsementDenunciationSerializer,
    blkh_de_serializer: BlockHeaderDenunciationSerializer,
    type_id_serializer: U32VarIntSerializer,
}

impl DenunciationSerializer {
    /// Creates a new `BlockHeaderDenunciationSerializer`
    pub const fn new() -> Self {
        Self {
            endo_de_serializer: EndorsementDenunciationSerializer::new(),
            blkh_de_serializer: BlockHeaderDenunciationSerializer::new(),
            type_id_serializer: U32VarIntSerializer::new(),
        }
    }
}

impl Default for DenunciationSerializer {
    fn default() -> Self {
        Self::new()
    }
}

impl Serializer<Denunciation> for DenunciationSerializer {
    fn serialize(&self, value: &Denunciation, buffer: &mut Vec<u8>) -> Result<(), SerializeError> {
        let de_type_id = DenunciationTypeId::from(value);
        self.type_id_serializer
            .serialize(&u32::from(de_type_id), buffer)?;
        match value {
            Denunciation::Endorsement(de) => {
                self.endo_de_serializer.serialize(de, buffer)?;
            }
            Denunciation::BlockHeader(de) => {
                self.blkh_de_serializer.serialize(de, buffer)?;
            }
        }
        Ok(())
    }
}

/// Deserializer for `Denunciation`
pub struct DenunciationDeserializer {
    endo_de_deserializer: EndorsementDenunciationDeserializer,
    blkh_de_deserializer: BlockHeaderDenunciationDeserializer,
    type_id_deserializer: U32VarIntDeserializer,
}

impl DenunciationDeserializer {
    /// Creates a new `DenunciationDeserializer`
    pub const fn new(thread_count: u8, endorsement_count: u32) -> Self {
        Self {
            endo_de_deserializer: EndorsementDenunciationDeserializer::new(
                thread_count,
                endorsement_count,
            ),
            blkh_de_deserializer: BlockHeaderDenunciationDeserializer::new(thread_count),
            type_id_deserializer: U32VarIntDeserializer::new(
                Included(0),
                Excluded(DenunciationTypeId::VARIANT_COUNT as u32),
            ),
        }
    }
}

impl Deserializer<Denunciation> for DenunciationDeserializer {
    fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
        &self,
        buffer: &'a [u8],
    ) -> IResult<&'a [u8], Denunciation, E> {
        let (rem, de_type_id_) = context("Failed Denunciation type id deserialization", |input| {
            self.type_id_deserializer.deserialize(input)
        })
        .parse(buffer)?;

        let de_type_id = DenunciationTypeId::try_from(de_type_id_).map_err(|_| {
            nom::Err::Error(ParseError::from_error_kind(
                buffer,
                nom::error::ErrorKind::Fail,
            ))
        })?;

        match de_type_id {
            DenunciationTypeId::Endorsement => {
                let (rem2, endo_de) = self.endo_de_deserializer.deserialize(rem)?;
                IResult::Ok((rem2, Denunciation::Endorsement(endo_de)))
            }
            DenunciationTypeId::BlockHeader => {
                let (rem2, blkh_de) = self.blkh_de_deserializer.deserialize(rem)?;
                IResult::Ok((rem2, Denunciation::BlockHeader(blkh_de)))
            }
        }
    }
}

// End Ser / Der

// Denunciation Index

#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, Serialize, Deserialize)]
/// Index for Denunciations in collections (e.g. like a HashMap...)
pub enum DenunciationIndex {
    /// Variant for Block header denunciation index
    BlockHeader {
        /// de slot
        slot: Slot,
    },
    /// Variant for Endorsement denunciation index
    Endorsement {
        /// de slot
        slot: Slot,
        /// de index
        index: u32,
    },
}

impl DenunciationIndex {
    /// Get field: slot
    pub fn get_slot(&self) -> &Slot {
        match self {
            DenunciationIndex::BlockHeader { slot } => slot,
            DenunciationIndex::Endorsement { slot, .. } => slot,
        }
    }

    /// Get field: index (return None for a block header denunciation index)
    pub fn get_index(&self) -> Option<&u32> {
        match self {
            DenunciationIndex::BlockHeader { .. } => None,
            DenunciationIndex::Endorsement { slot: _, index } => Some(index),
        }
    }

    /// Compute the hash
    pub fn get_hash(&self) -> Hash {
        let mut buffer = u32::from(DenunciationIndexTypeId::from(self))
            .to_le_bytes()
            .to_vec();
        match self {
            DenunciationIndex::BlockHeader { slot } => buffer.extend(slot.to_bytes_key()),
            DenunciationIndex::Endorsement { slot, index } => {
                buffer.extend(slot.to_bytes_key());
                buffer.extend(index.to_le_bytes());
            }
        }
        Hash::compute_from(&buffer)
    }
}

/// Create a `DenunciationIndex` from a `Denunciation`
impl From<&Denunciation> for DenunciationIndex {
    fn from(value: &Denunciation) -> Self {
        match value {
            Denunciation::Endorsement(endo_de) => DenunciationIndex::Endorsement {
                slot: endo_de.slot,
                index: endo_de.index,
            },
            Denunciation::BlockHeader(blkh_de) => {
                DenunciationIndex::BlockHeader { slot: blkh_de.slot }
            }
        }
    }
}

/// Create a `DenunciationIndex` from a `DenunciationPrecursor`
impl From<&DenunciationPrecursor> for DenunciationIndex {
    fn from(value: &DenunciationPrecursor) -> Self {
        match value {
            DenunciationPrecursor::Endorsement(de_p) => DenunciationIndex::Endorsement {
                slot: de_p.slot,
                index: de_p.index,
            },
            DenunciationPrecursor::BlockHeader(de_p) => {
                DenunciationIndex::BlockHeader { slot: de_p.slot }
            }
        }
    }
}

impl Ord for DenunciationIndex {
    fn cmp(&self, other: &Self) -> Ordering {
        // key ends with type id so that we avoid prioritizing one type over the other
        // when filling block headers (comparison of tuples is from left to right).
        let self_key = (
            self.get_slot(),
            self.get_index().unwrap_or(&0),
            u32::from(DenunciationIndexTypeId::from(self)),
        );
        let other_key = (
            other.get_slot(),
            other.get_index().unwrap_or(&0),
            u32::from(DenunciationIndexTypeId::from(other)),
        );
        self_key.cmp(&other_key)
    }
}

impl PartialOrd for DenunciationIndex {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

// End Denunciation Index

// Denunciation Index ser der

#[derive(IntoPrimitive, Debug, Eq, PartialEq, TryFromPrimitive)]
#[repr(u32)]
enum DenunciationIndexTypeId {
    BlockHeader = 0,
    Endorsement = 1,
}

impl From<&DenunciationIndex> for DenunciationIndexTypeId {
    fn from(value: &DenunciationIndex) -> Self {
        match value {
            DenunciationIndex::BlockHeader { .. } => DenunciationIndexTypeId::BlockHeader,
            DenunciationIndex::Endorsement { .. } => DenunciationIndexTypeId::Endorsement,
        }
    }
}

#[derive(Clone)]
/// Serializer for `DenunciationIndex`
pub struct DenunciationIndexSerializer {
    u32_serializer: U32VarIntSerializer,
    slot_serializer: SlotSerializer,
    index_serializer: U32VarIntSerializer,
}

impl DenunciationIndexSerializer {
    /// Creates a new `DenunciationIndexSerializer`
    pub const fn new() -> Self {
        Self {
            u32_serializer: U32VarIntSerializer::new(),
            slot_serializer: SlotSerializer::new(),
            index_serializer: U32VarIntSerializer::new(),
        }
    }
}

impl Default for DenunciationIndexSerializer {
    fn default() -> Self {
        Self::new()
    }
}

impl Serializer<DenunciationIndex> for DenunciationIndexSerializer {
    fn serialize(
        &self,
        value: &DenunciationIndex,
        buffer: &mut Vec<u8>,
    ) -> Result<(), SerializeError> {
        match value {
            DenunciationIndex::BlockHeader { slot } => {
                self.u32_serializer
                    .serialize(&u32::from(DenunciationIndexTypeId::BlockHeader), buffer)?;
                self.slot_serializer.serialize(slot, buffer)?;
            }
            DenunciationIndex::Endorsement { slot, index } => {
                self.u32_serializer
                    .serialize(&u32::from(DenunciationIndexTypeId::Endorsement), buffer)?;
                self.slot_serializer.serialize(slot, buffer)?;
                self.index_serializer.serialize(index, buffer)?;
            }
        }
        Ok(())
    }
}

#[derive(Clone)]
/// Deserializer for `DenunciationIndex`
pub struct DenunciationIndexDeserializer {
    id_deserializer: U32VarIntDeserializer,
    slot_deserializer: SlotDeserializer,
    index_deserializer: U32VarIntDeserializer,
}

impl DenunciationIndexDeserializer {
    /// Creates a new `DenunciationIndexDeserializer`
    pub const fn new(thread_count: u8, endorsement_count: u32) -> Self {
        Self {
            id_deserializer: U32VarIntDeserializer::new(Included(0), Included(u32::MAX)),
            slot_deserializer: SlotDeserializer::new(
                (Included(0), Included(u64::MAX)),
                (Included(0), Excluded(thread_count)),
            ),
            index_deserializer: U32VarIntDeserializer::new(
                Included(0),
                Included(endorsement_count),
            ),
        }
    }
}

impl Deserializer<DenunciationIndex> for DenunciationIndexDeserializer {
    fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
        &self,
        buffer: &'a [u8],
    ) -> IResult<&'a [u8], DenunciationIndex, E> {
        let (input, id) = self.id_deserializer.deserialize(buffer)?;
        let id = DenunciationIndexTypeId::try_from(id).map_err(|_| {
            nom::Err::Error(ParseError::from_error_kind(
                buffer,
                nom::error::ErrorKind::Eof,
            ))
        })?;

        match id {
            DenunciationIndexTypeId::BlockHeader => {
                context("Failed slot deserialization", |input| {
                    self.slot_deserializer.deserialize(input)
                })
                .map(|slot| DenunciationIndex::BlockHeader { slot })
                // .parse(&buffer[1..])
                .parse(input)
            }
            DenunciationIndexTypeId::Endorsement => context(
                "Failed Endorsement denunciation index",
                tuple((
                    context("Failed slot deserialization", |input| {
                        self.slot_deserializer.deserialize(input)
                    }),
                    context("Failed index deserialization", |input| {
                        self.index_deserializer.deserialize(input)
                    }),
                )),
            )
            .map(|(slot, index)| DenunciationIndex::Endorsement { slot, index })
            .parse(input),
        }
    }
}

// End Denunciation Index ser der

// Denunciation interest

/// DenunciationPrecursor variant for endorsement
#[derive(Debug, Clone, PartialEq)]
pub struct EndorsementDenunciationPrecursor {
    /// secure share endorsement public key
    pub public_key: PublicKey,
    /// endorsement slot
    pub slot: Slot,
    /// endorsement index
    pub index: u32,
    /// secured header partial hash
    hash: Hash,
    /// secured header signature
    signature: Signature,
}

/// DenunciationPrecursor variant for block header
#[derive(Debug, Clone, PartialEq)]
pub struct BlockHeaderDenunciationPrecursor {
    /// secured header public key
    pub public_key: PublicKey,
    /// block header slot
    pub slot: Slot,
    /// secured header partial hash
    hash: Hash,
    /// secured header signature
    signature: Signature,
}

/// Lightweight data for Denunciation creation
/// (avoid storing heavyweight secured header or secure share endorsement, see denunciation pool)
#[derive(Debug, Clone, PartialEq)]
pub enum DenunciationPrecursor {
    /// Endorsement variant
    Endorsement(EndorsementDenunciationPrecursor),
    /// Block header variant
    BlockHeader(BlockHeaderDenunciationPrecursor),
}

impl DenunciationPrecursor {
    /// Get field: slot
    pub fn get_slot(&self) -> &Slot {
        match self {
            DenunciationPrecursor::Endorsement(endo_de_p) => &endo_de_p.slot,
            DenunciationPrecursor::BlockHeader(blkh_de_p) => &blkh_de_p.slot,
        }
    }

    /// Get field: pub key
    pub fn get_public_key(&self) -> &PublicKey {
        match self {
            DenunciationPrecursor::Endorsement(endo_de_p) => &endo_de_p.public_key,
            DenunciationPrecursor::BlockHeader(blkh_de_p) => &blkh_de_p.public_key,
        }
    }
}

impl From<&SecureShareEndorsement> for DenunciationPrecursor {
    fn from(value: &SecureShareEndorsement) -> Self {
        DenunciationPrecursor::Endorsement(EndorsementDenunciationPrecursor {
            public_key: value.content_creator_pub_key,
            slot: value.content.slot,
            index: value.content.index,
            hash: *value.id.get_hash(),
            signature: value.signature,
        })
    }
}

impl From<&SecuredHeader> for DenunciationPrecursor {
    fn from(value: &SecuredHeader) -> Self {
        DenunciationPrecursor::BlockHeader(BlockHeaderDenunciationPrecursor {
            public_key: value.content_creator_pub_key,
            slot: value.content.slot,
            hash: *value.id.get_hash(),
            signature: value.signature,
        })
    }
}

/// Create a new Denunciation from 2 DenunciationPrecursor (legacy, chain-agnostic
/// signed-hash layout). Kept for backward compatibility. Production code should use
/// the chain-aware tuple variant.
impl TryFrom<(&DenunciationPrecursor, &DenunciationPrecursor)> for Denunciation {
    type Error = DenunciationError;

    fn try_from(
        (de_p_1, de_p_2): (&DenunciationPrecursor, &DenunciationPrecursor),
    ) -> Result<Self, Self::Error> {
        Denunciation::try_from((de_p_1, de_p_2, None))
    }
}

/// Create a new Denunciation from 2 DenunciationPrecursor using the chain-scoped
/// signed-hash layout selected by `sig_chain_id` (`None` = legacy, `Some(chain_id)`
/// = chain-scoped).
impl TryFrom<(&DenunciationPrecursor, &DenunciationPrecursor, Option<u64>)> for Denunciation {
    type Error = DenunciationError;

    fn try_from(
        (de_p_1, de_p_2, sig_chain_id): (
            &DenunciationPrecursor,
            &DenunciationPrecursor,
            Option<u64>,
        ),
    ) -> Result<Self, Self::Error> {
        match (de_p_1, de_p_2) {
            (
                DenunciationPrecursor::BlockHeader(de_p_blkh_1),
                DenunciationPrecursor::BlockHeader(de_p_blkh_2),
            ) => {
                // Cannot use the same block header (here: block header denunciation precursor) twice
                if de_p_blkh_1.slot != de_p_blkh_2.slot
                    || de_p_blkh_1.public_key != de_p_blkh_2.public_key
                    || de_p_blkh_1.hash == de_p_blkh_2.hash
                {
                    return Err(DenunciationError::InvalidInput(
                        format!("Not the same slot or public key or same hash for de precursor: {:?} & {:?}", de_p_blkh_1, de_p_blkh_2)
                    ));
                }

                // Check sig
                let de_p_blkh_1_hash = BlockHeaderDenunciation::compute_hash_for_sig_verif(
                    &de_p_blkh_1.public_key,
                    &de_p_blkh_1.slot,
                    &de_p_blkh_1.hash,
                    sig_chain_id,
                );
                let de_p_blkh_2_hash = BlockHeaderDenunciation::compute_hash_for_sig_verif(
                    &de_p_blkh_2.public_key,
                    &de_p_blkh_2.slot,
                    &de_p_blkh_2.hash,
                    sig_chain_id,
                );

                de_p_blkh_1
                    .public_key
                    .verify_signature(&de_p_blkh_1_hash, &de_p_blkh_1.signature)?;
                de_p_blkh_1
                    .public_key
                    .verify_signature(&de_p_blkh_2_hash, &de_p_blkh_2.signature)?;

                Ok(Denunciation::BlockHeader(BlockHeaderDenunciation {
                    public_key: de_p_blkh_1.public_key,
                    slot: de_p_blkh_1.slot,
                    signature_1: de_p_blkh_1.signature,
                    signature_2: de_p_blkh_2.signature,
                    hash_1: de_p_blkh_1.hash,
                    hash_2: de_p_blkh_2.hash,
                }))
            }
            (
                DenunciationPrecursor::Endorsement(de_p_endo_1),
                DenunciationPrecursor::Endorsement(de_p_endo_2),
            ) => {
                // Cannot use the same endorsement (here: endorsement denunciation) twice
                if de_p_endo_1.slot != de_p_endo_2.slot
                    || de_p_endo_1.index != de_p_endo_2.index
                    || de_p_endo_1.public_key != de_p_endo_2.public_key
                    || de_p_endo_1.hash == de_p_endo_2.hash
                {
                    return Err(DenunciationError::InvalidInput(
                        format!("Not the same slot, index or public key or same hash for de precursor: {:?} & {:?}", de_p_endo_1, de_p_endo_2)
                    ));
                }

                // Check sig
                let de_p_endo_1_hash = EndorsementDenunciation::compute_hash_for_sig_verif(
                    &de_p_endo_1.public_key,
                    &de_p_endo_1.slot,
                    &de_p_endo_1.index,
                    &de_p_endo_1.hash,
                    sig_chain_id,
                );
                let de_p_endo_2_hash = EndorsementDenunciation::compute_hash_for_sig_verif(
                    &de_p_endo_2.public_key,
                    &de_p_endo_2.slot,
                    &de_p_endo_2.index,
                    &de_p_endo_2.hash,
                    sig_chain_id,
                );

                de_p_endo_1
                    .public_key
                    .verify_signature(&de_p_endo_1_hash, &de_p_endo_1.signature)?;
                de_p_endo_1
                    .public_key
                    .verify_signature(&de_p_endo_2_hash, &de_p_endo_2.signature)?;

                Ok(Denunciation::Endorsement(EndorsementDenunciation {
                    public_key: de_p_endo_1.public_key,
                    slot: de_p_endo_1.slot,
                    index: de_p_endo_1.index,
                    signature_1: de_p_endo_1.signature,
                    signature_2: de_p_endo_2.signature,
                    hash_1: de_p_endo_1.hash,
                    hash_2: de_p_endo_2.hash,
                }))
            }
            _ => {
                // Different enum variants - this is invalid
                Err(DenunciationError::InvalidInput(
                    "Mixed endorsement and block header denunciation precursors".to_string(),
                ))
            }
        }
    }
}

// End Denunciation interest

// test-exports

#[cfg(any(test, feature = "test-exports"))]
impl Denunciation {
    /// Used under testing conditions to validate an instance of Self
    pub fn check_invariants(&self) -> Result<(), Box<dyn std::error::Error>> {
        if !self.is_valid_with_chain(Some(*crate::config::CHAINID)) {
            return Err(format!("Denunciation is invalid: {:?}", self).into());
        }
        Ok(())
    }
}

// end test-exports

#[cfg(test)]
mod tests {
    use super::*;

    use massa_hash::Hash;
    use massa_serialization::DeserializeError;
    use massa_signature::KeyPair;

    use crate::block_id::BlockId;
    use crate::config::{CHAINID, ENDORSEMENT_COUNT, THREAD_COUNT};
    use crate::endorsement::{Endorsement, EndorsementSerializer, SecureShareEndorsement};
    use crate::secure_share::{Id, SecureShareContent};

    use crate::test_exports::{
        gen_block_headers_for_denunciation, gen_endorsements_for_denunciation,
    };

    #[test]
    fn test_endorsement_denunciation() {
        // Create an endorsement denunciation and check if it is valid
        let (_slot, _keypair, s_endorsement_1, s_endorsement_2, _s_endorsement_3) =
            gen_endorsements_for_denunciation(None, None);
        let denunciation: Denunciation = (&s_endorsement_1, &s_endorsement_2, Some(*CHAINID))
            .try_into()
            .unwrap();

        assert!(denunciation.is_for_endorsement());
        assert!(denunciation.is_valid_with_chain(Some(*CHAINID)));
    }

    #[test]
    fn test_endorsement_denunciation_invalid_1() {
        let (slot, keypair, s_endorsement_1, _s_endorsement_2, _s_endorsement_3) =
            gen_endorsements_for_denunciation(None, None);

        // Try to create a denunciation from 2 endorsements @ != index
        let endorsement_4 = Endorsement {
            slot,
            index: 9,
            endorsed_block: BlockId::generate_from_hash(Hash::compute_from("foo".as_bytes())),
        };
        let s_endorsement_4 = Endorsement::new_verifiable(
            endorsement_4,
            EndorsementSerializer::new(),
            &keypair,
            *CHAINID,
            Some(*CHAINID),
        )
        .unwrap();

        let denunciation =
            Denunciation::try_from((&s_endorsement_1, &s_endorsement_4, Some(*CHAINID)));

        assert!(matches!(
            denunciation,
            Err(DenunciationError::InvalidInput(..))
        ));

        // Try to create a denunciation from only 1 endorsement
        let denunciation =
            Denunciation::try_from((&s_endorsement_1, &s_endorsement_1, Some(*CHAINID)));

        assert!(matches!(
            denunciation,
            Err(DenunciationError::InvalidInput(..))
        ));
    }

    #[test]
    fn test_endorsement_denunciation_is_for() {
        let (slot, keypair, s_endorsement_1, s_endorsement_2, s_endorsement_3) =
            gen_endorsements_for_denunciation(None, None);

        let denunciation: Denunciation = (&s_endorsement_1, &s_endorsement_2, Some(*CHAINID))
            .try_into()
            .unwrap();

        assert!(denunciation.is_for_endorsement());
        assert!(denunciation.is_valid_with_chain(Some(*CHAINID)));

        // Try to create a denunciation from 2 endorsements @ != index
        let endorsement_4 = Endorsement {
            slot,
            index: 9,
            endorsed_block: BlockId::generate_from_hash(Hash::compute_from("foo".as_bytes())),
        };
        let s_endorsement_4 = Endorsement::new_verifiable(
            endorsement_4,
            EndorsementSerializer::new(),
            &keypair,
            *CHAINID,
            Some(*CHAINID),
        )
        .unwrap();

        assert!(!denunciation
            .is_also_for_endorsement(&s_endorsement_4, Some(*CHAINID))
            .unwrap());
        assert!(denunciation
            .is_also_for_endorsement(&s_endorsement_3, Some(*CHAINID))
            .unwrap());
        assert!(denunciation.is_valid_with_chain(Some(*CHAINID)));
    }

    #[test]
    fn test_block_header_denunciation() {
        // Create an block header denunciation and check if it is valid
        let (_slot, _keypair, s_block_header_1, s_block_header_2, s_block_header_3) =
            gen_block_headers_for_denunciation(None, None);
        let denunciation: Denunciation = (&s_block_header_1, &s_block_header_2, Some(*CHAINID))
            .try_into()
            .unwrap();

        assert!(denunciation.is_for_block_header());
        assert!(denunciation.is_valid_with_chain(Some(*CHAINID)));
        assert!(denunciation
            .is_also_for_block_header(&s_block_header_3, Some(*CHAINID))
            .unwrap());
    }

    #[test]
    fn test_forge_invalid_denunciation() {
        let keypair = KeyPair::generate(0).unwrap();
        let slot_1 = Slot::new(4, 2);
        let slot_2 = Slot::new(3, 7);

        let endorsement_1 = Endorsement {
            slot: slot_1,
            index: 0,
            endorsed_block: BlockId::generate_from_hash(Hash::compute_from("blk1".as_bytes())),
        };

        let s_endorsement_1: SecureShareEndorsement = Endorsement::new_verifiable(
            endorsement_1,
            EndorsementSerializer::new(),
            &keypair,
            *CHAINID,
            Some(*CHAINID),
        )
        .unwrap();

        let endorsement_2 = Endorsement {
            slot: slot_2,
            index: 0,
            endorsed_block: BlockId::generate_from_hash(Hash::compute_from("blk2".as_bytes())),
        };

        let s_endorsement_2: SecureShareEndorsement = Endorsement::new_verifiable(
            endorsement_2,
            EndorsementSerializer::new(),
            &keypair,
            *CHAINID,
            Some(*CHAINID),
        )
        .unwrap();

        // from an attacker - building manually a Denunciation object
        let de_forged_1 = Denunciation::Endorsement(EndorsementDenunciation {
            public_key: keypair.get_public_key(),
            slot: slot_1,
            index: 0,
            hash_1: *s_endorsement_1.id.get_hash(), // use only data from s_endorsement_1
            hash_2: *s_endorsement_1.id.get_hash(),
            signature_1: s_endorsement_1.signature,
            signature_2: s_endorsement_1.signature,
        });

        // hash_1 == hash_2 -> this is invalid
        assert!(!de_forged_1.is_valid_with_chain(Some(*CHAINID)));

        // from an attacker - building manually a Denunciation object
        let de_forged_2 = Denunciation::Endorsement(EndorsementDenunciation {
            public_key: keypair.get_public_key(),
            slot: slot_2,
            index: 0,
            hash_1: *s_endorsement_1.id.get_hash(),
            hash_2: *s_endorsement_2.id.get_hash(),
            signature_1: s_endorsement_1.signature,
            signature_2: s_endorsement_2.signature,
        });

        // An attacker uses an old s_endorsement_1 to forge a Denunciation object @ slot_2
        // This has to be detected if Denunciation are send via the network
        assert!(!de_forged_2.is_valid_with_chain(Some(*CHAINID)));
    }

    // SER / DER
    #[test]
    fn test_endorsement_denunciation_ser_der() {
        let (_, _, s_endorsement_1, s_endorsement_2, _) =
            gen_endorsements_for_denunciation(None, None);

        let denunciation =
            Denunciation::try_from((&s_endorsement_1, &s_endorsement_2, Some(*CHAINID))).unwrap();

        let mut buffer = Vec::new();
        let de_ser = EndorsementDenunciationSerializer::new();

        match denunciation {
            Denunciation::Endorsement(de) => {
                de_ser.serialize(&de, &mut buffer).unwrap();
                let de_der =
                    EndorsementDenunciationDeserializer::new(THREAD_COUNT, ENDORSEMENT_COUNT);

                let (rem, de_der_res) = de_der.deserialize::<DeserializeError>(&buffer).unwrap();

                assert!(rem.is_empty());
                assert_eq!(de, de_der_res);
            }
            Denunciation::BlockHeader(_) => {
                unimplemented!()
            }
        }
    }

    #[test]
    fn test_block_header_denunciation_ser_der() {
        let (_, _, s_block_header_1, s_block_header_2, _) =
            gen_block_headers_for_denunciation(None, None);
        let denunciation: Denunciation = (&s_block_header_1, &s_block_header_2, Some(*CHAINID))
            .try_into()
            .unwrap();

        let mut buffer = Vec::new();
        let de_ser = BlockHeaderDenunciationSerializer::new();

        match denunciation {
            Denunciation::Endorsement(_) => {
                unimplemented!()
            }
            Denunciation::BlockHeader(de) => {
                de_ser.serialize(&de, &mut buffer).unwrap();
                let de_der = BlockHeaderDenunciationDeserializer::new(THREAD_COUNT);

                let (rem, de_der_res) = de_der.deserialize::<DeserializeError>(&buffer).unwrap();

                assert!(rem.is_empty());
                assert_eq!(de, de_der_res);
            }
        }
    }

    #[test]
    fn test_denunciation_ser_der() {
        let (_, _, s_block_header_1, s_block_header_2, _) =
            gen_block_headers_for_denunciation(None, None);
        let denunciation: Denunciation = (&s_block_header_1, &s_block_header_2, Some(*CHAINID))
            .try_into()
            .unwrap();

        let mut buffer = Vec::new();
        let de_ser = DenunciationSerializer::new();

        de_ser.serialize(&denunciation, &mut buffer).unwrap();
        let de_der = DenunciationDeserializer::new(THREAD_COUNT, ENDORSEMENT_COUNT);

        let (rem, de_der_res) = de_der.deserialize::<DeserializeError>(&buffer).unwrap();

        assert!(rem.is_empty());
        assert_eq!(denunciation, de_der_res);

        let (_, _, s_endorsement_1, s_endorsement_2, _) =
            gen_endorsements_for_denunciation(None, None);
        let denunciation =
            Denunciation::try_from((&s_endorsement_1, &s_endorsement_2, Some(*CHAINID))).unwrap();
        buffer.clear();

        de_ser.serialize(&denunciation, &mut buffer).unwrap();
        let (rem, de_der_res) = de_der.deserialize::<DeserializeError>(&buffer).unwrap();
        assert!(rem.is_empty());
        assert_eq!(denunciation, de_der_res);
    }

    #[test]
    fn test_denunciation_precursor() {
        let (_, _, s_block_header_1, s_block_header_2, _) =
            gen_block_headers_for_denunciation(None, None);
        let denunciation: Denunciation = (&s_block_header_1, &s_block_header_2, Some(*CHAINID))
            .try_into()
            .unwrap();

        let de_p_1 = DenunciationPrecursor::from(&s_block_header_1);
        let de_p_2 = DenunciationPrecursor::from(&s_block_header_2);
        let denunciation_2: Denunciation = (&de_p_1, &de_p_2, Some(*CHAINID)).try_into().unwrap();

        assert_eq!(denunciation, denunciation_2);

        let (_, _, s_endorsement_1, s_endorsement_2, _) =
            gen_endorsements_for_denunciation(None, None);
        let denunciation_3 =
            Denunciation::try_from((&s_endorsement_1, &s_endorsement_2, Some(*CHAINID))).unwrap();

        let de_p_3 = DenunciationPrecursor::from(&s_endorsement_1);
        let de_p_4 = DenunciationPrecursor::from(&s_endorsement_2);
        let denunciation_4: Denunciation = (&de_p_3, &de_p_4, Some(*CHAINID)).try_into().unwrap();

        assert_eq!(denunciation_3, denunciation_4);
    }

    #[test]
    fn test_denunciation_index_ser_der() {
        let (_, _, s_block_header_1, s_block_header_2, _) =
            gen_block_headers_for_denunciation(None, None);
        let denunciation_1: Denunciation = (&s_block_header_1, &s_block_header_2, Some(*CHAINID))
            .try_into()
            .unwrap();
        let denunciation_index_1 = DenunciationIndex::from(&denunciation_1);

        let (_, _, s_endorsement_1, s_endorsement_2, _) =
            gen_endorsements_for_denunciation(None, None);
        let denunciation_2 =
            Denunciation::try_from((&s_endorsement_1, &s_endorsement_2, Some(*CHAINID))).unwrap();
        let denunciation_index_2 = DenunciationIndex::from(&denunciation_2);

        let mut buffer = Vec::new();
        let de_idx_ser = DenunciationIndexSerializer::new();
        de_idx_ser
            .serialize(&denunciation_index_1, &mut buffer)
            .unwrap();
        let de_idx_der = DenunciationIndexDeserializer::new(THREAD_COUNT, ENDORSEMENT_COUNT);
        let (rem, de_idx_der_res) = de_idx_der.deserialize::<DeserializeError>(&buffer).unwrap();

        assert!(rem.is_empty());
        assert_eq!(denunciation_index_1, de_idx_der_res);

        let mut buffer = Vec::new();
        let de_idx_ser = DenunciationIndexSerializer::new();
        de_idx_ser
            .serialize(&denunciation_index_2, &mut buffer)
            .unwrap();
        let de_idx_der = DenunciationIndexDeserializer::new(THREAD_COUNT, ENDORSEMENT_COUNT);
        let (rem, de_idx_der_res) = de_idx_der.deserialize::<DeserializeError>(&buffer).unwrap();

        assert!(rem.is_empty());
        assert_eq!(denunciation_index_2, de_idx_der_res);
    }

    /// F90 / PDF #11: cross-chain replay of endorsements as denunciations.
    ///
    /// Validators commonly run the same key on several chains (e.g. MAINNET + LABNET).
    /// Pre-fix, the endorsement signed hash was chain-agnostic, so two legitimate
    /// same-(slot, index) endorsements from two different chains could be combined
    /// into a denunciation on either chain and slash the validator. Folding
    /// `chain_id` into the signed hash (gated on MIP-0002 `Execution` v2) makes the
    /// cross-chain combination fail to verify, while same-chain denunciations and
    /// legacy (pre-activation) denunciations still work.
    fn make_endorsement(
        keypair: &KeyPair,
        slot: Slot,
        endorsed_block: &str,
        chain_id: u64,
        sig_chain_id: Option<u64>,
    ) -> SecureShareEndorsement {
        Endorsement::new_verifiable(
            Endorsement {
                slot,
                index: 0,
                endorsed_block: BlockId::generate_from_hash(Hash::compute_from(
                    endorsed_block.as_bytes(),
                )),
            },
            EndorsementSerializer::new(),
            keypair,
            chain_id,
            sig_chain_id,
        )
        .unwrap()
    }

    #[test]
    fn test_endorsement_denunciation_cross_chain_rejected() {
        let keypair = KeyPair::generate(0).unwrap();
        let slot = Slot::new(3, 7);
        let chain_a: u64 = 77658377; // MAINNET
        let chain_b: u64 = 77658376; // LABNET

        // Two same-chain endorsements (signed with chain_a, chain-scoped layout).
        let e_a1 = make_endorsement(&keypair, slot, "blk_a1", chain_a, Some(chain_a));
        let e_a2 = make_endorsement(&keypair, slot, "blk_a2", chain_a, Some(chain_a));

        // Same-chain denunciation still verifies with the chain-scoped layout.
        let de_same =
            Denunciation::try_from((&e_a1, &e_a2, Some(chain_a))).expect("same-chain denunciation");
        assert!(de_same.is_valid_with_chain(Some(chain_a)));

        // A second endorsement produced by the same key on a different chain.
        let e_b2 = make_endorsement(&keypair, slot, "blk_b2", chain_b, Some(chain_b));

        // Cross-chain combination no longer verifies on chain A: the second
        // signature was produced over a hash folding in chain_b, not chain_a.
        let de_cross = Denunciation::try_from((&e_a1, &e_b2, Some(chain_a)));
        assert!(de_cross.is_err(), "cross-chain denunciation must not build");
        // And it does not verify either.
        assert!(!Denunciation::try_from((&e_a1, &e_b2, None))
            .map(|d| d.is_valid_with_chain(Some(chain_a)))
            .unwrap_or(false));
    }

    /// Migration / no-partition check across the activation boundary.
    ///
    /// Pre-activation endorsements are signed with the legacy (chain-agnostic)
    /// layout (`sig_chain_id = None`); post-activation with the chain-scoped layout
    /// (`sig_chain_id = Some(chain_id)`). A legacy denunciation must keep verifying
    /// with the legacy layout, and a chain-scoped denunciation must verify with the
    /// chain-scoped layout — so nodes flip layouts together at the deterministic
    /// activation slot without partitioning on signature validity.
    #[test]
    fn test_endorsement_denunciation_migration_no_partition() {
        let keypair = KeyPair::generate(0).unwrap();
        let slot = Slot::new(3, 7);
        let chain: u64 = *CHAINID;

        // Legacy (pre-activation) endorsements and denunciation.
        let e_l1 = make_endorsement(&keypair, slot, "blk_l1", chain, None);
        let e_l2 = make_endorsement(&keypair, slot, "blk_l2", chain, None);
        let de_legacy = Denunciation::try_from((&e_l1, &e_l2, None)).expect("legacy denunciation");
        assert!(de_legacy.is_valid_with_chain(None));
        // A legacy denunciation does NOT verify under the chain-scoped layout: the
        // signatures were produced over a chain-agnostic hash. This is expected and
        // is why the layout is gated on the denounced slot's network version.
        assert!(!de_legacy.is_valid_with_chain(Some(chain)));

        // Post-activation endorsements and denunciation.
        let e_n1 = make_endorsement(&keypair, slot, "blk_n1", chain, Some(chain));
        let e_n2 = make_endorsement(&keypair, slot, "blk_n2", chain, Some(chain));
        let de_scoped =
            Denunciation::try_from((&e_n1, &e_n2, Some(chain))).expect("scoped denunciation");
        assert!(de_scoped.is_valid_with_chain(Some(chain)));
        assert!(!de_scoped.is_valid_with_chain(None));
    }

    fn make_header(
        keypair: &KeyPair,
        slot: Slot,
        merkle: &str,
        chain_id: u64,
        sig_chain_id: Option<u64>,
    ) -> crate::block_header::SecuredHeader {
        crate::block_header::BlockHeader::new_verifiable(
            crate::block_header::BlockHeader {
                current_version: 0,
                announced_version: None,
                slot,
                parents: Vec::new(),
                operation_merkle_root: Hash::compute_from(merkle.as_bytes()),
                endorsements: Vec::new(),
                denunciations: Vec::new(),
            },
            crate::block_header::BlockHeaderSerializer::new(),
            keypair,
            chain_id,
            sig_chain_id,
        )
        .unwrap()
    }

    #[test]
    fn test_block_header_denunciation_cross_chain_rejected() {
        let keypair = KeyPair::generate(0).unwrap();
        let slot = Slot::new(3, 7);
        let chain_a: u64 = 77658377;
        let chain_b: u64 = 77658376;

        let h_a1 = make_header(&keypair, slot, "hdr_a1", chain_a, Some(chain_a));
        let h_a2 = make_header(&keypair, slot, "hdr_a2", chain_a, Some(chain_a));
        let de_same =
            Denunciation::try_from((&h_a1, &h_a2, Some(chain_a))).expect("same-chain header de");
        assert!(de_same.is_valid_with_chain(Some(chain_a)));

        let h_b2 = make_header(&keypair, slot, "hdr_b2", chain_b, Some(chain_b));
        assert!(
            Denunciation::try_from((&h_a1, &h_b2, Some(chain_a))).is_err(),
            "cross-chain header denunciation must not build"
        );
    }
}