Merge branch 'master' into jordan/6485-epoch-boundary-index

Author: jordanschalm

LicensingApproach.md

@@ -0,0 +1,31 @@
+# Flow's Approach to Licensing
+
+The founding team for Flow suggests that all open-source software built on or for Flow should adhere to the "[Coherent Open Source Licensing](https://licenseuse.org)" philosophy.
+To that end, we encourage the use of one of the following three licenses, as applicable by the use case (order from most permissive, to most restrictive):
+
+- Apache 2.0
+- LGPL 3
+- Affero GPL 3
+
+These licenses are all approved by both the Free Software Foundation and the Open Source Initiative and contain clauses regarding software patenting to avoid hidden patent concerns. Additionally, they are all compatible with each other meaning there is no conflict using them together in any project (provided the project as a whole meets the requirements of the most restrictive of the licenses included).
+
+
+### Apache 2.0
+
+Apache 2.0 is the most permissive, and allows reuse - with customization - in proprietary software. We recommend that this should be the default for any code that has significant potential use for off-chain tools and/or applications. In particular, all sample code (including smart contracts), SDKs, utility libraries and tools should default to Apache 2.0.
+
+
+### LGPL 3
+
+LGPL 3 allows use in proprietary software, provided that any customizations to the licensed code are shared. We considered LGPL for Cadence to avoid a proprietary fork of the language, but decided to use the more permissive Apache 2.0 license to emphasize that we hope Cadence can be adopted outside of Flow. LGPL can be used for other parts of Flow where necessary (e.g. if the component is itself a modification of other LGPL-licensed code).
+
+
+### Affero GPL 3
+
+Affero GPL 3 (AGPL) should be used for all code that exists primarily to power node software. In particular, the core consensus and computation layers should be provided via AGPL where possible. We chose this license because we interpret the clauses in the AGPL regarding "public use [...] on a publicly accessible server" as covering the operation of a node in the public Flow network. By requiring all modifications to the core node software to be made publicly available, we increase the security of the network (allowing any custom modifications to undergo public scrutiny), while also ensuring that improvements to the core infrastructure benefit all participants in the network.
+
+
+### Using the Unlicense
+
+For small snippets of sample code, we can provide access via the Unlicense.
+Broadly speaking, Apache 2.0 gives essentially the same rights to the receiver of the code as Unlicense, except that Apache protects the author(s) a bit more robustly, and protects the receiver against patent lawsuits. But, some people aren't aware of this, and using the "Unlicense" makes it very clear to anyone that the original authors aren't claiming ownership of derivative works. For any "complex" code that we want to be free, we should use Apache. For simple code snippets and examples, the Unlicense will probably make casual/inexperienced developers feel more comfortable.

admin/command_runner.go

@@ -324,3 +324,7 @@ func (r *CommandRunner) runCommand(ctx context.Context, command string, data int
 
 	return handleResult, nil
 }
+
+func (r *CommandRunner) GrpcAddress() string {
+	return r.grpcAddress
+}

cmd/access/node_builder/access_node_builder.go

@@ -236,14 +236,7 @@ func (builder *FlowAccessNodeBuilder) buildFollowerState() *FlowAccessNodeBuilde
 			return fmt.Errorf("only implementations of type badger.State are currently supported but read-only state has type %T", node.State)
 		}
 
-		followerState, err := badgerState.NewFollowerState(
-			state,
-			node.Storage.Index,
-			node.Storage.Payloads,
-			node.Tracer,
-			node.ProtocolEvents,
-			blocktimer.DefaultBlockTimer,
-		)
+		followerState, err := badgerState.NewFollowerState(state, node.Storage.Index, node.Storage.Payloads, node.Tracer, node.ProtocolEvents, blocktimer.DefaultBlockTimer)
 		builder.FollowerState = followerState
 
 		return err

cmd/bootstrap/cmd/qc.go

@@ -20,7 +20,13 @@ func constructRootQC(block *flow.Block, votes []*model.Vote, allNodes, internalN
 		log.Fatal().Err(err).Msg("failed to generate QC participant data")
 	}
 
-	qc, err := run.GenerateRootQC(block, votes, participantData, identities)
+	qc, invalidVotesErr, err := run.GenerateRootQC(block, votes, participantData, identities)
+	if len(invalidVotesErr) > 0 {
+		for _, err := range invalidVotesErr {
+			log.Warn().Err(err).Msg("invalid vote")
+		}
+	}
+
 	if err != nil {
 		log.Fatal().Err(err).Msg("generating root QC failed")
 	}

cmd/bootstrap/run/qc.go

