refactor: Rename pointer receivers for stateMachine (#3015)

Author: infrmtcs

consensus/tendermint/broadcast.go

@@ -5,54 +5,54 @@ import (
 	"github.com/NethermindEth/juno/utils"
 )
 
-func (t *stateMachine[V, H, A]) sendProposal(value *V) types.Action[V, H, A] {
+func (s *stateMachine[V, H, A]) sendProposal(value *V) types.Action[V, H, A] {
 	proposalMessage := types.Proposal[V, H, A]{
 		MessageHeader: types.MessageHeader[A]{
-			Height: t.state.height,
-			Round:  t.state.round,
-			Sender: t.nodeAddr,
+			Height: s.state.height,
+			Round:  s.state.round,
+			Sender: s.nodeAddr,
 		},
-		ValidRound: t.state.validRound,
+		ValidRound: s.state.validRound,
 		Value:      value,
 	}
 
-	if err := t.db.SetWALEntry(proposalMessage); err != nil && !t.replayMode {
-		t.log.Fatalf("Failed to store propsal in WAL")
+	if err := s.db.SetWALEntry(proposalMessage); err != nil && !s.replayMode {
+		s.log.Fatalf("Failed to store propsal in WAL")
 	}
 
-	t.voteCounter.AddProposal(&proposalMessage)
+	s.voteCounter.AddProposal(&proposalMessage)
 
 	return utils.HeapPtr(types.BroadcastProposal[V, H, A](proposalMessage))
 }
 
-func (t *stateMachine[V, H, A]) setStepAndSendPrevote(id *H) types.Action[V, H, A] {
+func (s *stateMachine[V, H, A]) setStepAndSendPrevote(id *H) types.Action[V, H, A] {
 	vote := types.Prevote[H, A]{
 		MessageHeader: types.MessageHeader[A]{
-			Height: t.state.height,
-			Round:  t.state.round,
-			Sender: t.nodeAddr,
+			Height: s.state.height,
+			Round:  s.state.round,
+			Sender: s.nodeAddr,
 		},
 		ID: id,
 	}
 
-	t.voteCounter.AddPrevote(&vote)
-	t.state.step = types.StepPrevote
+	s.voteCounter.AddPrevote(&vote)
+	s.state.step = types.StepPrevote
 
 	return utils.HeapPtr(types.BroadcastPrevote[H, A](vote))
 }
 
-func (t *stateMachine[V, H, A]) setStepAndSendPrecommit(id *H) types.Action[V, H, A] {
+func (s *stateMachine[V, H, A]) setStepAndSendPrecommit(id *H) types.Action[V, H, A] {
 	vote := types.Precommit[H, A]{
 		MessageHeader: types.MessageHeader[A]{
-			Height: t.state.height,
-			Round:  t.state.round,
-			Sender: t.nodeAddr,
+			Height: s.state.height,
+			Round:  s.state.round,
+			Sender: s.nodeAddr,
 		},
 		ID: id,
 	}
 
-	t.voteCounter.AddPrecommit(&vote)
-	t.state.step = types.StepPrecommit
+	s.voteCounter.AddPrecommit(&vote)
+	s.state.step = types.StepPrecommit
 
 	return utils.HeapPtr(types.BroadcastPrecommit[H, A](vote))
 }

consensus/tendermint/process.go

@@ -2,77 +2,77 @@ package tendermint
 
 import "github.com/NethermindEth/juno/consensus/types"
 
-func (t *stateMachine[V, H, A]) ProcessStart(round types.Round) []types.Action[V, H, A] {
-	return t.processLoop(t.startRound(round), nil)
+func (s *stateMachine[V, H, A]) ProcessStart(round types.Round) []types.Action[V, H, A] {
+	return s.processLoop(s.startRound(round), nil)
 }
 
-func (t *stateMachine[V, H, A]) ProcessProposal(p *types.Proposal[V, H, A]) []types.Action[V, H, A] {
-	return t.processMessage(p.MessageHeader, func() {
-		if t.voteCounter.AddProposal(p) && !t.replayMode && p.Height == t.state.height {
+func (s *stateMachine[V, H, A]) ProcessProposal(p *types.Proposal[V, H, A]) []types.Action[V, H, A] {
+	return s.processMessage(p.MessageHeader, func() {
+		if s.voteCounter.AddProposal(p) && !s.replayMode && p.Height == s.state.height {
 			// Store proposal if its the first time we see it
-			if err := t.db.SetWALEntry(p); err != nil {
-				t.log.Fatalf("Failed to store prevote in WAL")
+			if err := s.db.SetWALEntry(p); err != nil {
+				s.log.Fatalf("Failed to store prevote in WAL")
 			}
 		}
 	})
 }
 
-func (t *stateMachine[V, H, A]) ProcessPrevote(p *types.Prevote[H, A]) []types.Action[V, H, A] {
-	return t.processMessage(p.MessageHeader, func() {
-		if t.voteCounter.AddPrevote(p) && !t.replayMode && p.Height == t.state.height {
+func (s *stateMachine[V, H, A]) ProcessPrevote(p *types.Prevote[H, A]) []types.Action[V, H, A] {
+	return s.processMessage(p.MessageHeader, func() {
+		if s.voteCounter.AddPrevote(p) && !s.replayMode && p.Height == s.state.height {
 			// Store prevote if its the first time we see it
-			if err := t.db.SetWALEntry(p); err != nil {
-				t.log.Fatalf("Failed to store prevote in WAL")
+			if err := s.db.SetWALEntry(p); err != nil {
+				s.log.Fatalf("Failed to store prevote in WAL")
 			}
 		}
 	})
 }
 
-func (t *stateMachine[V, H, A]) ProcessPrecommit(p *types.Precommit[H, A]) []types.Action[V, H, A] {
-	return t.processMessage(p.MessageHeader, func() {
-		if t.voteCounter.AddPrecommit(p) && !t.replayMode && p.Height == t.state.height {
+func (s *stateMachine[V, H, A]) ProcessPrecommit(p *types.Precommit[H, A]) []types.Action[V, H, A] {
+	return s.processMessage(p.MessageHeader, func() {
+		if s.voteCounter.AddPrecommit(p) && !s.replayMode && p.Height == s.state.height {
 			// Store precommit if its the first time we see it
-			if err := t.db.SetWALEntry(p); err != nil {
-				t.log.Fatalf("Failed to store prevote in WAL")
+			if err := s.db.SetWALEntry(p); err != nil {
+				s.log.Fatalf("Failed to store prevote in WAL")
 			}
 		}
 	})
 }
 
-func (t *stateMachine[V, H, A]) processMessage(header types.MessageHeader[A], addMessage func()) []types.Action[V, H, A] {
-	if !t.preprocessMessage(header, addMessage) {
+func (s *stateMachine[V, H, A]) processMessage(header types.MessageHeader[A], addMessage func()) []types.Action[V, H, A] {
+	if !s.preprocessMessage(header, addMessage) {
 		return nil
 	}
 
-	return t.processLoop(nil, &header.Round)
+	return s.processLoop(nil, &header.Round)
 }
 
-func (t *stateMachine[V, H, A]) ProcessTimeout(tm types.Timeout) []types.Action[V, H, A] {
-	if !t.replayMode && tm.Height == t.state.height {
-		if err := t.db.SetWALEntry(tm); err != nil {
-			t.log.Fatalf("Failed to store timeout trigger in WAL")
+func (s *stateMachine[V, H, A]) ProcessTimeout(tm types.Timeout) []types.Action[V, H, A] {
+	if !s.replayMode && tm.Height == s.state.height {
+		if err := s.db.SetWALEntry(tm); err != nil {
+			s.log.Fatalf("Failed to store timeout trigger in WAL")
 		}
 	}
 	switch tm.Step {
 	case types.StepPropose:
-		return t.processLoop(t.onTimeoutPropose(tm.Height, tm.Round), nil)
+		return s.processLoop(s.onTimeoutPropose(tm.Height, tm.Round), nil)
 	case types.StepPrevote:
-		return t.processLoop(t.onTimeoutPrevote(tm.Height, tm.Round), nil)
+		return s.processLoop(s.onTimeoutPrevote(tm.Height, tm.Round), nil)
 	case types.StepPrecommit:
-		return t.processLoop(t.onTimeoutPrecommit(tm.Height, tm.Round), nil)
+		return s.processLoop(s.onTimeoutPrecommit(tm.Height, tm.Round), nil)
 	}
 
 	return nil
 }
 
-func (t *stateMachine[V, H, A]) processLoop(action types.Action[V, H, A], recentlyReceivedRound *types.Round) []types.Action[V, H, A] {
+func (s *stateMachine[V, H, A]) processLoop(action types.Action[V, H, A], recentlyReceivedRound *types.Round) []types.Action[V, H, A] {
 	actions, shouldContinue := []types.Action[V, H, A]{}, true
 	if action != nil {
 		actions = append(actions, action)
 	}
 
 	for shouldContinue {
-		action, shouldContinue = t.process(recentlyReceivedRound)
+		action, shouldContinue = s.process(recentlyReceivedRound)
 		if action != nil {
 			actions = append(actions, action)
 		}
@@ -81,46 +81,46 @@ func (t *stateMachine[V, H, A]) processLoop(action types.Action[V, H, A], recent
 	return actions
 }
 
-func (t *stateMachine[V, H, A]) process(recentlyReceivedRound *types.Round) (action types.Action[V, H, A], shouldContinue bool) {
-	cachedProposal := t.findProposal(t.state.round)
+func (s *stateMachine[V, H, A]) process(recentlyReceivedRound *types.Round) (action types.Action[V, H, A], shouldContinue bool) {
+	cachedProposal := s.findProposal(s.state.round)
 
 	var roundCachedProposal *CachedProposal[V, H, A]
 	if recentlyReceivedRound != nil {
-		roundCachedProposal = t.findProposal(*recentlyReceivedRound)
+		roundCachedProposal = s.findProposal(*recentlyReceivedRound)
 	}
 
 	switch {
 	// Line 22
-	case cachedProposal != nil && t.uponFirstProposal(cachedProposal):
-		return t.doFirstProposal(cachedProposal), true
+	case cachedProposal != nil && s.uponFirstProposal(cachedProposal):
+		return s.doFirstProposal(cachedProposal), true
 
 	// Line 28
-	case cachedProposal != nil && t.uponProposalAndPolkaPrevious(cachedProposal):
-		return t.doProposalAndPolkaPrevious(cachedProposal), true
+	case cachedProposal != nil && s.uponProposalAndPolkaPrevious(cachedProposal):
+		return s.doProposalAndPolkaPrevious(cachedProposal), true
 
 	// Line 34
-	case t.uponPolkaAny():
-		return t.doPolkaAny(), true
+	case s.uponPolkaAny():
+		return s.doPolkaAny(), true
 
 	// Line 36
-	case cachedProposal != nil && t.uponProposalAndPolkaCurrent(cachedProposal):
-		return t.doProposalAndPolkaCurrent(cachedProposal), true
+	case cachedProposal != nil && s.uponProposalAndPolkaCurrent(cachedProposal):
+		return s.doProposalAndPolkaCurrent(cachedProposal), true
 
 	// Line 44
-	case t.uponPolkaNil():
-		return t.doPolkaNil(), true
+	case s.uponPolkaNil():
+		return s.doPolkaNil(), true
 
 	// Line 47
-	case t.uponPrecommitAny():
-		return t.doPrecommitAny(), true
+	case s.uponPrecommitAny():
+		return s.doPrecommitAny(), true
 
 	// Line 49
-	case roundCachedProposal != nil && t.uponCommitValue(roundCachedProposal):
-		return t.doCommitValue(roundCachedProposal), false // We should stop immediately after committing
+	case roundCachedProposal != nil && s.uponCommitValue(roundCachedProposal):
+		return s.doCommitValue(roundCachedProposal), false // We should stop immediately after committing
 
 	// Line 55
-	case recentlyReceivedRound != nil && t.uponSkipRound(*recentlyReceivedRound):
-		return t.doSkipRound(*recentlyReceivedRound), true
+	case recentlyReceivedRound != nil && s.uponSkipRound(*recentlyReceivedRound):
+		return s.doSkipRound(*recentlyReceivedRound), true
 
 	default:
 		return nil, false // We should stop if none of the above conditions are met

consensus/tendermint/rule_commit_value.go

@@ -21,8 +21,8 @@ height and round.
 There is no need to check decision_p[h_p] = nil since it is implied that decision are made
 sequentially, i.e. x, x+1, x+2... .
 */
-func (t *stateMachine[V, H, A]) uponCommitValue(cachedProposal *CachedProposal[V, H, A]) bool {
-	hasQuorum := cachedProposal.ID != nil && t.voteCounter.HasQuorumForVote(cachedProposal.Round, votecounter.Precommit, cachedProposal.ID)
+func (s *stateMachine[V, H, A]) uponCommitValue(cachedProposal *CachedProposal[V, H, A]) bool {
+	hasQuorum := cachedProposal.ID != nil && s.voteCounter.HasQuorumForVote(cachedProposal.Round, votecounter.Precommit, cachedProposal.ID)
 
 	// This is checked here instead of inside execution, because it's the only case in execution in this rule
 	isValid := cachedProposal.Valid
@@ -31,13 +31,13 @@ func (t *stateMachine[V, H, A]) uponCommitValue(cachedProposal *CachedProposal[V
 	return hasQuorum && isValid
 }
 
-func (t *stateMachine[V, H, A]) doCommitValue(cachedProposal *CachedProposal[V, H, A]) types.Action[V, H, A] {
-	t.voteCounter.StartNewHeight()
-	t.state.height++
-	t.state.lockedRound = -1
-	t.state.lockedValue = nil
-	t.state.validRound = -1
-	t.state.validValue = nil
-	t.resetState(0)
+func (s *stateMachine[V, H, A]) doCommitValue(cachedProposal *CachedProposal[V, H, A]) types.Action[V, H, A] {
+	s.voteCounter.StartNewHeight()
+	s.state.height++
+	s.state.lockedRound = -1
+	s.state.lockedValue = nil
+	s.state.validRound = -1
+	s.state.validValue = nil
+	s.resetState(0)
 	return (*types.Commit[V, H, A])(&cachedProposal.Proposal)
 }

consensus/tendermint/rule_first_proposal.go

@@ -14,18 +14,18 @@ Check the upon condition on line 22:
 
 Since the value's id is expected to be unique the id can be used to compare the values.
 */
-func (t *stateMachine[V, H, A]) uponFirstProposal(cachedProposal *CachedProposal[V, H, A]) bool {
-	return cachedProposal.ValidRound == -1 && t.state.step == types.StepPropose
+func (s *stateMachine[V, H, A]) uponFirstProposal(cachedProposal *CachedProposal[V, H, A]) bool {
+	return cachedProposal.ValidRound == -1 && s.state.step == types.StepPropose
 }
 
-func (t *stateMachine[V, H, A]) doFirstProposal(cachedProposal *CachedProposal[V, H, A]) types.Action[V, H, A] {
+func (s *stateMachine[V, H, A]) doFirstProposal(cachedProposal *CachedProposal[V, H, A]) types.Action[V, H, A] {
 	shouldVoteForValue := cachedProposal.Valid &&
-		(t.state.lockedRound == -1 ||
-			t.state.lockedValue != nil && (*t.state.lockedValue).Hash() == *cachedProposal.ID)
+		(s.state.lockedRound == -1 ||
+			s.state.lockedValue != nil && (*s.state.lockedValue).Hash() == *cachedProposal.ID)
 
 	var votedID *H
 	if shouldVoteForValue {
 		votedID = cachedProposal.ID
 	}
-	return t.setStepAndSendPrevote(votedID)
+	return s.setStepAndSendPrevote(votedID)
 }

consensus/tendermint/rule_polka_any.go

@@ -11,17 +11,17 @@ Check the upon condition on line 34:
 	34: upon 2f + 1 {PREVOTE, h_p, round_p, ∗} while step_p = prevote for the first time do
 	35: schedule OnTimeoutPrevote(h_p, round_p) to be executed after timeoutPrevote(round_p)
 */
-func (t *stateMachine[V, H, A]) uponPolkaAny() bool {
-	isFirstTime := !t.state.timeoutPrevoteScheduled
+func (s *stateMachine[V, H, A]) uponPolkaAny() bool {
+	isFirstTime := !s.state.timeoutPrevoteScheduled
 
-	hasQuorum := t.voteCounter.HasQuorumForAny(t.state.round, votecounter.Prevote)
+	hasQuorum := s.voteCounter.HasQuorumForAny(s.state.round, votecounter.Prevote)
 
-	return t.state.step == types.StepPrevote &&
+	return s.state.step == types.StepPrevote &&
 		hasQuorum &&
 		isFirstTime
 }
 
-func (t *stateMachine[V, H, A]) doPolkaAny() types.Action[V, H, A] {
-	t.state.timeoutPrevoteScheduled = true
-	return t.scheduleTimeout(types.StepPrevote)
+func (s *stateMachine[V, H, A]) doPolkaAny() types.Action[V, H, A] {
+	s.state.timeoutPrevoteScheduled = true
+	return s.scheduleTimeout(types.StepPrevote)
 }

consensus/tendermint/rule_polka_nil.go

@@ -14,12 +14,12 @@ Check the upon condition on line 44:
 
 Line 36 and 44 for a round are mutually exclusive.
 */
-func (t *stateMachine[V, H, A]) uponPolkaNil() bool {
-	hasQuorum := t.voteCounter.HasQuorumForVote(t.state.round, votecounter.Prevote, nil)
+func (s *stateMachine[V, H, A]) uponPolkaNil() bool {
+	hasQuorum := s.voteCounter.HasQuorumForVote(s.state.round, votecounter.Prevote, nil)
 
-	return hasQuorum && t.state.step == types.StepPrevote
+	return hasQuorum && s.state.step == types.StepPrevote
 }
 
-func (t *stateMachine[V, H, A]) doPolkaNil() types.Action[V, H, A] {
-	return t.setStepAndSendPrecommit(nil)
+func (s *stateMachine[V, H, A]) doPolkaNil() types.Action[V, H, A] {
+	return s.setStepAndSendPrecommit(nil)
 }

consensus/tendermint/rule_precommit_any.go

@@ -11,15 +11,15 @@ Check the upon condition on line 47:
 	47: upon 2f + 1 {PRECOMMIT, h_p, round_p, ∗} for the first time do
 	48: schedule OnTimeoutPrecommit(h_p , round_p) to be executed after timeoutPrecommit(round_p)
 */
-func (t *stateMachine[V, H, A]) uponPrecommitAny() bool {
-	isFirstTime := !t.state.timeoutPrecommitScheduled
+func (s *stateMachine[V, H, A]) uponPrecommitAny() bool {
+	isFirstTime := !s.state.timeoutPrecommitScheduled
 
-	hasQuorum := t.voteCounter.HasQuorumForAny(t.state.round, votecounter.Precommit)
+	hasQuorum := s.voteCounter.HasQuorumForAny(s.state.round, votecounter.Precommit)
 
 	return hasQuorum && isFirstTime
 }
 
-func (t *stateMachine[V, H, A]) doPrecommitAny() types.Action[V, H, A] {
-	t.state.timeoutPrecommitScheduled = true
-	return t.scheduleTimeout(types.StepPrecommit)
+func (s *stateMachine[V, H, A]) doPrecommitAny() types.Action[V, H, A] {
+	s.state.timeoutPrecommitScheduled = true
+	return s.scheduleTimeout(types.StepPrecommit)
 }