[Dynamic Protocol State] Read-only interfaces of protocol state

cmd/scaffold.go

@@ -729,10 +729,7 @@ func (fnb *FlowNodeBuilder) initMetrics() error {
 		// metrics enabled, report node info metrics as post init event
 		fnb.PostInit(func(nodeConfig *NodeConfig) error {
 			nodeInfoMetrics := metrics.NewNodeInfoCollector()
-			protocolVersion, err := fnb.RootSnapshot.Params().ProtocolVersion()
-			if err != nil {
-				return fmt.Errorf("could not query root snapshoot protocol version: %w", err)
-			}
+			protocolVersion := fnb.RootSnapshot.Params().ProtocolVersion()
 			nodeInfoMetrics.NodeInfo(build.Semver(), build.Commit(), nodeConfig.SporkID.String(), protocolVersion)
 			return nil
 		})
@@ -1204,10 +1201,7 @@ func (fnb *FlowNodeBuilder) setRootSnapshot(rootSnapshot protocol.Snapshot) erro
 	}
 
 	fnb.RootChainID = fnb.FinalizedRootBlock.Header.ChainID
-	fnb.SporkID, err = fnb.RootSnapshot.Params().SporkID()
-	if err != nil {
-		return fmt.Errorf("failed to read spork ID: %w", err)
-	}
+	fnb.SporkID = fnb.RootSnapshot.Params().SporkID()
 
 	return nil
 }

engine/access/rpc/backend/backend.go

@@ -7,9 +7,6 @@ import (
 	"strconv"
 	"time"
 
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
-
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/rs/zerolog"
 
@@ -291,17 +288,11 @@ func (b *Backend) Ping(ctx context.Context) error {
 }
 
 // GetNodeVersionInfo returns node version information such as semver, commit, sporkID, protocolVersion, etc
-func (b *Backend) GetNodeVersionInfo(ctx context.Context) (*access.NodeVersionInfo, error) {
+func (b *Backend) GetNodeVersionInfo(_ context.Context) (*access.NodeVersionInfo, error) {
 	stateParams := b.state.Params()
-	sporkId, err := stateParams.SporkID()
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "failed to read spork ID: %v", err)
-	}
+	sporkId := stateParams.SporkID()
 
-	protocolVersion, err := stateParams.ProtocolVersion()
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "failed to read protocol version: %v", err)
-	}
+	protocolVersion := stateParams.ProtocolVersion()
 
 	return &access.NodeVersionInfo{
 		Semver:          build.Semver(),

engine/access/rpc/backend/backend_network.go

@@ -44,17 +44,10 @@ func (b *backendNetwork) GetNetworkParameters(_ context.Context) access.NetworkP
 	}
 }
 
