Skip to content

Commit

Permalink
feat: remove unused code (#2677)
Browse files Browse the repository at this point in the history
  • Loading branch information
@EclesioMeloJunior
EclesioMeloJunior authored Jul 19, 2022
1 parent 055e5c3 commit b3698d7
Show file tree
Hide file tree
Showing 2 changed files with 0 additions and 212 deletions.
93 changes: 0 additions & 93 deletions lib/grandpa/grandpa.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -753,53 +753,6 @@ func (s *Service) determinePreCommit() (*Vote, error) {
return &pvb, nil
}

// isFinalisable returns true if the round is finalisable, false otherwise.
func (s *Service) isFinalisable(round uint64) (bool, error) {
var pvb Vote
var err error

if round == 0 {
return true, nil
}

s.mapLock.Lock()
v, has := s.preVotedBlock[round]
s.mapLock.Unlock()

if !has {
return false, ErrNoPreVotedBlock
}
pvb = *v

bfc, err := s.getBestFinalCandidate()
if err != nil {
return false, err
}

if bfc == nil {
return false, errors.New("cannot find best final candidate for round")
}

pc, err := s.getTotalVotesForBlock(bfc.Hash, precommit)
if err != nil {
return false, err
}

s.mapLock.Lock()
prevBfc := s.bestFinalCandidate[s.state.round-1]
s.mapLock.Unlock()

if prevBfc == nil {
return false, errors.New("cannot find best final candidate for previous round")
}

if bfc.Number <= pvb.Number && (s.state.round == 0 || prevBfc.Number <= bfc.Number) && pc > s.state.threshold() {
return true, nil
}

return false, nil
}

// finalise finalises the round by setting the best final candidate for this round
func (s *Service) finalise() error {
// get best final candidate
Expand Down Expand Up @@ -983,52 +936,6 @@ func (s *Service) getBestFinalCandidate() (*Vote, error) {
return bfc, nil
}

// isCompletable returns true if the round is completable, false otherwise
func (s *Service) isCompletable() (bool, error) {
// haven't received enough votes, not completable
if uint64(s.lenVotes(precommit)+len(s.pcEquivocations)) <= s.state.threshold() {
return false, nil
}

prevoted, err := s.getPreVotedBlock()
if err != nil {
return false, err
}

votes := s.getVotes(precommit)

// for each block with at least 1 vote that's a descendant of the prevoted block,
// check that (total precommits - total pc equivocations - precommits for that block) >2/3|V|
// ie. there must not be a descendent of the prevotes block that is preferred
for _, v := range votes {
if prevoted.Hash == v.Hash {
continue
}

// check if the current block is a descendant of prevoted block
isDescendant, err := s.blockState.IsDescendantOf(prevoted.Hash, v.Hash)
if err != nil {
return false, err
}

if !isDescendant {
continue
}

c, err := s.getTotalVotesForBlock(v.Hash, precommit)
if err != nil {
return false, err
}

if uint64(len(votes)-len(s.pcEquivocations))-c <= s.state.threshold() {
// round isn't completable
return false, nil
}
}

return true, nil
}

// getPreVotedBlock returns the current pre-voted block B. also known as GRANDPA-GHOST.
// the pre-voted block is the block with the highest block number in the set of all the blocks with
// total votes >2/3 the total number of voters, where the total votes is determined by getTotalVotesForBlock.
Expand Down
119 changes: 0 additions & 119 deletions lib/grandpa/grandpa_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -781,43 +781,6 @@ func TestGetPreVotedBlock_EvenMoreCandidates(t *testing.T) {
require.Equal(t, uint32(4), block.Number)
}

func TestIsCompletable(t *testing.T) {
gs, st := newTestService(t)

branches := map[uint]int{6: 1}
state.AddBlocksToStateWithFixedBranches(t, st.Block, 8, branches)
leaves := gs.blockState.Leaves()

voteA, err := NewVoteFromHash(leaves[0], st.Block)
require.NoError(t, err)
voteB, err := NewVoteFromHash(leaves[1], st.Block)
require.NoError(t, err)

for i, k := range kr.Keys {
voter := k.Public().(*ed25519.PublicKey).AsBytes()

if i < 6 {
gs.prevotes.Store(voter, &SignedVote{
Vote: *voteA,
})
gs.precommits.Store(voter, &SignedVote{
Vote: *voteA,
})
} else {
gs.prevotes.Store(voter, &SignedVote{
Vote: *voteB,
})
gs.precommits.Store(voter, &SignedVote{
Vote: *voteB,
})
}
}

completable, err := gs.isCompletable()
require.NoError(t, err)
require.True(t, completable)
}

func TestFindParentWithNumber(t *testing.T) {
gs, st := newTestService(t)

Expand Down Expand Up @@ -1050,88 +1013,6 @@ func TestDeterminePreVote_WithInvalidPrimaryPreVote(t *testing.T) {
require.Equal(t, gs.head.Hash(), pv.Hash)
}

func TestIsFinalisable_True(t *testing.T) {
gs, st := newTestService(t)

branches := map[uint]int{6: 1}
state.AddBlocksToStateWithFixedBranches(t, st.Block, 8, branches)
leaves := gs.blockState.Leaves()

voteA, err := NewVoteFromHash(leaves[0], st.Block)
require.NoError(t, err)
voteB, err := NewVoteFromHash(leaves[1], st.Block)
require.NoError(t, err)

for i, k := range kr.Keys {
voter := k.Public().(*ed25519.PublicKey).AsBytes()

if i < 6 {
gs.prevotes.Store(voter, &SignedVote{
Vote: *voteA,
})
gs.precommits.Store(voter, &SignedVote{
Vote: *voteA,
})
} else {
gs.prevotes.Store(voter, &SignedVote{
Vote: *voteB,
})
gs.precommits.Store(voter, &SignedVote{
Vote: *voteB,
})
}
}

finalisable, err := gs.isFinalisable(gs.state.round)
require.NoError(t, err)
require.True(t, finalisable)
}

func TestIsFinalisable_False(t *testing.T) {
gs, st := newTestService(t)

branches := map[uint]int{2: 1}
branches[2] = 1
state.AddBlocksToStateWithFixedBranches(t, st.Block, 3, branches)
leaves := gs.blockState.Leaves()

voteA, err := NewVoteFromHash(leaves[0], st.Block)
require.NoError(t, err)
voteB, err := NewVoteFromHash(leaves[1], st.Block)
require.NoError(t, err)

for i, k := range kr.Keys {
voter := k.Public().(*ed25519.PublicKey).AsBytes()

if i < 6 {
gs.prevotes.Store(voter, &SignedVote{
Vote: *voteA,
})
gs.precommits.Store(voter, &SignedVote{
Vote: *voteA,
})
} else {
gs.prevotes.Store(voter, &SignedVote{
Vote: *voteB,
})
gs.precommits.Store(voter, &SignedVote{
Vote: *voteB,
})
}
}

// previous round has finalised block # higher than current, so round is not finalisable
gs.state.round = 1
gs.bestFinalCandidate[0] = &Vote{
Number: 4,
}
gs.preVotedBlock[gs.state.round] = voteA

finalisable, err := gs.isFinalisable(gs.state.round)
require.NoError(t, err)
require.False(t, finalisable)
}

func TestGetGrandpaGHOST_CommonAncestor(t *testing.T) {
gs, st := newTestService(t)

Expand Down

0 comments on commit b3698d7

Please sign in to comment.