Merge branch 'feat/parachain' into feat/parachain-collation-fetching-v2

Author: Yuri0405

dot/parachain/statement-distribution/cluster_tracker.go

@@ -10,94 +10,32 @@ import (
 	"github.com/ChainSafe/gossamer/lib/common"
 )
 
-// accept signifies that an incoming statement was accepted.
-type accept interface { //nolint:unused
-	isAccept()
-}
-
-// ok means neither the peer nor the originator have apparently exceeded limits.
-// Candidate or statement may already be known.
-type ok struct{}
-
-func (ok) isAccept() {}
-
-// / withPrejudice means accept the message; the peer hasn't exceeded limits but the originator has.
-type withPrejudice struct{}
-
-func (withPrejudice) isAccept() {}
-
-// / rejectIncoming signifies that an incoming statement was rejected.
-type rejectIncoming interface { //nolint:unused
-	isRejectIncoming()
-}
+type acceptOrReject byte
 
-// excessiveSecondedIncoming means peer sent excessive `Seconded` statements.
-type excessiveSecondedIncoming struct{}
+const (
+	// ok means neither the peer nor the originator have apparently exceeded limits.
+	// Candidate or statement may already be known.
+	ok acceptOrReject = iota
 
-func (excessiveSecondedIncoming) isRejectIncoming() {}
+	// withPrejudice means accept the message; the peer hasn't exceeded limits but the originator has.
+	withPrejudice
 
-// notInGroupIncoming means sender or originator is not in the group.
-type notInGroupIncoming struct{}
+	// excessiveSeconded means peer sent excessive `Seconded` statements or we attempted to send excessive `Seconded`
+	// statements. The latter indicates a bug on the local node's code.
+	excessiveSeconded
 
-func (notInGroupIncoming) isRejectIcoming() {} //nolint:unused
-
-// candidateUnknownIncoming means the candidate is unknown to us. Only applies to `Valid` statements.
-type candidateUnknownIncoming struct{}
-
-func (candidateUnknownIncoming) isRejectIncoming() {}
-
-// duplicateIncoming means the statement is a duplicate.
-type duplicateIncoming struct{}
-
-func (duplicateIncoming) isRejectIncoming() {}
-
-// / rejectOutgoing signifies that an outgoing statement was rejected.
-type rejectOutgoing interface { //nolint:unused
-	isRejectOutgoing()
-}
+	// notInGroup means sender/target or originator is not in the group.
+	notInGroup
 
-// candidateUnknownOutgoing means the candidate was unknown. Only applies to `Valid` statements.
-type candidateUnknownOutgoing struct{}
+	// candidateUnknown means the candidate is unknown to us. Only applies to `Valid` statements.
+	candidateUnknown
 
-func (candidateUnknownOutgoing) isRejectOutgoing() {}
+	// duplicate means the statement is a duplicate.
+	duplicate
 
-// excessiveSecondedOutgoing means we attempted to send excessive `Seconded` statements.
-// Indicates a bug on the local node's code.
-type excessiveSecondedOutgoing struct{}
-
-func (excessiveSecondedOutgoing) isRejectOutgoing() {}
-
-// knownOutgoing means the statement was already known to the peer.
-type knownOutgoing struct{}
-
-func (knownOutgoing) isRejectOutgoing() {}
-
-// notInGroupOutgoing means the target or originator are not in the group.
-type notInGroupOutgoing struct{}
-
-func (notInGroupOutgoing) isRejectOutgoing() {}
-
-type acceptOrRejectIncoming interface {
-	isAcceptOrRejectIncoming()
-}
-
-func (ok) isAcceptOrRejectIncoming()                        {}
-func (withPrejudice) isAcceptOrRejectIncoming()             {}
-func (excessiveSecondedIncoming) isAcceptOrRejectIncoming() {}
-func (notInGroupIncoming) isAcceptOrRejectIncoming()        {}
-func (candidateUnknownIncoming) isAcceptOrRejectIncoming()  {}
-func (duplicateIncoming) isAcceptOrRejectIncoming()         {}
-
-type acceptOrRejectOutgoing interface {
-	isAcceptOrRejectOutgoing()
-}
-
-func (ok) isAcceptOrRejectOutgoing()                        {}
-func (withPrejudice) isAcceptOrRejectOutgoing()             {}
-func (candidateUnknownOutgoing) isAcceptOrRejectOutgoing()  {}
-func (excessiveSecondedOutgoing) isAcceptOrRejectOutgoing() {}
-func (knownOutgoing) isAcceptOrRejectOutgoing()             {}
-func (notInGroupOutgoing) isAcceptOrRejectOutgoing()        {}
+	// known means the statement was already known to the peer.
+	known
+)
 
 // knowledge about a candidate
 type knowledge interface {
@@ -214,13 +152,13 @@ func (c *clusterTracker) canReceive(
 	sender parachaintypes.ValidatorIndex,
 	originator parachaintypes.ValidatorIndex,
 	statement parachaintypes.CompactStatement,
-) acceptOrRejectIncoming {
+) acceptOrReject {
 	if !c.isInGroup(sender) || !c.isInGroup(originator) {
-		return notInGroupIncoming{}
+		return notInGroup
 	}
 
 	if c.theySent(sender, specific{statement, originator}) {
-		return duplicateIncoming{}
+		return duplicate
 	}
 
 	switch statement.(type) {
@@ -250,20 +188,20 @@ func (c *clusterTracker) canReceive(
 		}
 
 		if otherSecondedForOrigFromRemote == c.secondingLimit {
-			return excessiveSecondedIncoming{}
+			return excessiveSeconded
 		}
 
 		// at this point, it doesn't seem like the remote has done anything wrong.
 		if c.secondedAlreadyOrWithinLimit(originator, statement.CandidateHash()) {
-			return ok{}
+			return ok
 		} else {
-			return withPrejudice{}
+			return withPrejudice
 		}
 	case *parachaintypes.CompactValid:
 		if !c.knowsCandidate(sender, statement.CandidateHash()) {
-			return candidateUnknownIncoming{}
+			return candidateUnknown
 		}
-		return ok{}
+		return ok
 	default:
 		panic("unreachable")
 	}
@@ -461,28 +399,28 @@ func (c *clusterTracker) canSend(
 	target parachaintypes.ValidatorIndex,
 	originator parachaintypes.ValidatorIndex,
 	statement parachaintypes.CompactStatement,
-) acceptOrRejectOutgoing {
+) acceptOrReject {
 	if !c.isInGroup(target) || !c.isInGroup(originator) {
-		return notInGroupOutgoing{}
+		return notInGroup
 	}
 
 	if c.theyKnowStatement(target, originator, statement) {
-		return knownOutgoing{}
+		return known
 	}
 
 	switch statement.(type) {
 	case *parachaintypes.CompactSeconded:
 		// we send the same `Seconded` statements to all our peers, and only the first `k`
 		// from each originator.
 		if !c.secondedAlreadyOrWithinLimit(originator, statement.CandidateHash()) {
-			return excessiveSecondedOutgoing{}
+			return excessiveSeconded
 		}
-		return ok{}
+		return ok
 	case *parachaintypes.CompactValid:
 		if !c.knowsCandidate(target, statement.CandidateHash()) {
-			return candidateUnknownOutgoing{}
+			return candidateUnknown
 		}
-		return ok{}
+		return ok
 	default:
 		panic("unreachable")
 	}