Enum EquivocationProof 

pub enum EquivocationProof {
    LockViolation {
        validator: ValidatorPublicKey,
        confirmed_header: BlockHeader,
        confirmed_round: Round,
        confirmed_attested: bool,
        confirmed_commitment: Option<CryptoHash>,
        confirmed_signature: ValidatorSignature,
        validated_header: BlockHeader,
        validated_round: Round,
        validated_unlocking_round: Option<Round>,
        validated_commitment: Option<CryptoHash>,
        validated_signature: ValidatorSignature,
    },
    DoubleVote {

        validator: ValidatorPublicKey,
        round: Round,
        kind: CertificateKind,
        first_header: BlockHeader,
        first_unlocking_round: Option<Round>,
        first_attested: bool,
        first_commitment: Option<CryptoHash>,
        first_signature: ValidatorSignature,
        second_header: BlockHeader,
        second_unlocking_round: Option<Round>,
        second_attested: bool,
        second_commitment: Option<CryptoHash>,
        second_signature: ValidatorSignature,
    
},
    FirstRoundViolation {
        validator: ValidatorPublicKey,
        attested_header: BlockHeader,
        attested_round: Round,
        attested_commitment: Option<CryptoHash>,
        attested_signature: ValidatorSignature,
        earlier_header: BlockHeader,
        earlier_round: Round,
        earlier_attested: bool,
        earlier_commitment: Option<CryptoHash>,
        earlier_signature: ValidatorSignature,
    },
    InvalidJustification {
        validator: ValidatorPublicKey,
        header: BlockHeader,
        round: Round,
        kind: CertificateKind,
        unlocking_round: Option<Round>,
        first_round: bool,
        signature: ValidatorSignature,
        opening: CommittedQuorum,
    },
}

A self-contained proof that a single validator misbehaved.

Variants

LockViolation

The validator voted to validate one block under an unlocking round while having voted to confirm a different block in a round at or above it — contradicting its own unlocking-round claim.

Fields

validator: ValidatorPublicKey

The misbehaving validator.

confirmed_header: BlockHeader

The header of the block the validator voted to confirm. Its hash, chain ID and height are read from here; it must share the chain and height of validated_header.

confirmed_round: Round

The round in which it voted to confirm.

confirmed_attested: bool

The first-round attestation the confirmation vote signed (see VoteValue).

confirmed_commitment: Option<CryptoHash>

The justification commitment the confirmation vote signed.

confirmed_signature: ValidatorSignature

Its ConfirmedBlock signature.

validated_header: BlockHeader

The header of the different block the validator voted to validate.

validated_round: Round

The round in which it voted to validate.

validated_unlocking_round: Option<Round>

The unlocking round the validation vote signed, contradicted by the confirmation.

validated_commitment: Option<CryptoHash>

The justification commitment the validation vote signed.

validated_signature: ValidatorSignature

Its ValidatedBlock signature.

DoubleVote

The validator cast two votes of the same kind for different blocks in the same round: either two ConfirmedBlock votes, or two ValidatedBlock votes (illegal regardless of the unlocking rounds, since a validator may vote for at most one block per round and kind).

Fields

validator: ValidatorPublicKey

The misbehaving validator.

round: Round

The round both votes share.

kind: CertificateKind

The certificate kind both votes share.

first_header: BlockHeader

The header of the first block voted for. The two headers must share a chain and height.

first_unlocking_round: Option<Round>

The unlocking round the first vote signed (None for ConfirmedBlock votes).

first_attested: bool

The first-round attestation the first vote signed (false for ValidatedBlock votes).

first_commitment: Option<CryptoHash>

The justification commitment the first vote signed.

first_signature: ValidatorSignature

The signature on the first vote.

second_header: BlockHeader

The header of the second, different block voted for.

second_unlocking_round: Option<Round>

The unlocking round the second vote signed (None for ConfirmedBlock votes).

second_attested: bool

The first-round attestation the second vote signed (false for ValidatedBlock votes).

second_commitment: Option<CryptoHash>

The justification commitment the second vote signed.

second_signature: ValidatorSignature

The signature on the second vote.

FirstRoundViolation

The validator voted to confirm a block with the first-round attestation — asserting that no lower round exists at this height — while having also voted to confirm a block in a lower round. The two votes cannot both be honest, regardless of the blocks they are for.

Fields

validator: ValidatorPublicKey

The misbehaving validator.

attested_header: BlockHeader

The header of the block confirmed with the attestation. It must share the chain and height of earlier_header.

attested_round: Round

The round the attestation asserts to be the chain’s first.

attested_commitment: Option<CryptoHash>

The justification commitment the attested vote signed.

attested_signature: ValidatorSignature

The ConfirmedBlock signature carrying the attestation.

earlier_header: BlockHeader

The header of the block the earlier vote confirmed.

earlier_round: Round

The round of the earlier vote — strictly below attested_round.

earlier_attested: bool

The first-round attestation the earlier vote signed.

earlier_commitment: Option<CryptoHash>

The justification commitment the earlier vote signed.

earlier_signature: ValidatorSignature

Its ConfirmedBlock signature.

InvalidJustification

The validator signed a justification commitment whose opening is not a quorum it could honestly have cited: the opening’s signatures are invalid or below the quorum threshold, it validates a different block, or its round does not ground the vote that cited it. By signing the commitment the validator attested that it had verified the cited quorum — certificate verification relies on that attestation instead of re-checking the chain — so an invalid opening is individually attributable, with no conflicting certificate needed.

Fields

validator: ValidatorPublicKey

The misbehaving validator.

header: BlockHeader

The header of the block the attesting vote was for.

round: Round

The round of the attesting vote.

kind: CertificateKind

The kind of the attesting vote.

unlocking_round: Option<Round>

The unlocking round the attesting vote signed.

first_round: bool

The first-round attestation the attesting vote signed.

signature: ValidatorSignature

The attesting vote’s signature. Its payload contains the opening’s hash as the justification commitment, binding the signature to the opening.

opening: CommittedQuorum

The opening of the signed commitment: the cited quorum, which is not valid.

Implementations

impl EquivocationProof

pub fn validator(&self) -> ValidatorPublicKey

Returns the misbehaving validator.

pub fn check(&self, committee: &Committee) -> Result<(), ChainError>

Verifies that this is a genuine proof of misbehavior: the referenced votes are actually incompatible (or the opened justification actually invalid, judged against committee) and signed by the named validator.

Trait Implementations

impl Clone for EquivocationProof

fn clone(&self) -> EquivocationProof

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EquivocationProof

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

Formats the value using the given formatter.