feat(permissionless batches): block production without signature

cmd/geth/main.go

@@ -177,6 +177,12 @@ var (
 		utils.DABlockNativeAPIEndpointFlag,
 		utils.DABlobScanAPIEndpointFlag,
 		utils.DABeaconNodeAPIEndpointFlag,
+		utils.DARecoveryModeFlag,
+		utils.DARecoveryInitialL1BlockFlag,
+		utils.DARecoveryInitialBatchFlag,
+		utils.DARecoverySignBlocksFlag,
+		utils.DARecoveryL2EndBlockFlag,
+		utils.DARecoveryProduceBlocksFlag,
 	}
 
 	rpcFlags = []cli.Flag{

cmd/utils/flags.go

@@ -886,22 +886,46 @@ var (
 	}
 
 	// DA syncing settings
-	DASyncEnabledFlag = &cli.BoolFlag{
+	DASyncEnabledFlag = cli.BoolFlag{
 		Name:  "da.sync",
 		Usage: "Enable node syncing from DA",
 	}
-	DABlobScanAPIEndpointFlag = &cli.StringFlag{
+	DABlobScanAPIEndpointFlag = cli.StringFlag{
 		Name:  "da.blob.blobscan",
 		Usage: "BlobScan blob API endpoint",
 	}
-	DABlockNativeAPIEndpointFlag = &cli.StringFlag{
+	DABlockNativeAPIEndpointFlag = cli.StringFlag{
 		Name:  "da.blob.blocknative",
 		Usage: "BlockNative blob API endpoint",
 	}
-	DABeaconNodeAPIEndpointFlag = &cli.StringFlag{
+	DABeaconNodeAPIEndpointFlag = cli.StringFlag{
 		Name:  "da.blob.beaconnode",
 		Usage: "Beacon node API endpoint",
 	}
+	DARecoveryModeFlag = cli.BoolFlag{
+		Name:  "da.recovery",
+		Usage: "Enable recovery mode for DA syncing",
+	}
+	DARecoveryInitialL1BlockFlag = cli.Uint64Flag{
+		Name:  "da.recovery.initiall1block",
+		Usage: "Initial L1 block to start recovery from",
+	}
+	DARecoveryInitialBatchFlag = cli.Uint64Flag{
+		Name:  "da.recovery.initialbatch",
+		Usage: "Initial batch to start recovery from",
+	}
+	DARecoverySignBlocksFlag = cli.BoolFlag{
+		Name:  "da.recovery.signblocks",
+		Usage: "Sign blocks during recovery (requires correct Clique signer key and history of blocks with Clique signatures)",
+	}
+	DARecoveryL2EndBlockFlag = cli.Uint64Flag{
+		Name:  "da.recovery.l2endblock",
+		Usage: "End L2 block to recover to",
+	}
+	DARecoveryProduceBlocksFlag = cli.BoolFlag{
+		Name:  "da.recovery.produceblocks",
+		Usage: "Produce unsigned blocks after L1 recovery for permissionless batch submission",
+	}
 )
 
 // MakeDataDir retrieves the currently requested data directory, terminating
@@ -1651,6 +1675,24 @@ func setDA(ctx *cli.Context, cfg *ethconfig.Config) {
 	if ctx.IsSet(DABeaconNodeAPIEndpointFlag.Name) {
 		cfg.DA.BeaconNodeAPIEndpoint = ctx.String(DABeaconNodeAPIEndpointFlag.Name)
 	}
+	if ctx.IsSet(DARecoveryModeFlag.Name) {
+		cfg.DA.RecoveryMode = ctx.Bool(DARecoveryModeFlag.Name)
+	}
+	if ctx.IsSet(DARecoveryInitialL1BlockFlag.Name) {
+		cfg.DA.InitialL1Block = ctx.Uint64(DARecoveryInitialL1BlockFlag.Name)
+	}
+	if ctx.IsSet(DARecoveryInitialBatchFlag.Name) {
+		cfg.DA.InitialBatch = ctx.Uint64(DARecoveryInitialBatchFlag.Name)
+	}
+	if ctx.IsSet(DARecoverySignBlocksFlag.Name) {
+		cfg.DA.SignBlocks = ctx.Bool(DARecoverySignBlocksFlag.Name)
+	}
+	if ctx.IsSet(DARecoveryL2EndBlockFlag.Name) {
+		cfg.DA.L2EndBlock = ctx.Uint64(DARecoveryL2EndBlockFlag.Name)
+	}
+	if ctx.IsSet(DARecoveryProduceBlocksFlag.Name) {
+		cfg.DA.ProduceBlocks = ctx.Bool(DARecoveryProduceBlocksFlag.Name)
+	}
 }
 
 func setMaxBlockRange(ctx *cli.Context, cfg *ethconfig.Config) {

core/blockchain.go

@@ -1806,15 +1806,15 @@ func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals bool) (int, er
 	return it.index, err
 }
 
-func (bc *BlockChain) BuildAndWriteBlock(parentBlock *types.Block, header *types.Header, txs types.Transactions) (WriteStatus, error) {
+func (bc *BlockChain) BuildAndWriteBlock(parentBlock *types.Block, header *types.Header, txs types.Transactions, sign bool) (*types.Block, WriteStatus, error) {
 	if !bc.chainmu.TryLock() {
-		return NonStatTy, errInsertionInterrupted
+		return nil, NonStatTy, errInsertionInterrupted
 	}
 	defer bc.chainmu.Unlock()
 
 	statedb, err := state.New(parentBlock.Root(), bc.stateCache, bc.snaps)
 	if err != nil {
-		return NonStatTy, err
+		return nil, NonStatTy, err
 	}
 
 	statedb.StartPrefetcher("l1sync", nil)
@@ -1825,18 +1825,51 @@ func (bc *BlockChain) BuildAndWriteBlock(parentBlock *types.Block, header *types
 	tempBlock := types.NewBlockWithHeader(header).WithBody(txs, nil)
 	receipts, logs, gasUsed, err := bc.processor.Process(tempBlock, statedb, bc.vmConfig)
 	if err != nil {
-		return NonStatTy, fmt.Errorf("error processing block: %w", err)
+		return nil, NonStatTy, fmt.Errorf("error processing block: %w", err)
 	}
 
 	// TODO: once we have the extra and difficulty we need to verify the signature of the block with Clique
 	//  This should be done with https://github.com/scroll-tech/go-ethereum/pull/913.
 
-	// finalize and assemble block as fullBlock
+	if sign {
+		// remember the time as Clique will override it
+		originalTime := header.Time
+
+		err = bc.engine.Prepare(bc, header)
+		if err != nil {
+			return nil, NonStatTy, fmt.Errorf("error preparing block %d: %w", tempBlock.Number().Uint64(), err)
+		}
+
+		// we want to re-sign the block: set time to original value again.
+		header.Time = originalTime
+	}
+
+	// finalize and assemble block as fullBlock: replicates consensus.FinalizeAndAssemble()
 	header.GasUsed = gasUsed
 	header.Root = statedb.IntermediateRoot(bc.chainConfig.IsEIP158(header.Number))
 
 	fullBlock := types.NewBlock(header, txs, nil, receipts, trie.NewStackTrie(nil))
 
+	// Sign the block if requested
+	if sign {
+		resultCh, stopCh := make(chan *types.Block), make(chan struct{})
+		if err = bc.engine.Seal(bc, fullBlock, resultCh, stopCh); err != nil {
+			return nil, NonStatTy, fmt.Errorf("error sealing block %d: %w", fullBlock.Number().Uint64(), err)
+		}
+		// Clique.Seal() will only wait for a second before giving up on us. So make sure there is nothing computational heavy
+		// or a call that blocks between the call to Seal and the line below. Seal might introduce some delay, so we keep track of
+		// that artificially added delay and subtract it from overall runtime of commit().
+		fullBlock = <-resultCh
+		if fullBlock == nil {
+			return nil, NonStatTy, fmt.Errorf("sealing block failed %d: block is nil", header.Number.Uint64())
+		}
+
+		// verify the generated block with local consensus engine to make sure everything is as expected
+		if err = bc.engine.VerifyHeader(bc, fullBlock.Header(), true); err != nil {
+			return nil, NonStatTy, fmt.Errorf("error verifying signed block %d: %w", fullBlock.Number().Uint64(), err)
+		}
+	}
+
 	blockHash := fullBlock.Hash()
 	// manually replace the block hash in the receipts
 	for i, receipt := range receipts {
@@ -1853,7 +1886,18 @@ func (bc *BlockChain) BuildAndWriteBlock(parentBlock *types.Block, header *types
 		l.BlockHash = blockHash
 	}
 
-	return bc.writeBlockWithState(fullBlock, receipts, logs, statedb, false)
+	// Double check: even though we just built the block, make sure it is valid.
+	if err = bc.validator.ValidateBody(fullBlock); err != nil {
+		bc.reportBlock(fullBlock, receipts, err)
+		return nil, NonStatTy, fmt.Errorf("error validating block %d: %w", fullBlock.Number().Uint64(), err)
+	}
+	if err = bc.validator.ValidateState(fullBlock, statedb, receipts, gasUsed); err != nil {
+		bc.reportBlock(fullBlock, receipts, err)
+		return nil, NonStatTy, fmt.Errorf("error validating block %d: %w", fullBlock.Number().Uint64(), err)
+	}
+
+	writeStatus, err := bc.writeBlockWithState(fullBlock, receipts, logs, statedb, false)
+	return fullBlock, writeStatus, err
 }
 
 // insertSideChain is called when an import batch hits upon a pruned ancestor

eth/backend.go

@@ -229,11 +229,15 @@ func New(stack *node.Node, config *ethconfig.Config, l1Client l1.Client) (*Ether
 	// simply let them run simultaneously. If messages are missing in DA syncing, it will be handled by the syncing pipeline
 	// by waiting and retrying.
 	if config.EnableDASyncing {
-		eth.syncingPipeline, err = da_syncer.NewSyncingPipeline(context.Background(), eth.blockchain, chainConfig, eth.chainDb, l1Client, stack.Config().L1DeploymentBlock, config.DA)
-		if err != nil {
-			return nil, fmt.Errorf("cannot initialize da syncer: %w", err)
+		// Do not start syncing pipeline if we are producing blocks for permissionless batches.
+		if !config.DA.ProduceBlocks {
+			eth.syncingPipeline, err = da_syncer.NewSyncingPipeline(context.Background(), eth.blockchain, chainConfig, eth.chainDb, l1Client, stack.Config().L1DeploymentBlock, config.DA)
+			if err != nil {
+				return nil, fmt.Errorf("cannot initialize da syncer: %w", err)
+			}
+
+			eth.syncingPipeline.Start()
 		}
-		eth.syncingPipeline.Start()
 	}
 
 	// initialize and start L1 message sync service
@@ -273,7 +277,8 @@ func New(stack *node.Node, config *ethconfig.Config, l1Client l1.Client) (*Ether
 		return nil, err
 	}
 
-	eth.miner = miner.New(eth, &config.Miner, chainConfig, eth.EventMux(), eth.engine, eth.isLocalBlock, config.EnableDASyncing)
+	config.Miner.SigningDisabled = config.DA.ProduceBlocks
+	eth.miner = miner.New(eth, &config.Miner, eth.blockchain.Config(), eth.EventMux(), eth.engine, eth.isLocalBlock, config.EnableDASyncing && !config.DA.ProduceBlocks)
 	eth.miner.SetExtra(makeExtraData(config.Miner.ExtraData))
 
 	eth.APIBackend = &EthAPIBackend{stack.Config().ExtRPCEnabled(), stack.Config().AllowUnprotectedTxs, eth, nil}
@@ -588,7 +593,10 @@ func (s *Ethereum) Protocols() []p2p.Protocol {
 // Start implements node.Lifecycle, starting all internal goroutines needed by the
 // Ethereum protocol implementation.
 func (s *Ethereum) Start() error {
-	eth.StartENRUpdater(s.blockchain, s.p2pServer.LocalNode())
+	// handler is not enabled when DA syncing enabled
+	if !s.config.EnableDASyncing {
+		eth.StartENRUpdater(s.blockchain, s.p2pServer.LocalNode())
+	}
 
 	// Start the bloom bits servicing goroutines
 	s.startBloomHandlers(params.BloomBitsBlocks)
@@ -629,7 +637,7 @@ func (s *Ethereum) Stop() error {
 	if s.config.EnableRollupVerify {
 		s.rollupSyncService.Stop()
 	}
-	if s.config.EnableDASyncing {
+	if s.config.EnableDASyncing && s.syncingPipeline != nil {
 		s.syncingPipeline.Stop()
 	}
 	s.miner.Close()

miner/miner.go

@@ -60,6 +60,8 @@ type Config struct {
 	StoreSkippedTxTraces bool // Whether store the wrapped traces when storing a skipped tx
 	MaxAccountsNum       int  // Maximum number of accounts that miner will fetch the pending transactions of when building a new block
 	CCCMaxWorkers        int  // Maximum number of workers to use for async CCC tasks
+
+	SigningDisabled bool // Whether to disable signing blocks with consensus enginek
 }
 
 // Miner creates blocks and searches for proof-of-work values.

miner/scroll_worker.go

@@ -477,11 +477,19 @@ func (w *worker) newWork(now time.Time, parentHash common.Hash, reorging bool, r
 		header.Coinbase = w.coinbase
 	}
 
-	prepareStart := time.Now()
-	if err := w.engine.Prepare(w.chain, header); err != nil {
-		return fmt.Errorf("failed to prepare header for mining: %w", err)
+	if w.config.SigningDisabled {
+		// Need to make sure to set difficulty so that a new canonical chain is detected in Blockchain
+		header.Difficulty = new(big.Int).SetUint64(1)
+		header.MixDigest = common.Hash{}
+		header.Coinbase = common.Address{}
+		header.Nonce = types.BlockNonce{}
+	} else {
+		prepareStart := time.Now()
+		if err := w.engine.Prepare(w.chain, header); err != nil {
+			return fmt.Errorf("failed to prepare header for mining: %w", err)
+		}
+		prepareTimer.UpdateSince(prepareStart)
 	}
-	prepareTimer.UpdateSince(prepareStart)
 
 	var nextL1MsgIndex uint64
 	if dbVal := rawdb.ReadFirstQueueIndexNotInL2Block(w.eth.ChainDb(), header.ParentHash); dbVal != nil {
@@ -828,28 +836,33 @@ func (w *worker) commit() (common.Hash, error) {
 		return common.Hash{}, err
 	}
 
-	sealHash := w.engine.SealHash(block.Header())
-	log.Info("Committing new mining work", "number", block.Number(), "sealhash", sealHash,
-		"txs", w.current.txs.Len(),
-		"gas", block.GasUsed(), "fees", totalFees(block, w.current.receipts))
-
-	resultCh, stopCh := make(chan *types.Block), make(chan struct{})
-	if err := w.engine.Seal(w.chain, block, resultCh, stopCh); err != nil {
-		return common.Hash{}, err
-	}
-	// Clique.Seal() will only wait for a second before giving up on us. So make sure there is nothing computational heavy
-	// or a call that blocks between the call to Seal and the line below. Seal might introduce some delay, so we keep track of
-	// that artificially added delay and subtract it from overall runtime of commit().
-	sealStart := time.Now()
-	block = <-resultCh
-	sealDelay = time.Since(sealStart)
-	if block == nil {
-		return common.Hash{}, errors.New("missed seal response from consensus engine")
-	}
+	var sealHash common.Hash
+	if w.config.SigningDisabled {
+		sealHash = block.Hash()
+	} else {
+		sealHash = w.engine.SealHash(block.Header())
+		log.Info("Committing new mining work", "number", block.Number(), "sealhash", sealHash,
+			"txs", w.current.txs.Len(),
+			"gas", block.GasUsed(), "fees", totalFees(block, w.current.receipts))
+
+		resultCh, stopCh := make(chan *types.Block), make(chan struct{})
+		if err := w.engine.Seal(w.chain, block, resultCh, stopCh); err != nil {
+			return common.Hash{}, err
+		}
+		// Clique.Seal() will only wait for a second before giving up on us. So make sure there is nothing computational heavy
+		// or a call that blocks between the call to Seal and the line below. Seal might introduce some delay, so we keep track of
+		// that artificially added delay and subtract it from overall runtime of commit().
+		sealStart := time.Now()
+		block = <-resultCh
+		sealDelay = time.Since(sealStart)
+		if block == nil {
+			return common.Hash{}, errors.New("missed seal response from consensus engine")
+		}
 
-	// verify the generated block with local consensus engine to make sure everything is as expected
-	if err = w.engine.VerifyHeader(w.chain, block.Header(), true); err != nil {
-		return common.Hash{}, retryableCommitError{inner: err}
+		// verify the generated block with local consensus engine to make sure everything is as expected
+		if err = w.engine.VerifyHeader(w.chain, block.Header(), true); err != nil {
+			return common.Hash{}, retryableCommitError{inner: err}
+		}
 	}
 
 	blockHash := block.Hash()

params/version.go

@@ -24,7 +24,7 @@ import (
 const (
 	VersionMajor = 5         // Major version component of the current release
 	VersionMinor = 8         // Minor version component of the current release
-	VersionPatch = 7         // Patch version component of the current release
+	VersionPatch = 8         // Patch version component of the current release
 	VersionMeta  = "mainnet" // Version metadata to append to the version string
 )
 

rollup/da_syncer/batch_queue.go

@@ -36,6 +36,12 @@ func (bq *BatchQueue) NextBatch(ctx context.Context) (da.Entry, error) {
 	}
 
 	for {
+		select {
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		default:
+		}
+
 		daEntry, err := bq.DAQueue.NextDA(ctx)
 		if err != nil {
 			return nil, err

rollup/da_syncer/da/calldata_blob_source.go

@@ -10,6 +10,7 @@ import (
 	"github.com/scroll-tech/go-ethereum/accounts/abi"
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/ethdb"
+	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/scroll-tech/go-ethereum/rollup/da_syncer/blob_client"
 	"github.com/scroll-tech/go-ethereum/rollup/da_syncer/serrors"
 	"github.com/scroll-tech/go-ethereum/rollup/l1"
@@ -65,6 +66,8 @@ func (ds *CalldataBlobSource) NextData() (Entries, error) {
 		to = min(to, ds.l1Finalized)
 	}
 
+	log.Debug("Fetching rollup events", "from", ds.l1Height, "to", to, "finalized", ds.l1Finalized)
+
 	if ds.l1Height > to {
 		return nil, ErrSourceExhausted
 	}
@@ -194,7 +197,7 @@ func (ds *CalldataBlobSource) getCommitBatchDA(commitEvents []*l1.CommitBatchEve
 	}
 
 	if commitEvents[0].BatchIndex().Uint64() == 0 {
-		return Entries{NewCommitBatchDAV0Empty()}, nil
+		return Entries{NewCommitBatchDAV0Empty(commitEvents[0])}, nil
 	}
 
 	firstCommitEvent := commitEvents[0]

rollup/da_syncer/da/commitV0.go

@@ -10,6 +10,7 @@ import (
 	"github.com/scroll-tech/go-ethereum/core/rawdb"
 	"github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/ethdb"
+	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/scroll-tech/go-ethereum/rollup/da_syncer/serrors"
 	"github.com/scroll-tech/go-ethereum/rollup/l1"
 )
@@ -65,9 +66,10 @@ func NewCommitBatchDAV0WithChunks(db ethdb.Database,
 	}, nil
 }
 
-func NewCommitBatchDAV0Empty() *CommitBatchDAV0 {
+func NewCommitBatchDAV0Empty(event *l1.CommitBatchEvent) *CommitBatchDAV0 {
 	return &CommitBatchDAV0{
 		batchIndex: 0,
+		event:      event,
 	}
 }
 
@@ -172,6 +174,7 @@ func getL1Messages(db ethdb.Database, parentTotalL1MessagePopped uint64, skipped
 		}
 		l1Tx := rawdb.ReadL1Message(db, currentIndex)
 		if l1Tx == nil {
+			log.Info("L1 message not yet available", "index", currentIndex)
 			// message not yet available
 			// we return serrors.EOFError as this will be handled in the syncing pipeline with a backoff and retry
 			return nil, serrors.EOFError