Validator Slashing: What the Word Actually Covers

What slashing is for

A validator with nothing to lose is a validator you cannot rely on. Slashing is the answer: misbehave provably, and the stake you posted is taken.

The offence that matters most is equivocation, which means signing two conflicting things at the same point in the protocol. It is the one misbehaviour that can actually break agreement, and it is the one every design of this family is built to punish.

And on this chain the word refers to something else

There is exactly one slashing transaction, and it targets compute operators.

It is not for validators. It works, and it is reasonable: a severe case removes the operator and zeroes its reputation, an ordinary one reduces reputation without removal, so the mechanism has two settings rather than one lever.

And any active validator may send it, which is the permission finding from another page and is part of the same picture.

For validators there is a detector, and nothing calls it

The consensus crate contains a double-sign detector. It takes two votes and returns evidence if they come from the same validator, in the same round, for different blocks.

A search across the whole workspace finds no caller. Its own definition and its own tests are the only places its name appears.

CONTROL: the same search style finds the compute-slash payload wired into the executor, so this is an absence rather than a failed query.

And the detector is partial by its own admission. A comment records that it compares block hashes and not signature validity, so what it returns is a claim about two objects rather than proven misconduct.

And there is nowhere to send evidence even if it were produced

The complete list of transaction types contains no validator-slash payload.

So there is no path from evidence to consequence. Nothing reduces a stake, removes a validator, or records an offence, and the staked balance of a misbehaving validator would be exactly as it was.

This is the shape this estate keeps finding: a mechanism whose first step exists and whose second does not. Detection without a penalty is a log line.

The second stack has the real version, and it deserves saying

The undeployed second consensus implementation carries a full equivocation module, several times the size of the live detector.

It defines two slashable offences precisely, a double vote and a double proposal, and its evidence is self-contained: a pair of signed messages that anybody can verify statelessly against the committee key. That is the correct shape, and it is a meaningful piece of work.

It is in the stack that is not deployed, alongside the other half of that line.

Sized honestly, and it cuts both ways

Nothing here is exploitable today. There is no peer network, one operator runs every validator, and the stake in question is denominated in a unit with no market.

And the sizing cuts the other way too. A slashing design is one of the things that has to exist before an outside validator would ever join, because slashing is what makes their stake mean something to everybody else. It is not a feature to add after opening the set.

What you can check yourself

list the transaction types this chain accepts and look for one that penalises a validator

There is none. The compute-slash type is there and works, which is what makes the absence of the other one a choice rather than an oversight of the whole area.