refactor: introduce partial header and partial block for data from DA before execution

Author: jonastheis

core/blockchain.go

@@ -1835,18 +1835,18 @@ func (bc *BlockChain) BuildAndWriteBlock(parentBlock *types.Block, header *types
 		return NonStatTy, err
 	}
 
+	header.ParentHash = parentBlock.Hash()
+
 	tempBlock := types.NewBlockWithHeader(header).WithBody(txs, nil)
 	receipts, logs, gasUsed, err := bc.processor.Process(tempBlock, statedb, bc.vmConfig)
 	if err != nil {
 		return NonStatTy, err
 	}
 
 	header.GasUsed = gasUsed
-	header.ParentHash = parentBlock.Hash()
 	header.Root = statedb.GetRootHash()
 	// Since we're using Clique consensus, we don't have uncles
 	header.UncleHash = types.EmptyUncleHash
-	// TODO: extraData and difficulty should be set
 
 	fullBlock := types.NewBlock(header, txs, nil, receipts, trie.NewStackTrie(nil))
 

rollup/da_syncer/block_queue.go

@@ -4,23 +4,22 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/rollup/da_syncer/da"
 )
 
 type BlockQueue struct {
 	batchQueue *BatchQueue
-	blocks     []*types.Block
+	blocks     []*da.PartialBlock
 }
 
 func NewBlockQueue(batchQueue *BatchQueue) *BlockQueue {
 	return &BlockQueue{
 		batchQueue: batchQueue,
-		blocks:     []*types.Block{},
+		blocks:     make([]*da.PartialBlock, 0),
 	}
 }
 
-func (bq *BlockQueue) NextBlock(ctx context.Context) (*types.Block, error) {
+func (bq *BlockQueue) NextBlock(ctx context.Context) (*da.PartialBlock, error) {
 	for len(bq.blocks) == 0 {
 		err := bq.getBlocksFromBatch(ctx)
 		if err != nil {

rollup/da_syncer/da/commitV0.go

@@ -4,7 +4,6 @@ import (
 	"encoding/binary"
 	"fmt"
 	"io"
-	"math/big"
 
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/da-codec/encoding/codecv0"
@@ -84,20 +83,13 @@ func (c *CommitBatchDAV0) BatchIndex() uint64 {
 	return c.batchIndex
 }
 
-func (c *CommitBatchDAV0) Blocks() ([]*types.Block, error) {
-	var blocks []*types.Block
+func (c *CommitBatchDAV0) Blocks() ([]*PartialBlock, error) {
+	var blocks []*PartialBlock
 	l1TxPointer := 0
 
 	curL1TxIndex := c.parentTotalL1MessagePopped
 	for _, chunk := range c.chunks {
 		for blockId, daBlock := range chunk.Blocks {
-			// create header
-			header := types.Header{
-				Number:   big.NewInt(0).SetUint64(daBlock.BlockNumber),
-				Time:     daBlock.Timestamp,
-				BaseFee:  daBlock.BaseFee,
-				GasLimit: daBlock.GasLimit,
-			}
 			// create txs
 			// var txs types.Transactions
 			txs := make(types.Transactions, 0, daBlock.NumTransactions)
@@ -110,7 +102,17 @@ func (c *CommitBatchDAV0) Blocks() ([]*types.Block, error) {
 			curL1TxIndex += uint64(daBlock.NumL1Messages)
 			// insert l2 txs
 			txs = append(txs, chunk.Transactions[blockId]...)
-			block := types.NewBlockWithHeader(&header).WithBody(txs, make([]*types.Header, 0))
+
+			block := NewPartialBlock(
+				&PartialHeader{
+					Number:   daBlock.BlockNumber,
+					Time:     daBlock.Timestamp,
+					BaseFee:  daBlock.BaseFee,
+					GasLimit: daBlock.GasLimit,
+					//TODO: Difficulty: new(big.Int).SetUint64(10),
+					//TODO: ExtraData:  []byte{1, 2, 3, 4, 5, 6, 7, 8},
+				},
+				txs)
 			blocks = append(blocks, block)
 		}
 	}

rollup/da_syncer/da/da.go

@@ -1,6 +1,8 @@
 package da
 
 import (
+	"math/big"
+
 	"github.com/scroll-tech/go-ethereum/core/types"
 )
 
@@ -29,7 +31,39 @@ type Entry interface {
 
 type EntryWithBlocks interface {
 	Entry
-	Blocks() ([]*types.Block, error)
+	Blocks() ([]*PartialBlock, error)
 }
 
 type Entries []Entry
+
+type PartialHeader struct {
+	Number     uint64
+	Time       uint64
+	BaseFee    *big.Int
+	GasLimit   uint64
+	Difficulty *big.Int
+	ExtraData  []byte
+}
+
+func (h *PartialHeader) ToHeader() *types.Header {
+	return &types.Header{
+		Number:     big.NewInt(0).SetUint64(h.Number),
+		Time:       h.Time,
+		BaseFee:    h.BaseFee,
+		GasLimit:   h.GasLimit,
+		Difficulty: h.Difficulty,
+		Extra:      h.ExtraData,
+	}
+}
+
+type PartialBlock struct {
+	PartialHeader *PartialHeader
+	Transactions  types.Transactions
+}
+
+func NewPartialBlock(partialHeader *PartialHeader, txs types.Transactions) *PartialBlock {
+	return &PartialBlock{
+		PartialHeader: partialHeader,
+		Transactions:  txs,
+	}
+}

rollup/da_syncer/da_syncer.go

@@ -2,12 +2,10 @@ package da_syncer
 
 import (
 	"fmt"
-	"math/big"
 
-	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/core"
-	"github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/scroll-tech/go-ethereum/rollup/da_syncer/da"
 )
 
 type DASyncer struct {
@@ -20,23 +18,19 @@ func NewDASyncer(blockchain *core.BlockChain) *DASyncer {
 	}
 }
 
-func (s *DASyncer) SyncOneBlock(block *types.Block) error {
+func (s *DASyncer) SyncOneBlock(block *da.PartialBlock) error {
 	parentBlock := s.blockchain.CurrentBlock()
-	if big.NewInt(0).Add(parentBlock.Number(), common.Big1).Cmp(block.Number()) != 0 {
-		return fmt.Errorf("not consecutive block, number: %d", block.Number())
+	if parentBlock.NumberU64()+1 != block.PartialHeader.Number {
+		return fmt.Errorf("not consecutive block, number: %d, chain height: %d", block.PartialHeader.Number, parentBlock.NumberU64())
 	}
 
-	header := block.Header()
-	header.Difficulty = common.Big1
-	header.BaseFee = nil // TODO: after Curie we need to fill this correctly
-	header.ParentHash = parentBlock.Hash()
-
-	if _, err := s.blockchain.BuildAndWriteBlock(parentBlock, header, block.Transactions()); err != nil {
-		return fmt.Errorf("failed building and writing block, number: %d, error: %v", block.Number(), err)
+	if _, err := s.blockchain.BuildAndWriteBlock(parentBlock, block.PartialHeader.ToHeader(), block.Transactions); err != nil {
+		return fmt.Errorf("failed building and writing block, number: %d, error: %v", block.PartialHeader.Number, err)
 	}
 
 	if s.blockchain.CurrentBlock().Header().Number.Uint64()%100 == 0 {
 		log.Info("inserted block", "blockhain height", s.blockchain.CurrentBlock().Header().Number, "block hash", s.blockchain.CurrentBlock().Header().Hash(), "root", s.blockchain.CurrentBlock().Header().Root)
 	}
+
 	return nil
 }