@@ -44,11 +44,18 @@ func (pd *ParticipantData) Identities() flow.IdentityList {
 // which assumes that only consensus participants construct QCs, which also have produce votes.
 //
 // TODO: modularize QC construction code (and code to verify QC) to be instantiated without needing private keys.
-func GenerateRootQC(block *flow.Block, votes []*model.Vote, participantData *ParticipantData, identities flow.IdentityList) (*flow.QuorumCertificate, error) {
+// It returns (qc, nil, nil) if a QC can be constructed with enough votes, and there is no invalid votes
+// It returns (qc, invalidVotes, nil) if there are some invalid votes, but a QC can still be constructed
+// It returns (nil, invalidVotes, err) if no qc can be constructed with not enough votes or running any any exception
+func GenerateRootQC(block *flow.Block, votes []*model.Vote, participantData *ParticipantData, identities flow.IdentityList) (
+	*flow.QuorumCertificate, // the constructed QC
+	[]error, // return invalid votes error
+	error, // exception or could not construct qc
+) {
 	// create consensus committee's state
 	committee, err := committees.NewStaticCommittee(identities, flow.Identifier{}, participantData.Lookup, participantData.GroupKey)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	// STEP 1: create VoteProcessor
@@ -58,34 +65,44 @@ func GenerateRootQC(block *flow.Block, votes []*model.Vote, participantData *Par
 		createdQC = qc
 	})
 	if err != nil {
-		return nil, fmt.Errorf("could not CombinedVoteProcessor processor: %w", err)
+		return nil, nil, fmt.Errorf("could not CombinedVoteProcessor processor: %w", err)
 	}
 
+	invalidVotes := make([]error, 0, len(votes))
 	// STEP 2: feed the votes into the vote processor to create QC
 	for _, vote := range votes {
 		err := processor.Process(vote)
+
+		// in case there are invalid votes, we continue process more votes,
+		// so that finalizing block won't be interrupted by any invalid vote.
+		// if no enough votes are collected, finalize will fail and exit anyway, because
+		// no QC will be built.
 		if err != nil {
-			return nil, fmt.Errorf("fail to process vote %v for block %v from signer %v: %w",
+			if model.IsInvalidVoteError(err) {
+				invalidVotes = append(invalidVotes, err)
+				continue
+			}
+			return nil, invalidVotes, fmt.Errorf("fail to process vote %v for block %v from signer %v: %w",
 				vote.ID(),
-				block.ID(),
+				vote.BlockID,
 				vote.SignerID,
 				err)
 		}
 	}
 
 	if createdQC == nil {
-		return nil, fmt.Errorf("QC is not created, total number of votes %v, expect to have 2/3 votes of %v participants",
+		return nil, invalidVotes, fmt.Errorf("QC is not created, total number of votes %v, expect to have 2/3 votes of %v participants",
 			len(votes), len(identities))
 	}
 
 	// STEP 3: validate constructed QC
 	val, err := createValidator(committee)
 	if err != nil {
-		return nil, err
+		return nil, invalidVotes, err
 	}
 	err = val.ValidateQC(createdQC)
 
-	return createdQC, err
+	return createdQC, invalidVotes, err
 }
 
 // GenerateRootBlockVotes generates votes for root block based on participantData

cmd/bootstrap/run/qc_test.go

@@ -17,19 +17,31 @@ import (
 func TestGenerateRootQC(t *testing.T) {
 	participantData := createSignerData(t, 3)
 
-	block := unittest.BlockFixture()
-	block.Payload.Guarantees = nil
-	block.Payload.Seals = nil
-	block.Header.Height = 0
-	block.Header.ParentID = flow.ZeroID
-	block.Header.View = 3
-	block.Header.PayloadHash = block.Payload.Hash()
-
-	votes, err := GenerateRootBlockVotes(&block, participantData)
+	block := unittest.GenesisFixture()
+
+	votes, err := GenerateRootBlockVotes(block, participantData)
+	require.NoError(t, err)
+
+	_, invalid, err := GenerateRootQC(block, votes, participantData, participantData.Identities())
 	require.NoError(t, err)
+	require.Len(t, invalid, 0) // no invalid votes
+}
+
+func TestGenerateRootQCWithSomeInvalidVotes(t *testing.T) {
+	participantData := createSignerData(t, 10)
+
+	block := unittest.GenesisFixture()
+
+	votes, err := GenerateRootBlockVotes(block, participantData)
+	require.NoError(t, err)
+
+	// make 2 votes invalid
+	votes[0].SigData = unittest.SignatureFixture()   // make invalid signature
+	votes[1].SignerID = unittest.IdentifierFixture() // make invalid signer
 
-	_, err = GenerateRootQC(&block, votes, participantData, participantData.Identities())
+	_, invalid, err := GenerateRootQC(block, votes, participantData, participantData.Identities())
 	require.NoError(t, err)
+	require.Len(t, invalid, 2) // 2 invalid votes
 }
 
 func createSignerData(t *testing.T, n int) *ParticipantData {

cmd/collection/main.go

@@ -180,14 +180,7 @@ func main() {
 			if !ok {
 				return fmt.Errorf("only implementations of type badger.State are currently supported but read-only state has type %T", node.State)
 			}
-			followerState, err = badgerState.NewFollowerState(
-				state,
-				node.Storage.Index,
-				node.Storage.Payloads,
-				node.Tracer,
-				node.ProtocolEvents,
-				blocktimer.DefaultBlockTimer,
-			)
+			followerState, err = badgerState.NewFollowerState(state, node.Storage.Index, node.Storage.Payloads, node.Tracer, node.ProtocolEvents, blocktimer.DefaultBlockTimer)
 			return err
 		}).
 		Module("transactions mempool", func(node *cmd.NodeConfig) error {

cmd/consensus/main.go

@@ -241,15 +241,7 @@ func main() {
 				return err
 			}
 
-			mutableState, err = badgerState.NewFullConsensusState(
-				state,
-				node.Storage.Index,
-				node.Storage.Payloads,
-				node.Tracer,
-				node.ProtocolEvents,
-				blockTimer,
-				receiptValidator,
-				sealValidator)
+			mutableState, err = badgerState.NewFullConsensusState(state, node.Storage.Index, node.Storage.Payloads, node.Tracer, node.ProtocolEvents, blockTimer, receiptValidator, sealValidator)
 			return err
 		}).
 		Module("random beacon key", func(node *cmd.NodeConfig) error {

cmd/execution_builder.go

@@ -51,6 +51,7 @@ import (
 	"github.com/onflow/flow-go/engine/execution/state/bootstrap"
 	"github.com/onflow/flow-go/engine/execution/state/delta"
 	"github.com/onflow/flow-go/fvm"
+	fvmState "github.com/onflow/flow-go/fvm/state"
 	"github.com/onflow/flow-go/fvm/systemcontracts"
 	"github.com/onflow/flow-go/ledger/common/pathfinder"
 	ledger "github.com/onflow/flow-go/ledger/complete"
@@ -219,14 +220,7 @@ func (exeNode *ExecutionNode) LoadMutableFollowerState(node *NodeConfig) error {
 		return fmt.Errorf("only implementations of type badger.State are currently supported but read-only state has type %T", node.State)
 	}
 	var err error
-	exeNode.followerState, err = badgerState.NewFollowerState(
-		bState,
-		node.Storage.Index,
-		node.Storage.Payloads,
-		node.Tracer,
-		node.ProtocolEvents,
-		blocktimer.DefaultBlockTimer,
-	)
+	exeNode.followerState, err = badgerState.NewFollowerState(bState, node.Storage.Index, node.Storage.Payloads, node.Tracer, node.ProtocolEvents, blocktimer.DefaultBlockTimer)
 	return err
 }
 
@@ -519,16 +513,26 @@ func (exeNode *ExecutionNode) LoadProviderEngine(
 	ctx := context.Background()
 	_, blockID, err := exeNode.executionState.GetHighestExecutedBlockID(ctx)
 	if err != nil {
-		return nil, fmt.Errorf("cannot get the latest executed block id: %w", err)
+		return nil, fmt.Errorf(
+			"cannot get the latest executed block id: %w",
+			err)
 	}
-	stateCommit, err := exeNode.executionState.StateCommitmentByBlockID(ctx, blockID)
+	stateCommit, err := exeNode.executionState.StateCommitmentByBlockID(
+		ctx,
+		blockID)
 	if err != nil {
-		return nil, fmt.Errorf("cannot get the state commitment at latest executed block id %s: %w", blockID.String(), err)
+		return nil, fmt.Errorf(
+			"cannot get the state commitment at latest executed block id %s: %w",
+			blockID.String(),
+			err)
 	}
-	blockView := exeNode.executionState.NewView(stateCommit)
+	blockSnapshot := exeNode.executionState.NewStorageSnapshot(stateCommit)
 
 	// Get the epoch counter from the smart contract at the last executed block.
-	contractEpochCounter, err := getContractEpochCounter(exeNode.computationManager.VM(), vmCtx, blockView)
+	contractEpochCounter, err := getContractEpochCounter(
+		exeNode.computationManager.VM(),
+		vmCtx,
+		blockSnapshot)
 	// Failing to fetch the epoch counter from the smart contract is a fatal error.
 	if err != nil {
 		return nil, fmt.Errorf("cannot get epoch counter from the smart contract at block %s: %w", blockID.String(), err)
@@ -1076,8 +1080,16 @@ func (exeNode *ExecutionNode) LoadBootstrapper(node *NodeConfig) error {
 	return nil
 }
 
-// getContractEpochCounter Gets the epoch counters from the FlowEpoch smart contract from the view provided.
-func getContractEpochCounter(vm fvm.VM, vmCtx fvm.Context, view *delta.View) (uint64, error) {
+// getContractEpochCounter Gets the epoch counters from the FlowEpoch smart
+// contract from the snapshot provided.
+func getContractEpochCounter(
+	vm fvm.VM,
+	vmCtx fvm.Context,
+	snapshot fvmState.StorageSnapshot,
+) (
+	uint64,
+	error,
+) {
 	// Get the address of the FlowEpoch smart contract
 	sc, err := systemcontracts.SystemContractsForChain(vmCtx.Chain.ChainID())
 	if err != nil {
@@ -1092,7 +1104,7 @@ func getContractEpochCounter(vm fvm.VM, vmCtx fvm.Context, view *delta.View) (ui
 	script := fvm.Script(scriptCode)
 
 	// execute the script
-	err = vm.Run(vmCtx, script, view)
+	err = vm.Run(vmCtx, script, delta.NewDeltaView(snapshot))
 	if err != nil {
 		return 0, fmt.Errorf("could not read epoch counter, internal error while executing script: %w", err)
 	}

cmd/observer/node_builder/observer_builder.go

@@ -268,14 +268,7 @@ func (builder *ObserverServiceBuilder) buildFollowerState() *ObserverServiceBuil
 			return fmt.Errorf("only implementations of type badger.State are currently supported but read-only state has type %T", node.State)
 		}
 
-		followerState, err := badgerState.NewFollowerState(
-			state,
-			node.Storage.Index,
-			node.Storage.Payloads,
-			node.Tracer,
-			node.ProtocolEvents,
-			blocktimer.DefaultBlockTimer,
-		)
+		followerState, err := badgerState.NewFollowerState(state, node.Storage.Index, node.Storage.Payloads, node.Tracer, node.ProtocolEvents, blocktimer.DefaultBlockTimer)
 		builder.FollowerState = followerState
 
 		return err

cmd/scaffold.go

@@ -928,6 +928,7 @@ func (fnb *FlowNodeBuilder) initStorage() error {
 	index := bstorage.NewIndex(fnb.Metrics.Cache, fnb.DB)
 	payloads := bstorage.NewPayloads(fnb.DB, index, guarantees, seals, receipts, results)
 	blocks := bstorage.NewBlocks(fnb.DB, headers, payloads)
+	qcs := bstorage.NewQuorumCertificates(fnb.Metrics.Cache, fnb.DB, bstorage.DefaultCacheSize)
 	transactions := bstorage.NewTransactions(fnb.Metrics.Cache, fnb.DB)
 	collections := bstorage.NewCollections(fnb.DB, transactions)
 	setups := bstorage.NewEpochSetups(fnb.Metrics.Cache, fnb.DB)
@@ -936,20 +937,21 @@ func (fnb *FlowNodeBuilder) initStorage() error {
 	commits := bstorage.NewCommits(fnb.Metrics.Cache, fnb.DB)
 
 	fnb.Storage = Storage{
-		Headers:      headers,
-		Guarantees:   guarantees,
-		Receipts:     receipts,
-		Results:      results,
-		Seals:        seals,
-		Index:        index,
-		Payloads:     payloads,
-		Blocks:       blocks,
-		Transactions: transactions,
-		Collections:  collections,
-		Setups:       setups,
-		EpochCommits: epochCommits,
-		Statuses:     statuses,
-		Commits:      commits,
+		Headers:            headers,
+		Guarantees:         guarantees,
+		Receipts:           receipts,
+		Results:            results,
+		Seals:              seals,
+		Index:              index,
+		Payloads:           payloads,
+		Blocks:             blocks,
+		QuorumCertificates: qcs,
+		Transactions:       transactions,
+		Collections:        collections,
+		Setups:             setups,
+		EpochCommits:       epochCommits,
+		Statuses:           statuses,
+		Commits:            commits,
 	}
 
 	return nil
@@ -1008,6 +1010,7 @@ func (fnb *FlowNodeBuilder) initState() error {
 			fnb.Storage.Seals,
 			fnb.Storage.Results,
 			fnb.Storage.Blocks,
+			fnb.Storage.QuorumCertificates,
 			fnb.Storage.Setups,
 			fnb.Storage.EpochCommits,
 			fnb.Storage.Statuses,
@@ -1058,6 +1061,7 @@ func (fnb *FlowNodeBuilder) initState() error {
 			fnb.Storage.Seals,
 			fnb.Storage.Results,
 			fnb.Storage.Blocks,
+			fnb.Storage.QuorumCertificates,
 			fnb.Storage.Setups,
 			fnb.Storage.EpochCommits,
 			fnb.Storage.Statuses,