Struct SlashingEvidence 

pub struct SlashingEvidence {
    pub offense_type: OffenseType,
    pub reporter_validator_index: u32,
    pub reporter_puzzle_hash: Bytes32,
    pub epoch: u64,
    pub payload: SlashingEvidencePayload,
}

Slashing-evidence envelope.

Per SPEC §3.5. Fields are frozen wire protocol; their order matters for the deterministic bincode serialization consumed by SlashingEvidence::hash — do NOT reorder without bumping the protocol version.

Fields

offense_type: OffenseType

Classification of the offense. Drives base-penalty lookup (DSL-001) and REMARK dispatch (DSL-102).

reporter_validator_index: u32

Validator index of the reporter. Receives the whistleblower reward (DSL-025). MUST NOT appear in slashable_validators (DSL-012 self-accuse check).

reporter_puzzle_hash: Bytes32

Puzzle hash the whistleblower reward is paid to (DSL-025). Bound into the hash so a malicious reporter cannot swap payout addresses after the evidence is admitted.

epoch: u64

Epoch at which the offense occurred. Used by DSL-011 (OffenseTooOld lookback check).

payload: SlashingEvidencePayload

The per-offense payload carrying the fraud-proof bytes.

Implementations

impl SlashingEvidence

pub fn hash(&self) -> Bytes32

Content-addressed identity of the envelope.

Implements DSL-002. Traces to SPEC §3.5.

Construction

hash = SHA-256(
  DOMAIN_SLASHING_EVIDENCE          (24 bytes, "DIG_SLASHING_EVIDENCE_V1")
  || bincode::serialize(self)       (variable, full envelope encoding)
)

Hasher: chia_sha2::Sha256 (matches attester signing root, DSL-004).

Invariants (all enforced by the DSL-002 test suite)

• Deterministic: identical envelopes always produce identical digests, across runs and processes.
• Domain-bound: DOMAIN_SLASHING_EVIDENCE is mixed in as the first input, so the digest cannot collide with any other protocol hash.
• Field-covering: every byte of every field (including the payload enum discriminant + inner variant bytes) participates; mutating any one shifts the digest.

Why bincode

bincode produces a compact, deterministic encoding with explicit length prefixes on variable-length fields. serde_json would be non-canonical (field-order flexibility, whitespace). Serialization failure is treated as unreachable — SlashingEvidence contains no types bincode cannot encode, so .expect is the honest signal on a programmer bug rather than a runtime Result every caller must thread.

pub fn slashable_validators(&self) -> Vec<u32>

List of validator indices this envelope accuses.

Implements DSL-010. Traces to SPEC §3.5.

Returns

• Proposer / InvalidBlock → exactly one index (the proposer_index from the signed header).
• Attester → sorted, deduplicated intersection of the two indexed-attestation index lists (DSL-007). Cardinality 0..=N.

Consumed by verify_evidence (DSL-012 reporter-self-accuse) and SlashingManager::submit_evidence per-validator loop (DSL-022).

Trait Implementations

impl Clone for SlashingEvidence

fn clone(&self) -> SlashingEvidence

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SlashingEvidence

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SlashingEvidence

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SlashingEvidence

fn eq(&self, other: &SlashingEvidence) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SlashingEvidence

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SlashingEvidence

impl StructuralPartialEq for SlashingEvidence