package types
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
amino "github.com/tendermint/go-amino"
|
|
|
|
"github.com/tendermint/tendermint/crypto"
|
|
"github.com/tendermint/tendermint/crypto/merkle"
|
|
"github.com/tendermint/tendermint/crypto/tmhash"
|
|
tmmath "github.com/tendermint/tendermint/libs/math"
|
|
tmproto "github.com/tendermint/tendermint/proto/types"
|
|
)
|
|
|
|
const (
|
|
// MaxEvidenceBytes is a maximum size of any evidence (including amino overhead).
|
|
MaxEvidenceBytes int64 = 444
|
|
|
|
// An invalid field in the header from LunaticValidatorEvidence.
|
|
// Must be a function of the ABCI application state.
|
|
ValidatorsHashField = "ValidatorsHash"
|
|
NextValidatorsHashField = "NextValidatorsHash"
|
|
ConsensusHashField = "ConsensusHash"
|
|
AppHashField = "AppHash"
|
|
LastResultsHashField = "LastResultsHash"
|
|
)
|
|
|
|
// ErrEvidenceInvalid wraps a piece of evidence and the error denoting how or why it is invalid.
|
|
type ErrEvidenceInvalid struct {
|
|
Evidence Evidence
|
|
ErrorValue error
|
|
}
|
|
|
|
// NewErrEvidenceInvalid returns a new EvidenceInvalid with the given err.
|
|
func NewErrEvidenceInvalid(ev Evidence, err error) *ErrEvidenceInvalid {
|
|
return &ErrEvidenceInvalid{ev, err}
|
|
}
|
|
|
|
// Error returns a string representation of the error.
|
|
func (err *ErrEvidenceInvalid) Error() string {
|
|
return fmt.Sprintf("Invalid evidence: %v. Evidence: %v", err.ErrorValue, err.Evidence)
|
|
}
|
|
|
|
// ErrEvidenceOverflow is for when there is too much evidence in a block.
|
|
type ErrEvidenceOverflow struct {
|
|
MaxNum int
|
|
GotNum int
|
|
}
|
|
|
|
// NewErrEvidenceOverflow returns a new ErrEvidenceOverflow where got > max.
|
|
func NewErrEvidenceOverflow(max, got int) *ErrEvidenceOverflow {
|
|
return &ErrEvidenceOverflow{max, got}
|
|
}
|
|
|
|
// Error returns a string representation of the error.
|
|
func (err *ErrEvidenceOverflow) Error() string {
|
|
return fmt.Sprintf("Too much evidence: Max %d, got %d", err.MaxNum, err.GotNum)
|
|
}
|
|
|
|
//-------------------------------------------
|
|
|
|
// Evidence represents any provable malicious activity by a validator.
|
|
type Evidence interface {
|
|
Height() int64 // height of the equivocation
|
|
Time() time.Time // time of the equivocation
|
|
Address() []byte // address of the equivocating validator
|
|
Bytes() []byte // bytes which comprise the evidence
|
|
Hash() []byte // hash of the evidence
|
|
Verify(chainID string, pubKey crypto.PubKey) error // verify the evidence
|
|
Equal(Evidence) bool // check equality of evidence
|
|
|
|
ValidateBasic() error
|
|
String() string
|
|
}
|
|
|
|
type CompositeEvidence interface {
|
|
VerifyComposite(committedHeader *Header, valSet *ValidatorSet) error
|
|
Split(committedHeader *Header, valSet *ValidatorSet, valToLastHeight map[string]int64) []Evidence
|
|
}
|
|
|
|
func EvidenceToProto(evidence Evidence) (*tmproto.Evidence, error) {
|
|
if evidence == nil {
|
|
return nil, errors.New("nil evidence")
|
|
}
|
|
|
|
switch evi := evidence.(type) {
|
|
case *DuplicateVoteEvidence:
|
|
voteB := evi.VoteB.ToProto()
|
|
voteA := evi.VoteA.ToProto()
|
|
tp := &tmproto.Evidence{
|
|
Sum: &tmproto.Evidence_DuplicateVoteEvidence{
|
|
DuplicateVoteEvidence: &tmproto.DuplicateVoteEvidence{
|
|
VoteA: voteA,
|
|
VoteB: voteB,
|
|
},
|
|
},
|
|
}
|
|
return tp, nil
|
|
case ConflictingHeadersEvidence:
|
|
pbh1 := evi.H1.ToProto()
|
|
pbh2 := evi.H2.ToProto()
|
|
|
|
tp := &tmproto.Evidence{
|
|
Sum: &tmproto.Evidence_ConflictingHeadersEvidence{
|
|
ConflictingHeadersEvidence: &tmproto.ConflictingHeadersEvidence{
|
|
H1: pbh1,
|
|
H2: pbh2,
|
|
},
|
|
},
|
|
}
|
|
|
|
return tp, nil
|
|
case *ConflictingHeadersEvidence:
|
|
pbh1 := evi.H1.ToProto()
|
|
pbh2 := evi.H2.ToProto()
|
|
|
|
tp := &tmproto.Evidence{
|
|
Sum: &tmproto.Evidence_ConflictingHeadersEvidence{
|
|
ConflictingHeadersEvidence: &tmproto.ConflictingHeadersEvidence{
|
|
H1: pbh1,
|
|
H2: pbh2,
|
|
},
|
|
},
|
|
}
|
|
|
|
return tp, nil
|
|
case *LunaticValidatorEvidence:
|
|
h := evi.Header.ToProto()
|
|
v := evi.Vote.ToProto()
|
|
|
|
tp := &tmproto.Evidence{
|
|
Sum: &tmproto.Evidence_LunaticValidatorEvidence{
|
|
LunaticValidatorEvidence: &tmproto.LunaticValidatorEvidence{
|
|
Header: h,
|
|
Vote: v,
|
|
InvalidHeaderField: evi.InvalidHeaderField,
|
|
},
|
|
},
|
|
}
|
|
return tp, nil
|
|
case LunaticValidatorEvidence:
|
|
h := evi.Header.ToProto()
|
|
v := evi.Vote.ToProto()
|
|
|
|
tp := &tmproto.Evidence{
|
|
Sum: &tmproto.Evidence_LunaticValidatorEvidence{
|
|
LunaticValidatorEvidence: &tmproto.LunaticValidatorEvidence{
|
|
Header: h,
|
|
Vote: v,
|
|
InvalidHeaderField: evi.InvalidHeaderField,
|
|
},
|
|
},
|
|
}
|
|
return tp, nil
|
|
case *PotentialAmnesiaEvidence:
|
|
voteB := evi.VoteB.ToProto()
|
|
voteA := evi.VoteA.ToProto()
|
|
|
|
tp := &tmproto.Evidence{
|
|
Sum: &tmproto.Evidence_PotentialAmnesiaEvidence{
|
|
PotentialAmnesiaEvidence: &tmproto.PotentialAmnesiaEvidence{
|
|
VoteA: voteA,
|
|
VoteB: voteB,
|
|
},
|
|
},
|
|
}
|
|
|
|
return tp, nil
|
|
case PotentialAmnesiaEvidence:
|
|
voteB := evi.VoteB.ToProto()
|
|
voteA := evi.VoteA.ToProto()
|
|
|
|
tp := &tmproto.Evidence{
|
|
Sum: &tmproto.Evidence_PotentialAmnesiaEvidence{
|
|
PotentialAmnesiaEvidence: &tmproto.PotentialAmnesiaEvidence{
|
|
VoteA: voteA,
|
|
VoteB: voteB,
|
|
},
|
|
},
|
|
}
|
|
|
|
return tp, nil
|
|
case MockEvidence:
|
|
if err := evi.ValidateBasic(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
tp := &tmproto.Evidence{
|
|
Sum: &tmproto.Evidence_MockEvidence{
|
|
MockEvidence: &tmproto.MockEvidence{
|
|
EvidenceHeight: evi.Height(),
|
|
EvidenceTime: evi.Time(),
|
|
EvidenceAddress: evi.Address(),
|
|
},
|
|
},
|
|
}
|
|
|
|
return tp, nil
|
|
case MockRandomEvidence:
|
|
if err := evi.ValidateBasic(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
tp := &tmproto.Evidence{
|
|
Sum: &tmproto.Evidence_MockRandomEvidence{
|
|
MockRandomEvidence: &tmproto.MockRandomEvidence{
|
|
EvidenceHeight: evi.Height(),
|
|
EvidenceTime: evi.Time(),
|
|
EvidenceAddress: evi.Address(),
|
|
RandBytes: evi.randBytes,
|
|
},
|
|
},
|
|
}
|
|
return tp, nil
|
|
default:
|
|
return nil, fmt.Errorf("toproto: evidence is not recognized: %T", evi)
|
|
}
|
|
}
|
|
|
|
func EvidenceFromProto(evidence *tmproto.Evidence) (Evidence, error) {
|
|
if evidence == nil {
|
|
return nil, errors.New("nil evidence")
|
|
}
|
|
|
|
switch evi := evidence.Sum.(type) {
|
|
case *tmproto.Evidence_DuplicateVoteEvidence:
|
|
|
|
vA, err := VoteFromProto(evi.DuplicateVoteEvidence.VoteA)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
vB, err := VoteFromProto(evi.DuplicateVoteEvidence.VoteB)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
dve := DuplicateVoteEvidence{
|
|
VoteA: vA,
|
|
VoteB: vB,
|
|
}
|
|
|
|
return &dve, dve.ValidateBasic()
|
|
case *tmproto.Evidence_ConflictingHeadersEvidence:
|
|
h1, err := SignedHeaderFromProto(evi.ConflictingHeadersEvidence.H1)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("from proto err: %w", err)
|
|
}
|
|
h2, err := SignedHeaderFromProto(evi.ConflictingHeadersEvidence.H2)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("from proto err: %w", err)
|
|
}
|
|
|
|
tp := ConflictingHeadersEvidence{
|
|
H1: h1,
|
|
H2: h2,
|
|
}
|
|
|
|
return tp, tp.ValidateBasic()
|
|
case *tmproto.Evidence_LunaticValidatorEvidence:
|
|
h, err := HeaderFromProto(evi.LunaticValidatorEvidence.GetHeader())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
v, err := VoteFromProto(evi.LunaticValidatorEvidence.GetVote())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
tp := LunaticValidatorEvidence{
|
|
Header: &h,
|
|
Vote: v,
|
|
InvalidHeaderField: evi.LunaticValidatorEvidence.InvalidHeaderField,
|
|
}
|
|
|
|
return &tp, tp.ValidateBasic()
|
|
case *tmproto.Evidence_PotentialAmnesiaEvidence:
|
|
voteA, err := VoteFromProto(evi.PotentialAmnesiaEvidence.GetVoteA())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
voteB, err := VoteFromProto(evi.PotentialAmnesiaEvidence.GetVoteB())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
tp := PotentialAmnesiaEvidence{
|
|
VoteA: voteA,
|
|
VoteB: voteB,
|
|
}
|
|
|
|
return &tp, tp.ValidateBasic()
|
|
case *tmproto.Evidence_MockEvidence:
|
|
me := MockEvidence{
|
|
EvidenceHeight: evi.MockEvidence.GetEvidenceHeight(),
|
|
EvidenceAddress: evi.MockEvidence.GetEvidenceAddress(),
|
|
EvidenceTime: evi.MockEvidence.GetEvidenceTime(),
|
|
}
|
|
return me, me.ValidateBasic()
|
|
case *tmproto.Evidence_MockRandomEvidence:
|
|
mre := MockRandomEvidence{
|
|
MockEvidence: MockEvidence{
|
|
EvidenceHeight: evi.MockRandomEvidence.GetEvidenceHeight(),
|
|
EvidenceAddress: evi.MockRandomEvidence.GetEvidenceAddress(),
|
|
EvidenceTime: evi.MockRandomEvidence.GetEvidenceTime(),
|
|
},
|
|
randBytes: evi.MockRandomEvidence.RandBytes,
|
|
}
|
|
return mre, mre.ValidateBasic()
|
|
default:
|
|
return nil, errors.New("evidence is not recognized")
|
|
}
|
|
}
|
|
|
|
func RegisterEvidences(cdc *amino.Codec) {
|
|
cdc.RegisterInterface((*Evidence)(nil), nil)
|
|
cdc.RegisterConcrete(&DuplicateVoteEvidence{}, "tendermint/DuplicateVoteEvidence", nil)
|
|
cdc.RegisterConcrete(&ConflictingHeadersEvidence{}, "tendermint/ConflictingHeadersEvidence", nil)
|
|
cdc.RegisterConcrete(&PhantomValidatorEvidence{}, "tendermint/PhantomValidatorEvidence", nil)
|
|
cdc.RegisterConcrete(&LunaticValidatorEvidence{}, "tendermint/LunaticValidatorEvidence", nil)
|
|
cdc.RegisterConcrete(&PotentialAmnesiaEvidence{}, "tendermint/PotentialAmnesiaEvidence", nil)
|
|
}
|
|
|
|
func RegisterMockEvidences(cdc *amino.Codec) {
|
|
cdc.RegisterConcrete(MockEvidence{}, "tendermint/MockEvidence", nil)
|
|
cdc.RegisterConcrete(MockRandomEvidence{}, "tendermint/MockRandomEvidence", nil)
|
|
}
|
|
|
|
//-------------------------------------------
|
|
|
|
// DuplicateVoteEvidence contains evidence a validator signed two conflicting
|
|
// votes.
|
|
type DuplicateVoteEvidence struct {
|
|
VoteA *Vote
|
|
VoteB *Vote
|
|
}
|
|
|
|
var _ Evidence = &DuplicateVoteEvidence{}
|
|
|
|
// NewDuplicateVoteEvidence creates DuplicateVoteEvidence with right ordering given
|
|
// two conflicting votes. If one of the votes is nil, evidence returned is nil as well
|
|
func NewDuplicateVoteEvidence(vote1 *Vote, vote2 *Vote) *DuplicateVoteEvidence {
|
|
var voteA, voteB *Vote
|
|
if vote1 == nil || vote2 == nil {
|
|
return nil
|
|
}
|
|
if strings.Compare(vote1.BlockID.Key(), vote2.BlockID.Key()) == -1 {
|
|
voteA = vote1
|
|
voteB = vote2
|
|
} else {
|
|
voteA = vote2
|
|
voteB = vote1
|
|
}
|
|
return &DuplicateVoteEvidence{
|
|
VoteA: voteA,
|
|
VoteB: voteB,
|
|
}
|
|
}
|
|
|
|
// String returns a string representation of the evidence.
|
|
func (dve *DuplicateVoteEvidence) String() string {
|
|
return fmt.Sprintf("DuplicateVoteEvidence{VoteA: %v, VoteB: %v}", dve.VoteA, dve.VoteB)
|
|
|
|
}
|
|
|
|
// Height returns the height this evidence refers to.
|
|
func (dve *DuplicateVoteEvidence) Height() int64 {
|
|
return dve.VoteA.Height
|
|
}
|
|
|
|
// Time returns the time the evidence was created.
|
|
func (dve *DuplicateVoteEvidence) Time() time.Time {
|
|
return dve.VoteA.Timestamp
|
|
}
|
|
|
|
// Address returns the address of the validator.
|
|
func (dve *DuplicateVoteEvidence) Address() []byte {
|
|
return dve.VoteA.ValidatorAddress
|
|
}
|
|
|
|
// Hash returns the hash of the evidence.
|
|
func (dve *DuplicateVoteEvidence) Bytes() []byte {
|
|
return cdcEncode(dve)
|
|
}
|
|
|
|
// Hash returns the hash of the evidence.
|
|
func (dve *DuplicateVoteEvidence) Hash() []byte {
|
|
return tmhash.Sum(cdcEncode(dve))
|
|
}
|
|
|
|
// Verify returns an error if the two votes aren't conflicting.
|
|
//
|
|
// To be conflicting, they must be from the same validator, for the same H/R/S,
|
|
// but for different blocks.
|
|
func (dve *DuplicateVoteEvidence) Verify(chainID string, pubKey crypto.PubKey) error {
|
|
// H/R/S must be the same
|
|
if dve.VoteA.Height != dve.VoteB.Height ||
|
|
dve.VoteA.Round != dve.VoteB.Round ||
|
|
dve.VoteA.Type != dve.VoteB.Type {
|
|
return fmt.Errorf("h/r/s does not match: %d/%d/%v vs %d/%d/%v",
|
|
dve.VoteA.Height, dve.VoteA.Round, dve.VoteA.Type,
|
|
dve.VoteB.Height, dve.VoteB.Round, dve.VoteB.Type)
|
|
}
|
|
|
|
// Address must be the same
|
|
if !bytes.Equal(dve.VoteA.ValidatorAddress, dve.VoteB.ValidatorAddress) {
|
|
return fmt.Errorf("validator addresses do not match: %X vs %X",
|
|
dve.VoteA.ValidatorAddress,
|
|
dve.VoteB.ValidatorAddress,
|
|
)
|
|
}
|
|
|
|
// Index must be the same
|
|
if dve.VoteA.ValidatorIndex != dve.VoteB.ValidatorIndex {
|
|
return fmt.Errorf(
|
|
"validator indices do not match: %d and %d",
|
|
dve.VoteA.ValidatorIndex,
|
|
dve.VoteB.ValidatorIndex,
|
|
)
|
|
}
|
|
|
|
// BlockIDs must be different
|
|
if dve.VoteA.BlockID.Equals(dve.VoteB.BlockID) {
|
|
return fmt.Errorf(
|
|
"block IDs are the same (%v) - not a real duplicate vote",
|
|
dve.VoteA.BlockID,
|
|
)
|
|
}
|
|
|
|
// pubkey must match address (this should already be true, sanity check)
|
|
addr := dve.VoteA.ValidatorAddress
|
|
if !bytes.Equal(pubKey.Address(), addr) {
|
|
return fmt.Errorf("address (%X) doesn't match pubkey (%v - %X)",
|
|
addr, pubKey, pubKey.Address())
|
|
}
|
|
|
|
// Signatures must be valid
|
|
if !pubKey.VerifyBytes(dve.VoteA.SignBytes(chainID), dve.VoteA.Signature) {
|
|
return fmt.Errorf("verifying VoteA: %w", ErrVoteInvalidSignature)
|
|
}
|
|
if !pubKey.VerifyBytes(dve.VoteB.SignBytes(chainID), dve.VoteB.Signature) {
|
|
return fmt.Errorf("verifying VoteB: %w", ErrVoteInvalidSignature)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Equal checks if two pieces of evidence are equal.
|
|
func (dve *DuplicateVoteEvidence) Equal(ev Evidence) bool {
|
|
if _, ok := ev.(*DuplicateVoteEvidence); !ok {
|
|
return false
|
|
}
|
|
|
|
// just check their hashes
|
|
dveHash := tmhash.Sum(cdcEncode(dve))
|
|
evHash := tmhash.Sum(cdcEncode(ev))
|
|
fmt.Println(dveHash, evHash)
|
|
return bytes.Equal(dveHash, evHash)
|
|
}
|
|
|
|
// ValidateBasic performs basic validation.
|
|
func (dve *DuplicateVoteEvidence) ValidateBasic() error {
|
|
if dve.VoteA == nil || dve.VoteB == nil {
|
|
return fmt.Errorf("one or both of the votes are empty %v, %v", dve.VoteA, dve.VoteB)
|
|
}
|
|
if err := dve.VoteA.ValidateBasic(); err != nil {
|
|
return fmt.Errorf("invalid VoteA: %w", err)
|
|
}
|
|
if err := dve.VoteB.ValidateBasic(); err != nil {
|
|
return fmt.Errorf("invalid VoteB: %w", err)
|
|
}
|
|
// Enforce Votes are lexicographically sorted on blockID
|
|
if strings.Compare(dve.VoteA.BlockID.Key(), dve.VoteB.BlockID.Key()) >= 0 {
|
|
return errors.New("duplicate votes in invalid order")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//-------------------------------------------
|
|
|
|
// EvidenceList is a list of Evidence. Evidences is not a word.
|
|
type EvidenceList []Evidence
|
|
|
|
// Hash returns the simple merkle root hash of the EvidenceList.
|
|
func (evl EvidenceList) Hash() []byte {
|
|
// These allocations are required because Evidence is not of type Bytes, and
|
|
// golang slices can't be typed cast. This shouldn't be a performance problem since
|
|
// the Evidence size is capped.
|
|
evidenceBzs := make([][]byte, len(evl))
|
|
for i := 0; i < len(evl); i++ {
|
|
evidenceBzs[i] = evl[i].Bytes()
|
|
}
|
|
return merkle.SimpleHashFromByteSlices(evidenceBzs)
|
|
}
|
|
|
|
func (evl EvidenceList) String() string {
|
|
s := ""
|
|
for _, e := range evl {
|
|
s += fmt.Sprintf("%s\t\t", e)
|
|
}
|
|
return s
|
|
}
|
|
|
|
// Has returns true if the evidence is in the EvidenceList.
|
|
func (evl EvidenceList) Has(evidence Evidence) bool {
|
|
for _, ev := range evl {
|
|
if ev.Equal(evidence) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
//-------------------------------------------
|
|
|
|
// ConflictingHeadersEvidence is primarily used by the light client when it
|
|
// observes two conflicting headers, both having 1/3+ of the voting power of
|
|
// the currently trusted validator set.
|
|
type ConflictingHeadersEvidence struct {
|
|
H1 *SignedHeader `json:"h_1"`
|
|
H2 *SignedHeader `json:"h_2"`
|
|
}
|
|
|
|
var _ Evidence = &ConflictingHeadersEvidence{}
|
|
var _ CompositeEvidence = &ConflictingHeadersEvidence{}
|
|
var _ Evidence = ConflictingHeadersEvidence{}
|
|
var _ CompositeEvidence = ConflictingHeadersEvidence{}
|
|
|
|
// Split breaks up eviddence into smaller chunks (one per validator except for
|
|
// PotentialAmnesiaEvidence): PhantomValidatorEvidence,
|
|
// LunaticValidatorEvidence, DuplicateVoteEvidence and
|
|
// PotentialAmnesiaEvidence.
|
|
//
|
|
// committedHeader - header at height H1.Height == H2.Height
|
|
// valSet - validator set at height H1.Height == H2.Height
|
|
// valToLastHeight - map between active validators and respective last heights
|
|
func (ev ConflictingHeadersEvidence) Split(committedHeader *Header, valSet *ValidatorSet,
|
|
valToLastHeight map[string]int64) []Evidence {
|
|
|
|
evList := make([]Evidence, 0)
|
|
|
|
var alternativeHeader *SignedHeader
|
|
if bytes.Equal(committedHeader.Hash(), ev.H1.Hash()) {
|
|
alternativeHeader = ev.H2
|
|
} else {
|
|
alternativeHeader = ev.H1
|
|
}
|
|
|
|
// If there are signers(alternativeHeader) that are not part of
|
|
// validators(committedHeader), they misbehaved as they are signing protocol
|
|
// messages in heights they are not validators => immediately slashable
|
|
// (#F4).
|
|
for i, sig := range alternativeHeader.Commit.Signatures {
|
|
if sig.Absent() {
|
|
continue
|
|
}
|
|
|
|
lastHeightValidatorWasInSet, ok := valToLastHeight[string(sig.ValidatorAddress)]
|
|
if !ok {
|
|
continue
|
|
}
|
|
|
|
if !valSet.HasAddress(sig.ValidatorAddress) {
|
|
evList = append(evList, &PhantomValidatorEvidence{
|
|
Vote: alternativeHeader.Commit.GetVote(i),
|
|
LastHeightValidatorWasInSet: lastHeightValidatorWasInSet,
|
|
})
|
|
}
|
|
}
|
|
|
|
// If ValidatorsHash, NextValidatorsHash, ConsensusHash, AppHash, and
|
|
// LastResultsHash in alternativeHeader are different (incorrect application
|
|
// state transition), then it is a lunatic misbehavior => immediately
|
|
// slashable (#F5).
|
|
var invalidField string
|
|
switch {
|
|
case !bytes.Equal(committedHeader.ValidatorsHash, alternativeHeader.ValidatorsHash):
|
|
invalidField = "ValidatorsHash"
|
|
case !bytes.Equal(committedHeader.NextValidatorsHash, alternativeHeader.NextValidatorsHash):
|
|
invalidField = "NextValidatorsHash"
|
|
case !bytes.Equal(committedHeader.ConsensusHash, alternativeHeader.ConsensusHash):
|
|
invalidField = "ConsensusHash"
|
|
case !bytes.Equal(committedHeader.AppHash, alternativeHeader.AppHash):
|
|
invalidField = "AppHash"
|
|
case !bytes.Equal(committedHeader.LastResultsHash, alternativeHeader.LastResultsHash):
|
|
invalidField = "LastResultsHash"
|
|
}
|
|
if invalidField != "" {
|
|
for i, sig := range alternativeHeader.Commit.Signatures {
|
|
if sig.Absent() {
|
|
continue
|
|
}
|
|
evList = append(evList, &LunaticValidatorEvidence{
|
|
Header: alternativeHeader.Header,
|
|
Vote: alternativeHeader.Commit.GetVote(i),
|
|
InvalidHeaderField: invalidField,
|
|
})
|
|
}
|
|
return evList
|
|
}
|
|
|
|
// Use the fact that signatures are sorted by ValidatorAddress.
|
|
var (
|
|
i = 0
|
|
j = 0
|
|
)
|
|
OUTER_LOOP:
|
|
for i < len(ev.H1.Commit.Signatures) {
|
|
sigA := ev.H1.Commit.Signatures[i]
|
|
if sigA.Absent() {
|
|
i++
|
|
continue
|
|
}
|
|
// FIXME: Replace with HasAddress once DuplicateVoteEvidence#PubKey is
|
|
// removed.
|
|
_, val := valSet.GetByAddress(sigA.ValidatorAddress)
|
|
if val == nil {
|
|
i++
|
|
continue
|
|
}
|
|
|
|
for j < len(ev.H2.Commit.Signatures) {
|
|
sigB := ev.H2.Commit.Signatures[j]
|
|
if sigB.Absent() {
|
|
j++
|
|
continue
|
|
}
|
|
|
|
switch bytes.Compare(sigA.ValidatorAddress, sigB.ValidatorAddress) {
|
|
case 0:
|
|
// if H1.Round == H2.Round, and some signers signed different precommit
|
|
// messages in both commits, then it is an equivocation misbehavior =>
|
|
// immediately slashable (#F1).
|
|
if ev.H1.Commit.Round == ev.H2.Commit.Round {
|
|
evList = append(evList, &DuplicateVoteEvidence{
|
|
VoteA: ev.H1.Commit.GetVote(i),
|
|
VoteB: ev.H2.Commit.GetVote(j),
|
|
})
|
|
} else {
|
|
// if H1.Round != H2.Round we need to run full detection procedure => not
|
|
// immediately slashable.
|
|
evList = append(evList, &PotentialAmnesiaEvidence{
|
|
VoteA: ev.H1.Commit.GetVote(i),
|
|
VoteB: ev.H2.Commit.GetVote(j),
|
|
})
|
|
}
|
|
|
|
i++
|
|
j++
|
|
continue OUTER_LOOP
|
|
case 1:
|
|
i++
|
|
continue OUTER_LOOP
|
|
case -1:
|
|
j++
|
|
}
|
|
}
|
|
}
|
|
|
|
return evList
|
|
}
|
|
|
|
func (ev ConflictingHeadersEvidence) Height() int64 { return ev.H1.Height }
|
|
|
|
// XXX: this is not the time of equivocation
|
|
func (ev ConflictingHeadersEvidence) Time() time.Time { return ev.H1.Time }
|
|
|
|
func (ev ConflictingHeadersEvidence) Address() []byte {
|
|
panic("use ConflictingHeadersEvidence#Split to split evidence into individual pieces")
|
|
}
|
|
|
|
func (ev ConflictingHeadersEvidence) Bytes() []byte {
|
|
return cdcEncode(ev)
|
|
}
|
|
|
|
func (ev ConflictingHeadersEvidence) Hash() []byte {
|
|
bz := make([]byte, tmhash.Size*2)
|
|
copy(bz[:tmhash.Size-1], ev.H1.Hash().Bytes())
|
|
copy(bz[tmhash.Size:], ev.H2.Hash().Bytes())
|
|
return tmhash.Sum(bz)
|
|
}
|
|
|
|
func (ev ConflictingHeadersEvidence) Verify(chainID string, _ crypto.PubKey) error {
|
|
panic("use ConflictingHeadersEvidence#VerifyComposite to verify composite evidence")
|
|
}
|
|
|
|
// VerifyComposite verifies that both headers belong to the same chain, same
|
|
// height and signed by 1/3+ of validators at height H1.Height == H2.Height.
|
|
func (ev ConflictingHeadersEvidence) VerifyComposite(committedHeader *Header, valSet *ValidatorSet) error {
|
|
var alternativeHeader *SignedHeader
|
|
switch {
|
|
case bytes.Equal(committedHeader.Hash(), ev.H1.Hash()):
|
|
alternativeHeader = ev.H2
|
|
case bytes.Equal(committedHeader.Hash(), ev.H2.Hash()):
|
|
alternativeHeader = ev.H1
|
|
default:
|
|
return errors.New("none of the headers are committed from this node's perspective")
|
|
}
|
|
|
|
// ChainID must be the same
|
|
if committedHeader.ChainID != alternativeHeader.ChainID {
|
|
return errors.New("alt header is from a different chain")
|
|
}
|
|
|
|
// Height must be the same
|
|
if committedHeader.Height != alternativeHeader.Height {
|
|
return errors.New("alt header is from a different height")
|
|
}
|
|
|
|
// Limit the number of signatures to avoid DoS attacks where a header
|
|
// contains too many signatures.
|
|
//
|
|
// Validator set size = 100 [node]
|
|
// Max validator set size = 100 * 2 = 200 [fork?]
|
|
maxNumValidators := valSet.Size() * 2
|
|
if len(alternativeHeader.Commit.Signatures) > maxNumValidators {
|
|
return fmt.Errorf("alt commit contains too many signatures: %d, expected no more than %d",
|
|
len(alternativeHeader.Commit.Signatures),
|
|
maxNumValidators)
|
|
}
|
|
|
|
// Header must be signed by at least 1/3+ of voting power of currently
|
|
// trusted validator set.
|
|
if err := valSet.VerifyCommitTrusting(
|
|
alternativeHeader.ChainID,
|
|
alternativeHeader.Commit,
|
|
tmmath.Fraction{Numerator: 1, Denominator: 3}); err != nil {
|
|
return fmt.Errorf("alt header does not have 1/3+ of voting power of our validator set: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (ev ConflictingHeadersEvidence) Equal(ev2 Evidence) bool {
|
|
switch e2 := ev2.(type) {
|
|
case ConflictingHeadersEvidence:
|
|
return bytes.Equal(ev.H1.Hash(), e2.H1.Hash()) && bytes.Equal(ev.H2.Hash(), e2.H2.Hash())
|
|
case *ConflictingHeadersEvidence:
|
|
return bytes.Equal(ev.H1.Hash(), e2.H1.Hash()) && bytes.Equal(ev.H2.Hash(), e2.H2.Hash())
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (ev ConflictingHeadersEvidence) ValidateBasic() error {
|
|
if ev.H1 == nil {
|
|
return errors.New("first header is missing")
|
|
}
|
|
|
|
if ev.H2 == nil {
|
|
return errors.New("second header is missing")
|
|
}
|
|
|
|
if err := ev.H1.ValidateBasic(ev.H1.ChainID); err != nil {
|
|
return fmt.Errorf("h1: %w", err)
|
|
}
|
|
if err := ev.H2.ValidateBasic(ev.H2.ChainID); err != nil {
|
|
return fmt.Errorf("h2: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ev ConflictingHeadersEvidence) String() string {
|
|
return fmt.Sprintf("ConflictingHeadersEvidence{H1: %d#%X, H2: %d#%X}",
|
|
ev.H1.Height, ev.H1.Hash(),
|
|
ev.H2.Height, ev.H2.Hash())
|
|
}
|
|
|
|
//-------------------------------------------
|
|
|
|
type PhantomValidatorEvidence struct {
|
|
Vote *Vote `json:"vote"`
|
|
LastHeightValidatorWasInSet int64 `json:"last_height_validator_was_in_set"`
|
|
}
|
|
|
|
var _ Evidence = &PhantomValidatorEvidence{}
|
|
var _ Evidence = PhantomValidatorEvidence{}
|
|
|
|
func (e PhantomValidatorEvidence) Height() int64 {
|
|
return e.Vote.Height
|
|
}
|
|
|
|
func (e PhantomValidatorEvidence) Time() time.Time {
|
|
return e.Vote.Timestamp
|
|
}
|
|
|
|
func (e PhantomValidatorEvidence) Address() []byte {
|
|
return e.Vote.ValidatorAddress
|
|
}
|
|
|
|
func (e PhantomValidatorEvidence) Hash() []byte {
|
|
return tmhash.Sum(cdcEncode(e))
|
|
}
|
|
|
|
func (e PhantomValidatorEvidence) Bytes() []byte {
|
|
return cdcEncode(e)
|
|
}
|
|
|
|
func (e PhantomValidatorEvidence) Verify(chainID string, pubKey crypto.PubKey) error {
|
|
|
|
// signature must be verified to the chain ID
|
|
if !pubKey.VerifyBytes(e.Vote.SignBytes(chainID), e.Vote.Signature) {
|
|
return errors.New("invalid signature")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (e PhantomValidatorEvidence) Equal(ev Evidence) bool {
|
|
switch e2 := ev.(type) {
|
|
case PhantomValidatorEvidence:
|
|
return e.Vote.Height == e2.Vote.Height &&
|
|
bytes.Equal(e.Vote.ValidatorAddress, e2.Vote.ValidatorAddress)
|
|
case *PhantomValidatorEvidence:
|
|
return e.Vote.Height == e2.Vote.Height &&
|
|
bytes.Equal(e.Vote.ValidatorAddress, e2.Vote.ValidatorAddress)
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (e PhantomValidatorEvidence) ValidateBasic() error {
|
|
|
|
if e.Vote == nil {
|
|
return errors.New("empty vote")
|
|
}
|
|
|
|
if err := e.Vote.ValidateBasic(); err != nil {
|
|
return fmt.Errorf("invalid signature: %v", err)
|
|
}
|
|
|
|
if !e.Vote.BlockID.IsComplete() {
|
|
return errors.New("expected vote for block")
|
|
}
|
|
|
|
if e.LastHeightValidatorWasInSet <= 0 {
|
|
return errors.New("negative or zero LastHeightValidatorWasInSet")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (e PhantomValidatorEvidence) String() string {
|
|
return fmt.Sprintf("PhantomValidatorEvidence{%X voted at height %d}",
|
|
e.Vote.ValidatorAddress, e.Vote.Height)
|
|
}
|
|
|
|
//-------------------------------------------
|
|
|
|
type LunaticValidatorEvidence struct {
|
|
Header *Header `json:"header"`
|
|
Vote *Vote `json:"vote"`
|
|
InvalidHeaderField string `json:"invalid_header_field"`
|
|
}
|
|
|
|
var _ Evidence = &LunaticValidatorEvidence{}
|
|
var _ Evidence = LunaticValidatorEvidence{}
|
|
|
|
func (e LunaticValidatorEvidence) Height() int64 {
|
|
return e.Header.Height
|
|
}
|
|
|
|
func (e LunaticValidatorEvidence) Time() time.Time {
|
|
return e.Header.Time
|
|
}
|
|
|
|
func (e LunaticValidatorEvidence) Address() []byte {
|
|
return e.Vote.ValidatorAddress
|
|
}
|
|
|
|
func (e LunaticValidatorEvidence) Hash() []byte {
|
|
bz := make([]byte, tmhash.Size+crypto.AddressSize)
|
|
copy(bz[:tmhash.Size-1], e.Header.Hash().Bytes())
|
|
copy(bz[tmhash.Size:], e.Vote.ValidatorAddress.Bytes())
|
|
return tmhash.Sum(bz)
|
|
}
|
|
|
|
func (e LunaticValidatorEvidence) Bytes() []byte {
|
|
return cdcEncode(e)
|
|
}
|
|
|
|
func (e LunaticValidatorEvidence) Verify(chainID string, pubKey crypto.PubKey) error {
|
|
// chainID must be the same
|
|
if chainID != e.Header.ChainID {
|
|
return fmt.Errorf("chainID do not match: %s vs %s",
|
|
chainID,
|
|
e.Header.ChainID,
|
|
)
|
|
}
|
|
|
|
if !pubKey.VerifyBytes(e.Vote.SignBytes(chainID), e.Vote.Signature) {
|
|
return errors.New("invalid signature")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (e LunaticValidatorEvidence) Equal(ev Evidence) bool {
|
|
switch e2 := ev.(type) {
|
|
case LunaticValidatorEvidence:
|
|
return bytes.Equal(e.Header.Hash(), e2.Header.Hash()) &&
|
|
bytes.Equal(e.Vote.ValidatorAddress, e2.Vote.ValidatorAddress)
|
|
case *LunaticValidatorEvidence:
|
|
return bytes.Equal(e.Header.Hash(), e2.Header.Hash()) &&
|
|
bytes.Equal(e.Vote.ValidatorAddress, e2.Vote.ValidatorAddress)
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (e LunaticValidatorEvidence) ValidateBasic() error {
|
|
if e.Header == nil {
|
|
return errors.New("empty header")
|
|
}
|
|
|
|
if e.Vote == nil {
|
|
return errors.New("empty vote")
|
|
}
|
|
|
|
if err := e.Header.ValidateBasic(); err != nil {
|
|
return fmt.Errorf("invalid header: %v", err)
|
|
}
|
|
|
|
if err := e.Vote.ValidateBasic(); err != nil {
|
|
return fmt.Errorf("invalid signature: %v", err)
|
|
}
|
|
|
|
if !e.Vote.BlockID.IsComplete() {
|
|
return errors.New("expected vote for block")
|
|
}
|
|
|
|
if e.Header.Height != e.Vote.Height {
|
|
return fmt.Errorf("header and vote have different heights: %d vs %d",
|
|
e.Header.Height,
|
|
e.Vote.Height,
|
|
)
|
|
}
|
|
|
|
switch e.InvalidHeaderField {
|
|
case "ValidatorsHash", "NextValidatorsHash", "ConsensusHash", "AppHash", "LastResultsHash":
|
|
return nil
|
|
default:
|
|
return errors.New("unknown invalid header field")
|
|
}
|
|
}
|
|
|
|
func (e LunaticValidatorEvidence) String() string {
|
|
return fmt.Sprintf("LunaticValidatorEvidence{%X voted for %d/%X, which contains invalid %s}",
|
|
e.Vote.ValidatorAddress, e.Header.Height, e.Header.Hash(), e.InvalidHeaderField)
|
|
}
|
|
|
|
func (e LunaticValidatorEvidence) VerifyHeader(committedHeader *Header) error {
|
|
matchErr := func(field string) error {
|
|
return fmt.Errorf("%s matches committed hash", field)
|
|
}
|
|
|
|
switch e.InvalidHeaderField {
|
|
case ValidatorsHashField:
|
|
if bytes.Equal(committedHeader.ValidatorsHash, e.Header.ValidatorsHash) {
|
|
return matchErr(ValidatorsHashField)
|
|
}
|
|
case NextValidatorsHashField:
|
|
if bytes.Equal(committedHeader.NextValidatorsHash, e.Header.NextValidatorsHash) {
|
|
return matchErr(NextValidatorsHashField)
|
|
}
|
|
case ConsensusHashField:
|
|
if bytes.Equal(committedHeader.ConsensusHash, e.Header.ConsensusHash) {
|
|
return matchErr(ConsensusHashField)
|
|
}
|
|
case AppHashField:
|
|
if bytes.Equal(committedHeader.AppHash, e.Header.AppHash) {
|
|
return matchErr(AppHashField)
|
|
}
|
|
case LastResultsHashField:
|
|
if bytes.Equal(committedHeader.LastResultsHash, e.Header.LastResultsHash) {
|
|
return matchErr(LastResultsHashField)
|
|
}
|
|
default:
|
|
return errors.New("unknown InvalidHeaderField")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
//-------------------------------------------
|
|
|
|
type PotentialAmnesiaEvidence struct {
|
|
VoteA *Vote `json:"vote_a"`
|
|
VoteB *Vote `json:"vote_b"`
|
|
}
|
|
|
|
var _ Evidence = &PotentialAmnesiaEvidence{}
|
|
var _ Evidence = PotentialAmnesiaEvidence{}
|
|
|
|
func (e PotentialAmnesiaEvidence) Height() int64 {
|
|
return e.VoteA.Height
|
|
}
|
|
|
|
func (e PotentialAmnesiaEvidence) Time() time.Time {
|
|
if e.VoteA.Timestamp.Before(e.VoteB.Timestamp) {
|
|
return e.VoteA.Timestamp
|
|
}
|
|
return e.VoteB.Timestamp
|
|
}
|
|
|
|
func (e PotentialAmnesiaEvidence) Address() []byte {
|
|
return e.VoteA.ValidatorAddress
|
|
}
|
|
|
|
func (e PotentialAmnesiaEvidence) Hash() []byte {
|
|
return tmhash.Sum(cdcEncode(e))
|
|
}
|
|
|
|
func (e PotentialAmnesiaEvidence) Bytes() []byte {
|
|
return cdcEncode(e)
|
|
}
|
|
|
|
func (e PotentialAmnesiaEvidence) Verify(chainID string, pubKey crypto.PubKey) error {
|
|
// pubkey must match address (this should already be true, sanity check)
|
|
addr := e.VoteA.ValidatorAddress
|
|
if !bytes.Equal(pubKey.Address(), addr) {
|
|
return fmt.Errorf("address (%X) doesn't match pubkey (%v - %X)",
|
|
addr, pubKey, pubKey.Address())
|
|
}
|
|
|
|
// Signatures must be valid
|
|
if !pubKey.VerifyBytes(e.VoteA.SignBytes(chainID), e.VoteA.Signature) {
|
|
return fmt.Errorf("verifying VoteA: %w", ErrVoteInvalidSignature)
|
|
}
|
|
if !pubKey.VerifyBytes(e.VoteB.SignBytes(chainID), e.VoteB.Signature) {
|
|
return fmt.Errorf("verifying VoteB: %w", ErrVoteInvalidSignature)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (e PotentialAmnesiaEvidence) Equal(ev Evidence) bool {
|
|
switch e2 := ev.(type) {
|
|
case PotentialAmnesiaEvidence:
|
|
return bytes.Equal(e.Hash(), e2.Hash())
|
|
case *PotentialAmnesiaEvidence:
|
|
return bytes.Equal(e.Hash(), e2.Hash())
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (e PotentialAmnesiaEvidence) ValidateBasic() error {
|
|
if e.VoteA == nil || e.VoteB == nil {
|
|
return fmt.Errorf("one or both of the votes are empty %v, %v", e.VoteA, e.VoteB)
|
|
}
|
|
if err := e.VoteA.ValidateBasic(); err != nil {
|
|
return fmt.Errorf("invalid VoteA: %v", err)
|
|
}
|
|
if err := e.VoteB.ValidateBasic(); err != nil {
|
|
return fmt.Errorf("invalid VoteB: %v", err)
|
|
}
|
|
// Enforce Votes are lexicographically sorted on blockID
|
|
if strings.Compare(e.VoteA.BlockID.Key(), e.VoteB.BlockID.Key()) >= 0 {
|
|
return errors.New("amnesia votes in invalid order")
|
|
}
|
|
|
|
// H/S must be the same
|
|
if e.VoteA.Height != e.VoteB.Height ||
|
|
e.VoteA.Type != e.VoteB.Type {
|
|
return fmt.Errorf("h/s do not match: %d/%v vs %d/%v",
|
|
e.VoteA.Height, e.VoteA.Type, e.VoteB.Height, e.VoteB.Type)
|
|
}
|
|
|
|
// R must be different
|
|
if e.VoteA.Round == e.VoteB.Round {
|
|
return fmt.Errorf("expected votes from different rounds, got %d", e.VoteA.Round)
|
|
}
|
|
|
|
// Address must be the same
|
|
if !bytes.Equal(e.VoteA.ValidatorAddress, e.VoteB.ValidatorAddress) {
|
|
return fmt.Errorf("validator addresses do not match: %X vs %X",
|
|
e.VoteA.ValidatorAddress,
|
|
e.VoteB.ValidatorAddress,
|
|
)
|
|
}
|
|
|
|
// Index must be the same
|
|
// https://github.com/tendermint/tendermint/issues/4619
|
|
if e.VoteA.ValidatorIndex != e.VoteB.ValidatorIndex {
|
|
return fmt.Errorf(
|
|
"duplicateVoteEvidence Error: Validator indices do not match. Got %d and %d",
|
|
e.VoteA.ValidatorIndex,
|
|
e.VoteB.ValidatorIndex,
|
|
)
|
|
}
|
|
|
|
// BlockIDs must be different
|
|
if e.VoteA.BlockID.Equals(e.VoteB.BlockID) {
|
|
return fmt.Errorf(
|
|
"block IDs are the same (%v) - not a real duplicate vote",
|
|
e.VoteA.BlockID,
|
|
)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (e PotentialAmnesiaEvidence) String() string {
|
|
return fmt.Sprintf("PotentialAmnesiaEvidence{VoteA: %v, VoteB: %v}", e.VoteA, e.VoteB)
|
|
}
|
|
|
|
// ProofOfLockChange (POLC) proves that a node followed the consensus protocol and voted for a precommit in two
|
|
// different rounds because the node received a majority of votes for a different block in the latter round. In cases of
|
|
// amnesia evidence, a suspected node will need ProofOfLockChange to prove that the node did not break protocol.
|
|
type ProofOfLockChange struct {
|
|
Votes []Vote `json:"votes"`
|
|
PubKey crypto.PubKey `json:"pubkey"`
|
|
}
|
|
|
|
// MakePOLCFromVoteSet can be used when a majority of prevotes or precommits for a block is seen
|
|
// that the node has itself not yet voted for in order to process the vote set into a proof of lock change
|
|
func MakePOLCFromVoteSet(voteSet *VoteSet, pubKey crypto.PubKey, blockID BlockID) (ProofOfLockChange, error) {
|
|
polc := makePOLCFromVoteSet(voteSet, pubKey, blockID)
|
|
return polc, polc.ValidateBasic()
|
|
}
|
|
|
|
func makePOLCFromVoteSet(voteSet *VoteSet, pubKey crypto.PubKey, blockID BlockID) ProofOfLockChange {
|
|
var votes []Vote
|
|
valSetSize := voteSet.Size()
|
|
for valIdx := 0; valIdx < valSetSize; valIdx++ {
|
|
vote := voteSet.GetByIndex(valIdx)
|
|
if vote != nil && vote.BlockID.Equals(blockID) {
|
|
votes = append(votes, *vote)
|
|
}
|
|
}
|
|
return ProofOfLockChange{
|
|
Votes: votes,
|
|
PubKey: pubKey,
|
|
}
|
|
}
|
|
|
|
func (e ProofOfLockChange) Height() int64 {
|
|
return e.Votes[0].Height
|
|
}
|
|
|
|
// returns the time of the last vote
|
|
func (e ProofOfLockChange) Time() time.Time {
|
|
latest := e.Votes[0].Timestamp
|
|
for _, vote := range e.Votes {
|
|
if vote.Timestamp.After(latest) {
|
|
latest = vote.Timestamp
|
|
}
|
|
}
|
|
return latest
|
|
}
|
|
|
|
func (e ProofOfLockChange) Round() int {
|
|
return e.Votes[0].Round
|
|
}
|
|
|
|
func (e ProofOfLockChange) Address() []byte {
|
|
return e.PubKey.Address()
|
|
}
|
|
|
|
func (e ProofOfLockChange) BlockID() BlockID {
|
|
return e.Votes[0].BlockID
|
|
}
|
|
|
|
// In order for a ProofOfLockChange to be valid, a validator must have received +2/3 majority of votes
|
|
// MajorityOfVotes checks that there were sufficient votes in order to change locks
|
|
func (e ProofOfLockChange) MajorityOfVotes(valSet *ValidatorSet) bool {
|
|
talliedVotingPower := int64(0)
|
|
votingPowerNeeded := valSet.TotalVotingPower() * 2 / 3
|
|
for _, validator := range valSet.Validators {
|
|
for _, vote := range e.Votes {
|
|
if bytes.Equal(validator.Address, vote.ValidatorAddress) {
|
|
talliedVotingPower += validator.VotingPower
|
|
|
|
if talliedVotingPower > votingPowerNeeded {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (e ProofOfLockChange) Equal(e2 ProofOfLockChange) bool {
|
|
return bytes.Equal(e.Address(), e2.Address()) && e.Height() == e2.Height() &&
|
|
e.Round() == e2.Round()
|
|
}
|
|
|
|
func (e ProofOfLockChange) ValidateBasic() error {
|
|
if e.PubKey == nil {
|
|
return errors.New("missing public key")
|
|
}
|
|
// validate basic doesn't count the number of votes and their voting power, this is to be done by VerifyEvidence
|
|
if e.Votes == nil {
|
|
return errors.New("missing votes")
|
|
}
|
|
// height, round and vote type must be the same for all votes
|
|
height := e.Height()
|
|
round := e.Round()
|
|
if round == 0 {
|
|
return errors.New("can't have a polc for the first round")
|
|
}
|
|
voteType := e.Votes[0].Type
|
|
for idx, vote := range e.Votes {
|
|
if err := vote.ValidateBasic(); err != nil {
|
|
return fmt.Errorf("invalid vote#%d: %w", idx, err)
|
|
}
|
|
|
|
if vote.Height != height {
|
|
return fmt.Errorf("invalid height for vote#%d: %d instead of %d", idx, vote.Height, height)
|
|
}
|
|
|
|
if vote.Round != round {
|
|
return fmt.Errorf("invalid round for vote#%d: %d instead of %d", idx, vote.Round, round)
|
|
}
|
|
|
|
if vote.Type != voteType {
|
|
return fmt.Errorf("invalid vote type for vote#%d: %d instead of %d", idx, vote.Type, voteType)
|
|
}
|
|
|
|
if !vote.BlockID.Equals(e.BlockID()) {
|
|
return fmt.Errorf("vote must be for the same block id: %v instead of %v", e.BlockID(), vote.BlockID)
|
|
}
|
|
|
|
if bytes.Equal(vote.ValidatorAddress.Bytes(), e.PubKey.Address().Bytes()) {
|
|
return fmt.Errorf("vote validator address cannot be the same as the public key address: %X all votes %v",
|
|
vote.ValidatorAddress.Bytes(), e.Votes)
|
|
}
|
|
|
|
for i := idx + 1; i < len(e.Votes); i++ {
|
|
if bytes.Equal(vote.ValidatorAddress.Bytes(), e.Votes[i].ValidatorAddress.Bytes()) {
|
|
return fmt.Errorf("duplicate votes: %v", vote)
|
|
}
|
|
}
|
|
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (e ProofOfLockChange) String() string {
|
|
return fmt.Sprintf("ProofOfLockChange {Address: %X, Height: %d, Round: %d", e.Address(), e.Height(),
|
|
e.Votes[0].Round)
|
|
}
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
// UNSTABLE
|
|
type MockRandomEvidence struct {
|
|
MockEvidence
|
|
randBytes []byte
|
|
}
|
|
|
|
var _ Evidence = &MockRandomEvidence{}
|
|
|
|
// UNSTABLE
|
|
func NewMockRandomEvidence(height int64, eTime time.Time, address []byte, randBytes []byte) MockRandomEvidence {
|
|
return MockRandomEvidence{
|
|
MockEvidence{
|
|
EvidenceHeight: height,
|
|
EvidenceTime: eTime,
|
|
EvidenceAddress: address}, randBytes,
|
|
}
|
|
}
|
|
|
|
func (e MockRandomEvidence) Hash() []byte {
|
|
return []byte(fmt.Sprintf("%d-%x", e.EvidenceHeight, e.randBytes))
|
|
}
|
|
|
|
func (e MockRandomEvidence) Equal(ev Evidence) bool { return false }
|
|
|
|
// UNSTABLE
|
|
type MockEvidence struct {
|
|
EvidenceHeight int64
|
|
EvidenceTime time.Time
|
|
EvidenceAddress []byte
|
|
}
|
|
|
|
var _ Evidence = &MockEvidence{}
|
|
|
|
// UNSTABLE
|
|
func NewMockEvidence(height int64, eTime time.Time, address []byte) MockEvidence {
|
|
return MockEvidence{
|
|
EvidenceHeight: height,
|
|
EvidenceTime: eTime,
|
|
EvidenceAddress: address}
|
|
}
|
|
|
|
func (e MockEvidence) Height() int64 { return e.EvidenceHeight }
|
|
func (e MockEvidence) Time() time.Time { return e.EvidenceTime }
|
|
func (e MockEvidence) Address() []byte { return e.EvidenceAddress }
|
|
func (e MockEvidence) Hash() []byte {
|
|
return []byte(fmt.Sprintf("%d-%x-%s",
|
|
e.EvidenceHeight, e.EvidenceAddress, e.EvidenceTime))
|
|
}
|
|
func (e MockEvidence) Bytes() []byte {
|
|
return []byte(fmt.Sprintf("%d-%x-%s",
|
|
e.EvidenceHeight, e.EvidenceAddress, e.EvidenceTime))
|
|
}
|
|
func (e MockEvidence) Verify(chainID string, pubKey crypto.PubKey) error { return nil }
|
|
func (e MockEvidence) Equal(ev Evidence) bool {
|
|
return e.EvidenceHeight == ev.Height() &&
|
|
bytes.Equal(e.EvidenceAddress, ev.Address())
|
|
}
|
|
func (e MockEvidence) ValidateBasic() error { return nil }
|
|
func (e MockEvidence) String() string {
|
|
return fmt.Sprintf("Evidence: %d/%s/%s", e.EvidenceHeight, e.Time(), e.EvidenceAddress)
|
|
}
|
|
|
|
// mock polc - fails validate basic, not stable
|
|
func NewMockPOLC(height int64, time time.Time, pubKey crypto.PubKey) ProofOfLockChange {
|
|
voteVal := NewMockPV()
|
|
pKey, _ := voteVal.GetPubKey()
|
|
vote := Vote{Type: PrecommitType, Height: height, Round: 1, BlockID: BlockID{},
|
|
Timestamp: time, ValidatorAddress: pKey.Address(), ValidatorIndex: 1, Signature: []byte{}}
|
|
_ = voteVal.SignVote("mock-chain-id", &vote)
|
|
return ProofOfLockChange{
|
|
Votes: []Vote{vote},
|
|
PubKey: pubKey,
|
|
}
|
|
}
|