FEATURE: Serializable Snapshots

access/api.go

@@ -39,6 +39,8 @@ type API interface {
 
 	GetEventsForHeightRange(ctx context.Context, eventType string, startHeight, endHeight uint64) ([]flow.BlockEvents, error)
 	GetEventsForBlockIDs(ctx context.Context, eventType string, blockIDs []flow.Identifier) ([]flow.BlockEvents, error)
+
+	GetLatestProtocolStateSnapshot(ctx context.Context) ([]byte, error)
 }
 
 // TODO: Combine this with flow.TransactionResult?

access/handler.go

@@ -2,7 +2,6 @@ package access
 
 import (
 	"context"
-	"fmt"
 
 	"github.com/golang/protobuf/ptypes"
 	"github.com/onflow/flow/protobuf/go/flow/access"
@@ -36,11 +35,6 @@ func (h *Handler) Ping(ctx context.Context, _ *access.PingRequest) (*access.Ping
 	return &access.PingResponse{}, nil
 }
 
-func (h *Handler) GetLatestProtocolStateSnapshot(_ context.Context,
-	_ *access.GetLatestProtocolStateSnapshotRequest) (*access.ProtocolStateSnapshotResponse, error) {
-	return nil, fmt.Errorf("unimplemented method")
-}
-
 func (h *Handler) GetNetworkParameters(
 	ctx context.Context,
 	_ *access.GetNetworkParametersRequest,
@@ -411,6 +405,18 @@ func (h *Handler) GetEventsForBlockIDs(
 	}, nil
 }
 
+// GetLatestProtocolStateSnapshot returns the latest serializable Snapshot
+func (h *Handler) GetLatestProtocolStateSnapshot(ctx context.Context, req *access.GetLatestProtocolStateSnapshotRequest) (*access.ProtocolStateSnapshotResponse, error) {
+	snapshot, err := h.api.GetLatestProtocolStateSnapshot(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return &access.ProtocolStateSnapshotResponse{
+		SerializedSnapshot: snapshot,
+	}, nil
+}
+
 func blockResponse(block *flow.Block) (*access.BlockResponse, error) {
 	msg, err := convert.BlockToMessage(block)
 	if err != nil {

cmd/bootstrap/cmd/block.go

@@ -5,7 +5,6 @@ import (
 	"time"
 
 	"github.com/onflow/flow-go/cmd/bootstrap/run"
-	model "github.com/onflow/flow-go/model/bootstrap"
 	"github.com/onflow/flow-go/model/flow"
 )
 
@@ -18,8 +17,6 @@ func constructRootBlock(rootChain string, rootParent string, rootHeight uint64,
 
 	block := run.GenerateRootBlock(chainID, parentID, height, timestamp)
 
-	writeJSON(model.PathRootBlock, block)
-
 	return block
 }
 

cmd/bootstrap/cmd/finalize.go

@@ -15,6 +15,7 @@ import (
 	model "github.com/onflow/flow-go/model/bootstrap"
 	"github.com/onflow/flow-go/model/encodable"
 	"github.com/onflow/flow-go/model/flow"
+	"github.com/onflow/flow-go/state/protocol/inmem"
 )
 
 var (
@@ -146,7 +147,7 @@ func finalize(cmd *cobra.Command, args []string) {
 	log.Info().Msg("")
 
 	log.Info().Msg("constructing root QC")
-	constructRootQC(
+	rootQC := constructRootQC(
 		block,
 		model.FilterByRole(stakingNodes, flow.RoleConsensus),
 		model.FilterByRole(internalNodes, flow.RoleConsensus),
@@ -167,7 +168,17 @@ func finalize(cmd *cobra.Command, args []string) {
 	log.Info().Msg("")
 
 	log.Info().Msg("constructing root execution result and block seal")
-	constructRootResultAndSeal(flagRootCommit, block, stakingNodes, assignments, clusterQCs, dkgData)
+	result, seal := constructRootResultAndSeal(flagRootCommit, block, stakingNodes, assignments, clusterQCs, dkgData)
+	log.Info().Msg("")
+
+	// construct serializable root protocol snapshot
+	log.Info().Msg("constructing root procotol snapshot")
+	snapshot, err := inmem.SnapshotFromBootstrapState(block, result, seal, rootQC)
+	if err != nil {
+		log.Fatal().Err(err).Msg("unable to generate root protocol snapshot")
+	}
+	// write snapshot to disk
+	writeJSON(model.PathRootProtocolStateSnapshot, snapshot.Encodable())
 	log.Info().Msg("")
 
 	// copy files only if the directories differ

cmd/bootstrap/cmd/qc.go

@@ -6,7 +6,7 @@ import (
 	"github.com/onflow/flow-go/model/flow"
 )
 
-func constructRootQC(block *flow.Block, allNodes, internalNodes []model.NodeInfo, dkgData model.DKGData) {
+func constructRootQC(block *flow.Block, allNodes, internalNodes []model.NodeInfo, dkgData model.DKGData) *flow.QuorumCertificate {
 	participantData, err := run.GenerateQCParticipantData(allNodes, internalNodes, dkgData)
 	if err != nil {
 		log.Fatal().Err(err).Msg("failed to generate QC participant data")
@@ -17,5 +17,5 @@ func constructRootQC(block *flow.Block, allNodes, internalNodes []model.NodeInfo
 		log.Fatal().Err(err).Msg("generating root QC failed")
 	}
 
-	writeJSON(model.PathRootQC, qc)
+	return qc
 }

cmd/bootstrap/cmd/seal.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"crypto/rand"
 	"encoding/hex"
 
 	"github.com/onflow/flow-go/cmd/bootstrap/run"
@@ -16,22 +17,28 @@ func constructRootResultAndSeal(
 	assignments flow.AssignmentList,
 	clusterQCs []*flow.QuorumCertificate,
 	dkgData model.DKGData,
-) {
+) (*flow.ExecutionResult, *flow.Seal) {
 
 	stateCommit, err := hex.DecodeString(rootCommit)
 	if err != nil {
 		log.Fatal().Err(err).Msg("could not decode state commitment")
 	}
 
 	participants := model.ToIdentityList(participantNodes)
-	blockID := block.ID()
+
+	randomSource := make([]byte, flow.EpochSetupRandomSourceLength)
+	_, err = rand.Read(randomSource)
+	if err != nil {
+		log.Fatal().Err(err).Msg("could not generate random source for epoch setup event")
+	}
 
 	epochSetup := &flow.EpochSetup{
 		Counter:      flagEpochCounter,
+		FirstView:    block.Header.View,
 		FinalView:    block.Header.View + leader.EstimatedSixMonthOfViews,
 		Participants: participants,
 		Assignments:  assignments,
-		RandomSource: blockID[:],
+		RandomSource: randomSource,
 	}
 
 	dkgLookup := model.ToDKGLookup(dkgData, participants)
@@ -43,9 +50,8 @@ func constructRootResultAndSeal(
 		DKGParticipants: dkgLookup,
 	}
 
-	result := run.GenerateRootResult(block, stateCommit)
-	seal := run.GenerateRootSeal(result, epochSetup, epochCommit)
+	result := run.GenerateRootResult(block, stateCommit, epochSetup, epochCommit)
+	seal := run.GenerateRootSeal(result)
 
-	writeJSON(model.PathRootResult, result)
-	writeJSON(model.PathRootSeal, seal)
+	return result, seal
 }

cmd/bootstrap/run/result.go

@@ -5,11 +5,18 @@ import (
 	"github.com/onflow/flow-go/model/flow"
 )
 
-func GenerateRootResult(block *flow.Block, commit flow.StateCommitment) *flow.ExecutionResult {
+func GenerateRootResult(
+	block *flow.Block,
+	commit flow.StateCommitment,
+	epochSetup *flow.EpochSetup,
+	epochCommit *flow.EpochCommit,
+) *flow.ExecutionResult {
+
 	result := &flow.ExecutionResult{
 		PreviousResultID: flow.ZeroID,
 		BlockID:          block.ID(),
 		Chunks:           chunks.ChunkListFromCommit(commit),
+		ServiceEvents:    []flow.ServiceEvent{epochSetup.ServiceEvent(), epochCommit.ServiceEvent()},
 	}
 	return result
 }

cmd/bootstrap/run/seal.go

@@ -4,13 +4,12 @@ import (
 	"github.com/onflow/flow-go/model/flow"
 )
 
-func GenerateRootSeal(result *flow.ExecutionResult, setup *flow.EpochSetup, commit *flow.EpochCommit) *flow.Seal {
+func GenerateRootSeal(result *flow.ExecutionResult) *flow.Seal {
 	finalState, _ := result.FinalStateCommitment()
 	seal := &flow.Seal{
-		BlockID:       result.BlockID,
-		ResultID:      result.ID(),
-		FinalState:    finalState,
-		ServiceEvents: []flow.ServiceEvent{setup.ServiceEvent(), commit.ServiceEvent()},
+		BlockID:    result.BlockID,
+		ResultID:   result.ID(),
+		FinalState: finalState,
 	}
 	return seal
 }