feat(iota-core, iota-types): Enable misbehavior report creation (#9363)

# Description of change

This PR enables the creation of the MisbehaviorReport consensus message,
as their submission to consensus in order to disseminate it with the
rest of the committee.

## Links to any relevant issues

Be sure to reference any related issues by adding `fixes #(issue)`.

## How the change has been tested

- [x] Basic tests (linting, compilation, formatting, unit/integration
tests)
- [ ] Patch-specific tests (correctness, functionality coverage)
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] I have checked that new and existing unit tests pass locally with
my changes

### Release Notes

Check each box that your changes affect. If none of the boxes relate to
your changes, release notes aren't required.

For each box you select, include information after the relevant heading
that describes the impact of your changes that a user might notice and
any actions they must take to implement updates.

- [x] Protocol: Enables misbehavior report creation and dissemination.
- [ ] Nodes (Validators and Full nodes):
- [ ] Indexer:
- [ ] JSON-RPC:
- [ ] GraphQL:
- [ ] CLI:
- [ ] Rust SDK:
- [ ] REST API:

---------

Co-authored-by: Andrew <[email protected]>

Author: oliviasaa

crates/iota-core/src/checkpoints/checkpoint_output.rs

@@ -123,6 +123,20 @@ impl<T: SubmitToConsensus + ReconfigurationInitiator> CheckpointOutput
                 .set(checkpoint_seq as i64);
         }
 
+        // We also send misbehavior reports to consensus at this point. Misbehavior
+        // reports containing proofs of misbehaviour can be send whenever the
+        // misbehavior is detected, but we choose to send the ones that include only
+        // unprovable counts at this point, due to periodicity reasons and to ensure a
+        // (approximate) synchronization with the score updates.
+        let misbehavior_report = epoch_store.scorer.current_local_metrics_count.to_report();
+        let transaction = ConsensusTransaction::new_misbehavior_report(
+            epoch_store.name,
+            &misbehavior_report,
+            checkpoint_seq,
+        );
+        self.sender
+            .submit_to_consensus(&vec![transaction], epoch_store)?;
+
         if checkpoint_timestamp >= self.next_reconfiguration_timestamp_ms {
             // close_epoch is ok if called multiple times
             self.sender.close_epoch(epoch_store);

crates/iota-core/src/checkpoints/mod.rs

@@ -1381,7 +1381,8 @@ impl CheckpointBuilder {
 
         batch.write()?;
 
-        // Send all checkpoint sigs to consensus.
+        // Send all checkpoint sigs to consensus. The messages including
+        // MisbehaviorReports are also sent in this step.
         for (summary, contents) in &new_checkpoints {
             self.output
                 .checkpoint_created(summary, contents, &self.epoch_store, &self.store)

crates/iota-types/src/messages_consensus.rs

@@ -20,8 +20,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     base_types::{
-        AuthorityName, CommitRound, ConciseableName, ObjectID, ObjectRef, SequenceNumber,
-        TransactionDigest,
+        AuthorityName, ConciseableName, ObjectID, ObjectRef, SequenceNumber, TransactionDigest,
     },
     crypto::{AuthoritySignature, DefaultHash},
     digests::{ConsensusCommitDigest, Digest},
@@ -91,10 +90,10 @@ pub enum ConsensusTransactionKey {
     NewJWKFetched(Box<(AuthorityName, JwkId, JWK)>),
     RandomnessDkgMessage(AuthorityName),
     RandomnessDkgConfirmation(AuthorityName),
-    // If a validator submits more than one report for the same round, we update the
-    // scoring metrics using the maximum reported metric, so CommitRound is sufficient to
-    // identify a report from a single AuthorityName.
-    MisbehaviorReport(AuthorityName, CommitRound),
+    // If a validator submits more than one report for the same checkpoint, we update the
+    // scoring metrics using the maximum reported metric, so the checkpoint sequence number is
+    // sufficient to identify a report from a single AuthorityName.
+    MisbehaviorReport(AuthorityName, u64 /* checkpoint_seq */),
     // New entries should be added at the end to preserve serialization compatibility. DO NOT
     // CHANGE THE ORDER OF EXISTING ENTRIES!
 }
@@ -107,8 +106,13 @@ impl Debug for ConsensusTransactionKey {
                 write!(f, "CheckpointSignature({:?}, {:?})", name.concise(), seq)
             }
             Self::EndOfPublish(name) => write!(f, "EndOfPublish({:?})", name.concise()),
-            Self::MisbehaviorReport(name, round) => {
-                write!(f, "MisbehaviorReport({:?},{:?})", name.concise(), round)
+            Self::MisbehaviorReport(name, checkpoint_seq) => {
+                write!(
+                    f,
+                    "MisbehaviorReport({:?},{:?})",
+                    name.concise(),
+                    checkpoint_seq
+                )
             }
             Self::CapabilityNotification(name, generation) => write!(
                 f,
@@ -268,7 +272,11 @@ pub enum ConsensusTransactionKind {
     // of `RandomnessDkgMessages` have been received locally, to complete the key generation
     // process. Contents are a serialized `fastcrypto_tbls::dkg::Confirmation`.
     RandomnessDkgConfirmation(AuthorityName, Vec<u8>),
-    MisbehaviorReport(AuthorityName, VersionedMisbehaviorReport, CommitRound),
+    MisbehaviorReport(
+        AuthorityName,
+        VersionedMisbehaviorReport,
+        u64, // checkpoint_seq
+    ),
     // New entries should be added at the end to preserve serialization compatibility. DO NOT
     // CHANGE THE ORDER OF EXISTING ENTRIES!
 }
@@ -563,10 +571,10 @@ impl ConsensusTransaction {
         }
     }
 
-    pub fn new_misbehavior_report_v1(
+    pub fn new_misbehavior_report(
         authority: AuthorityName,
-        report: &MisbehaviorsV1<Vec<u64>>,
-        round: CommitRound,
+        report: &VersionedMisbehaviorReport,
+        checkpoint_seq: u64,
     ) -> Self {
         let serialized_report =
             bcs::to_bytes(report).expect("report serialization should not fail");
@@ -577,8 +585,8 @@ impl ConsensusTransaction {
             tracking_id,
             kind: ConsensusTransactionKind::MisbehaviorReport(
                 authority,
-                VersionedMisbehaviorReport::V1(report.clone()),
-                round,
+                report.clone(),
+                checkpoint_seq,
             ),
         }
     }
@@ -603,8 +611,8 @@ impl ConsensusTransaction {
             ConsensusTransactionKind::EndOfPublish(authority) => {
                 ConsensusTransactionKey::EndOfPublish(*authority)
             }
-            ConsensusTransactionKind::MisbehaviorReport(authority, _, round) => {
-                ConsensusTransactionKey::MisbehaviorReport(*authority, *round)
+            ConsensusTransactionKind::MisbehaviorReport(authority, _, checkpoint_seq) => {
+                ConsensusTransactionKey::MisbehaviorReport(*authority, *checkpoint_seq)
             }
             ConsensusTransactionKind::CapabilityNotificationV1(cap) => {
                 ConsensusTransactionKey::CapabilityNotification(cap.authority, cap.generation)