fix(block): save created block for recovery and simplify genesis flow (#2672)

<!--
Please read and fill out this form before submitting your PR.

Please make sure you have reviewed our contributors guide before
submitting your
first PR.

NOTE: PR titles should follow semantic commits:
https://www.conventionalcommits.org/en/v1.0.0/
-->

## Overview

<!-- 
Please provide an explanation of the PR, including the appropriate
context,
background, goal, and rationale. If there is an issue with this
information,
please provide a tl;dr and link the issue. 

Ex: Closes #<issue number>
-->

Author: julienrbrt

block/components_test.go

@@ -123,23 +123,28 @@ func TestNewAggregatorComponents_Creation(t *testing.T) {
 	memStore := store.New(ds)
 
 	cfg := config.DefaultConfig
+
+	// Create a test signer first
+	priv, _, err := crypto.GenerateEd25519Key(crand.Reader)
+	require.NoError(t, err)
+	mockSigner, err := noop.NewNoopSigner(priv)
+	require.NoError(t, err)
+
+	// Get the signer's address to use as proposer
+	signerAddr, err := mockSigner.GetAddress()
+	require.NoError(t, err)
+
 	gen := genesis.Genesis{
 		ChainID:         "test-chain",
 		InitialHeight:   1,
 		StartTime:       time.Now(),
-		ProposerAddress: []byte("test-proposer"),
+		ProposerAddress: signerAddr,
 	}
 
 	mockExec := testmocks.NewMockExecutor(t)
 	mockSeq := testmocks.NewMockSequencer(t)
 	dummyDA := coreda.NewDummyDA(10_000_000, 0, 0, 10*time.Millisecond)
 
-	// Create a test signer
-	priv, _, err := crypto.GenerateEd25519Key(crand.Reader)
-	require.NoError(t, err)
-	mockSigner, err := noop.NewNoopSigner(priv)
-	require.NoError(t, err)
-
 	components, err := NewAggregatorComponents(
 		cfg,
 		gen,

block/internal/common/errors.go

@@ -4,9 +4,9 @@ import (
 	"errors"
 )
 
-// These errors are used by Manager.
+// These errors are used by block components.
 var (
-	// ErrNotProposer is used when the manager is not a proposer
+	// ErrNotProposer is used when the node is not a proposer
 	ErrNotProposer = errors.New("not a proposer")
 
 	// ErrNoBatch indicate no batch is available for creating block

block/internal/executing/executor.go

@@ -8,6 +8,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/ipfs/go-datastore"
 	"github.com/rs/zerolog"
 	"golang.org/x/sync/errgroup"
 
@@ -187,11 +188,6 @@ func (e *Executor) initializeState() error {
 			return fmt.Errorf("failed to initialize chain: %w", err)
 		}
 
-		// Create genesis block
-		if err := e.createGenesisBlock(e.ctx, stateRoot); err != nil {
-			return fmt.Errorf("failed to create genesis block: %w", err)
-		}
-
 		state = types.State{
 			ChainID:         e.genesis.ChainID,
 			InitialHeight:   e.genesis.InitialHeight,
@@ -215,55 +211,6 @@ func (e *Executor) initializeState() error {
 	return nil
 }
 
-// createGenesisBlock creates and stores the genesis block
-func (e *Executor) createGenesisBlock(ctx context.Context, stateRoot []byte) error {
-	header := types.Header{
-		AppHash:         stateRoot,
-		DataHash:        common.DataHashForEmptyTxs,
-		ProposerAddress: e.genesis.ProposerAddress,
-		BaseHeader: types.BaseHeader{
-			ChainID: e.genesis.ChainID,
-			Height:  e.genesis.InitialHeight,
-			Time:    uint64(e.genesis.StartTime.UnixNano()),
-		},
-	}
-
-	if e.signer == nil {
-		return errors.New("signer cannot be nil")
-	}
-
-	pubKey, err := e.signer.GetPublic()
-	if err != nil {
-		return fmt.Errorf("failed to get public key: %w", err)
-	}
-
-	bz, err := e.options.AggregatorNodeSignatureBytesProvider(&header)
-	if err != nil {
-		return fmt.Errorf("failed to get signature payload: %w", err)
-	}
-
-	sig, err := e.signer.Sign(bz)
-	if err != nil {
-		return fmt.Errorf("failed to sign header: %w", err)
-	}
-
-	var signature types.Signature
-	data := &types.Data{}
-
-	signature = sig
-
-	genesisHeader := &types.SignedHeader{
-		Header: header,
-		Signer: types.Signer{
-			PubKey:  pubKey,
-			Address: e.genesis.ProposerAddress,
-		},
-		Signature: signature,
-	}
-
-	return e.store.SaveBlockData(ctx, genesisHeader, data, &signature)
-}
-
 // executionLoop handles block production and aggregation
 func (e *Executor) executionLoop() {
 	e.logger.Info().Msg("starting execution loop")
@@ -364,20 +311,41 @@ func (e *Executor) produceBlock() error {
 		}
 	}
 
-	// get batch from sequencer
-	batchData, err := e.retrieveBatch(e.ctx)
-	if errors.Is(err, common.ErrNoBatch) {
-		e.logger.Debug().Msg("no batch available")
-		return nil
-	} else if errors.Is(err, common.ErrNoTransactionsInBatch) {
-		e.logger.Debug().Msg("no transactions in batch")
-	} else if err != nil {
-		return fmt.Errorf("failed to retrieve batch: %w", err)
-	}
+	var (
+		header *types.SignedHeader
+		data   *types.Data
+	)
+
+	// Check if there's an already stored block at the newHeight
+	// If there is use that instead of creating a new block
+	pendingHeader, pendingData, err := e.store.GetBlockData(e.ctx, newHeight)
+	if err == nil {
+		e.logger.Info().Uint64("height", newHeight).Msg("using pending block")
+		header = pendingHeader
+		data = pendingData
+	} else if !errors.Is(err, datastore.ErrNotFound) {
+		return fmt.Errorf("failed to get block data: %w", err)
+	} else {
+		// get batch from sequencer
+		batchData, err := e.retrieveBatch(e.ctx)
+		if errors.Is(err, common.ErrNoBatch) {
+			e.logger.Debug().Msg("no batch available")
+			return nil
+		} else if errors.Is(err, common.ErrNoTransactionsInBatch) {
+			e.logger.Debug().Msg("no transactions in batch")
+		} else if err != nil {
+			return fmt.Errorf("failed to retrieve batch: %w", err)
+		}
 
-	header, data, err := e.createBlock(e.ctx, newHeight, batchData)
-	if err != nil {
-		return fmt.Errorf("failed to create block: %w", err)
+		header, data, err = e.createBlock(e.ctx, newHeight, batchData)
+		if err != nil {
+			return fmt.Errorf("failed to create block: %w", err)
+		}
+
+		// saved early for crash recovery, will be overwritten later with the final signature
+		if err = e.store.SaveBlockData(e.ctx, header, data, &types.Signature{}); err != nil {
+			return fmt.Errorf("failed to save block: %w", err)
+		}
 	}
 
 	newState, err := e.applyBlock(e.ctx, header.Header, data)
@@ -459,18 +427,28 @@ func (e *Executor) retrieveBatch(ctx context.Context) (*BatchData, error) {
 // createBlock creates a new block from the given batch
 func (e *Executor) createBlock(ctx context.Context, height uint64, batchData *BatchData) (*types.SignedHeader, *types.Data, error) {
 	currentState := e.GetLastState()
+	headerTime := uint64(e.genesis.StartTime.UnixNano())
 
 	// Get last block info
 	var lastHeaderHash types.Hash
 	var lastDataHash types.Hash
+	var lastSignature types.Signature
 
 	if height > e.genesis.InitialHeight {
+		headerTime = uint64(batchData.UnixNano())
+
 		lastHeader, lastData, err := e.store.GetBlockData(ctx, height-1)
 		if err != nil {
 			return nil, nil, fmt.Errorf("failed to get last block: %w", err)
 		}
 		lastHeaderHash = lastHeader.Hash()
 		lastDataHash = lastData.Hash()
+
+		lastSignaturePtr, err := e.store.GetSignature(ctx, height-1)
+		if err != nil {
+			return nil, nil, fmt.Errorf("failed to get last signature: %w", err)
+		}
+		lastSignature = *lastSignaturePtr
 	}
 
 	// Get signer info
@@ -479,7 +457,6 @@ func (e *Executor) createBlock(ctx context.Context, height uint64, batchData *Ba
 		return nil, nil, fmt.Errorf("failed to get public key: %w", err)
 	}
 
-	// Build validator hash
 	// Get validator hash
 	validatorHash, err := e.options.ValidatorHasherProvider(e.genesis.ProposerAddress, pubKey)
 	if err != nil {
@@ -496,14 +473,15 @@ func (e *Executor) createBlock(ctx context.Context, height uint64, batchData *Ba
 			BaseHeader: types.BaseHeader{
 				ChainID: e.genesis.ChainID,
 				Height:  height,
-				Time:    uint64(batchData.UnixNano()),
+				Time:    headerTime,
 			},
 			LastHeaderHash:  lastHeaderHash,
 			ConsensusHash:   make(types.Hash, 32),
 			AppHash:         currentState.AppHash,
 			ProposerAddress: e.genesis.ProposerAddress,
 			ValidatorHash:   validatorHash,
 		},
+		Signature: lastSignature,
 		Signer: types.Signer{
 			PubKey:  pubKey,
 			Address: e.genesis.ProposerAddress,
@@ -639,6 +617,9 @@ func (e *Executor) sendCriticalError(err error) {
 
 // recordBlockMetrics records metrics for the produced block
 func (e *Executor) recordBlockMetrics(data *types.Data) {
+	if data == nil || data.Metadata == nil {
+		return
+	}
 	e.metrics.NumTxs.Set(float64(len(data.Txs)))
 	e.metrics.TotalTxs.Add(float64(len(data.Txs)))
 	e.metrics.BlockSizeBytes.Set(float64(data.Size()))