add instruction to close violation report

program/src/error.rs

@@ -9,6 +9,11 @@ use {
 /// Errors that may be returned by the program.
 #[derive(Clone, Copy, Debug, Eq, Error, FromPrimitive, PartialEq)]
 pub enum SlashingError {
+    /// Attempting to close a violation report before 3
+    /// epochs have passed
+    #[error("Closing violation report too soon")]
+    CloseViolationReportTooSoon,
+
     /// Violation has already been reported
     #[error("Duplicate report")]
     DuplicateReport,
@@ -17,6 +22,10 @@ pub enum SlashingError {
     #[error("Exceeds statute of limitations")]
     ExceedsStatuteOfLimitations,
 
+    /// Destination account does not match the key on the report
+    #[error("Invalid destination account")]
+    InvalidDestinationAccount,
+
     /// Invalid shred variant
     #[error("Invalid shred variant")]
     InvalidShredVariant,

program/src/instruction.rs

@@ -29,14 +29,30 @@ use {
 #[repr(u8)]
 #[derive(Clone, Copy, Debug, PartialEq, TryFromPrimitive, IntoPrimitive)]
 pub enum SlashingInstruction {
+    /// Close the report account that was created after successfully submitting
+    /// a slashing proof. To ensure that the runtime and indexers have seen the
+    /// report, we require that at least 3 epochs have passed since creation.
+    ///
+    /// After closing the account, we credit the lamports to the destination
+    /// address denoted in the report.
+    ///
+    /// Accounts expected by this instruction:
+    /// 0. `[WRITE]` PDA where the violation report is stored, see
+    ///    `[get_violation_report_address]` for the address derivation.
+    /// 1. `[WRITE]` Destination account which will be credited the lamports
+    ///    from the PDA.
+    /// 2. `[]` System program
+    CloseViolationReport,
+
     /// Submit a slashable violation proof for `node_pubkey`, which indicates
     /// that they submitted a duplicate block to the network
     ///
     ///
     /// Accounts expected by this instruction:
     /// 0. `[]` Proof account, must be previously initialized with the proof
     ///    data.
-    /// 1. `[WRITE]` PDA to store the violation report
+    /// 1. `[WRITE]` PDA to store the violation report, see
+    ///    `[get_violation_report_address]` for the address derivation.
     /// 2. `[]` Instructions sysvar
     /// 3. `[]` System program
     ///
@@ -141,6 +157,25 @@ pub(crate) fn decode_instruction_data<T: Pod>(input_with_type: &[u8]) -> Result<
     }
 }
 
+/// Create a `SlashingInstruction::CloseViolationReport` instruction
+/// Callers can use `[get_violation_report_address]` to derive the report
+/// account address
+pub fn close_violation_report(
+    report_account: &Pubkey,
+    destination_account: &Pubkey,
+) -> Instruction {
+    let accounts = vec![
+        AccountMeta::new(*report_account, false),
+        AccountMeta::new(*destination_account, false),
+        AccountMeta::new_readonly(system_program::id(), false),
+    ];
+    encode_instruction(
+        accounts,
+        SlashingInstruction::CloseViolationReport,
+        &[0u8; 0],
+    )
+}
+
 /// Create a `SlashingInstruction::DuplicateBlockProof` instruction
 pub fn duplicate_block_proof(
     proof_account: &Pubkey,
@@ -286,7 +321,7 @@ mod tests {
             shred_2_signature,
         };
         let instruction = duplicate_block_proof(&Pubkey::new_unique(), &instruction_data);
-        let mut expected = vec![0];
+        let mut expected = vec![1];
         expected.extend_from_slice(&offset.to_le_bytes());
         expected.extend_from_slice(&slot.to_le_bytes());
         expected.extend_from_slice(&node_pubkey.to_bytes());
@@ -316,6 +351,16 @@ mod tests {
         assert_eq!(instruction_data.shred_2_signature, shred_2_signature);
     }
 
+    #[test]
+    fn serialize_close_violation_report() {
+        let instruction = close_violation_report(&Pubkey::new_unique(), &Pubkey::new_unique());
+
+        assert_eq!(
+            SlashingInstruction::CloseViolationReport,
+            decode_instruction_type(&instruction.data).unwrap()
+        );
+    }
+
     #[test]
     fn deserialize_invalid_instruction() {
         let mut expected = vec![12];

program/src/lib.rs

@@ -15,7 +15,7 @@ pub mod state;
 pub use solana_program;
 use {
     solana_program::{clock::Slot, pubkey::Pubkey},
-    state::ProofType,
+    state::{ProofType, ViolationReport},
 };
 
 solana_program::declare_id!("S1ashing11111111111111111111111111111111111");
@@ -37,3 +37,51 @@ pub fn get_violation_report_address(
         &id(),
     )
 }
+
+struct ViolationReportAddress<'a> {
+    address: Pubkey,
+    pubkey_seed: &'a [u8],
+    slot_seed: &'a [u8; 8],
+    violation_seed: [u8; 1],
+    bump_seed: [u8; 1],
+}
+
+impl<'a> ViolationReportAddress<'a> {
+    pub(crate) fn new(report: &'a ViolationReport) -> ViolationReportAddress<'a> {
+        let pubkey_seed = report.pubkey.as_ref();
+        let slot_seed = &report.slot.0;
+        let violation_seed = [report.violation_type];
+        let (pda, bump) =
+            Pubkey::find_program_address(&[pubkey_seed, slot_seed, &violation_seed], &id());
+        let bump_seed = [bump];
+        Self {
+            address: pda,
+            pubkey_seed,
+            slot_seed,
+            violation_seed,
+            bump_seed,
+        }
+    }
+
+    pub(crate) fn key(&self) -> &Pubkey {
+        &self.address
+    }
+
+    pub(crate) fn seeds(&self) -> [&[u8]; 4] {
+        [
+            self.pubkey_seed,
+            self.slot_seed,
+            &self.violation_seed,
+            &self.bump_seed,
+        ]
+    }
+
+    pub(crate) fn seeds_owned(&self) -> [Vec<u8>; 4] {
+        [
+            self.pubkey_seed.to_owned(),
+            Vec::from(self.slot_seed),
+            Vec::from(self.violation_seed),
+            Vec::from(self.bump_seed),
+        ]
+    }
+}

program/src/processor.rs

@@ -2,23 +2,25 @@
 
 use {
     crate::{
+        check_id,
         duplicate_block_proof::DuplicateBlockProofData,
         error::SlashingError,
         instruction::{
             decode_instruction_data, decode_instruction_type, DuplicateBlockProofInstructionData,
             SlashingInstruction,
         },
         state::{
-            store_violation_report, PodEpoch, ProofType, SlashingAccounts, SlashingProofData,
-            ViolationReport,
+            close_violation_report, store_violation_report, PodEpoch, ProofType, SlashingAccounts,
+            SlashingProofData, ViolationReport,
         },
     },
     solana_program::{
-        account_info::AccountInfo,
+        account_info::{next_account_info, AccountInfo},
         entrypoint::ProgramResult,
         msg,
         program_error::ProgramError,
         pubkey::Pubkey,
+        system_program,
         sysvar::{clock::Clock, epoch_schedule::EpochSchedule, Sysvar},
     },
 };
@@ -65,9 +67,27 @@ pub fn process_instruction(
 ) -> ProgramResult {
     let instruction_type = decode_instruction_type(input)?;
     let account_info_iter = &mut accounts.iter();
-    let accounts = SlashingAccounts::new(account_info_iter)?;
     match instruction_type {
+        SlashingInstruction::CloseViolationReport => {
+            let report_account = next_account_info(account_info_iter)?;
+            let destination_account = next_account_info(account_info_iter)?;
+            let system_program_account = next_account_info(account_info_iter)?;
+
+            if !check_id(report_account.owner) || report_account.data_is_empty() {
+                return Err(ProgramError::from(
+                    SlashingError::InvalidViolationReportAcccount,
+                ));
+            }
+            if !system_program::check_id(system_program_account.key) {
+                return Err(ProgramError::from(
+                    SlashingError::MissingSystemProgramAccount,
+                ));
+            }
+
+            close_violation_report(report_account, destination_account, system_program_account)?;
+        }
         SlashingInstruction::DuplicateBlockProof => {
+            let accounts = SlashingAccounts::new(account_info_iter)?;
             let data = decode_instruction_data::<DuplicateBlockProofInstructionData>(input)?;
             let proof_data = &accounts.proof_account.try_borrow_data()?[data.offset()?..];
             let violation_report = ViolationReport {
@@ -86,9 +106,9 @@ pub fn process_instruction(
                 proof_data,
                 input,
             )?;
-            Ok(())
         }
     }
+    Ok(())
 }
 
 #[cfg(test)]

program/src/state.rs

@@ -1,10 +1,13 @@
 //! Program state
 use {
-    crate::{check_id, duplicate_block_proof::DuplicateBlockProofData, error::SlashingError, id},
+    crate::{
+        check_id, duplicate_block_proof::DuplicateBlockProofData, error::SlashingError, id,
+        ViolationReportAddress,
+    },
     bytemuck::{Pod, Zeroable},
     solana_program::{
         account_info::{next_account_info, AccountInfo},
-        clock::Slot,
+        clock::{Epoch, Slot},
         msg,
         program::invoke_signed,
         program_error::ProgramError,
@@ -13,7 +16,7 @@ use {
         system_instruction, system_program,
         sysvar::{self, Sysvar},
     },
-    spl_pod::primitives::PodU64,
+    spl_pod::{bytemuck::pod_from_bytes, primitives::PodU64},
 };
 
 const PACKET_DATA_SIZE: usize = 1232;
@@ -222,16 +225,15 @@ pub(crate) fn store_violation_report<'a, 'b, T>(
 where
     T: SlashingProofData<'a>,
 {
-    let slot = report.slot;
-    let pubkey_seed = report.pubkey.as_ref();
-    let slot_seed = slot.0;
-    let violation_seed = [report.violation_type];
-    let mut seeds: Vec<&[u8]> = vec![&pubkey_seed, &slot_seed, &violation_seed];
-    let (pda, bump) = Pubkey::find_program_address(&seeds, &id());
-    let bump_seed = [bump];
-    seeds.push(&bump_seed);
-
-    if pda != *accounts.violation_account() {
+    let report_address = ViolationReportAddress::new(&report);
+    let report_key = report_address.key();
+    let seeds = report_address.seeds();
+    let cpi_accounts = [
+        accounts.violation_pda_account.clone(),
+        accounts.system_program_account.clone(),
+    ];
+
+    if *report_key != *accounts.violation_account() {
         return Err(ProgramError::from(
             SlashingError::InvalidViolationReportAcccount,
         ));
@@ -242,7 +244,7 @@ where
         msg!(
             "{} violation verified in slot {} however the violation has already been reported",
             T::PROOF_TYPE.violation_str(),
-            u64::from(slot),
+            u64::from(report.slot),
         );
         return Err(ProgramError::from(SlashingError::DuplicateReport));
     }
@@ -255,15 +257,8 @@ where
     }
 
     // Assign the slashing program as the owner
-    let assign_instruction = system_instruction::assign(&pda, &id());
-    invoke_signed(
-        &assign_instruction,
-        &[
-            accounts.violation_pda_account.clone(),
-            accounts.system_program_account.clone(),
-        ],
-        &[&seeds],
-    )?;
+    let assign_instruction = system_instruction::assign(report_key, &id());
+    invoke_signed(&assign_instruction, &cpi_accounts, &[&seeds])?;
 
     // Allocate enough space for the report
     accounts.violation_pda_account.realloc(data_len, false)?;
@@ -282,6 +277,61 @@ where
     accounts.write_violation_report(report, proof_data)
 }
 
+pub(crate) fn close_violation_report<'a, 'b>(
+    report_account: &'a AccountInfo<'b>,
+    destination_account: &'a AccountInfo<'b>,
+    system_program_account: &'a AccountInfo<'b>,
+) -> Result<(), ProgramError> {
+    let report_data = report_account.try_borrow_data()?;
+    let report: &ViolationReport =
+        pod_from_bytes(&report_data[0..std::mem::size_of::<ViolationReport>()])?;
+    let report_address = ViolationReportAddress::new(report);
+    let report_key = *report_address.key();
+    let destination = report.destination;
+
+    debug_assert_eq!(*report_account.key, report_key);
+
+    if Epoch::from(report.epoch).saturating_add(3) > sysvar::clock::Clock::get()?.epoch {
+        return Err(ProgramError::from(
+            SlashingError::CloseViolationReportTooSoon,
+        ));
+    }
+
+    if destination != *destination_account.key {
+        return Err(ProgramError::from(SlashingError::InvalidDestinationAccount));
+    }
+
+    // Copy seeds and drop as we will modify the report account
+    let seeds = report_address.seeds_owned();
+    let seeds: Vec<&[u8]> = seeds.iter().map(|seed| &seed[..]).collect();
+    drop(report_data);
+
+    // Reallocate the account to 0 bytes
+    report_account.realloc(0, false)?;
+
+    // Assign the system program as the owner
+    report_account.assign(&system_program::id());
+
+    // Transfer the lamports to the destination address
+    let lamports = report_account.lamports();
+    let transfer_instruction = system_instruction::transfer(&report_key, &destination, lamports);
+    invoke_signed(
+        &transfer_instruction,
+        &[
+            report_account.clone(),
+            destination_account.clone(),
+            system_program_account.clone(),
+        ],
+        &[&seeds],
+    )?;
+
+    msg!(
+        "Closed violation report and credited {} lamports to the destination address",
+        lamports
+    );
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use crate::state::PACKET_DATA_SIZE;