mirrors/tendermint
1
0
Fork 0
mirror of https://github.com/tendermint/tendermint.git synced 2026-05-01 12:55:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

evidence: adr56 form amnesia evidence (#4821)

Browse Source 
Creates Amnesia Evidence which is formed from Potential Amnesia Evidence with either a matching proof or after a period of time denoted as the Amnesia Trial Period. This also adds the code necessary so that Amnesia Evidence can be validated and committed on a block
This commit is contained in:
Callum Waters
2020-06-10 13:53:55 +02:00
committed by GitHub
parent 65909a13d5
commit 5697e144a7
19 changed files with 1658 additions and 276 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
consensus/common_test.go
View File

@@ -25,6 +25,7 @@ import (
abci "github.com/tendermint/tendermint/abci/types"
cfg "github.com/tendermint/tendermint/config"
cstypes "github.com/tendermint/tendermint/consensus/types"
"github.com/tendermint/tendermint/evidence"
tmbytes "github.com/tendermint/tendermint/libs/bytes"
"github.com/tendermint/tendermint/libs/log"
tmos "github.com/tendermint/tendermint/libs/os"
@@ -422,6 +423,47 @@ func randState(nValidators int) (*State, []*validatorStub) {
return cs, vss
}
func randStateWithEvpool(nValidators int) (*State, []*validatorStub, *evidence.Pool) {
state, privVals := randGenesisState(nValidators, false, 10)
vss := make([]*validatorStub, nValidators)
app := counter.NewApplication(true)
config := cfg.ResetTestRoot("consensus_state_test")
blockStore := store.NewBlockStore(dbm.NewMemDB())
evidenceDB := dbm.NewMemDB()
mtx := new(sync.Mutex)
proxyAppConnMem := abcicli.NewLocalClient(mtx, app)
proxyAppConnCon := abcicli.NewLocalClient(mtx, app)
mempool := mempl.NewCListMempool(config.Mempool, proxyAppConnMem, 0)
mempool.SetLogger(log.TestingLogger().With("module", "mempool"))
if config.Consensus.WaitForTxs() {
mempool.EnableTxsAvailable()
}
stateDB := dbm.NewMemDB()
evpool, _ := evidence.NewPool(stateDB, evidenceDB, blockStore)
blockExec := sm.NewBlockExecutor(stateDB, log.TestingLogger(), proxyAppConnCon, mempool, evpool)
cs := NewState(config.Consensus, state, blockExec, blockStore, mempool, evpool)
cs.SetLogger(log.TestingLogger().With("module", "consensus"))
cs.SetPrivValidator(privVals[0])
eventBus := types.NewEventBus()
eventBus.SetLogger(log.TestingLogger().With("module", "events"))
eventBus.Start()
cs.SetEventBus(eventBus)
for i := 0; i < nValidators; i++ {
vss[i] = newValidatorStub(privVals[i], int32(i))
}
// since cs1 starts at 1
incrementHeight(vss[1:]...)
return cs, vss, evpool
}
//-------------------------------------------------------------------------------
func ensureNoNewEvent(ch <-chan tmpubsub.Message, timeout time.Duration,

19
consensus/state_test.go
View File

@@ -616,7 +616,7 @@ func TestStateLockPOLRelockThenChangeLock(t *testing.T) {
// 4 vals, one precommits, other 3 polka at next round, so we unlock and precomit the polka
func TestStateLockPOLUnlock(t *testing.T) {
cs1, vss := randState(4)
cs1, vss, evpool := randStateWithEvpool(4)
vs2, vs3, vs4 := vss[1], vss[2], vss[3]
height, round := cs1.Height, cs1.Round
@@ -703,6 +703,16 @@ func TestStateLockPOLUnlock(t *testing.T) {
signAddVotes(cs1, tmproto.PrecommitType, nil, types.PartSetHeader{}, vs2, vs3)
ensureNewRound(newRoundCh, height, round+1)
// polc should be in the evpool for round 1
polc, err := evpool.RetrievePOLC(height, round)
assert.NoError(t, err)
assert.False(t, polc.IsAbsent())
t.Log(polc.Address())
// but not for round 0
polc, err = evpool.RetrievePOLC(height, round-1)
assert.Error(t, err)
assert.True(t, polc.IsAbsent())
}
// 4 vals, v1 locks on proposed block in the first round but the other validators only prevote
@@ -710,7 +720,7 @@ func TestStateLockPOLUnlock(t *testing.T) {
// v1 should unlock and precommit nil. In the third round another block is proposed, all vals
// prevote and now v1 can lock onto the third block and precommit that
func TestStateLockPOLUnlockOnUnknownBlock(t *testing.T) {
cs1, vss := randState(4)
cs1, vss, evpool := randStateWithEvpool(4)
vs2, vs3, vs4 := vss[1], vss[2], vss[3]
height, round := cs1.Height, cs1.Round
@@ -803,6 +813,11 @@ func TestStateLockPOLUnlockOnUnknownBlock(t *testing.T) {
thirdPropBlockHash := propBlock.Hash()
require.NotEqual(t, secondBlockHash, thirdPropBlockHash)
// polc should be in the evpool for round 1
polc, err := evpool.RetrievePOLC(height, round)
assert.NoError(t, err)
assert.False(t, polc.IsAbsent())
incrementRound(vs2, vs3, vs4)
// timeout to new round

180
evidence/pool.go
View File

@@ -21,6 +21,7 @@ const (
baseKeyCommitted = byte(0x00)
baseKeyPending = byte(0x01)
baseKeyPOLC = byte(0x02)
baseKeyAwaiting = byte(0x03)
)
// Pool maintains a pool of valid evidence to be broadcasted and committed
@@ -43,6 +44,8 @@ type Pool struct {
// currently is (ie. [MaxAgeNumBlocks, CurrentHeight])
// In simple words, it means it's still bonded -> therefore slashable.
valToLastHeight valToLastHeightMap
nextEvidenceTrialEndedHeight int64
}
// Validator.Address -> Last height it was in validator set
@@ -59,22 +62,19 @@ func NewPool(stateDB, evidenceDB dbm.DB, blockStore *store.BlockStore) (*Pool, e
}
pool := &Pool{
stateDB: stateDB,
blockStore: blockStore,
state: state,
logger: log.NewNopLogger(),
evidenceStore: evidenceDB,
evidenceList: clist.New(),
valToLastHeight: valToLastHeight,
stateDB: stateDB,
blockStore: blockStore,
state: state,
logger: log.NewNopLogger(),
evidenceStore: evidenceDB,
evidenceList: clist.New(),
valToLastHeight: valToLastHeight,
nextEvidenceTrialEndedHeight: -1,
}
// if pending evidence already in db, in event of prior failure, then load it back to the evidenceList
evList := pool.AllPendingEvidence()
for _, ev := range evList {
if pool.IsEvidenceExpired(ev) {
pool.removePendingEvidence(ev)
continue
}
pool.evidenceList.PushBack(ev)
}
@@ -84,6 +84,7 @@ func NewPool(stateDB, evidenceDB dbm.DB, blockStore *store.BlockStore) (*Pool, e
// PendingEvidence is used primarily as part of block proposal and returns up to maxNum of uncommitted evidence.
// If maxNum is -1, all evidence is returned. Pending evidence is prioritised based on time.
func (evpool *Pool) PendingEvidence(maxNum uint32) []types.Evidence {
evpool.removeExpiredPendingEvidence()
evidence, err := evpool.listEvidence(baseKeyPending, int64(maxNum))
if err != nil {
evpool.logger.Error("Unable to retrieve pending evidence", "err", err)
@@ -92,6 +93,7 @@ func (evpool *Pool) PendingEvidence(maxNum uint32) []types.Evidence {
}
func (evpool *Pool) AllPendingEvidence() []types.Evidence {
evpool.removeExpiredPendingEvidence()
evidence, err := evpool.listEvidence(baseKeyPending, -1)
if err != nil {
evpool.logger.Error("Unable to retrieve pending evidence", "err", err)
@@ -104,23 +106,24 @@ func (evpool *Pool) AllPendingEvidence() []types.Evidence {
func (evpool *Pool) Update(block *types.Block, state sm.State) {
// sanity check
if state.LastBlockHeight != block.Height {
panic(
fmt.Sprintf("Failed EvidencePool.Update sanity check: got state.Height=%d with block.Height=%d",
state.LastBlockHeight,
block.Height,
),
panic(fmt.Sprintf("Failed EvidencePool.Update sanity check: got state.Height=%d with block.Height=%d",
state.LastBlockHeight,
block.Height,
),
)
}
// remove evidence from pending and mark committed
evpool.MarkEvidenceAsCommitted(block.Height, block.Time, block.Evidence.Evidence)
evpool.MarkEvidenceAsCommitted(block.Height, block.Evidence.Evidence)
// remove expired evidence - this should be done at every height to ensure we don't send expired evidence to peers
evpool.removeExpiredPendingEvidence()
// as it's not vital to remove expired POLCs, we only prune periodically
// prune pending, committed and potential evidence and polc's periodically
if block.Height%state.ConsensusParams.Evidence.MaxAgeNumBlocks == 0 {
evpool.pruneExpiredPOLC()
evpool.removeExpiredPendingEvidence()
}
if evpool.nextEvidenceTrialEndedHeight > 0 && block.Height < evpool.nextEvidenceTrialEndedHeight {
evpool.upgradePotentialAmnesiaEvidence()
}
// update the state
@@ -202,9 +205,74 @@ func (evpool *Pool) AddEvidence(evidence types.Evidence) error {
return fmt.Errorf("failed to verify %v: %w", ev, err)
}
// For potential amnesia evidence, if this node is indicted it shall retrieve a polc
// to form AmensiaEvidence
if pe, ok := ev.(types.PotentialAmnesiaEvidence); ok {
var (
height = pe.Height()
exists = false
polc types.ProofOfLockChange
)
pe.HeightStamp = evpool.State().LastBlockHeight
// a) first try to find a corresponding polc
for round := pe.VoteB.Round; round > pe.VoteA.Round; round-- {
polc, err = evpool.RetrievePOLC(height, round)
if err != nil {
evpool.logger.Error("Failed to retrieve polc for potential amnesia evidence", "err", err, "pae", pe.String())
continue
}
if err == nil && !polc.IsAbsent() {
// we should not need to verify it if both the polc and potential amnesia evidence have already
// been verified. We replace the potential amnesia evidence.
ae := types.MakeAmnesiaEvidence(pe, polc)
err := evpool.AddEvidence(ae)
if err != nil {
evpool.logger.Error("Failed to create amnesia evidence from potential amnesia evidence", "err", err)
// revert back to processing potential amnesia evidence
exists = false
} else {
evpool.logger.Info("Formed amnesia evidence from own polc", "amnesiaEvidence", ae)
}
break
}
}
// b) check if amnesia evidence can be made now or if we need to enact the trial period
if !exists && pe.Primed(1, pe.HeightStamp) {
err := evpool.AddEvidence(types.MakeAmnesiaEvidence(pe, types.EmptyPOLC()))
if err != nil {
return err
}
} else if !exists && evpool.State().LastBlockHeight+evpool.State().ConsensusParams.Evidence.ProofTrialPeriod <
pe.Height()+evpool.State().ConsensusParams.Evidence.MaxAgeNumBlocks {
// if we can't find a proof of lock change and we know that the trial period will finish before the
// evidence has expired, then we commence the trial period by saving it in the awaiting bucket
pbe, err := types.EvidenceToProto(pe)
if err != nil {
return err
}
evBytes, err := pbe.Marshal()
if err != nil {
return err
}
key := keyAwaiting(pe)
err = evpool.evidenceStore.Set(key, evBytes)
if err != nil {
return err
}
// keep track of when the next pe has finished the trial period
if evpool.nextEvidenceTrialEndedHeight == -1 {
evpool.nextEvidenceTrialEndedHeight = ev.Height() + evpool.State().ConsensusParams.Evidence.ProofTrialPeriod
}
}
// we don't need to do anymore processing so we can move on to the next piece of evidence
continue
}
// 2) Save to store.
if err := evpool.addPendingEvidence(ev); err != nil {
return fmt.Errorf("database error: %v", err)
return fmt.Errorf("database error when adding evidence: %v", err)
}
// 3) Add evidence to clist.
@@ -218,7 +286,7 @@ func (evpool *Pool) AddEvidence(evidence types.Evidence) error {
// MarkEvidenceAsCommitted marks all the evidence as committed and removes it
// from the queue.
func (evpool *Pool) MarkEvidenceAsCommitted(height int64, lastBlockTime time.Time, evidence []types.Evidence) {
func (evpool *Pool) MarkEvidenceAsCommitted(height int64, evidence []types.Evidence) {
// make a map of committed evidence to remove from the clist
blockEvidenceMap := make(map[string]struct{})
for _, ev := range evidence {
@@ -291,17 +359,19 @@ func (evpool *Pool) IsPending(evidence types.Evidence) bool {
return ok
}
// RetrievePOLC attempts to find a polc at the given height and round, if not there it returns an error
// RetrievePOLC attempts to find a polc at the given height and round, if not there than exist returns false, all
// database errors are automatically logged
func (evpool *Pool) RetrievePOLC(height int64, round int32) (polc types.ProofOfLockChange, err error) {
var pbpolc tmproto.ProofOfLockChange
key := keyPOLCFromHeightAndRound(height, round)
polcBytes, err := evpool.evidenceStore.Get(key)
if err != nil {
evpool.logger.Error("Unable to retrieve polc", "err", err)
return polc, err
}
if polcBytes == nil {
return polc, fmt.Errorf("unable to find polc at height %d and round %d", height, round)
return polc, fmt.Errorf("nil value in database for key: %s", key)
}
err = proto.Unmarshal(polcBytes, &pbpolc)
@@ -366,7 +436,7 @@ func (evpool *Pool) State() sm.State {
func (evpool *Pool) addPendingEvidence(evidence types.Evidence) error {
evi, err := types.EvidenceToProto(evidence)
if err != nil {
return err
return fmt.Errorf("unable to convert to proto, err: %w", err)
}
evBytes, err := proto.Marshal(evi)
@@ -399,13 +469,12 @@ func (evpool *Pool) listEvidence(prefixKey byte, maxNum int64) ([]types.Evidence
}
defer iter.Close()
for ; iter.Valid(); iter.Next() {
val := iter.Value()
if count == maxNum {
return evidence, nil
}
count++
val := iter.Value()
var (
ev types.Evidence
evpb tmproto.Evidence
@@ -511,6 +580,57 @@ func (evpool *Pool) pruneExpiredPOLC() {
}
}
// upgrades any potential evidence that has undergone the trial period and is primed to be made into
// amnesia evidence
func (evpool *Pool) upgradePotentialAmnesiaEvidence() int64 {
iter, err := dbm.IteratePrefix(evpool.evidenceStore, []byte{baseKeyAwaiting})
if err != nil {
evpool.logger.Error("Unable to iterate over POLC's", "err", err)
return -1
}
defer iter.Close()
trialPeriod := evpool.State().ConsensusParams.Evidence.ProofTrialPeriod
// 1) Iterate through all potential amnesia evidence in order of height
for ; iter.Valid(); iter.Next() {
paeBytes := iter.Value()
// 2) Retrieve the evidence
var evpb tmproto.Evidence
err := evpb.Unmarshal(paeBytes)
if err != nil {
evpool.logger.Error("Unable to unmarshal potential amnesia evidence", "err", err)
continue
}
ev, err := types.EvidenceFromProto(&evpb)
if err != nil {
evpool.logger.Error("coverting to evidence from proto", "err", err)
continue
}
// 3) Check if the trial period has lapsed and amnesia evidence can be formed
if pe, ok := ev.(*types.PotentialAmnesiaEvidence); ok {
if pe.Primed(trialPeriod, evpool.State().LastBlockHeight) {
ae := types.MakeAmnesiaEvidence(*pe, types.EmptyPOLC())
err := evpool.AddEvidence(ae)
if err != nil {
evpool.logger.Error("Unable to add amnesia evidence", "err", err)
continue
}
err = evpool.evidenceStore.Delete(iter.Key())
if err != nil {
evpool.logger.Error("Unable to delete potential amnesia evidence", "err", err)
continue
}
} else {
evpool.logger.Debug("Potential amnesia evidence not ready to be upgraded. Ready at height", "height",
pe.HeightStamp+trialPeriod)
// once we reach a piece of evidence that isn't ready send back the height with which it will be ready
return pe.HeightStamp + trialPeriod
}
}
}
// if we have no evidence left to process we want to reset nextEvidenceTrialEndedHeight
return -1
}
func evMapKey(ev types.Evidence) string {
return string(ev.Hash())
}
@@ -604,6 +724,10 @@ func keyPending(evidence types.Evidence) []byte {
return append([]byte{baseKeyPending}, keySuffix(evidence)...)
}
func keyAwaiting(evidence types.Evidence) []byte {
return append([]byte{baseKeyAwaiting}, keySuffix(evidence)...)
}
func keyPOLC(polc types.ProofOfLockChange) []byte {
return keyPOLCFromHeightAndRound(polc.Height(), polc.Round())
}

170
evidence/pool_test.go
View File

@@ -12,7 +12,8 @@ import (
dbm "github.com/tendermint/tm-db"
"github.com/tendermint/tendermint/crypto"
"github.com/tendermint/tendermint/crypto/ed25519"
"github.com/tendermint/tendermint/libs/bytes"
"github.com/tendermint/tendermint/libs/log"
tmrand "github.com/tendermint/tendermint/libs/rand"
tmproto "github.com/tendermint/tendermint/proto/types"
sm "github.com/tendermint/tendermint/state"
@@ -27,6 +28,8 @@ func TestMain(m *testing.M) {
os.Exit(code)
}
const evidenceChainID = "test_chain"
func TestEvidencePool(t *testing.T) {
var (
valAddr = tmrand.Bytes(crypto.AddressSize)
@@ -78,14 +81,13 @@ func TestEvidencePool(t *testing.T) {
func TestProposingAndCommittingEvidence(t *testing.T) {
var (
valAddr = tmrand.Bytes(crypto.AddressSize)
height = int64(1)
lastBlockTime = time.Now()
stateDB = initializeValidatorState(valAddr, height)
evidenceDB = dbm.NewMemDB()
blockStoreDB = dbm.NewMemDB()
blockStore = initializeBlockStore(blockStoreDB, sm.LoadState(stateDB), valAddr)
evidenceTime = time.Date(2019, 1, 1, 0, 0, 0, 0, time.UTC)
valAddr = tmrand.Bytes(crypto.AddressSize)
height = int64(1)
stateDB = initializeValidatorState(valAddr, height)
evidenceDB = dbm.NewMemDB()
blockStoreDB = dbm.NewMemDB()
blockStore = initializeBlockStore(blockStoreDB, sm.LoadState(stateDB), valAddr)
evidenceTime = time.Date(2019, 1, 1, 0, 0, 0, 0, time.UTC)
)
pool, err := NewPool(stateDB, evidenceDB, blockStore)
@@ -104,7 +106,7 @@ func TestProposingAndCommittingEvidence(t *testing.T) {
assert.Equal(t, proposedEvidence[0], evidence)
// evidence seen and committed:
pool.MarkEvidenceAsCommitted(height, lastBlockTime, proposedEvidence)
pool.MarkEvidenceAsCommitted(height, proposedEvidence)
assert.True(t, pool.IsCommitted(evidence))
assert.False(t, pool.IsPending(evidence))
assert.Equal(t, 0, pool.evidenceList.Len())
@@ -161,14 +163,10 @@ func TestEvidencePoolUpdate(t *testing.T) {
blockStoreDB = dbm.NewMemDB()
state = sm.LoadState(stateDB)
blockStore = initializeBlockStore(blockStoreDB, state, valAddr)
evidenceTime = time.Date(2019, 1, 1, 0, 0, 0, 0, time.UTC)
)
pool, err := NewPool(stateDB, evidenceDB, blockStore)
require.NoError(t, err)
expiredEvidence := types.NewMockEvidence(1, evidenceTime, valAddr)
err = pool.AddEvidence(expiredEvidence)
require.NoError(t, err)
// create new block (no need to save it to blockStore)
evidence := types.NewMockEvidence(height, time.Now(), valAddr)
@@ -183,8 +181,6 @@ func TestEvidencePoolUpdate(t *testing.T) {
assert.True(t, pool.IsCommitted(evidence))
// b) Update updates valToLastHeight map
assert.Equal(t, height+1, pool.ValidatorLastHeight(valAddr))
// c) Expired ecvidence should be removed
assert.False(t, pool.IsPending(expiredEvidence))
}
func TestEvidencePoolNewPool(t *testing.T) {
@@ -246,9 +242,7 @@ func TestAddingAndPruningPOLC(t *testing.T) {
pool.Update(block, state)
emptyPolc, err = pool.RetrievePOLC(1, 1)
if assert.Error(t, err) {
assert.Equal(t, "unable to find polc at height 1 and round 1", err.Error())
}
assert.Error(t, err)
assert.Equal(t, types.ProofOfLockChange{}, emptyPolc)
}
@@ -290,18 +284,108 @@ func TestRecoverPendingEvidence(t *testing.T) {
assert.True(t, pool.IsPending(goodEvidence))
}
func initializeValidatorState(valAddr []byte, height int64) dbm.DB {
stateDB := dbm.NewMemDB()
pk := ed25519.GenPrivKey().PubKey()
func TestPotentialAmnesiaEvidence(t *testing.T) {
var (
val = types.NewMockPV()
pubKey = val.PrivKey.PubKey()
valSet = &types.ValidatorSet{
Validators: []*types.Validator{
val.ExtractIntoValidator(0),
},
Proposer: val.ExtractIntoValidator(0),
}
height = int64(30)
stateDB = initializeStateFromValidatorSet(valSet, height)
evidenceDB = dbm.NewMemDB()
blockStoreDB = dbm.NewMemDB()
state = sm.LoadState(stateDB)
blockStore = initializeBlockStore(blockStoreDB, state, pubKey.Address())
//evidenceTime = time.Date(2019, 1, 1, 0, 0, 0, 0, time.UTC)
firstBlockID = types.BlockID{
Hash: []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
PartsHeader: types.PartSetHeader{
Total: 1,
Hash: []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
},
}
secondBlockID = types.BlockID{
Hash: []byte("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
PartsHeader: types.PartSetHeader{
Total: 1,
Hash: []byte("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
},
}
evidenceTime = time.Date(2019, 1, 1, 0, 0, 0, 0, time.UTC)
)
// create validator set and state
validator := &types.Validator{Address: valAddr, VotingPower: 100, PubKey: pk}
valSet := &types.ValidatorSet{
Validators: []*types.Validator{validator},
Proposer: validator,
pool, err := NewPool(stateDB, evidenceDB, blockStore)
require.NoError(t, err)
pool.SetLogger(log.TestingLogger())
polc := types.NewMockPOLC(25, evidenceTime, pubKey)
err = pool.AddPOLC(polc)
require.NoError(t, err)
_, err = pool.RetrievePOLC(25, 1)
require.NoError(t, err)
voteA := makeVote(25, 0, 0, pubKey.Address(), firstBlockID)
err = val.SignVote(evidenceChainID, voteA)
require.NoError(t, err)
voteB := makeVote(25, 1, 0, pubKey.Address(), secondBlockID)
err = val.SignVote(evidenceChainID, voteB)
require.NoError(t, err)
voteC := makeVote(25, 0, 0, pubKey.Address(), firstBlockID)
voteC.Timestamp.Add(1 * time.Second)
err = val.SignVote(evidenceChainID, voteC)
require.NoError(t, err)
ev := types.PotentialAmnesiaEvidence{
VoteA: voteA,
VoteB: voteB,
}
// we expect the evidence pool to find the polc but log an error as the polc is not valid -> vote was
// not from a validator in this set. However, an error isn't thrown because the evidence pool
// should still be able to save the regular potential amnesia evidence.
err = pool.AddEvidence(ev)
assert.NoError(t, err)
// evidence requires trial period until it is available -> we expect no evidence to be returned
assert.Equal(t, 0, len(pool.PendingEvidence(1)))
nextHeight := pool.nextEvidenceTrialEndedHeight
assert.Greater(t, nextHeight, int64(0))
// evidence is not ready to be upgraded so we return the height we expect the evidence to be.
nextHeight = pool.upgradePotentialAmnesiaEvidence()
assert.Equal(t, height+pool.state.ConsensusParams.Evidence.ProofTrialPeriod, nextHeight)
// now evidence is ready to be upgraded to amnesia evidence -> we expect -1 to be the next height as their is
// no more pending potential amnesia evidence left
pool.state.LastBlockHeight = nextHeight
nextHeight = pool.upgradePotentialAmnesiaEvidence()
assert.Equal(t, int64(-1), nextHeight)
assert.Equal(t, 1, len(pool.PendingEvidence(1)))
// evidence of voting back in the past which is instantly punishable -> amnesia evidence is made directly
voteA.Timestamp.Add(1 * time.Second)
ev2 := types.PotentialAmnesiaEvidence{
VoteA: voteB,
VoteB: voteC,
}
err = pool.AddEvidence(ev2)
assert.NoError(t, err)
assert.Equal(t, 2, len(pool.AllPendingEvidence()))
}
func initializeStateFromValidatorSet(valSet *types.ValidatorSet, height int64) dbm.DB {
stateDB := dbm.NewMemDB()
state := sm.State{
ChainID: evidenceChainID,
LastBlockHeight: height,
LastBlockTime: tmtime.Now(),
Validators: valSet,
@@ -314,8 +398,10 @@ func initializeValidatorState(valAddr []byte, height int64) dbm.DB {
MaxGas: -1,
},
Evidence: tmproto.EvidenceParams{
MaxAgeNumBlocks: 20,
MaxAgeDuration: 48 * time.Hour,
MaxAgeNumBlocks: 20,
MaxAgeDuration: 48 * time.Hour,
MaxNum: 50,
ProofTrialPeriod: 1,
},
},
}
@@ -329,6 +415,20 @@ func initializeValidatorState(valAddr []byte, height int64) dbm.DB {
return stateDB
}
func initializeValidatorState(valAddr []byte, height int64) dbm.DB {
pubKey, _ := types.NewMockPV().GetPubKey()
validator := &types.Validator{Address: valAddr, VotingPower: 0, PubKey: pubKey}
// create validator set and state
valSet := &types.ValidatorSet{
Validators: []*types.Validator{validator},
Proposer: validator,
}
return initializeStateFromValidatorSet(valSet, height)
}
// initializeBlockStore creates a block storage and populates it w/ a dummy
// block at +height+.
func initializeBlockStore(db dbm.DB, state sm.State, valAddr []byte) *store.BlockStore {
@@ -358,3 +458,15 @@ func makeCommit(height int64, valAddr []byte) *types.Commit {
}}
return types.NewCommit(height, 0, types.BlockID{}, commitSigs)
}
func makeVote(height int64, round, index int32, addr bytes.HexBytes, blockID types.BlockID) *types.Vote {
return &types.Vote{
Type: tmproto.SignedMsgType(2),
Height: height,
Round: round,
BlockID: blockID,
Timestamp: time.Now(),
ValidatorAddress: addr,
ValidatorIndex: index,
}
}

512
proto/types/evidence.pb.go
View File

@@ -83,8 +83,9 @@ func (m *DuplicateVoteEvidence) GetVoteB() *Vote {
}
type PotentialAmnesiaEvidence struct {
VoteA *Vote `protobuf:"bytes,1,opt,name=vote_a,json=voteA,proto3" json:"vote_a,omitempty"`
VoteB *Vote `protobuf:"bytes,2,opt,name=vote_b,json=voteB,proto3" json:"vote_b,omitempty"`
VoteA *Vote `protobuf:"bytes,1,opt,name=vote_a,json=voteA,proto3" json:"vote_a,omitempty"`
VoteB *Vote `protobuf:"bytes,2,opt,name=vote_b,json=voteB,proto3" json:"vote_b,omitempty"`
HeightStamp int64 `protobuf:"varint,3,opt,name=height_stamp,json=heightStamp,proto3" json:"height_stamp,omitempty"`
}
func (m *PotentialAmnesiaEvidence) Reset() { *m = PotentialAmnesiaEvidence{} }
@@ -134,6 +135,65 @@ func (m *PotentialAmnesiaEvidence) GetVoteB() *Vote {
return nil
}
func (m *PotentialAmnesiaEvidence) GetHeightStamp() int64 {
if m != nil {
return m.HeightStamp
}
return 0
}
type AmnesiaEvidence struct {
PotentialAmnesiaEvidence *PotentialAmnesiaEvidence `protobuf:"bytes,1,opt,name=potential_amnesia_evidence,json=potentialAmnesiaEvidence,proto3" json:"potential_amnesia_evidence,omitempty"`
Polc *ProofOfLockChange `protobuf:"bytes,2,opt,name=polc,proto3" json:"polc,omitempty"`
}
func (m *AmnesiaEvidence) Reset() { *m = AmnesiaEvidence{} }
func (m *AmnesiaEvidence) String() string { return proto.CompactTextString(m) }
func (*AmnesiaEvidence) ProtoMessage() {}
func (*AmnesiaEvidence) Descriptor() ([]byte, []int) {
return fileDescriptor_86495eef24aeacc0, []int{2}
}
func (m *AmnesiaEvidence) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *AmnesiaEvidence) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_AmnesiaEvidence.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *AmnesiaEvidence) XXX_Merge(src proto.Message) {
xxx_messageInfo_AmnesiaEvidence.Merge(m, src)
}
func (m *AmnesiaEvidence) XXX_Size() int {
return m.Size()
}
func (m *AmnesiaEvidence) XXX_DiscardUnknown() {
xxx_messageInfo_AmnesiaEvidence.DiscardUnknown(m)
}
var xxx_messageInfo_AmnesiaEvidence proto.InternalMessageInfo
func (m *AmnesiaEvidence) GetPotentialAmnesiaEvidence() *PotentialAmnesiaEvidence {
if m != nil {
return m.PotentialAmnesiaEvidence
}
return nil
}
func (m *AmnesiaEvidence) GetPolc() *ProofOfLockChange {
if m != nil {
return m.Polc
}
return nil
}
// MockEvidence is used for testing pruposes
type MockEvidence struct {
EvidenceHeight int64 `protobuf:"varint,1,opt,name=evidence_height,json=evidenceHeight,proto3" json:"evidence_height,omitempty"`
@@ -145,7 +205,7 @@ func (m *MockEvidence) Reset() { *m = MockEvidence{} }
func (m *MockEvidence) String() string { return proto.CompactTextString(m) }
func (*MockEvidence) ProtoMessage() {}
func (*MockEvidence) Descriptor() ([]byte, []int) {
return fileDescriptor_86495eef24aeacc0, []int{2}
return fileDescriptor_86495eef24aeacc0, []int{3}
}
func (m *MockEvidence) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -206,7 +266,7 @@ func (m *MockRandomEvidence) Reset() { *m = MockRandomEvidence{} }
func (m *MockRandomEvidence) String() string { return proto.CompactTextString(m) }
func (*MockRandomEvidence) ProtoMessage() {}
func (*MockRandomEvidence) Descriptor() ([]byte, []int) {
return fileDescriptor_86495eef24aeacc0, []int{3}
return fileDescriptor_86495eef24aeacc0, []int{4}
}
func (m *MockRandomEvidence) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -272,7 +332,7 @@ func (m *ConflictingHeadersEvidence) Reset() { *m = ConflictingHeadersEv
func (m *ConflictingHeadersEvidence) String() string { return proto.CompactTextString(m) }
func (*ConflictingHeadersEvidence) ProtoMessage() {}
func (*ConflictingHeadersEvidence) Descriptor() ([]byte, []int) {
return fileDescriptor_86495eef24aeacc0, []int{4}
return fileDescriptor_86495eef24aeacc0, []int{5}
}
func (m *ConflictingHeadersEvidence) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -325,7 +385,7 @@ func (m *LunaticValidatorEvidence) Reset() { *m = LunaticValidatorEviden
func (m *LunaticValidatorEvidence) String() string { return proto.CompactTextString(m) }
func (*LunaticValidatorEvidence) ProtoMessage() {}
func (*LunaticValidatorEvidence) Descriptor() ([]byte, []int) {
return fileDescriptor_86495eef24aeacc0, []int{5}
return fileDescriptor_86495eef24aeacc0, []int{6}
}
func (m *LunaticValidatorEvidence) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -381,6 +441,7 @@ type Evidence struct {
// *Evidence_ConflictingHeadersEvidence
// *Evidence_LunaticValidatorEvidence
// *Evidence_PotentialAmnesiaEvidence
// *Evidence_AmnesiaEvidence
// *Evidence_MockEvidence
// *Evidence_MockRandomEvidence
Sum isEvidence_Sum `protobuf_oneof:"sum"`
@@ -390,7 +451,7 @@ func (m *Evidence) Reset() { *m = Evidence{} }
func (m *Evidence) String() string { return proto.CompactTextString(m) }
func (*Evidence) ProtoMessage() {}
func (*Evidence) Descriptor() ([]byte, []int) {
return fileDescriptor_86495eef24aeacc0, []int{6}
return fileDescriptor_86495eef24aeacc0, []int{7}
}
func (m *Evidence) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -437,17 +498,21 @@ type Evidence_LunaticValidatorEvidence struct {
type Evidence_PotentialAmnesiaEvidence struct {
PotentialAmnesiaEvidence *PotentialAmnesiaEvidence `protobuf:"bytes,4,opt,name=potential_amnesia_evidence,json=potentialAmnesiaEvidence,proto3,oneof" json:"potential_amnesia_evidence,omitempty"`
}
type Evidence_AmnesiaEvidence struct {
AmnesiaEvidence *AmnesiaEvidence `protobuf:"bytes,5,opt,name=amnesia_evidence,json=amnesiaEvidence,proto3,oneof" json:"amnesia_evidence,omitempty"`
}
type Evidence_MockEvidence struct {
MockEvidence *MockEvidence `protobuf:"bytes,5,opt,name=mock_evidence,json=mockEvidence,proto3,oneof" json:"mock_evidence,omitempty"`
MockEvidence *MockEvidence `protobuf:"bytes,6,opt,name=mock_evidence,json=mockEvidence,proto3,oneof" json:"mock_evidence,omitempty"`
}
type Evidence_MockRandomEvidence struct {
MockRandomEvidence *MockRandomEvidence `protobuf:"bytes,6,opt,name=mock_random_evidence,json=mockRandomEvidence,proto3,oneof" json:"mock_random_evidence,omitempty"`
MockRandomEvidence *MockRandomEvidence `protobuf:"bytes,7,opt,name=mock_random_evidence,json=mockRandomEvidence,proto3,oneof" json:"mock_random_evidence,omitempty"`
}
func (*Evidence_DuplicateVoteEvidence) isEvidence_Sum() {}
func (*Evidence_ConflictingHeadersEvidence) isEvidence_Sum() {}
func (*Evidence_LunaticValidatorEvidence) isEvidence_Sum() {}
func (*Evidence_PotentialAmnesiaEvidence) isEvidence_Sum() {}
func (*Evidence_AmnesiaEvidence) isEvidence_Sum() {}
func (*Evidence_MockEvidence) isEvidence_Sum() {}
func (*Evidence_MockRandomEvidence) isEvidence_Sum() {}
@@ -486,6 +551,13 @@ func (m *Evidence) GetPotentialAmnesiaEvidence() *PotentialAmnesiaEvidence {
return nil
}
func (m *Evidence) GetAmnesiaEvidence() *AmnesiaEvidence {
if x, ok := m.GetSum().(*Evidence_AmnesiaEvidence); ok {
return x.AmnesiaEvidence
}
return nil
}
func (m *Evidence) GetMockEvidence() *MockEvidence {
if x, ok := m.GetSum().(*Evidence_MockEvidence); ok {
return x.MockEvidence
@@ -507,6 +579,7 @@ func (*Evidence) XXX_OneofWrappers() []interface{} {
(*Evidence_ConflictingHeadersEvidence)(nil),
(*Evidence_LunaticValidatorEvidence)(nil),
(*Evidence_PotentialAmnesiaEvidence)(nil),
(*Evidence_AmnesiaEvidence)(nil),
(*Evidence_MockEvidence)(nil),
(*Evidence_MockRandomEvidence)(nil),
}
@@ -522,7 +595,7 @@ func (m *EvidenceData) Reset() { *m = EvidenceData{} }
func (m *EvidenceData) String() string { return proto.CompactTextString(m) }
func (*EvidenceData) ProtoMessage() {}
func (*EvidenceData) Descriptor() ([]byte, []int) {
return fileDescriptor_86495eef24aeacc0, []int{7}
return fileDescriptor_86495eef24aeacc0, []int{8}
}
func (m *EvidenceData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -574,7 +647,7 @@ func (m *ProofOfLockChange) Reset() { *m = ProofOfLockChange{} }
func (m *ProofOfLockChange) String() string { return proto.CompactTextString(m) }
func (*ProofOfLockChange) ProtoMessage() {}
func (*ProofOfLockChange) Descriptor() ([]byte, []int) {
return fileDescriptor_86495eef24aeacc0, []int{8}
return fileDescriptor_86495eef24aeacc0, []int{9}
}
func (m *ProofOfLockChange) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -620,6 +693,7 @@ func (m *ProofOfLockChange) GetPubKey() *keys.PublicKey {
func init() {
proto.RegisterType((*DuplicateVoteEvidence)(nil), "tendermint.proto.types.DuplicateVoteEvidence")
proto.RegisterType((*PotentialAmnesiaEvidence)(nil), "tendermint.proto.types.PotentialAmnesiaEvidence")
proto.RegisterType((*AmnesiaEvidence)(nil), "tendermint.proto.types.AmnesiaEvidence")
proto.RegisterType((*MockEvidence)(nil), "tendermint.proto.types.MockEvidence")
proto.RegisterType((*MockRandomEvidence)(nil), "tendermint.proto.types.MockRandomEvidence")
proto.RegisterType((*ConflictingHeadersEvidence)(nil), "tendermint.proto.types.ConflictingHeadersEvidence")
@@ -632,57 +706,61 @@ func init() {
func init() { proto.RegisterFile("proto/types/evidence.proto", fileDescriptor_86495eef24aeacc0) }
var fileDescriptor_86495eef24aeacc0 = []byte{
// 786 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x55, 0xcf, 0x4f, 0xdc, 0x46,
0x14, 0xb6, 0xd9, 0x1f, 0x85, 0xc7, 0xd2, 0x1f, 0x16, 0x94, 0x95, 0x05, 0x0b, 0xb2, 0xaa, 0x42,
0xab, 0xd6, 0x0b, 0x4b, 0xd5, 0x73, 0x59, 0x28, 0xda, 0x0a, 0xaa, 0x22, 0x37, 0xe2, 0x90, 0x43,
0xac, 0xb1, 0x3d, 0x6b, 0x8f, 0xd6, 0xf6, 0x58, 0xf6, 0x78, 0x25, 0x1f, 0xa3, 0xe4, 0x90, 0xdc,
0xf8, 0x47, 0x72, 0xcd, 0xdf, 0xc0, 0x11, 0xe5, 0x94, 0x53, 0x12, 0xc1, 0x3f, 0x12, 0x79, 0xfc,
0x6b, 0x11, 0x18, 0xed, 0x2d, 0xca, 0x65, 0x35, 0xfb, 0xe6, 0x7d, 0xef, 0xfb, 0xc6, 0xef, 0xcd,
0x37, 0x20, 0x07, 0x21, 0x65, 0xb4, 0xcf, 0x92, 0x00, 0x47, 0x7d, 0x3c, 0x25, 0x16, 0xf6, 0x4d,
0xac, 0xf2, 0xa0, 0xf4, 0x23, 0xc3, 0xbe, 0x85, 0x43, 0x8f, 0xf8, 0x2c, 0x8b, 0xa8, 0x3c, 0x4d,
0xfe, 0x99, 0x39, 0x24, 0xb4, 0xf4, 0x00, 0x85, 0x2c, 0xe9, 0x67, 0x78, 0x9b, 0xda, 0xb4, 0x5a,
0x65, 0xd9, 0xf2, 0xfa, 0x6c, 0x6d, 0xfe, 0x9b, 0x6f, 0x6c, 0xd9, 0x94, 0xda, 0x2e, 0xce, 0xb0,
0x46, 0x3c, 0xee, 0x33, 0xe2, 0xe1, 0x88, 0x21, 0x2f, 0xc8, 0x13, 0x36, 0x33, 0xa4, 0x19, 0x26,
0x01, 0xa3, 0xfd, 0x09, 0x4e, 0xee, 0xe0, 0x95, 0xe7, 0x22, 0xac, 0x1d, 0xc7, 0x81, 0x4b, 0x4c,
0xc4, 0xf0, 0x05, 0x65, 0xf8, 0xef, 0x5c, 0xb8, 0x74, 0x00, 0xed, 0x29, 0x65, 0x58, 0x47, 0x5d,
0x71, 0x5b, 0xdc, 0x5d, 0x1e, 0x6c, 0xa8, 0x0f, 0x9f, 0x41, 0x4d, 0x51, 0x5a, 0x2b, 0xcd, 0x3d,
0x2c, 0x41, 0x46, 0x77, 0x61, 0x5e, 0xd0, 0x50, 0x79, 0x29, 0x42, 0xf7, 0x9c, 0x32, 0xec, 0x33,
0x82, 0xdc, 0x43, 0xcf, 0xc7, 0x11, 0x41, 0x5f, 0x40, 0xc6, 0x1b, 0x11, 0x3a, 0xff, 0x52, 0x73,
0x52, 0x52, 0xef, 0xc0, 0x77, 0x45, 0x1b, 0x75, 0x07, 0x13, 0xdb, 0x61, 0x5c, 0x43, 0x43, 0xfb,
0xb6, 0x08, 0x8f, 0x78, 0x54, 0xfa, 0x07, 0x56, 0xca, 0xc4, 0xf4, 0xfb, 0xe7, 0xac, 0xb2, 0x9a,
0x35, 0x47, 0x2d, 0x9a, 0xa3, 0x3e, 0x29, 0x9a, 0x33, 0x5c, 0xbc, 0xfa, 0xb0, 0x25, 0x5c, 0x7e,
0xdc, 0x12, 0xb5, 0x4e, 0x01, 0x4d, 0x37, 0xa5, 0x5f, 0xe0, 0xfb, 0xb2, 0x14, 0xb2, 0xac, 0x10,
0x47, 0x51, 0xb7, 0xb1, 0x2d, 0xee, 0x76, 0xb4, 0x52, 0xcb, 0x61, 0x16, 0x56, 0xde, 0x89, 0x20,
0xa5, 0x7a, 0x35, 0xe4, 0x5b, 0xd4, 0xfb, 0x4a, 0x54, 0x4b, 0x9b, 0x00, 0x21, 0xf2, 0x2d, 0xdd,
0x48, 0x18, 0x8e, 0xba, 0x4d, 0x9e, 0xb4, 0x94, 0x46, 0x86, 0x69, 0x40, 0x79, 0x25, 0x82, 0x7c,
0x44, 0xfd, 0xb1, 0x4b, 0x4c, 0x46, 0x7c, 0x7b, 0x84, 0x91, 0x85, 0xc3, 0xa8, 0x3c, 0xdc, 0x1f,
0xb0, 0xe0, 0xec, 0xe7, 0x93, 0xf0, 0x53, 0x5d, 0x53, 0xff, 0x27, 0xb6, 0x8f, 0xad, 0x0c, 0xaa,
0x2d, 0x38, 0xfb, 0x1c, 0x35, 0xc8, 0x8f, 0x37, 0x2f, 0x6a, 0xa0, 0xbc, 0x15, 0xa1, 0x7b, 0x16,
0xfb, 0x88, 0x11, 0xf3, 0x02, 0xb9, 0xc4, 0x42, 0x8c, 0x86, 0xa5, 0x90, 0x3f, 0xa1, 0xed, 0xf0,
0xd4, 0x5c, 0x4c, 0xaf, 0xae, 0x6c, 0x5e, 0x30, 0xcf, 0x96, 0xf6, 0xa0, 0x99, 0x4e, 0xdb, 0x5c,
0x73, 0xc9, 0x33, 0xa5, 0x3d, 0x58, 0x25, 0xfe, 0x34, 0x15, 0xa0, 0x67, 0x35, 0xf4, 0x31, 0xc1,
0xae, 0xc5, 0xbf, 0xef, 0x92, 0x26, 0xe5, 0x7b, 0x19, 0xcd, 0x49, 0xba, 0xa3, 0xbc, 0x68, 0xc1,
0x62, 0x29, 0xd4, 0x86, 0x75, 0xab, 0xb8, 0xdf, 0x3a, 0xbf, 0x14, 0x45, 0x47, 0x72, 0xe5, 0xbf,
0xd7, 0x69, 0x78, 0xd0, 0x16, 0x46, 0x82, 0xb6, 0x66, 0x3d, 0xe8, 0x17, 0x53, 0xd8, 0x30, 0xab,
0xc6, 0xe5, 0x5a, 0xa3, 0x8a, 0x2d, 0x3b, 0xf1, 0xa0, 0x8e, 0xad, 0xbe, 0xe9, 0x23, 0x41, 0x93,
0xcd, 0xfa, 0x91, 0x08, 0x40, 0x76, 0xb3, 0x2e, 0xe9, 0xd3, 0xa2, 0x4d, 0x15, 0x6b, 0x83, 0xb3,
0xee, 0xd5, 0xb1, 0xd6, 0xf5, 0x77, 0x24, 0x68, 0x5d, 0xb7, 0xae, 0xf7, 0x01, 0xc8, 0x41, 0x61,
0x57, 0x3a, 0xca, 0xfc, 0xaa, 0x62, 0x6c, 0x3e, 0xce, 0x58, 0x67, 0x74, 0x29, 0x63, 0x50, 0x67,
0x82, 0xa7, 0xb0, 0xe2, 0x51, 0x73, 0x52, 0x91, 0xb4, 0x1e, 0x9f, 0xe5, 0x59, 0x1b, 0x1b, 0x09,
0x5a, 0xc7, 0x9b, 0xb5, 0xb5, 0x67, 0xb0, 0xca, 0x8b, 0x85, 0xdc, 0x37, 0xaa, 0x9a, 0x6d, 0x5e,
0xf3, 0xd7, 0xc7, 0x6a, 0xde, 0xb5, 0x9a, 0x91, 0xa0, 0x49, 0xde, 0xbd, 0xe8, 0xb0, 0x05, 0x8d,
0x28, 0xf6, 0x94, 0x31, 0x74, 0x8a, 0xd0, 0x31, 0x62, 0x48, 0x1a, 0xc2, 0xe2, 0xcc, 0xe4, 0x35,
0x76, 0x97, 0x07, 0xdb, 0x75, 0x54, 0x65, 0xa9, 0x66, 0xea, 0x37, 0x5a, 0x89, 0x93, 0x24, 0x68,
0x3a, 0x28, 0x72, 0xf8, 0x2c, 0x75, 0x34, 0xbe, 0x56, 0x5e, 0x8b, 0xf0, 0xc3, 0x79, 0x48, 0xe9,
0xf8, 0xbf, 0xf1, 0x19, 0x35, 0x27, 0x47, 0x0e, 0xf2, 0x6d, 0x2c, 0x0d, 0x80, 0xbb, 0x7a, 0x94,
0x53, 0xcd, 0xf1, 0x00, 0x44, 0xd2, 0x5f, 0xf0, 0x4d, 0x10, 0x1b, 0xfa, 0x04, 0x27, 0xf9, 0xb0,
0xee, 0xdc, 0x47, 0x65, 0xef, 0xa8, 0x9a, 0xbe, 0xa3, 0xea, 0x79, 0x6c, 0xb8, 0xc4, 0x3c, 0xc5,
0x89, 0xd6, 0x0e, 0x62, 0xe3, 0x14, 0x27, 0xc3, 0x93, 0xab, 0x9b, 0x9e, 0x78, 0x7d, 0xd3, 0x13,
0x3f, 0xdd, 0xf4, 0xc4, 0xcb, 0xdb, 0x9e, 0x70, 0x7d, 0xdb, 0x13, 0xde, 0xdf, 0xf6, 0x84, 0xa7,
0xbf, 0xd9, 0x84, 0x39, 0xb1, 0xa1, 0x9a, 0xd4, 0xeb, 0x57, 0x45, 0x67, 0x97, 0x33, 0x2f, 0xbc,
0xd1, 0xe6, 0x7f, 0x0e, 0x3e, 0x07, 0x00, 0x00, 0xff, 0xff, 0x6a, 0x4c, 0xe5, 0x0b, 0x53, 0x08,
0x00, 0x00,
// 858 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0xcf, 0x6f, 0xdc, 0x44,
0x14, 0xb6, 0xb3, 0x9b, 0x6d, 0xfa, 0xb2, 0x25, 0x65, 0xd4, 0x52, 0xcb, 0x6a, 0x37, 0xc1, 0x42,
0x34, 0x45, 0xe0, 0x4d, 0xb7, 0x88, 0x1b, 0x12, 0xd9, 0x96, 0x6a, 0x51, 0x8a, 0xa8, 0xa6, 0x55,
0x0f, 0x1c, 0xb0, 0xc6, 0xf6, 0xac, 0x3d, 0x5a, 0xdb, 0x63, 0xd9, 0xe3, 0x95, 0x7c, 0xe4, 0x06,
0xb7, 0xfe, 0x17, 0x9c, 0xb8, 0x72, 0xe6, 0xd8, 0x63, 0xc5, 0x09, 0x2e, 0x80, 0x92, 0x7f, 0x04,
0x79, 0xc6, 0xf6, 0x6e, 0x7e, 0x38, 0x8a, 0x38, 0x20, 0x71, 0x59, 0x79, 0xdf, 0xbc, 0xef, 0x7b,
0xdf, 0x9b, 0xf7, 0xc3, 0x06, 0x33, 0xcd, 0xb8, 0xe0, 0x63, 0x51, 0xa6, 0x34, 0x1f, 0xd3, 0x25,
0xf3, 0x69, 0xe2, 0x51, 0x5b, 0x1a, 0xd1, 0x7b, 0x82, 0x26, 0x3e, 0xcd, 0x62, 0x96, 0x08, 0x65,
0xb1, 0xa5, 0x9b, 0xf9, 0xa1, 0x08, 0x59, 0xe6, 0x3b, 0x29, 0xc9, 0x44, 0x39, 0x56, 0xf8, 0x80,
0x07, 0x7c, 0xf5, 0xa4, 0xbc, 0xcd, 0x3b, 0xeb, 0xdc, 0xf2, 0xb7, 0x3e, 0xd8, 0x0d, 0x38, 0x0f,
0x22, 0xaa, 0xb0, 0x6e, 0x31, 0x1f, 0x0b, 0x16, 0xd3, 0x5c, 0x90, 0x38, 0xad, 0x1d, 0xee, 0x29,
0xa4, 0x97, 0x95, 0xa9, 0xe0, 0xe3, 0x05, 0x2d, 0x4f, 0xe1, 0xad, 0xef, 0x75, 0xb8, 0xfd, 0xa4,
0x48, 0x23, 0xe6, 0x11, 0x41, 0x5f, 0x71, 0x41, 0xbf, 0xac, 0x85, 0xa3, 0x47, 0x30, 0x58, 0x72,
0x41, 0x1d, 0x62, 0xe8, 0x7b, 0xfa, 0xfe, 0xf6, 0xe4, 0xae, 0x7d, 0x71, 0x0e, 0x76, 0x85, 0xc2,
0x9b, 0x95, 0xef, 0x61, 0x0b, 0x72, 0x8d, 0x8d, 0xab, 0x82, 0xa6, 0xd6, 0x4f, 0x3a, 0x18, 0xcf,
0xb9, 0xa0, 0x89, 0x60, 0x24, 0x3a, 0x8c, 0x13, 0x9a, 0x33, 0xf2, 0xdf, 0xcb, 0x40, 0xef, 0xc3,
0x30, 0xa4, 0x2c, 0x08, 0x85, 0x23, 0xef, 0xcf, 0xe8, 0xed, 0xe9, 0xfb, 0x3d, 0xbc, 0xad, 0x6c,
0x2f, 0x2a, 0x93, 0xf5, 0xab, 0x0e, 0x3b, 0x67, 0x05, 0x26, 0x60, 0xa6, 0x8d, 0x78, 0x87, 0xa8,
0x43, 0xa7, 0x29, 0x7f, 0x2d, 0xfa, 0xa0, 0x2b, 0x7e, 0x57, 0xda, 0xd8, 0x48, 0xbb, 0x2e, 0xe4,
0x73, 0xe8, 0xa7, 0x3c, 0xf2, 0xea, 0xcc, 0x1e, 0x74, 0x32, 0x67, 0x9c, 0xcf, 0xbf, 0x99, 0x3f,
0xe3, 0xde, 0xe2, 0x71, 0x48, 0x92, 0x80, 0x62, 0x09, 0xb3, 0x7e, 0xd6, 0x61, 0xf8, 0x35, 0xf7,
0x16, 0x2d, 0xdf, 0x7d, 0xd8, 0x69, 0xd4, 0x3a, 0x2a, 0x57, 0x29, 0xba, 0x87, 0xdf, 0x69, 0xcc,
0x33, 0x69, 0x45, 0x5f, 0xc1, 0x8d, 0xd6, 0xb1, 0xea, 0xb2, 0x5a, 0x81, 0x69, 0xab, 0x16, 0xb4,
0x9b, 0x16, 0xb4, 0x5f, 0x36, 0x2d, 0x38, 0xdd, 0x7a, 0xf3, 0xe7, 0xae, 0xf6, 0xfa, 0xaf, 0x5d,
0x1d, 0x0f, 0x1b, 0x68, 0x75, 0x88, 0x1e, 0xc0, 0xcd, 0x96, 0x8a, 0xf8, 0x7e, 0x46, 0xf3, 0x5c,
0x5e, 0xf7, 0x10, 0xb7, 0x5a, 0x0e, 0x95, 0xd9, 0xfa, 0x4d, 0x07, 0x54, 0xe9, 0xc5, 0x24, 0xf1,
0x79, 0xfc, 0x3f, 0x51, 0x8d, 0xee, 0x01, 0x64, 0x24, 0xf1, 0x1d, 0xb7, 0x14, 0x34, 0x37, 0xfa,
0xd2, 0xe9, 0x7a, 0x65, 0x99, 0x56, 0x06, 0xeb, 0x07, 0x1d, 0xcc, 0xc7, 0x3c, 0x99, 0x47, 0xcc,
0x13, 0x2c, 0x09, 0x66, 0x94, 0xf8, 0x34, 0xcb, 0xdb, 0xe4, 0x3e, 0x85, 0x8d, 0xf0, 0x61, 0xdd,
0x3a, 0x1f, 0x74, 0x15, 0xf8, 0x05, 0x0b, 0x12, 0xea, 0x2b, 0x28, 0xde, 0x08, 0x1f, 0x4a, 0xd4,
0xa4, 0x4e, 0xef, 0xaa, 0xa8, 0x89, 0xf5, 0x8b, 0x0e, 0xc6, 0xb3, 0x22, 0x21, 0x82, 0x79, 0xaf,
0x48, 0xc4, 0x7c, 0x22, 0x78, 0xd6, 0x0a, 0xf9, 0x0c, 0x06, 0xa1, 0x74, 0xad, 0xc5, 0x8c, 0xba,
0x68, 0x6b, 0xc2, 0xda, 0x1b, 0x1d, 0x40, 0xbf, 0x9a, 0xa9, 0x2b, 0x4d, 0x9f, 0xf4, 0x44, 0x07,
0x70, 0x8b, 0x25, 0xcb, 0x4a, 0x80, 0xa3, 0x38, 0x9c, 0x39, 0xa3, 0x91, 0x2f, 0xef, 0xf7, 0x3a,
0x46, 0xf5, 0x99, 0x0a, 0xf3, 0xb4, 0x3a, 0xb1, 0xfe, 0xd8, 0x84, 0xad, 0x56, 0x68, 0x00, 0x77,
0xfc, 0x66, 0x8b, 0x39, 0x72, 0xf4, 0xcf, 0x4c, 0xe0, 0x27, 0x5d, 0x1a, 0x2e, 0x5c, 0x7e, 0x33,
0x0d, 0xdf, 0xf6, 0x2f, 0xdc, 0x8a, 0x4b, 0xb8, 0xeb, 0xad, 0x0a, 0x57, 0x6b, 0xcd, 0x57, 0xd1,
0x54, 0xc6, 0x93, 0xae, 0x68, 0xdd, 0x45, 0x9f, 0x69, 0xd8, 0xf4, 0xba, 0x5b, 0x22, 0x05, 0x33,
0x52, 0x55, 0x72, 0x96, 0x4d, 0x99, 0x56, 0x51, 0x7b, 0x97, 0x6f, 0x99, 0xae, 0xfa, 0xce, 0x34,
0x6c, 0x44, 0x5d, 0xb5, 0x4f, 0x2f, 0xdd, 0x6b, 0xfd, 0x7f, 0xb7, 0xd7, 0xaa, 0x88, 0x9d, 0x9b,
0xed, 0x25, 0xdc, 0x3c, 0x17, 0x67, 0x53, 0xc6, 0xb9, 0xdf, 0x15, 0xe7, 0x3c, 0xfd, 0x0e, 0x39,
0xc3, 0x7a, 0x04, 0x37, 0x62, 0xee, 0x2d, 0x56, 0x94, 0x83, 0xcb, 0x27, 0x64, 0x7d, 0x39, 0xce,
0x34, 0x3c, 0x8c, 0xd7, 0x97, 0xe5, 0x77, 0x70, 0x4b, 0x92, 0x65, 0x72, 0x1b, 0xad, 0x38, 0xaf,
0x49, 0xce, 0x8f, 0x2e, 0xe3, 0x3c, 0xbd, 0xc0, 0x66, 0x1a, 0x46, 0xf1, 0x39, 0xeb, 0x74, 0x13,
0x7a, 0x79, 0x11, 0x5b, 0x73, 0x18, 0x36, 0xa6, 0x27, 0x44, 0x10, 0x34, 0x85, 0xad, 0xb5, 0x7e,
0xee, 0xed, 0x6f, 0x4f, 0xf6, 0xba, 0x42, 0xb5, 0x54, 0xfd, 0x6a, 0x8b, 0xe1, 0x16, 0x87, 0x10,
0xf4, 0x43, 0x92, 0x87, 0xb2, 0x43, 0x87, 0x58, 0x3e, 0x5b, 0x3f, 0xea, 0xf0, 0xee, 0xb9, 0x17,
0x05, 0x9a, 0x80, 0x7c, 0x23, 0xe6, 0x75, 0xa8, 0x2b, 0xbc, 0x3c, 0x73, 0xf4, 0x05, 0x5c, 0x4b,
0x0b, 0xd7, 0x59, 0xd0, 0xb2, 0x1e, 0x81, 0x0b, 0x4a, 0xa6, 0xbe, 0x41, 0xec, 0xea, 0x1b, 0xc4,
0x7e, 0x5e, 0xb8, 0x11, 0xf3, 0x8e, 0x68, 0x89, 0x07, 0x69, 0xe1, 0x1e, 0xd1, 0x72, 0xfa, 0xf4,
0xcd, 0xf1, 0x48, 0x7f, 0x7b, 0x3c, 0xd2, 0xff, 0x3e, 0x1e, 0xe9, 0xaf, 0x4f, 0x46, 0xda, 0xdb,
0x93, 0x91, 0xf6, 0xfb, 0xc9, 0x48, 0xfb, 0xf6, 0xe3, 0x80, 0x89, 0xb0, 0x70, 0x6d, 0x8f, 0xc7,
0xe3, 0x15, 0xe9, 0xfa, 0xe3, 0xda, 0xd7, 0x91, 0x3b, 0x90, 0x7f, 0x1e, 0xfd, 0x13, 0x00, 0x00,
0xff, 0xff, 0xa6, 0x62, 0x87, 0x20, 0x8f, 0x09, 0x00, 0x00,
}
func (m *DuplicateVoteEvidence) Marshal() (dAtA []byte, err error) {
@@ -752,6 +830,11 @@ func (m *PotentialAmnesiaEvidence) MarshalToSizedBuffer(dAtA []byte) (int, error
_ = i
var l int
_ = l
if m.HeightStamp != 0 {
i = encodeVarintEvidence(dAtA, i, uint64(m.HeightStamp))
i--
dAtA[i] = 0x18
}
if m.VoteB != nil {
{
size, err := m.VoteB.MarshalToSizedBuffer(dAtA[:i])
@@ -779,6 +862,53 @@ func (m *PotentialAmnesiaEvidence) MarshalToSizedBuffer(dAtA []byte) (int, error
return len(dAtA) - i, nil
}
func (m *AmnesiaEvidence) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *AmnesiaEvidence) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *AmnesiaEvidence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Polc != nil {
{
size, err := m.Polc.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintEvidence(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
}
if m.PotentialAmnesiaEvidence != nil {
{
size, err := m.PotentialAmnesiaEvidence.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintEvidence(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *MockEvidence) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@@ -806,12 +936,12 @@ func (m *MockEvidence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x1a
}
n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EvidenceTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EvidenceTime):])
if err5 != nil {
return 0, err5
n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EvidenceTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EvidenceTime):])
if err7 != nil {
return 0, err7
}
i -= n5
i = encodeVarintEvidence(dAtA, i, uint64(n5))
i -= n7
i = encodeVarintEvidence(dAtA, i, uint64(n7))
i--
dAtA[i] = 0x12
if m.EvidenceHeight != 0 {
@@ -856,12 +986,12 @@ func (m *MockRandomEvidence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x1a
}
n6, err6 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EvidenceTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EvidenceTime):])
if err6 != nil {
return 0, err6
n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EvidenceTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EvidenceTime):])
if err8 != nil {
return 0, err8
}
i -= n6
i = encodeVarintEvidence(dAtA, i, uint64(n6))
i -= n8
i = encodeVarintEvidence(dAtA, i, uint64(n8))
i--
dAtA[i] = 0x12
if m.EvidenceHeight != 0 {
@@ -1089,6 +1219,27 @@ func (m *Evidence_PotentialAmnesiaEvidence) MarshalToSizedBuffer(dAtA []byte) (i
}
return len(dAtA) - i, nil
}
func (m *Evidence_AmnesiaEvidence) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Evidence_AmnesiaEvidence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
if m.AmnesiaEvidence != nil {
{
size, err := m.AmnesiaEvidence.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintEvidence(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x2a
}
return len(dAtA) - i, nil
}
func (m *Evidence_MockEvidence) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
@@ -1106,7 +1257,7 @@ func (m *Evidence_MockEvidence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i = encodeVarintEvidence(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x2a
dAtA[i] = 0x32
}
return len(dAtA) - i, nil
}
@@ -1127,7 +1278,7 @@ func (m *Evidence_MockRandomEvidence) MarshalToSizedBuffer(dAtA []byte) (int, er
i = encodeVarintEvidence(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x32
dAtA[i] = 0x3a
}
return len(dAtA) - i, nil
}
@@ -1266,6 +1417,26 @@ func (m *PotentialAmnesiaEvidence) Size() (n int) {
l = m.VoteB.Size()
n += 1 + l + sovEvidence(uint64(l))
}
if m.HeightStamp != 0 {
n += 1 + sovEvidence(uint64(m.HeightStamp))
}
return n
}
func (m *AmnesiaEvidence) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.PotentialAmnesiaEvidence != nil {
l = m.PotentialAmnesiaEvidence.Size()
n += 1 + l + sovEvidence(uint64(l))
}
if m.Polc != nil {
l = m.Polc.Size()
n += 1 + l + sovEvidence(uint64(l))
}
return n
}
@@ -1407,6 +1578,18 @@ func (m *Evidence_PotentialAmnesiaEvidence) Size() (n int) {
}
return n
}
func (m *Evidence_AmnesiaEvidence) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.AmnesiaEvidence != nil {
l = m.AmnesiaEvidence.Size()
n += 1 + l + sovEvidence(uint64(l))
}
return n
}
func (m *Evidence_MockEvidence) Size() (n int) {
if m == nil {
return 0
@@ -1701,6 +1884,150 @@ func (m *PotentialAmnesiaEvidence) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field HeightStamp", wireType)
}
m.HeightStamp = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowEvidence
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.HeightStamp |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipEvidence(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthEvidence
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthEvidence
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *AmnesiaEvidence) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowEvidence
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: AmnesiaEvidence: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: AmnesiaEvidence: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PotentialAmnesiaEvidence", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowEvidence
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthEvidence
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthEvidence
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.PotentialAmnesiaEvidence == nil {
m.PotentialAmnesiaEvidence = &PotentialAmnesiaEvidence{}
}
if err := m.PotentialAmnesiaEvidence.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Polc", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowEvidence
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthEvidence
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthEvidence
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Polc == nil {
m.Polc = &ProofOfLockChange{}
}
if err := m.Polc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipEvidence(dAtA[iNdEx:])
@@ -2489,6 +2816,41 @@ func (m *Evidence) Unmarshal(dAtA []byte) error {
m.Sum = &Evidence_PotentialAmnesiaEvidence{v}
iNdEx = postIndex
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field AmnesiaEvidence", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowEvidence
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthEvidence
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthEvidence
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
v := &AmnesiaEvidence{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
m.Sum = &Evidence_AmnesiaEvidence{v}
iNdEx = postIndex
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field MockEvidence", wireType)
}
@@ -2523,7 +2885,7 @@ func (m *Evidence) Unmarshal(dAtA []byte) error {
}
m.Sum = &Evidence_MockEvidence{v}
iNdEx = postIndex
case 6:
case 7:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field MockRandomEvidence", wireType)
}

12
proto/types/evidence.proto
View File

@@ -18,6 +18,13 @@ message DuplicateVoteEvidence {
message PotentialAmnesiaEvidence {
Vote vote_a = 1;
Vote vote_b = 2;
int64 height_stamp = 3;
}
message AmnesiaEvidence {
PotentialAmnesiaEvidence potential_amnesia_evidence = 1;
ProofOfLockChange polc = 2;
}
// MockEvidence is used for testing pruposes
@@ -52,9 +59,10 @@ message Evidence {
ConflictingHeadersEvidence conflicting_headers_evidence = 2;
LunaticValidatorEvidence lunatic_validator_evidence = 3;
PotentialAmnesiaEvidence potential_amnesia_evidence = 4;
AmnesiaEvidence amnesia_evidence = 5;
MockEvidence mock_evidence = 5;
MockRandomEvidence mock_random_evidence = 6;
MockEvidence mock_evidence = 6;
MockRandomEvidence mock_random_evidence = 7;
}
}

109
proto/types/params.pb.go
View File

@@ -174,6 +174,10 @@ type EvidenceParams struct {
// each evidence (See MaxEvidenceBytes). The maximum number is MaxEvidencePerBlock.
// Default is 50
MaxNum uint32 `protobuf:"varint,3,opt,name=max_num,json=maxNum,proto3" json:"max_num,omitempty"`
// Proof trial period dictates the time given for nodes accused of amnesia evidence, incorrectly
// voting twice in two different rounds to respond with their respective proofs.
// Default is half the max age in blocks: 50,000
ProofTrialPeriod int64 `protobuf:"varint,4,opt,name=proof_trial_period,json=proofTrialPeriod,proto3" json:"proof_trial_period,omitempty"`
}
func (m *EvidenceParams) Reset() { *m = EvidenceParams{} }
@@ -230,6 +234,13 @@ func (m *EvidenceParams) GetMaxNum() uint32 {
return 0
}
func (m *EvidenceParams) GetProofTrialPeriod() int64 {
if m != nil {
return m.ProofTrialPeriod
}
return 0
}
// ValidatorParams restrict the public key types validators can use.
// NOTE: uses ABCI pubkey naming, not Amino names.
type ValidatorParams struct {
@@ -348,39 +359,41 @@ func init() { proto.RegisterFile("proto/types/params.proto", fileDescriptor_95a9
func init() { golang_proto.RegisterFile("proto/types/params.proto", fileDescriptor_95a9f934fa6f056c) }
var fileDescriptor_95a9f934fa6f056c = []byte{
// 512 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x53, 0x31, 0x6f, 0xd3, 0x40,
0x14, 0xce, 0x61, 0x28, 0xe9, 0x4b, 0xd3, 0xa0, 0x1b, 0xc0, 0x14, 0xc9, 0x89, 0x8c, 0x14, 0x2a,
0x81, 0x6c, 0x09, 0x36, 0x96, 0x0a, 0x03, 0x6a, 0x51, 0x95, 0x08, 0x59, 0x88, 0xa1, 0x8b, 0x75,
0x8e, 0x0f, 0xc7, 0x6a, 0xce, 0x67, 0xf9, 0xee, 0xaa, 0xf8, 0x5f, 0x30, 0x32, 0x76, 0x41, 0xe2,
0x27, 0x30, 0x32, 0x76, 0xec, 0xc8, 0x04, 0x28, 0x59, 0xe0, 0x5f, 0x20, 0x9f, 0x63, 0x9c, 0x54,
0x74, 0xbb, 0x7b, 0xef, 0xfb, 0xbe, 0x7b, 0xdf, 0xf7, 0x6c, 0x30, 0xb3, 0x9c, 0x4b, 0xee, 0xca,
0x22, 0xa3, 0xc2, 0xcd, 0x48, 0x4e, 0x98, 0x70, 0x74, 0x09, 0xdf, 0x95, 0x34, 0x8d, 0x68, 0xce,
0x92, 0x54, 0x56, 0x15, 0x47, 0x83, 0xf6, 0x86, 0x72, 0x9a, 0xe4, 0x51, 0x90, 0x91, 0x5c, 0x16,
0x6e, 0xc5, 0x8e, 0x79, 0xcc, 0x9b, 0x53, 0x85, 0xde, 0xb3, 0x62, 0xce, 0xe3, 0x19, 0xad, 0x20,
0xa1, 0xfa, 0xe0, 0x46, 0x2a, 0x27, 0x32, 0xe1, 0x69, 0xd5, 0xb7, 0xff, 0x20, 0xe8, 0xbd, 0xe4,
0xa9, 0xa0, 0xa9, 0x50, 0xe2, 0xad, 0x7e, 0x19, 0x1f, 0xc0, 0xad, 0x70, 0xc6, 0x27, 0xa7, 0x26,
0x1a, 0xa0, 0xfd, 0xce, 0xd3, 0x87, 0xce, 0xff, 0x67, 0x70, 0xbc, 0x12, 0x54, 0x71, 0xbc, 0x9b,
0x17, 0x3f, 0xfa, 0x2d, 0xbf, 0xe2, 0xe1, 0x23, 0x68, 0xd3, 0xb3, 0x24, 0xa2, 0xe9, 0x84, 0x9a,
0x37, 0xb4, 0xc6, 0xf0, 0x3a, 0x8d, 0xd7, 0x2b, 0xdc, 0x86, 0xcc, 0x3f, 0x36, 0x3e, 0x86, 0xed,
0x33, 0x32, 0x4b, 0x22, 0x22, 0x79, 0x6e, 0x1a, 0x5a, 0xea, 0xd1, 0x75, 0x52, 0xef, 0x6b, 0xe0,
0x86, 0x56, 0xc3, 0xb7, 0x29, 0x74, 0xd6, 0x46, 0xc6, 0x0f, 0x60, 0x9b, 0x91, 0x79, 0x10, 0x16,
0x92, 0x0a, 0x6d, 0xd5, 0xf0, 0xdb, 0x8c, 0xcc, 0xbd, 0xf2, 0x8e, 0xef, 0xc1, 0xed, 0xb2, 0x19,
0x13, 0xa1, 0x1d, 0x18, 0xfe, 0x16, 0x23, 0xf3, 0x43, 0x22, 0xf0, 0x00, 0x76, 0x64, 0xc2, 0x68,
0x90, 0x70, 0x49, 0x02, 0x26, 0xf4, 0x50, 0x86, 0x0f, 0x65, 0xed, 0x0d, 0x97, 0x64, 0x24, 0xec,
0xcf, 0x08, 0x76, 0x37, 0x6d, 0xe1, 0xc7, 0x80, 0x4b, 0x35, 0x12, 0xd3, 0x20, 0x55, 0x2c, 0xd0,
0x29, 0xd5, 0x6f, 0xf6, 0x18, 0x99, 0xbf, 0x88, 0xe9, 0x58, 0x31, 0x3d, 0x9c, 0xc0, 0x23, 0xb8,
0x53, 0x83, 0xeb, 0x65, 0xad, 0x52, 0xbc, 0xef, 0x54, 0xdb, 0x74, 0xea, 0x6d, 0x3a, 0xaf, 0x56,
0x00, 0xaf, 0x5d, 0x9a, 0xfd, 0xf4, 0xb3, 0x8f, 0xfc, 0xdd, 0x4a, 0xaf, 0xee, 0xd4, 0x4e, 0x52,
0xc5, 0xf4, 0xac, 0x5d, 0xed, 0x64, 0xac, 0x98, 0x7d, 0x00, 0xbd, 0x2b, 0x91, 0x61, 0x1b, 0xba,
0x99, 0x0a, 0x83, 0x53, 0x5a, 0x04, 0x3a, 0x53, 0x13, 0x0d, 0x8c, 0xfd, 0x6d, 0xbf, 0x93, 0xa9,
0xf0, 0x98, 0x16, 0xef, 0xca, 0xd2, 0xf3, 0xf6, 0xd7, 0xf3, 0x3e, 0xfa, 0x7d, 0xde, 0x47, 0xf6,
0x09, 0xec, 0x1c, 0x11, 0x31, 0xa5, 0xd1, 0x8a, 0x3d, 0x84, 0x9e, 0x76, 0x16, 0x5c, 0x8d, 0xb5,
0xab, 0xcb, 0xa3, 0x3a, 0x5b, 0x1b, 0xba, 0x0d, 0xae, 0x49, 0xb8, 0x53, 0xa3, 0x0e, 0x89, 0xf0,
0xc6, 0x5f, 0x16, 0x16, 0xba, 0x58, 0x58, 0xe8, 0x72, 0x61, 0xa1, 0x5f, 0x0b, 0x0b, 0x7d, 0x5c,
0x5a, 0xad, 0x6f, 0x4b, 0x0b, 0x5d, 0x2e, 0xad, 0xd6, 0xf7, 0xa5, 0xd5, 0x3a, 0x79, 0x12, 0x27,
0x72, 0xaa, 0x42, 0x67, 0xc2, 0x99, 0xdb, 0x7c, 0x11, 0xeb, 0xc7, 0xb5, 0x9f, 0x2a, 0xdc, 0xd2,
0x97, 0x67, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x66, 0x2c, 0xc5, 0x1a, 0x6a, 0x03, 0x00, 0x00,
// 540 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x53, 0xbf, 0x6f, 0xd3, 0x40,
0x18, 0xcd, 0x91, 0x52, 0x92, 0x4b, 0xd3, 0x54, 0x37, 0x80, 0x29, 0x92, 0x13, 0x19, 0x29, 0x54,
0xa2, 0x72, 0x24, 0xd8, 0x58, 0x2a, 0x02, 0xa8, 0x45, 0x55, 0xa2, 0xca, 0xaa, 0x18, 0xba, 0x9c,
0xce, 0xf1, 0xd5, 0x39, 0x35, 0xe7, 0xb3, 0xee, 0x47, 0x95, 0xfc, 0x17, 0x8c, 0x8c, 0x1d, 0xf9,
0x13, 0x18, 0x19, 0x3b, 0x56, 0x62, 0x61, 0x02, 0x94, 0x2c, 0xf0, 0x5f, 0x20, 0x9f, 0x63, 0x9c,
0x54, 0x74, 0xbb, 0xfb, 0xbe, 0xf7, 0xbd, 0x7b, 0xef, 0x7b, 0x36, 0x74, 0x52, 0x29, 0xb4, 0xe8,
0xe9, 0x59, 0x4a, 0x55, 0x2f, 0x25, 0x92, 0x70, 0xe5, 0xdb, 0x12, 0x7a, 0xa8, 0x69, 0x12, 0x51,
0xc9, 0x59, 0xa2, 0xf3, 0x8a, 0x6f, 0x41, 0xbb, 0x5d, 0x3d, 0x66, 0x32, 0xc2, 0x29, 0x91, 0x7a,
0xd6, 0xcb, 0xa7, 0x63, 0x11, 0x8b, 0xf2, 0x94, 0xa3, 0x77, 0xdd, 0x58, 0x88, 0x78, 0x42, 0x73,
0x48, 0x68, 0xce, 0x7b, 0x91, 0x91, 0x44, 0x33, 0x91, 0xe4, 0x7d, 0xef, 0x0f, 0x80, 0xad, 0x37,
0x22, 0x51, 0x34, 0x51, 0x46, 0x9d, 0xd8, 0x97, 0xd1, 0x01, 0xbc, 0x1f, 0x4e, 0xc4, 0xe8, 0xc2,
0x01, 0x1d, 0xb0, 0xd7, 0x78, 0xf1, 0xd4, 0xff, 0xbf, 0x06, 0xbf, 0x9f, 0x81, 0xf2, 0x99, 0xfe,
0xc6, 0xf5, 0x8f, 0x76, 0x25, 0xc8, 0xe7, 0xd0, 0x11, 0xac, 0xd1, 0x4b, 0x16, 0xd1, 0x64, 0x44,
0x9d, 0x7b, 0x96, 0xa3, 0x7b, 0x17, 0xc7, 0xbb, 0x25, 0x6e, 0x8d, 0xe6, 0xdf, 0x34, 0x3a, 0x86,
0xf5, 0x4b, 0x32, 0x61, 0x11, 0xd1, 0x42, 0x3a, 0x55, 0x4b, 0xf5, 0xec, 0x2e, 0xaa, 0x0f, 0x05,
0x70, 0x8d, 0xab, 0x9c, 0xf7, 0x28, 0x6c, 0xac, 0x48, 0x46, 0x4f, 0x60, 0x9d, 0x93, 0x29, 0x0e,
0x67, 0x9a, 0x2a, 0x6b, 0xb5, 0x1a, 0xd4, 0x38, 0x99, 0xf6, 0xb3, 0x3b, 0x7a, 0x04, 0x1f, 0x64,
0xcd, 0x98, 0x28, 0xeb, 0xa0, 0x1a, 0x6c, 0x72, 0x32, 0x3d, 0x24, 0x0a, 0x75, 0xe0, 0x96, 0x66,
0x9c, 0x62, 0x26, 0x34, 0xc1, 0x5c, 0x59, 0x51, 0xd5, 0x00, 0x66, 0xb5, 0xf7, 0x42, 0x93, 0x81,
0xf2, 0xbe, 0x01, 0xb8, 0xbd, 0x6e, 0x0b, 0x3d, 0x87, 0x28, 0x63, 0x23, 0x31, 0xc5, 0x89, 0xe1,
0xd8, 0x6e, 0xa9, 0x78, 0xb3, 0xc5, 0xc9, 0xf4, 0x75, 0x4c, 0x87, 0x86, 0x5b, 0x71, 0x0a, 0x0d,
0xe0, 0x4e, 0x01, 0x2e, 0xc2, 0x5a, 0x6e, 0xf1, 0xb1, 0x9f, 0xa7, 0xe9, 0x17, 0x69, 0xfa, 0x6f,
0x97, 0x80, 0x7e, 0x2d, 0x33, 0xfb, 0xe9, 0x67, 0x1b, 0x04, 0xdb, 0x39, 0x5f, 0xd1, 0x29, 0x9c,
0x24, 0x86, 0x5b, 0xad, 0x4d, 0xeb, 0x64, 0x68, 0x38, 0xda, 0x87, 0x28, 0x95, 0x42, 0x9c, 0x63,
0x2d, 0x19, 0x99, 0xe0, 0x94, 0x4a, 0x26, 0x22, 0x67, 0xc3, 0x8a, 0xda, 0xb1, 0x9d, 0xd3, 0xac,
0x71, 0x62, 0xeb, 0xde, 0x01, 0x6c, 0xdd, 0x5a, 0x30, 0xf2, 0x60, 0x33, 0x35, 0x21, 0xbe, 0xa0,
0x33, 0x6c, 0x13, 0x70, 0x40, 0xa7, 0xba, 0x57, 0x0f, 0x1a, 0xa9, 0x09, 0x8f, 0xe9, 0xec, 0x34,
0x2b, 0xbd, 0xaa, 0x7d, 0xb9, 0x6a, 0x83, 0xdf, 0x57, 0x6d, 0xe0, 0x9d, 0xc1, 0xad, 0x23, 0xa2,
0xc6, 0x34, 0x5a, 0x4e, 0x77, 0x61, 0xcb, 0xee, 0x01, 0xdf, 0x0e, 0xa1, 0x69, 0xcb, 0x83, 0x22,
0x09, 0x0f, 0x36, 0x4b, 0x5c, 0x99, 0x47, 0xa3, 0x40, 0x1d, 0x12, 0xd5, 0x1f, 0x7e, 0x9e, 0xbb,
0xe0, 0x7a, 0xee, 0x82, 0x9b, 0xb9, 0x0b, 0x7e, 0xcd, 0x5d, 0xf0, 0x71, 0xe1, 0x56, 0xbe, 0x2e,
0x5c, 0x70, 0xb3, 0x70, 0x2b, 0xdf, 0x17, 0x6e, 0xe5, 0x6c, 0x3f, 0x66, 0x7a, 0x6c, 0x42, 0x7f,
0x24, 0x78, 0xaf, 0xfc, 0x7e, 0x56, 0x8f, 0x2b, 0xbf, 0x60, 0xb8, 0x69, 0x2f, 0x2f, 0xff, 0x06,
0x00, 0x00, 0xff, 0xff, 0x5d, 0x39, 0x60, 0xf5, 0x98, 0x03, 0x00, 0x00,
}
func (this *ConsensusParams) Equal(that interface{}) bool {
@@ -471,6 +484,9 @@ func (this *EvidenceParams) Equal(that interface{}) bool {
if this.MaxNum != that1.MaxNum {
return false
}
if this.ProofTrialPeriod != that1.ProofTrialPeriod {
return false
}
return true
}
func (this *ValidatorParams) Equal(that interface{}) bool {
@@ -640,6 +656,11 @@ func (m *EvidenceParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if m.ProofTrialPeriod != 0 {
i = encodeVarintParams(dAtA, i, uint64(m.ProofTrialPeriod))
i--
dAtA[i] = 0x20
}
if m.MaxNum != 0 {
i = encodeVarintParams(dAtA, i, uint64(m.MaxNum))
i--
@@ -868,6 +889,9 @@ func (m *EvidenceParams) Size() (n int) {
if m.MaxNum != 0 {
n += 1 + sovParams(uint64(m.MaxNum))
}
if m.ProofTrialPeriod != 0 {
n += 1 + sovParams(uint64(m.ProofTrialPeriod))
}
return n
}
@@ -1269,6 +1293,25 @@ func (m *EvidenceParams) Unmarshal(dAtA []byte) error {
break
}
}
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ProofTrialPeriod", wireType)
}
m.ProofTrialPeriod = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowParams
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ProofTrialPeriod |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipParams(dAtA[iNdEx:])

5
proto/types/params.proto
View File

@@ -52,6 +52,11 @@ message EvidenceParams {
// each evidence (See MaxEvidenceBytes). The maximum number is MaxEvidencePerBlock.
// Default is 50
uint32 max_num = 3;
// Proof trial period dictates the time given for nodes accused of amnesia evidence, incorrectly
// voting twice in two different rounds to respond with their respective proofs.
// Default is half the max age in blocks: 50,000
int64 proof_trial_period = 4;
}
// ValidatorParams restrict the public key types validators can use.

4
state/store_test.go
View File

@@ -12,7 +12,9 @@ import (
abci "github.com/tendermint/tendermint/abci/types"
cfg "github.com/tendermint/tendermint/config"
"github.com/tendermint/tendermint/crypto"
"github.com/tendermint/tendermint/crypto/ed25519"
tmrand "github.com/tendermint/tendermint/libs/rand"
tmstate "github.com/tendermint/tendermint/proto/state"
tmproto "github.com/tendermint/tendermint/proto/types"
sm "github.com/tendermint/tendermint/state"
@@ -99,7 +101,7 @@ func TestPruneStates(t *testing.T) {
// Generate a bunch of state data. Validators change for heights ending with 3, and
// parameters when ending with 5.
validator := &types.Validator{Address: []byte{1, 2, 3}, VotingPower: 100, PubKey: pk}
validator := &types.Validator{Address: tmrand.Bytes(crypto.AddressSize), VotingPower: 100, PubKey: pk}
validatorSet := &types.ValidatorSet{
Validators: []*types.Validator{validator},
Proposer: validator,

31
state/validation.go
View File

@@ -142,6 +142,16 @@ func validateBlock(evidencePool EvidencePool, stateDB dbm.DB, state State, block
continue
}
}
// if we don't already have amnesia evidence we need to add it to start our own timer unless
// a) a valid polc has already been attached
// b) the accused node voted back on an earlier round
if ae, ok := ev.(types.AmnesiaEvidence); ok && ae.Polc.IsAbsent() && ae.PotentialAmnesiaEvidence.VoteA.Round <
ae.PotentialAmnesiaEvidence.VoteB.Round {
if err := evidencePool.AddEvidence(ae); err != nil {
return types.NewErrEvidenceInvalid(ev,
fmt.Errorf("unknown amnesia evidence, trying to add to evidence pool, err: %w", err))
}
}
var header *types.Header
if _, ok := ev.(*types.LunaticValidatorEvidence); ok {
@@ -154,6 +164,7 @@ func validateBlock(evidencePool EvidencePool, stateDB dbm.DB, state State, block
if err := VerifyEvidence(stateDB, state, ev, header); err != nil {
return types.NewErrEvidenceInvalid(ev, err)
}
}
// NOTE: We can't actually verify it's the right proposer because we dont
@@ -197,7 +208,7 @@ func VerifyEvidence(stateDB dbm.DB, state State, evidence types.Evidence, commit
state.LastBlockTime.Add(evidenceParams.MaxAgeDuration),
)
}
if ev, ok := evidence.(*types.LunaticValidatorEvidence); ok {
if ev, ok := evidence.(types.LunaticValidatorEvidence); ok {
if err := ev.VerifyHeader(committedHeader); err != nil {
return err
}
@@ -216,7 +227,9 @@ func VerifyEvidence(stateDB dbm.DB, state State, evidence types.Evidence, commit
// For PhantomValidatorEvidence, check evidence.Address was not part of the
// validator set at height evidence.Height, but was a validator before OR
// after.
if phve, ok := evidence.(*types.PhantomValidatorEvidence); ok {
if phve, ok := evidence.(types.PhantomValidatorEvidence); ok {
// confirm that it hasn't been forged
_, val = valset.GetByAddress(addr)
if val != nil {
return fmt.Errorf("address %X was a validator at height %d", addr, evidence.Height())
@@ -224,9 +237,9 @@ func VerifyEvidence(stateDB dbm.DB, state State, evidence types.Evidence, commit
// check if last height validator was in the validator set is within
// MaxAgeNumBlocks.
if ageNumBlocks > 0 && phve.LastHeightValidatorWasInSet <= ageNumBlocks {
if height-phve.LastHeightValidatorWasInSet > evidenceParams.MaxAgeNumBlocks {
return fmt.Errorf("last time validator was in the set at height %d, min: %d",
phve.LastHeightValidatorWasInSet, ageNumBlocks+1)
phve.LastHeightValidatorWasInSet, height-phve.LastHeightValidatorWasInSet)
}
valset, err := LoadValidators(stateDB, phve.LastHeightValidatorWasInSet)
@@ -240,6 +253,16 @@ func VerifyEvidence(stateDB dbm.DB, state State, evidence types.Evidence, commit
return fmt.Errorf("phantom validator %X not found", addr)
}
} else {
if ae, ok := evidence.(types.AmnesiaEvidence); ok {
// check the validator set against the polc to make sure that a majority of valid votes was reached
if !ae.Polc.IsAbsent() {
err = ae.Polc.ValidateVotes(valset, state.ChainID)
if err != nil {
return fmt.Errorf("amnesia evidence contains invalid polc, err: %w", err)
}
}
}
// For all other types, expect evidence.Address to be a validator at height
// evidence.Height.
_, val = valset.GetByAddress(addr)

283
state/validation_test.go
View File

@@ -1,16 +1,22 @@
package state_test
import (
"fmt"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto"
"github.com/tendermint/tendermint/libs/bytes"
"github.com/tendermint/tendermint/proto/version"
"github.com/tendermint/tendermint/crypto/ed25519"
"github.com/tendermint/tendermint/crypto/tmhash"
"github.com/tendermint/tendermint/libs/log"
memmock "github.com/tendermint/tendermint/mempool/mock"
protostate "github.com/tendermint/tendermint/proto/state"
tmproto "github.com/tendermint/tendermint/proto/types"
sm "github.com/tendermint/tendermint/state"
"github.com/tendermint/tendermint/state/mocks"
@@ -285,8 +291,8 @@ func TestValidateFailBlockOnCommittedEvidence(t *testing.T) {
block.EvidenceHash = block.Evidence.Hash()
err := blockExec.ValidateBlock(state, block)
require.Error(t, err)
require.IsType(t, err, &types.ErrEvidenceInvalid{})
assert.Error(t, err)
assert.IsType(t, err, &types.ErrEvidenceInvalid{})
}
func TestValidateAlreadyPendingEvidence(t *testing.T) {
@@ -314,7 +320,7 @@ func TestValidateAlreadyPendingEvidence(t *testing.T) {
block.EvidenceHash = block.Evidence.Hash()
err := blockExec.ValidateBlock(state, block)
require.NoError(t, err)
assert.NoError(t, err)
}
func TestValidateDuplicateEvidenceShouldFail(t *testing.T) {
@@ -336,5 +342,274 @@ func TestValidateDuplicateEvidenceShouldFail(t *testing.T) {
block.EvidenceHash = block.Evidence.Hash()
err := blockExec.ValidateBlock(state, block)
require.Error(t, err)
assert.Error(t, err)
}
var blockID = types.BlockID{
Hash: []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
PartsHeader: types.PartSetHeader{
Total: 1,
Hash: []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
},
}
func TestValidateAmnesiaEvidence(t *testing.T) {
var height int64 = 1
state, stateDB, vals := makeState(1, int(height))
addr, val := state.Validators.GetByIndex(0)
voteA := makeVote(height, 1, 0, addr, blockID)
err := vals[val.Address.String()].SignVote(chainID, voteA)
require.NoError(t, err)
voteB := makeVote(height, 2, 0, addr, types.BlockID{})
err = vals[val.Address.String()].SignVote(chainID, voteB)
require.NoError(t, err)
ae := types.AmnesiaEvidence{
PotentialAmnesiaEvidence: types.PotentialAmnesiaEvidence{
VoteA: voteA,
VoteB: voteB,
},
Polc: types.EmptyPOLC(),
}
evpool := &mocks.EvidencePool{}
evpool.On("IsPending", ae).Return(false)
evpool.On("IsCommitted", ae).Return(false)
evpool.On("AddEvidence", ae).Return(fmt.Errorf("test error"))
blockExec := sm.NewBlockExecutor(
stateDB, log.TestingLogger(),
nil,
nil,
evpool)
// A block with a couple pieces of evidence passes.
block := makeBlock(state, height)
block.Evidence.Evidence = []types.Evidence{ae}
block.EvidenceHash = block.Evidence.Hash()
err = blockExec.ValidateBlock(state, block)
errMsg := "Invalid evidence: unknown amnesia evidence, trying to add to evidence pool, err: test error"
if assert.Error(t, err) {
assert.Equal(t, err.Error()[:len(errMsg)], errMsg)
}
}
func TestVerifyEvidenceWrongAddress(t *testing.T) {
var height int64 = 1
state, stateDB, _ := makeState(1, int(height))
randomAddr := []byte("wrong address")
ev := types.NewMockEvidence(height, defaultTestTime, randomAddr)
blockExec := sm.NewBlockExecutor(
stateDB, log.TestingLogger(),
nil,
nil,
sm.MockEvidencePool{})
// A block with a couple pieces of evidence passes.
block := makeBlock(state, height)
block.Evidence.Evidence = []types.Evidence{ev}
block.EvidenceHash = block.Evidence.Hash()
err := blockExec.ValidateBlock(state, block)
errMsg := "Invalid evidence: address 77726F6E672061646472657373 was not a validator at height 1"
if assert.Error(t, err) {
assert.Equal(t, err.Error()[:len(errMsg)], errMsg)
}
}
func TestVerifyEvidenceExpiredEvidence(t *testing.T) {
var height int64 = 4
state, stateDB, _ := makeState(1, int(height))
state.ConsensusParams.Evidence.MaxAgeNumBlocks = 1
addr, _ := state.Validators.GetByIndex(0)
ev := types.NewMockEvidence(1, defaultTestTime, addr)
err := sm.VerifyEvidence(stateDB, state, ev, nil)
errMsg := "evidence from height 1 (created at: 2019-01-01 00:00:00 +0000 UTC) is too old"
if assert.Error(t, err) {
assert.Equal(t, err.Error()[:len(errMsg)], errMsg)
}
}
func TestVerifyEvidenceWithAmnesiaEvidence(t *testing.T) {
var height int64 = 1
state, stateDB, vals := makeState(4, int(height))
addr, val := state.Validators.GetByIndex(0)
addr2, val2 := state.Validators.GetByIndex(1)
voteA := makeVote(height, 1, 0, addr, types.BlockID{})
err := vals[val.Address.String()].SignVote(chainID, voteA)
require.NoError(t, err)
voteB := makeVote(height, 2, 0, addr, blockID)
err = vals[val.Address.String()].SignVote(chainID, voteB)
require.NoError(t, err)
voteC := makeVote(height, 2, 1, addr2, blockID)
err = vals[val2.Address.String()].SignVote(chainID, voteC)
require.NoError(t, err)
//var ae types.Evidence
badAe := types.AmnesiaEvidence{
PotentialAmnesiaEvidence: types.PotentialAmnesiaEvidence{
VoteA: voteA,
VoteB: voteB,
},
Polc: types.ProofOfLockChange{
Votes: []types.Vote{*voteC},
PubKey: val.PubKey,
},
}
err = sm.VerifyEvidence(stateDB, state, badAe, nil)
if assert.Error(t, err) {
assert.Equal(t, err.Error(), "amnesia evidence contains invalid polc, err: "+
"invalid commit -- insufficient voting power: got 1000, needed more than 2667")
}
addr3, val3 := state.Validators.GetByIndex(2)
voteD := makeVote(height, 2, 2, addr3, blockID)
err = vals[val3.Address.String()].SignVote(chainID, voteD)
require.NoError(t, err)
addr4, val4 := state.Validators.GetByIndex(3)
voteE := makeVote(height, 2, 3, addr4, blockID)
err = vals[val4.Address.String()].SignVote(chainID, voteE)
require.NoError(t, err)
goodAe := types.AmnesiaEvidence{
PotentialAmnesiaEvidence: types.PotentialAmnesiaEvidence{
VoteA: voteA,
VoteB: voteB,
},
Polc: types.ProofOfLockChange{
Votes: []types.Vote{*voteC, *voteD, *voteE},
PubKey: val.PubKey,
},
}
err = sm.VerifyEvidence(stateDB, state, goodAe, nil)
assert.NoError(t, err)
goodAe = types.AmnesiaEvidence{
PotentialAmnesiaEvidence: types.PotentialAmnesiaEvidence{
VoteA: voteA,
VoteB: voteB,
},
Polc: types.EmptyPOLC(),
}
err = sm.VerifyEvidence(stateDB, state, goodAe, nil)
assert.NoError(t, err)
}
func TestVerifyEvidenceWithLunaticValidatorEvidence(t *testing.T) {
state, stateDB, vals := makeState(4, 4)
state.ConsensusParams.Evidence.MaxAgeNumBlocks = 1
addr, val := state.Validators.GetByIndex(0)
h := &types.Header{
Version: version.Consensus{Block: 1, App: 2},
ChainID: chainID,
Height: 3,
Time: defaultTestTime,
LastBlockID: blockID,
LastCommitHash: tmhash.Sum([]byte("last_commit_hash")),
DataHash: tmhash.Sum([]byte("data_hash")),
ValidatorsHash: tmhash.Sum([]byte("validators_hash")),
NextValidatorsHash: tmhash.Sum([]byte("next_validators_hash")),
ConsensusHash: tmhash.Sum([]byte("consensus_hash")),
AppHash: tmhash.Sum([]byte("app_hash")),
LastResultsHash: tmhash.Sum([]byte("last_results_hash")),
EvidenceHash: tmhash.Sum([]byte("evidence_hash")),
ProposerAddress: crypto.AddressHash([]byte("proposer_address")),
}
vote := makeVote(3, 1, 0, addr, blockID)
err := vals[val.Address.String()].SignVote(chainID, vote)
require.NoError(t, err)
ev := types.LunaticValidatorEvidence{
Header: h,
Vote: vote,
InvalidHeaderField: "ConsensusHash",
}
err = ev.ValidateBasic()
require.NoError(t, err)
err = sm.VerifyEvidence(stateDB, state, ev, h)
if assert.Error(t, err) {
assert.Equal(t, "ConsensusHash matches committed hash", err.Error())
}
}
func TestVerifyEvidenceWithPhantomValidatorEvidence(t *testing.T) {
state, stateDB, vals := makeState(4, 4)
state.ConsensusParams.Evidence.MaxAgeNumBlocks = 1
addr, val := state.Validators.GetByIndex(0)
vote := makeVote(3, 1, 0, addr, blockID)
err := vals[val.Address.String()].SignVote(chainID, vote)
require.NoError(t, err)
ev := types.PhantomValidatorEvidence{
Vote: vote,
LastHeightValidatorWasInSet: 1,
}
err = ev.ValidateBasic()
require.NoError(t, err)
err = sm.VerifyEvidence(stateDB, state, ev, nil)
if assert.Error(t, err) {
assert.Equal(t, "address 576585A00DD4D58318255611D8AAC60E8E77CB32 was a validator at height 3", err.Error())
}
privVal := types.NewMockPV()
pubKey, _ := privVal.GetPubKey()
vote2 := makeVote(3, 1, 0, pubKey.Address(), blockID)
err = privVal.SignVote(chainID, vote2)
require.NoError(t, err)
ev = types.PhantomValidatorEvidence{
Vote: vote2,
LastHeightValidatorWasInSet: 1,
}
err = ev.ValidateBasic()
assert.NoError(t, err)
err = sm.VerifyEvidence(stateDB, state, ev, nil)
if assert.Error(t, err) {
assert.Equal(t, "last time validator was in the set at height 1, min: 2", err.Error())
}
ev = types.PhantomValidatorEvidence{
Vote: vote2,
LastHeightValidatorWasInSet: 2,
}
err = ev.ValidateBasic()
assert.NoError(t, err)
err = sm.VerifyEvidence(stateDB, state, ev, nil)
errMsg := "phantom validator"
if assert.Error(t, err) {
assert.Equal(t, errMsg, err.Error()[:len(errMsg)])
}
vals2, err := sm.LoadValidators(stateDB, 2)
require.NoError(t, err)
vals2.Validators = append(vals2.Validators, types.NewValidator(pubKey, 1000))
valKey := []byte("validatorsKey:2")
protoVals, err := vals2.ToProto()
require.NoError(t, err)
valInfo := &protostate.ValidatorsInfo{
LastHeightChanged: 2,
ValidatorSet: protoVals,
}
bz, err := valInfo.Marshal()
require.NoError(t, err)
stateDB.Set(valKey, bz)
ev = types.PhantomValidatorEvidence{
Vote: vote2,
LastHeightValidatorWasInSet: 2,
}
err = ev.ValidateBasic()
assert.NoError(t, err)
err = sm.VerifyEvidence(stateDB, state, ev, nil)
if !assert.NoError(t, err) {
t.Log(err)
}
}
func makeVote(height int64, round, index int32, addr bytes.HexBytes, blockID types.BlockID) *types.Vote {
return &types.Vote{
Type: tmproto.SignedMsgType(2),
Height: height,
Round: round,
BlockID: blockID,
Timestamp: time.Now(),
ValidatorAddress: addr,
ValidatorIndex: index,
}
}

3
tools/tm-signer-harness/internal/test_harness_test.go
View File

@@ -48,7 +48,8 @@ const (
"evidence": {
"max_age_num_blocks": "100000",
"max_age_duration": "172800000000000",
"max_num_evidence": 50
"max_num": 50,
"proof_trial_period": "50000"
},
"validator": {
"pub_key_types": [

319
types/evidence.go
View File

@@ -165,8 +165,9 @@ func EvidenceToProto(evidence Evidence) (*tmproto.Evidence, error) {
tp := &tmproto.Evidence{
Sum: &tmproto.Evidence_PotentialAmnesiaEvidence{
PotentialAmnesiaEvidence: &tmproto.PotentialAmnesiaEvidence{
VoteA: voteA,
VoteB: voteB,
VoteA: voteA,
VoteB: voteB,
HeightStamp: evi.HeightStamp,
},
},
}
@@ -179,13 +180,20 @@ func EvidenceToProto(evidence Evidence) (*tmproto.Evidence, error) {
tp := &tmproto.Evidence{
Sum: &tmproto.Evidence_PotentialAmnesiaEvidence{
PotentialAmnesiaEvidence: &tmproto.PotentialAmnesiaEvidence{
VoteA: voteA,
VoteB: voteB,
VoteA: voteA,
VoteB: voteB,
HeightStamp: evi.HeightStamp,
},
},
}
return tp, nil
case AmnesiaEvidence:
return AmnesiaEvidenceToProto(evi)
case *AmnesiaEvidence:
return AmnesiaEvidenceToProto(*evi)
case MockEvidence:
if err := evi.ValidateBasic(); err != nil {
return nil, err
@@ -284,21 +292,24 @@ func EvidenceFromProto(evidence *tmproto.Evidence) (Evidence, error) {
return &tp, tp.ValidateBasic()
case *tmproto.Evidence_PotentialAmnesiaEvidence:
voteA, err := VoteFromProto(evi.PotentialAmnesiaEvidence.GetVoteA())
return PotentialAmnesiaEvidenceFromProto(evi.PotentialAmnesiaEvidence)
case *tmproto.Evidence_AmnesiaEvidence:
pae, err := PotentialAmnesiaEvidenceFromProto(evi.AmnesiaEvidence.PotentialAmnesiaEvidence)
if err != nil {
return nil, err
}
polc, err := ProofOfLockChangeFromProto(evi.AmnesiaEvidence.Polc)
if err != nil {
return nil, err
}
voteB, err := VoteFromProto(evi.PotentialAmnesiaEvidence.GetVoteB())
if err != nil {
return nil, err
}
tp := PotentialAmnesiaEvidence{
VoteA: voteA,
VoteB: voteB,
tp := AmnesiaEvidence{
PotentialAmnesiaEvidence: *pae,
Polc: *polc,
}
return &tp, tp.ValidateBasic()
return tp, tp.ValidateBasic()
case *tmproto.Evidence_MockEvidence:
me := MockEvidence{
EvidenceHeight: evi.MockEvidence.GetEvidenceHeight(),
@@ -328,6 +339,7 @@ func RegisterEvidences(cdc *amino.Codec) {
cdc.RegisterConcrete(&PhantomValidatorEvidence{}, "tendermint/PhantomValidatorEvidence", nil)
cdc.RegisterConcrete(&LunaticValidatorEvidence{}, "tendermint/LunaticValidatorEvidence", nil)
cdc.RegisterConcrete(&PotentialAmnesiaEvidence{}, "tendermint/PotentialAmnesiaEvidence", nil)
cdc.RegisterConcrete(&AmnesiaEvidence{}, "tendermint/AmnesiaEvidence", nil)
}
func init() {
@@ -336,6 +348,7 @@ func init() {
tmjson.RegisterType(&PhantomValidatorEvidence{}, "tendermint/PhantomValidatorEvidence")
tmjson.RegisterType(&LunaticValidatorEvidence{}, "tendermint/LunaticValidatorEvidence")
tmjson.RegisterType(&PotentialAmnesiaEvidence{}, "tendermint/PotentialAmnesiaEvidence")
tmjson.RegisterType(&AmnesiaEvidence{}, "tendermint/AmnesiaEvidence")
}
func RegisterMockEvidences(cdc *amino.Codec) {
@@ -654,10 +667,26 @@ OUTER_LOOP:
} 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(int32(i)),
VoteB: ev.H2.Commit.GetVote(int32(j)),
})
firstVote := ev.H1.Commit.GetVote(int32(i))
secondVote := ev.H2.Commit.GetVote(int32(j))
var newEv PotentialAmnesiaEvidence
if firstVote.Timestamp.Before(secondVote.Timestamp) {
newEv = PotentialAmnesiaEvidence{
VoteA: firstVote,
VoteB: secondVote,
}
} else {
newEv = PotentialAmnesiaEvidence{
VoteA: secondVote,
VoteB: firstVote,
}
}
// has the validator incorrectly voted for a previous round
if newEv.VoteA.Round > newEv.VoteB.Round {
evList = append(evList, MakeAmnesiaEvidence(newEv, EmptyPOLC()))
} else {
evList = append(evList, newEv)
}
}
i++
@@ -1001,9 +1030,16 @@ func (e LunaticValidatorEvidence) VerifyHeader(committedHeader *Header) error {
//-------------------------------------------
// PotentialAmnesiaEvidence is constructed when a validator votes on two different blocks at different rounds
// in the same height. PotentialAmnesiaEvidence can then evolve into AmensiaEvidence if the indicted validator
// is incapable of providing the proof of lock change that validates voting twice in the allotted trial period.
// Heightstamp is used for each node to keep a track of how much time has passed so as to know when the trial period
// is finished and is set when the node first receives the evidence.
type PotentialAmnesiaEvidence struct {
VoteA *Vote `json:"vote_a"`
VoteB *Vote `json:"vote_b"`
HeightStamp int64
}
var _ Evidence = PotentialAmnesiaEvidence{}
@@ -1013,10 +1049,7 @@ func (e PotentialAmnesiaEvidence) Height() int64 {
}
func (e PotentialAmnesiaEvidence) Time() time.Time {
if e.VoteA.Timestamp.Before(e.VoteB.Timestamp) {
return e.VoteA.Timestamp
}
return e.VoteB.Timestamp
return e.VoteA.Timestamp
}
func (e PotentialAmnesiaEvidence) Address() []byte {
@@ -1053,9 +1086,11 @@ func (e PotentialAmnesiaEvidence) Verify(chainID string, pubKey crypto.PubKey) e
func (e PotentialAmnesiaEvidence) Equal(ev Evidence) bool {
switch e2 := ev.(type) {
case PotentialAmnesiaEvidence:
return bytes.Equal(e.Hash(), e2.Hash())
return e.Height() == e2.Height() && e.VoteA.Round == e2.VoteA.Round && e.VoteB.Round == e2.VoteB.Round &&
bytes.Equal(e.Address(), e2.Address())
case *PotentialAmnesiaEvidence:
return bytes.Equal(e.Hash(), e2.Hash())
return e.Height() == e2.Height() && e.VoteA.Round == e2.VoteA.Round && e.VoteB.Round == e2.VoteB.Round &&
bytes.Equal(e.Address(), e2.Address())
default:
return false
}
@@ -1071,10 +1106,6 @@ func (e PotentialAmnesiaEvidence) ValidateBasic() error {
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 ||
@@ -1083,9 +1114,10 @@ func (e PotentialAmnesiaEvidence) ValidateBasic() error {
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)
// Enforce that vote A came before vote B
if e.VoteA.Timestamp.After(e.VoteB.Timestamp) {
return fmt.Errorf("vote A should have a timestamp before vote B, but got %s > %s",
e.VoteA.Timestamp, e.VoteB.Timestamp)
}
// Address must be the same
@@ -1121,6 +1153,21 @@ func (e PotentialAmnesiaEvidence) String() string {
return fmt.Sprintf("PotentialAmnesiaEvidence{VoteA: %v, VoteB: %v}", e.VoteA, e.VoteB)
}
// Primed finds whether the PotentialAmnesiaEvidence is ready to be upgraded to Amnesia Evidence. It is decided if
// either the prosecuted node voted in the past or if the allocated trial period has expired without a proof of lock
// change having been provided.
func (e PotentialAmnesiaEvidence) Primed(trialPeriod, currentHeight int64) bool {
// voted in the past can be instantly punishable
if e.VoteA.Round > e.VoteB.Round {
return true
}
// has the trial period expired
if e.HeightStamp > 0 {
return e.HeightStamp+trialPeriod <= currentHeight
}
return false
}
// 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.
@@ -1151,6 +1198,15 @@ func makePOLCFromVoteSet(voteSet *VoteSet, pubKey crypto.PubKey, blockID BlockID
}
}
// EmptyPOLC returns an empty polc. This is used when no polc has been provided in the allocated trial period time
// and the node now needs to move to upgrading to AmnesiaEvidence and hence uses an empty polc
func EmptyPOLC() ProofOfLockChange {
return ProofOfLockChange{
nil,
nil,
}
}
func (e ProofOfLockChange) Height() int64 {
return e.Votes[0].Height
}
@@ -1178,23 +1234,38 @@ 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 {
// ValidateVotes checks the polc against the validator set of that height. The function makes sure that the polc
// contains a majority of votes and that each
func (e ProofOfLockChange) ValidateVotes(valSet *ValidatorSet, chainID string) error {
if e.IsAbsent() {
return errors.New("polc is empty")
}
talliedVotingPower := int64(0)
votingPowerNeeded := valSet.TotalVotingPower() * 2 / 3
for _, validator := range valSet.Validators {
for _, vote := range e.Votes {
for _, vote := range e.Votes {
exists := false
for _, validator := range valSet.Validators {
if bytes.Equal(validator.Address, vote.ValidatorAddress) {
talliedVotingPower += validator.VotingPower
if talliedVotingPower > votingPowerNeeded {
return true
exists = true
if !validator.PubKey.VerifyBytes(vote.SignBytes(chainID), vote.Signature) {
return fmt.Errorf("cannot verify vote (from validator: %d) against signature: %v",
vote.ValidatorIndex, vote.Signature)
}
talliedVotingPower += validator.VotingPower
}
}
if !exists {
return fmt.Errorf("vote was not from a validator in this set: %v", vote.String())
}
}
return false
if talliedVotingPower <= votingPowerNeeded {
return ErrNotEnoughVotingPowerSigned{
Got: talliedVotingPower,
Needed: votingPowerNeeded + 1,
}
}
return nil
}
func (e ProofOfLockChange) Equal(e2 ProofOfLockChange) bool {
@@ -1203,6 +1274,11 @@ func (e ProofOfLockChange) Equal(e2 ProofOfLockChange) bool {
}
func (e ProofOfLockChange) ValidateBasic() error {
// first check if the polc is absent / empty
if e.IsAbsent() {
return nil
}
if e.PubKey == nil {
return errors.New("missing public key")
}
@@ -1240,7 +1316,7 @@ func (e ProofOfLockChange) ValidateBasic() error {
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)
vote.ValidatorAddress.Bytes(), e.PubKey.Address().Bytes())
}
for i := idx + 1; i < len(e.Votes); i++ {
@@ -1254,10 +1330,18 @@ func (e ProofOfLockChange) ValidateBasic() error {
}
func (e ProofOfLockChange) String() string {
if e.IsAbsent() {
return "Empty ProofOfLockChange"
}
return fmt.Sprintf("ProofOfLockChange {Address: %X, Height: %d, Round: %d", e.Address(), e.Height(),
e.Votes[0].Round)
}
// IsAbsent checks if the polc is empty
func (e ProofOfLockChange) IsAbsent() bool {
return e.Votes == nil && e.PubKey == nil
}
func (e *ProofOfLockChange) ToProto() (*tmproto.ProofOfLockChange, error) {
if e == nil {
return nil, errors.New("nil proof of lock change")
@@ -1265,6 +1349,14 @@ func (e *ProofOfLockChange) ToProto() (*tmproto.ProofOfLockChange, error) {
plc := new(tmproto.ProofOfLockChange)
vpb := make([]*tmproto.Vote, len(e.Votes))
// if absent create empty proto polc
if e.IsAbsent() {
return plc, nil
}
if e.Votes == nil {
return nil, errors.New("polc is not absent but has no votes")
}
for i, v := range e.Votes {
pb := v.ToProto()
if pb != nil {
@@ -1282,12 +1374,105 @@ func (e *ProofOfLockChange) ToProto() (*tmproto.ProofOfLockChange, error) {
return plc, nil
}
// AmnesiaEvidence is the progression of PotentialAmnesiaEvidence and is used to prove an infringement of the
// Tendermint consensus when a validator incorrectly sends a vote in a later round without correctly changing the lock
type AmnesiaEvidence struct {
PotentialAmnesiaEvidence
Polc ProofOfLockChange
}
// Height, Time, Address and Verify functions are all inherited by the PotentialAmnesiaEvidence struct
var _ Evidence = &AmnesiaEvidence{}
var _ Evidence = AmnesiaEvidence{}
func MakeAmnesiaEvidence(pe PotentialAmnesiaEvidence, proof ProofOfLockChange) AmnesiaEvidence {
return AmnesiaEvidence{
pe,
proof,
}
}
func (e AmnesiaEvidence) Equal(ev Evidence) bool {
e2, ok := ev.(AmnesiaEvidence)
if !ok {
return false
}
return e.PotentialAmnesiaEvidence.Equal(e2.PotentialAmnesiaEvidence)
}
func (e AmnesiaEvidence) ValidateBasic() error {
if err := e.PotentialAmnesiaEvidence.ValidateBasic(); err != nil {
return fmt.Errorf("invalid potential amnesia evidence: %w", err)
}
if !e.Polc.IsAbsent() {
if err := e.Polc.ValidateBasic(); err != nil {
return fmt.Errorf("invalid proof of lock change: %w", err)
}
if !bytes.Equal(e.PotentialAmnesiaEvidence.Address(), e.Polc.Address()) {
return fmt.Errorf("validator addresses do not match (%X - %X)", e.PotentialAmnesiaEvidence.Address(),
e.Polc.Address())
}
if e.PotentialAmnesiaEvidence.Height() != e.Polc.Height() {
return fmt.Errorf("heights do not match (%d - %d)", e.PotentialAmnesiaEvidence.Height(),
e.Polc.Height())
}
if e.Polc.Round() <= e.VoteA.Round || e.Polc.Round() > e.VoteB.Round {
return fmt.Errorf("polc must be between %d and %d (inclusive)", e.VoteA.Round+1, e.VoteB.Round)
}
if !e.Polc.BlockID().Equals(e.PotentialAmnesiaEvidence.VoteB.BlockID) && !e.Polc.BlockID().IsZero() {
return fmt.Errorf("polc must be either for a nil block or for the same block as the second vote: %v != %v",
e.Polc.BlockID(), e.PotentialAmnesiaEvidence.VoteB.BlockID)
}
if e.Polc.Time().After(e.PotentialAmnesiaEvidence.VoteB.Timestamp) {
return fmt.Errorf("validator voted again before receiving a majority of votes for the new block: %v is after %v",
e.Polc.Time(), e.PotentialAmnesiaEvidence.VoteB.Timestamp)
}
}
return nil
}
// ViolatedConsensus assess on the basis of the AmensiaEvidence whether the validator has violated the
// Tendermint consensus. Evidence must be validated first (see ValidateBasic).
// We are only interested in proving that the latter of the votes in terms of time was correctly done.
func (e AmnesiaEvidence) ViolatedConsensus() (bool, string) {
// a validator having voted cannot go back and vote on an earlier round
if e.PotentialAmnesiaEvidence.VoteA.Round > e.PotentialAmnesiaEvidence.VoteB.Round {
return true, "validator went back and voted on a previous round"
}
// if empty, then no proof was provided to defend the validators actions
if e.Polc.IsAbsent() {
return true, "no proof of lock was provided"
}
return false, ""
}
func (e AmnesiaEvidence) String() string {
return fmt.Sprintf("AmnesiaEvidence{ %v, polc: %v }", e.PotentialAmnesiaEvidence, e.Polc)
}
func ProofOfLockChangeFromProto(pb *tmproto.ProofOfLockChange) (*ProofOfLockChange, error) {
if pb == nil {
return nil, errors.New("nil proof of lock change")
}
plc := new(ProofOfLockChange)
// check if it is an empty polc
if pb.PubKey == nil && pb.Votes == nil {
return plc, nil
}
if pb.Votes == nil {
return nil, errors.New("proofOfLockChange: is not absent but has no votes")
}
vpb := make([]Vote, len(pb.Votes))
for i, v := range pb.Votes {
vi, err := VoteFromProto(v)
@@ -1298,7 +1483,7 @@ func ProofOfLockChangeFromProto(pb *tmproto.ProofOfLockChange) (*ProofOfLockChan
}
if pb.PubKey == nil {
return nil, errors.New("proofOfLockChange: nil PubKey")
return nil, errors.New("proofOfLockChange: is not abest but has nil PubKey")
}
pk, err := cryptoenc.PubKeyFromProto(*pb.PubKey)
if err != nil {
@@ -1311,6 +1496,54 @@ func ProofOfLockChangeFromProto(pb *tmproto.ProofOfLockChange) (*ProofOfLockChan
return plc, nil
}
func PotentialAmnesiaEvidenceFromProto(pb *tmproto.PotentialAmnesiaEvidence) (*PotentialAmnesiaEvidence, error) {
voteA, err := VoteFromProto(pb.GetVoteA())
if err != nil {
return nil, err
}
voteB, err := VoteFromProto(pb.GetVoteB())
if err != nil {
return nil, err
}
tp := PotentialAmnesiaEvidence{
VoteA: voteA,
VoteB: voteB,
HeightStamp: pb.GetHeightStamp(),
}
return &tp, tp.ValidateBasic()
}
func AmnesiaEvidenceToProto(evi AmnesiaEvidence) (*tmproto.Evidence, error) {
ev, err := EvidenceToProto(evi.PotentialAmnesiaEvidence)
if err != nil {
return nil, err
}
paepb := ev.GetPotentialAmnesiaEvidence()
if paepb == nil {
return nil, errors.New("provided evidence is not potential amnesia evidence")
}
polc, err := evi.Polc.ToProto()
if err != nil {
return nil, err
}
tp := &tmproto.Evidence{
Sum: &tmproto.Evidence_AmnesiaEvidence{
AmnesiaEvidence: &tmproto.AmnesiaEvidence{
PotentialAmnesiaEvidence: paepb,
Polc: polc,
},
},
}
return tp, nil
}
//-----------------------------------------------------------------
// UNSTABLE

166
types/evidence_test.go
View File

@@ -22,27 +22,6 @@ type voteData struct {
var defaultVoteTime = time.Date(2019, 1, 1, 0, 0, 0, 0, time.UTC)
func makeVote(
t *testing.T, val PrivValidator, chainID string, valIndex int32, height int64, round int32, step int, blockID BlockID,
time time.Time) *Vote {
pubKey, err := val.GetPubKey()
require.NoError(t, err)
v := &Vote{
ValidatorAddress: pubKey.Address(),
ValidatorIndex: valIndex,
Height: height,
Round: round,
Type: tmproto.SignedMsgType(step),
Timestamp: time,
BlockID: blockID,
}
err = val.SignVote(chainID, v)
if err != nil {
panic(err)
}
return v
}
func TestEvidence(t *testing.T) {
val := NewMockPV()
val2 := NewMockPV()
@@ -368,8 +347,8 @@ func TestPotentialAmnesiaEvidence(t *testing.T) {
)
ev := &PotentialAmnesiaEvidence{
VoteA: vote2,
VoteB: vote1,
VoteA: vote1,
VoteB: vote2,
}
assert.Equal(t, height, ev.Height())
@@ -391,7 +370,7 @@ func TestPotentialAmnesiaEvidence(t *testing.T) {
func TestProofOfLockChange(t *testing.T) {
const (
chainID = "TestProofOfLockChange"
chainID = "test_chain_id"
height int64 = 37
)
// 1: valid POLC - nothing should fail
@@ -402,9 +381,21 @@ func TestProofOfLockChange(t *testing.T) {
assert.Equal(t, height, polc.Height())
assert.NoError(t, polc.ValidateBasic())
assert.True(t, polc.MajorityOfVotes(valSet))
assert.NoError(t, polc.ValidateVotes(valSet, chainID))
assert.NotEmpty(t, polc.String())
// tamper with one of the votes
polc.Votes[0].Timestamp = time.Now().Add(1 * time.Second)
err = polc.ValidateVotes(valSet, chainID)
t.Log(err)
assert.Error(t, err)
// remove a vote such that majority wasn't reached
polc.Votes = polc.Votes[1:]
err = polc.ValidateVotes(valSet, chainID)
t.Log(err)
assert.Error(t, err)
// test validate basic on a set of bad cases
var badPOLCs []ProofOfLockChange
// 2: node has already voted in next round
@@ -438,6 +429,7 @@ func TestProofOfLockChange(t *testing.T) {
for idx, polc := range badPOLCs {
err := polc.ValidateBasic()
t.Logf("case: %d: %v", idx+2, err)
assert.Error(t, err)
if err == nil {
t.Errorf("test no. %d failed", idx+2)
@@ -446,6 +438,117 @@ func TestProofOfLockChange(t *testing.T) {
}
func TestAmnesiaEvidence(t *testing.T) {
const (
chainID = "test_chain_id"
height int64 = 37
)
voteSet, valSet, privValidators, blockID := buildVoteSet(height, 1, 2, 7, 0, tmproto.PrecommitType)
var (
val = privValidators[7]
pubKey, _ = val.GetPubKey()
blockID2 = makeBlockID(tmhash.Sum([]byte("blockhash2")), math.MaxInt32, tmhash.Sum([]byte("partshash")))
vote1 = makeVote(t, val, chainID, 7, height, 0, 2, blockID2, time.Now())
vote2 = makeVote(t, val, chainID, 7, height, 1, 2, blockID,
time.Now().Add(time.Second))
vote3 = makeVote(t, val, chainID, 7, height, 2, 2, blockID2, time.Now())
polc = makePOLCFromVoteSet(voteSet, pubKey, blockID)
)
require.False(t, polc.IsAbsent())
pe := PotentialAmnesiaEvidence{
VoteA: vote1,
VoteB: vote2,
}
emptyAmnesiaEvidence := MakeAmnesiaEvidence(pe, EmptyPOLC())
assert.NoError(t, emptyAmnesiaEvidence.ValidateBasic())
violated, reason := emptyAmnesiaEvidence.ViolatedConsensus()
if assert.True(t, violated) {
assert.Equal(t, reason, "no proof of lock was provided")
}
assert.NoError(t, emptyAmnesiaEvidence.Verify(chainID, pubKey))
completeAmnesiaEvidence := MakeAmnesiaEvidence(pe, polc)
assert.NoError(t, completeAmnesiaEvidence.ValidateBasic())
violated, reason = completeAmnesiaEvidence.ViolatedConsensus()
if !assert.False(t, violated) {
t.Log(reason)
}
assert.NoError(t, completeAmnesiaEvidence.Verify(chainID, pubKey))
assert.NoError(t, completeAmnesiaEvidence.Polc.ValidateVotes(valSet, chainID))
assert.True(t, completeAmnesiaEvidence.Equal(emptyAmnesiaEvidence))
assert.NotEmpty(t, completeAmnesiaEvidence.Hash())
assert.NotEmpty(t, completeAmnesiaEvidence.Bytes())
pe2 := PotentialAmnesiaEvidence{
VoteA: vote3,
VoteB: vote2,
}
// validator has incorrectly voted for a previous round after voting for a later round
ae := MakeAmnesiaEvidence(pe2, EmptyPOLC())
assert.NoError(t, ae.ValidateBasic())
violated, reason = ae.ViolatedConsensus()
if assert.True(t, violated) {
assert.Equal(t, reason, "validator went back and voted on a previous round")
}
var badAE []AmnesiaEvidence
// 1) Polc is at an incorrect height
voteSet, _, _ = buildVoteSetForBlock(height+1, 1, 2, 7, 0, tmproto.PrecommitType, blockID)
polc = makePOLCFromVoteSet(voteSet, pubKey, blockID)
badAE = append(badAE, MakeAmnesiaEvidence(pe, polc))
// 2) Polc is of a later round
voteSet, _, _ = buildVoteSetForBlock(height, 2, 2, 7, 0, tmproto.PrecommitType, blockID)
polc = makePOLCFromVoteSet(voteSet, pubKey, blockID)
badAE = append(badAE, MakeAmnesiaEvidence(pe, polc))
// 3) Polc has a different public key
voteSet, _, privValidators = buildVoteSetForBlock(height, 1, 2, 7, 0, tmproto.PrecommitType, blockID)
pubKey2, _ := privValidators[7].GetPubKey()
polc = makePOLCFromVoteSet(voteSet, pubKey2, blockID)
badAE = append(badAE, MakeAmnesiaEvidence(pe, polc))
// 4) Polc has a different block ID
voteSet, _, _, blockID = buildVoteSet(height, 1, 2, 7, 0, tmproto.PrecommitType)
polc = makePOLCFromVoteSet(voteSet, pubKey, blockID)
badAE = append(badAE, MakeAmnesiaEvidence(pe, polc))
for idx, ae := range badAE {
t.Log(ae.ValidateBasic())
if !assert.Error(t, ae.ValidateBasic()) {
t.Errorf("test no. %d failed", idx+1)
}
}
}
func makeVote(
t *testing.T, val PrivValidator, chainID string, valIndex int32, height int64, round int32, step int, blockID BlockID,
time time.Time) *Vote {
pubKey, err := val.GetPubKey()
require.NoError(t, err)
v := &Vote{
ValidatorAddress: pubKey.Address(),
ValidatorIndex: valIndex,
Height: height,
Round: round,
Type: tmproto.SignedMsgType(step),
BlockID: blockID,
Timestamp: time,
}
err = val.SignVote(chainID, v)
if err != nil {
panic(err)
}
return v
}
func makeHeaderRandom() *Header {
return &Header{
ChainID: tmrand.Str(12),
@@ -591,24 +694,25 @@ func TestProofOfLockChangeProtoBuf(t *testing.T) {
expErr2 bool
}{
{"failure, empty key", ProofOfLockChange{Votes: []Vote{*v, *v2}}, true, true},
{"failure empty ProofOfLockChange", ProofOfLockChange{}, true, true},
{"failure, empty votes", ProofOfLockChange{PubKey: val3.PrivKey.PubKey()}, true, true},
{"success empty ProofOfLockChange", EmptyPOLC(), false, false},
{"success", ProofOfLockChange{Votes: []Vote{*v, *v2}, PubKey: val3.PrivKey.PubKey()}, false, false},
}
for _, tc := range testCases {
tc := tc
pbpolc, err := tc.polc.ToProto()
if tc.expErr {
require.Error(t, err)
assert.Error(t, err, tc.msg)
} else {
require.NoError(t, err)
assert.NoError(t, err, tc.msg)
}
c, err := ProofOfLockChangeFromProto(pbpolc)
if !tc.expErr2 {
require.NoError(t, err, tc.msg)
require.Equal(t, &tc.polc, c, tc.msg)
assert.NoError(t, err, tc.msg)
assert.Equal(t, &tc.polc, c, tc.msg)
} else {
require.Error(t, err, tc.msg)
assert.Error(t, err, tc.msg)
}
}
}

19
types/params.go
View File

@@ -42,12 +42,13 @@ func DefaultBlockParams() tmproto.BlockParams {
}
}
// DefaultEvidenceParams Params returns a default EvidenceParams.
// DefaultEvidenceParams returns a default EvidenceParams.
func DefaultEvidenceParams() tmproto.EvidenceParams {
return tmproto.EvidenceParams{
MaxAgeNumBlocks: 100000, // 27.8 hrs at 1block/s
MaxAgeDuration: 48 * time.Hour,
MaxNum: 50,
MaxAgeNumBlocks: 100000, // 27.8 hrs at 1block/s
MaxAgeDuration: 48 * time.Hour,
MaxNum: 50,
ProofTrialPeriod: 50000, // half MaxAgeNumBlocks
}
}
@@ -110,6 +111,16 @@ func ValidateConsensusParams(params tmproto.ConsensusParams) error {
int64(params.Evidence.MaxNum)*MaxEvidenceBytes, params.Block.MaxBytes)
}
if params.Evidence.ProofTrialPeriod <= 0 {
return fmt.Errorf("evidenceParams.ProofTrialPeriod must be grater than 0 if provided, Got %v",
params.Evidence.ProofTrialPeriod)
}
if params.Evidence.ProofTrialPeriod >= params.Evidence.MaxAgeNumBlocks {
return fmt.Errorf("evidenceParams.ProofTrialPeriod must be smaller than evidenceParams.MaxAgeNumBlocks, %d > %d",
params.Evidence.ProofTrialPeriod, params.Evidence.MaxAgeDuration)
}
if len(params.Validator.PubKeyTypes) == 0 {
return errors.New("len(Validator.PubKeyTypes) must be greater than 0")
}

31
types/params_test.go
View File

@@ -23,24 +23,24 @@ func TestConsensusParamsValidation(t *testing.T) {
valid bool
}{
// test block params
0: {makeParams(1, 0, 10, 1, 0, valEd25519), true},
1: {makeParams(0, 0, 10, 1, 0, valEd25519), false},
2: {makeParams(47*1024*1024, 0, 10, 1, 0, valEd25519), true},
3: {makeParams(10, 0, 10, 1, 0, valEd25519), true},
4: {makeParams(100*1024*1024, 0, 10, 1, 0, valEd25519), true},
5: {makeParams(101*1024*1024, 0, 10, 1, 0, valEd25519), false},
6: {makeParams(1024*1024*1024, 0, 10, 1, 0, valEd25519), false},
0: {makeParams(1, 0, 10, 2, 0, valEd25519), true},
1: {makeParams(0, 0, 10, 2, 0, valEd25519), false},
2: {makeParams(47*1024*1024, 0, 10, 2, 0, valEd25519), true},
3: {makeParams(10, 0, 10, 2, 0, valEd25519), true},
4: {makeParams(100*1024*1024, 0, 10, 2, 0, valEd25519), true},
5: {makeParams(101*1024*1024, 0, 10, 2, 0, valEd25519), false},
6: {makeParams(1024*1024*1024, 0, 10, 2, 0, valEd25519), false},
7: {makeParams(1024*1024*1024, 0, 10, -1, 0, valEd25519), false},
8: {makeParams(1, 0, -10, 1, 0, valEd25519), false},
8: {makeParams(1, 0, -10, 2, 0, valEd25519), false},
// test evidence params
9: {makeParams(1, 0, 10, 0, 0, valEd25519), false},
10: {makeParams(1, 0, 10, 1, 1, valEd25519), false},
11: {makeParams(1000, 0, 10, 1, 1, valEd25519), true},
10: {makeParams(1, 0, 10, 2, 1, valEd25519), false},
11: {makeParams(1000, 0, 10, 2, 1, valEd25519), true},
12: {makeParams(1, 0, 10, -1, 0, valEd25519), false},
// test no pubkey type provided
13: {makeParams(1, 0, 10, 1, 0, []string{}), false},
13: {makeParams(1, 0, 10, 2, 0, []string{}), false},
// test invalid pubkey type provided
14: {makeParams(1, 0, 10, 1, 0, []string{"potatoes make good pubkeys"}), false},
14: {makeParams(1, 0, 10, 2, 0, []string{"potatoes make good pubkeys"}), false},
}
for i, tc := range testCases {
if tc.valid {
@@ -65,9 +65,10 @@ func makeParams(
TimeIotaMs: blockTimeIotaMs,
},
Evidence: tmproto.EvidenceParams{
MaxAgeNumBlocks: evidenceAge,
MaxAgeDuration: time.Duration(evidenceAge),
MaxNum: maxEvidence,
MaxAgeNumBlocks: evidenceAge,
MaxAgeDuration: time.Duration(evidenceAge),
MaxNum: maxEvidence,
ProofTrialPeriod: 1,
},
Validator: tmproto.ValidatorParams{
PubKeyTypes: pubkeyTypes,

9
types/priv_validator.go
View File

@@ -100,6 +100,15 @@ func (pv MockPV) SignProposal(chainID string, proposal *Proposal) error {
return nil
}
func (pv MockPV) ExtractIntoValidator(votingPower int64) *Validator {
pubKey, _ := pv.GetPubKey()
return &Validator{
Address: pubKey.Address(),
PubKey: pubKey,
VotingPower: votingPower,
}
}
// String returns a string representation of the MockPV.
func (pv MockPV) String() string {
mpv, _ := pv.GetPubKey() // mockPV will never return an error, ignored here

3
types/validator_set.go
View File

@@ -856,6 +856,9 @@ func (vals *ValidatorSet) ToProto() (*tmproto.ValidatorSet, error) {
if vals == nil {
return nil, errors.New("nil validator set") // validator set should never be nil
}
if err := vals.ValidateBasic(); err != nil {
return nil, fmt.Errorf("validator set failed basic: %w", err)
}
vp := new(tmproto.ValidatorSet)
valsProto := make([]*tmproto.Validator, len(vals.Validators))
for i := 0; i < len(vals.Validators); i++ {

17
types/vote_set_test.go
View File

@@ -598,12 +598,21 @@ func TestMakeCommit(t *testing.T) {
}
func buildVoteSet(
height int64,
height int64, round int32, nonVotes, nonNilVotes, nilVotes int,
voteType tmproto.SignedMsgType) (voteSet *VoteSet, valSet *ValidatorSet,
privValidators []PrivValidator, blockID BlockID) {
blockID = makeBlockIDRandom()
voteSet, valSet, privValidators = buildVoteSetForBlock(height, round, nonVotes, nonNilVotes, nilVotes, voteType,
blockID)
return
}
func buildVoteSetForBlock(height int64,
round int32, nonVotes, nonNilVotes, nilVotes int,
voteType tmproto.SignedMsgType) (*VoteSet, *ValidatorSet, []PrivValidator, BlockID) {
voteType tmproto.SignedMsgType, blockID BlockID) (*VoteSet, *ValidatorSet, []PrivValidator) {
valSize := nonVotes + nilVotes + nonNilVotes
voteSet, valSet, privValidators := randVoteSet(height, round, voteType, valSize, 1)
blockID := makeBlockIDRandom()
voteProto := &Vote{
ValidatorAddress: nil,
ValidatorIndex: -1,
@@ -625,5 +634,5 @@ func buildVoteSet(
vote := withValidator(voteProto, addr, int32(i))
_, _ = signAddVote(privValidators[i], withBlockHash(vote, nil), voteSet)
}
return voteSet, valSet, privValidators, blockID
return voteSet, valSet, privValidators
}