-func (b *backendNetwork) GetNodeVersionInfo(ctx context.Context) (*access.NodeVersionInfo, error) {
+func (b *backendNetwork) GetNodeVersionInfo(_ context.Context) (*access.NodeVersionInfo, error) {
 	stateParams := b.state.Params()
-	sporkId, err := stateParams.SporkID()
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "failed to read spork ID: %v", err)
-	}
-
-	protocolVersion, err := stateParams.ProtocolVersion()
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "failed to read protocol version: %v", err)
-	}
+	sporkId := stateParams.SporkID()
+	protocolVersion := stateParams.ProtocolVersion()
 
 	return &access.NodeVersionInfo{
 		Semver:          build.Semver(),

engine/access/rpc/backend/backend_transactions.go

@@ -453,11 +453,7 @@ func (b *backendTransactions) GetTransactionResultsByBlockID(
 	// after iterating through all transactions in each collection, i equals the total number of
 	// user transactions in the block
 	txCount := i
-
-	sporkRootBlockHeight, err := b.state.Params().SporkRootBlockHeight()
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "failed to retrieve root block: %v", err)
-	}
+	sporkRootBlockHeight := b.state.Params().SporkRootBlockHeight()
 
 	// root block has no system transaction result
 	if block.Header.Height > sporkRootBlockHeight {

engine/collection/epochmgr/engine.go

@@ -532,10 +532,7 @@ func (e *Engine) activeClusterIDs() (flow.ChainIDList, error) {
 	defer e.mu.RUnlock()
 	clusterIDs := make(flow.ChainIDList, 0)
 	for _, epoch := range e.epochs {
-		chainID, err := epoch.state.Params().ChainID() // cached, does not hit database
-		if err != nil {
-			return nil, fmt.Errorf("failed to get active cluster ids: %w", err)
-		}
+		chainID := epoch.state.Params().ChainID() // cached, does not hit database
 		clusterIDs = append(clusterIDs, chainID)
 	}
 	return clusterIDs, nil

engine/collection/message_hub/message_hub.go

@@ -156,10 +156,7 @@ func NewMessageHub(log zerolog.Logger,
 	}
 
 	// register network conduit
-	chainID, err := clusterState.Params().ChainID()
-	if err != nil {
-		return nil, fmt.Errorf("could not get chain ID: %w", err)
-	}
+	chainID := clusterState.Params().ChainID()
 	conduit, err := net.Register(channels.ConsensusCluster(chainID), hub)
 	if err != nil {
 		return nil, fmt.Errorf("could not register engine: %w", err)

engine/collection/synchronization/engine.go

@@ -100,11 +100,7 @@ func New(
 	if err != nil {
 		return nil, fmt.Errorf("could not setup message handler")
 	}
-
-	chainID, err := state.Params().ChainID()
-	if err != nil {
-		return nil, fmt.Errorf("could not get chain ID: %w", err)
-	}
+	chainID := state.Params().ChainID()
 
 	// register the engine with the network layer and store the conduit
 	con, err := net.Register(channels.SyncCluster(chainID), e)

go.sum

@@ -783,6 +783,7 @@ github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/u
 github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
 github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
 github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
@@ -1141,6 +1142,7 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJ
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/montanaflynn/stats v0.6.6 h1:Duep6KMIDpY4Yo11iFsvyqJDyfzLF9+sndUKT+v64GQ=
 github.com/montanaflynn/stats v0.6.6/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow=
 github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8=

model/flow/protocol_state.go

@@ -1,6 +1,9 @@
 package flow
 
-import "fmt"
+import (
+	"fmt"
+	"sort"
+)
 
 // DynamicIdentityEntry encapsulates nodeID and dynamic portion of identity.
 type DynamicIdentityEntry struct {
@@ -154,6 +157,59 @@ func (e *ProtocolStateEntry) ID() Identifier {
 	return MakeID(body)
 }
 
+// Copy returns a full copy of the entry.
+func (e *ProtocolStateEntry) Copy() *ProtocolStateEntry {
+	if e == nil {
+		return nil
+	}
+	return &ProtocolStateEntry{
+		CurrentEpochEventIDs:            e.CurrentEpochEventIDs,
+		PreviousEpochEventIDs:           e.PreviousEpochEventIDs,
+		Identities:                      e.Identities.Copy(),
+		InvalidStateTransitionAttempted: e.InvalidStateTransitionAttempted,
+		NextEpochProtocolState:          e.NextEpochProtocolState.Copy(),
+	}
+}
+
+// Copy returns a full copy of rich protocol state entry.
+// Embedded service events are copied by reference (not deep-copied).
+func (e *RichProtocolStateEntry) Copy() *RichProtocolStateEntry {
+	if e == nil {
+		return nil
+	}
+	return &RichProtocolStateEntry{
+		ProtocolStateEntry:     e.ProtocolStateEntry.Copy(),
+		CurrentEpochSetup:      e.CurrentEpochSetup,
+		CurrentEpochCommit:     e.CurrentEpochCommit,
+		PreviousEpochSetup:     e.PreviousEpochSetup,
+		PreviousEpochCommit:    e.PreviousEpochCommit,
+		Identities:             e.Identities.Copy(),
+		NextEpochProtocolState: e.NextEpochProtocolState.Copy(),
+	}
+}
+
+// EpochStatus returns epoch status for the current protocol state.
+func (e *ProtocolStateEntry) EpochStatus() *EpochStatus {
+	var nextEpoch EventIDs
+	if e.NextEpochProtocolState != nil {
+		nextEpoch = e.NextEpochProtocolState.CurrentEpochEventIDs
+	}
+	return &EpochStatus{
+		PreviousEpoch:                   e.PreviousEpochEventIDs,
+		CurrentEpoch:                    e.CurrentEpochEventIDs,
+		NextEpoch:                       nextEpoch,
+		InvalidServiceEventIncorporated: e.InvalidStateTransitionAttempted,
+	}
+}
+
+func (ll DynamicIdentityEntryList) Lookup() map[Identifier]*DynamicIdentityEntry {
+	result := make(map[Identifier]*DynamicIdentityEntry, len(ll))
+	for _, entry := range ll {
+		result[entry.NodeID] = entry
+	}
+	return result
+}
+
 // Sorted returns whether the list is sorted by the input ordering.
 func (ll DynamicIdentityEntryList) Sorted(less IdentifierOrder) bool {
 	for i := 0; i < len(ll)-1; i++ {
@@ -166,6 +222,37 @@ func (ll DynamicIdentityEntryList) Sorted(less IdentifierOrder) bool {
 	return true
 }
 
+// ByNodeID gets a node from the list by node ID.
+func (ll DynamicIdentityEntryList) ByNodeID(nodeID Identifier) (*DynamicIdentityEntry, bool) {
+	for _, identity := range ll {
+		if identity.NodeID == nodeID {
+			return identity, true
+		}
+	}
+	return nil, false
+}
+
+func (ll DynamicIdentityEntryList) Copy() DynamicIdentityEntryList {
+	dup := make(DynamicIdentityEntryList, 0, len(ll))
+
+	lenList := len(ll)
+	for i := 0; i < lenList; i++ {
+		// copy the object
+		next := *(ll[i])
+		dup = append(dup, &next)
+	}
+	return dup
+}
+
+// Sort sorts the list by the input ordering. Returns a new, sorted list without modifying the input.
+func (ll DynamicIdentityEntryList) Sort(less IdentifierOrder) DynamicIdentityEntryList {
+	dup := ll.Copy()
+	sort.Slice(dup, func(i int, j int) bool {
+		return less(dup[i].NodeID, dup[j].NodeID)
+	})
+	return dup
+}
+
 // buildIdentityTable builds identity table for current epoch combining data from previous, current epoch setups and dynamic identities
 // that are stored in protocol state. It also performs sanity checks to make sure that data is consistent.
 // No errors are expected during normal operation.

model/flow/protocol_state_test.go

@@ -94,3 +94,29 @@ func TestNewRichProtocolStateEntry(t *testing.T) {
 		assert.Equal(t, expectedIdentities, richEntry.NextEpochProtocolState.Identities, "should be equal to next epoch setup participants + current epoch setup participants")
 	})
 }
+
+// TestProtocolStateEntry_Copy tests if the copy method returns a deep copy of the entry. All changes to cpy shouldn't affect the original entry.
+func TestProtocolStateEntry_Copy(t *testing.T) {
+	entry := unittest.ProtocolStateFixture(unittest.WithNextEpochProtocolState()).ProtocolStateEntry
+	cpy := entry.Copy()
+	assert.Equal(t, entry, cpy)
+	assert.NotSame(t, entry.NextEpochProtocolState, cpy.NextEpochProtocolState)
+	assert.NotSame(t, entry.PreviousEpochEventIDs, cpy.PreviousEpochEventIDs)
+	assert.NotSame(t, entry.CurrentEpochEventIDs, cpy.CurrentEpochEventIDs)
+
+	cpy.InvalidStateTransitionAttempted = !entry.InvalidStateTransitionAttempted
+	assert.NotEqual(t, entry, cpy)
+
+	assert.Equal(t, entry.Identities[0], cpy.Identities[0])
+	cpy.Identities[0].Dynamic.Weight = 123
+	assert.NotEqual(t, entry.Identities[0], cpy.Identities[0])
+
+	cpy.Identities = append(cpy.Identities, &flow.DynamicIdentityEntry{
+		NodeID: unittest.IdentifierFixture(),
+		Dynamic: flow.DynamicIdentity{
+			Weight:  100,
+			Ejected: false,
+		},
+	})
+	assert.NotEqual(t, entry.Identities, cpy.Identities)
+}

state/cluster/badger/params.go

@@ -8,6 +8,6 @@ type Params struct {
 	state *State
 }
 
-func (p *Params) ChainID() (flow.ChainID, error) {
-	return p.state.clusterID, nil
+func (p *Params) ChainID() flow.ChainID {
+	return p.state.clusterID
 }

state/cluster/badger/snapshot_test.go

@@ -290,8 +290,6 @@ func (suite *SnapshotSuite) TestPending_Grandchildren() {
 }
 
 func (suite *SnapshotSuite) TestParams_ChainID() {
-
-	chainID, err := suite.state.Params().ChainID()
-	suite.Require().Nil(err)
+	chainID := suite.state.Params().ChainID()
 	suite.Assert().Equal(suite.genesis.Header.ChainID, chainID)
 }

state/cluster/params.go

@@ -6,8 +6,6 @@ import (
 
 // Params contains constant information about this cluster state.
 type Params interface {
-
 	// ChainID returns the chain ID for this cluster.
-	// No errors are expected during normal operation.
-	ChainID() (flow.ChainID, error)
+	ChainID() flow.ChainID
 }

state/protocol/badger/mutator.go

@@ -812,10 +812,7 @@ func (m *FollowerState) epochFallbackTriggeredByFinalizedBlock(block *flow.Heade
 	}
 
 	// 2.(a) determine whether block B is past the epoch commitment deadline
-	safetyThreshold, err := m.Params().EpochCommitSafetyThreshold()
-	if err != nil {
-		return false, fmt.Errorf("could not get epoch commit safety threshold: %w", err)
-	}
+	safetyThreshold := m.Params().EpochCommitSafetyThreshold()
 	blockExceedsDeadline := block.View+safetyThreshold >= currentEpochSetup.FinalView
 
 	// 2.(b) determine whether the next epoch is committed w.r.t. block B

state/protocol/badger/mutator_test.go

@@ -1686,7 +1686,7 @@ func TestEmergencyEpochFallback(t *testing.T) {
 			require.NoError(t, err)
 			result, _, err := rootSnapshot.SealedResult()
 			require.NoError(t, err)
-			safetyThreshold, err := rootSnapshot.Params().EpochCommitSafetyThreshold()
+			safetyThreshold := rootSnapshot.Params().EpochCommitSafetyThreshold()
 			require.NoError(t, err)
 
 			epoch1Setup := result.ServiceEvents[0].Event.(*flow.EpochSetup)
@@ -1744,7 +1744,7 @@ func TestEmergencyEpochFallback(t *testing.T) {
 			require.NoError(t, err)
 			result, _, err := rootSnapshot.SealedResult()
 			require.NoError(t, err)
-			safetyThreshold, err := rootSnapshot.Params().EpochCommitSafetyThreshold()
+			safetyThreshold := rootSnapshot.Params().EpochCommitSafetyThreshold()
 			require.NoError(t, err)
 
 			// add a block for the first seal to reference