all cmd changes to pass in functions in chaincmd

Author: shantichanal

cmd/era/main.go

@@ -170,14 +170,15 @@ func open(ctx *cli.Context, epoch uint64) (*onedb.Era, error) {
 		dir     = ctx.String(dirFlag.Name)
 		network = ctx.String(networkFlag.Name)
 	)
-	entries, err := onedb.ReadDir(dir, network)
+	entries, err := era.ReadDir(dir, network)
 	if err != nil {
 		return nil, fmt.Errorf("error reading era dir: %w", err)
 	}
 	if epoch >= uint64(len(entries)) {
 		return nil, fmt.Errorf("epoch out-of-bounds: last %d, want %d", len(entries)-1, epoch)
 	}
-	return onedb.Open(filepath.Join(dir, entries[epoch]))
+	era, err := onedb.Open(filepath.Join(dir, entries[epoch]))
+	return era.(*onedb.Era), err
 }
 
 // verify checks each era1 file in a directory to ensure it is well-formed and
@@ -199,7 +200,7 @@ func verify(ctx *cli.Context) error {
 		reported = time.Now()
 	)
 
-	entries, err := onedb.ReadDir(dir, network)
+	entries, err := era.ReadDir(dir, network)
 	if err != nil {
 		return fmt.Errorf("error reading %s: %w", dir, err)
 	}
@@ -214,18 +215,19 @@ func verify(ctx *cli.Context) error {
 		err := func() error {
 			name := entries[i]
 			e, err := onedb.Open(filepath.Join(dir, name))
+			eraPointer := e.(*onedb.Era)
 			if err != nil {
 				return fmt.Errorf("error opening era1 file %s: %w", name, err)
 			}
 			defer e.Close()
 			// Read accumulator and check against expected.
-			if got, err := e.Accumulator(); err != nil {
+			if got, err := eraPointer.Accumulator(); err != nil {
 				return fmt.Errorf("error retrieving accumulator for %s: %w", name, err)
 			} else if got != want {
 				return fmt.Errorf("invalid root %s: got %s, want %s", name, got, want)
 			}
 			// Recompute accumulator.
-			if err := checkAccumulator(e); err != nil {
+			if err := checkAccumulator(eraPointer); err != nil {
 				return fmt.Errorf("error verify era1 file %s: %w", name, err)
 			}
 			// Give the user some feedback that something is happening.

cmd/geth/chaincmd.go

@@ -43,6 +43,8 @@ import (
 	"github.com/ethereum/go-ethereum/internal/debug"
 	"github.com/ethereum/go-ethereum/internal/era"
 	"github.com/ethereum/go-ethereum/internal/era/eradl"
+	"github.com/ethereum/go-ethereum/internal/era/execdb"
+	"github.com/ethereum/go-ethereum/internal/era/onedb"
 	"github.com/ethereum/go-ethereum/internal/flags"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/node"
@@ -505,11 +507,11 @@ func importHistory(ctx *cli.Context) error {
 	format := ctx.String(utils.EraFormatFlag.Name)
 	switch format {
 	case "era1", "era":
-		if err := utils.ImportHistory(chain, dir, network, utils.Era1); err != nil {
+		if err := utils.ImportHistory(chain, dir, network, onedb.From, onedb.NewIterator); err != nil {
 			return err
 		}
 	case "erae":
-		if err := utils.ImportHistory(chain, dir, network, utils.EraE); err != nil {
+		if err := utils.ImportHistory(chain, dir, network, execdb.From, execdb.NewIterator); err != nil {
 			return err
 		}
 	default:
@@ -550,11 +552,11 @@ func exportHistory(ctx *cli.Context) error {
 	format := ctx.String(utils.EraFormatFlag.Get(ctx))
 	switch format {
 	case "era1", "era":
-		if err := utils.ExportHistory(chain, dir, uint64(first), uint64(last), uint64(era.MaxEra1Size), utils.Era1); err != nil {
+		if err := utils.ExportHistory(chain, dir, uint64(first), uint64(last), uint64(era.MaxSize), onedb.NewBuilder, onedb.Filename); err != nil {
 			utils.Fatalf("Export error: %v\n", err)
 		}
 	case "erae":
-		if err := utils.ExportHistory(chain, dir, uint64(first), uint64(last), uint64(era2.MaxEraESize), utils.EraE); err != nil {
+		if err := utils.ExportHistory(chain, dir, uint64(first), uint64(last), uint64(era.MaxSize), execdb.NewBuilder, execdb.Filename); err != nil {
 			utils.Fatalf("Export error: %v\n", err)
 		}
 	default:

cmd/utils/cmd.go

@@ -43,7 +43,7 @@ import (
 	"github.com/ethereum/go-ethereum/eth/ethconfig"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/internal/debug"
-	era2 "github.com/ethereum/go-ethereum/internal/era/execdb"
+	"github.com/ethereum/go-ethereum/internal/era"
 	"github.com/ethereum/go-ethereum/internal/era/onedb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/node"
@@ -251,11 +251,11 @@ func readList(filename string) ([]string, error) {
 // ImportHistory imports Era1 files containing historical block information,
 // starting from genesis. The assumption is held that the provided chain
 // segment in Era1 file should all be canonical and verified.
-func ImportHistory(chain *core.BlockChain, dir string, network string) error {
+func ImportHistory(chain *core.BlockChain, dir string, network string, from era.FromFn, iterator era.NewIteratorFn) error {
 	if chain.CurrentSnapBlock().Number.BitLen() != 0 {
 		return errors.New("history import only supported when starting from genesis")
 	}
-	entries, err := onedb.ReadDir(dir, network)
+	entries, err := era.ReadDir(dir, network)
 	if err != nil {
 		return fmt.Errorf("error reading %s: %w", dir, err)
 	}
@@ -299,11 +299,11 @@ func ImportHistory(chain *core.BlockChain, dir string, network string) error {
 				return fmt.Errorf("%s checksum mismatch: have %s want %s", file, got, want)
 			}
 			// Import all block data from Era1.
-			e, err := onedb.From(f)
+			e, err := from(f)
 			if err != nil {
 				return fmt.Errorf("error opening era: %w", err)
 			}
-			it, err := onedb.NewIterator(e)
+			it, err := iterator(e)
 			if err != nil {
 				return fmt.Errorf("error creating iterator: %w", err)
 			}
@@ -345,105 +345,6 @@ func ImportHistory(chain *core.BlockChain, dir string, network string) error {
 	return nil
 }
 
-// ImportHistoryEraE imports Era-E files containing historical block information,
-// starting from genesis. Currently this function follows the assumptions that the provided chain
-// segment in Era-E file should all be canonical and verified. In the future, this function will be
-// extended to support importing Era-E files with proof verification.
-func ImportHistoryEraE(chain *core.BlockChain, dir, network string) error {
-	if chain.CurrentSnapBlock().Number.Sign() != 0 {
-		return errors.New("history import only supported when starting from genesis")
-	}
-
-	entries, err := era2.ReadDir(dir, network)
-	if err != nil {
-		return fmt.Errorf("reading %q: %w", dir, err)
-	}
-	checksums, err := readList(filepath.Join(dir, "checksums.txt"))
-	if err != nil {
-		return fmt.Errorf("reading checksums.txt: %w", err)
-	}
-	if len(entries) != len(checksums) {
-		return fmt.Errorf("mismatch: %d erae files, %d checksums", len(entries), len(checksums))
-	}
-
-	var (
-		start    = time.Now()
-		reported = time.Now()
-		imported int
-		h        = sha256.New()
-		scratch  bytes.Buffer
-	)
-
-	for i, file := range entries {
-		path := filepath.Join(dir, file)
-
-		// validate against checksum file in directory
-		f, err := os.Open(path)
-		if err != nil {
-			return fmt.Errorf("open %s: %w", path, err)
-		}
-		if _, err := io.Copy(h, f); err != nil {
-			f.Close()
-			return fmt.Errorf("checksum %s: %w", path, err)
-		}
-		got := common.BytesToHash(h.Sum(scratch.Bytes()[:])).Hex()
-		want := checksums[i]
-		h.Reset()
-		scratch.Reset()
-		if got != want {
-			f.Close()
-			return fmt.Errorf("%s checksum mismatch: have %s want %s", file, got, want)
-		}
-		// rewind for reading
-		if _, err := f.Seek(0, io.SeekStart); err != nil {
-			f.Close()
-			return fmt.Errorf("rewind %s: %w", file, err)
-		}
-		// import archive
-		e, err := era2.From(f)
-		if err != nil {
-			f.Close()
-			return fmt.Errorf("open erae %s: %w", file, err)
-		}
-		blockCount := e.Count()
-
-		for j := uint64(0); j < blockCount; j++ {
-			hdr, err := e.GetHeader(e.Start() + j)
-			if err != nil {
-				return fmt.Errorf("header #%d: %w", hdr.Number.Uint64(), err)
-			}
-			if hdr.Number.Sign() == 0 { // skip genesis
-				continue
-			}
-			body, err := e.GetBody(hdr.Number.Uint64())
-			if err != nil {
-				return fmt.Errorf("body #%d: %w", hdr.Number.Uint64(), err)
-			}
-			rcpts, err := e.GetReceipts(hdr.Number.Uint64(), 1)
-			if err != nil {
-				return fmt.Errorf("receipts #%d: %w", hdr.Number.Uint64(), err)
-			}
-			blk := types.NewBlockWithHeader(hdr).WithBody(*body)
-
-			enc := types.EncodeBlockReceiptLists(rcpts)
-			if _, err := chain.InsertReceiptChain([]*types.Block{blk}, enc, ^uint64(0)); err != nil {
-				return fmt.Errorf("insert #%d: %w", hdr.Number.Uint64(), err)
-			}
-
-			imported++
-			if time.Since(reported) >= 8*time.Second {
-				log.Info("Importing Era‑E", "head", hdr.Number, "imported", imported, "elapsed", common.PrettyDuration(time.Since(start)))
-				reported = time.Now()
-				imported = 0
-			}
-		}
-		f.Close()
-	}
-
-	log.Info("Era‑E import complete", "duration", common.PrettyDuration(time.Since(start)))
-	return nil
-}
-
 func missingBlocks(chain *core.BlockChain, blocks []*types.Block) []*types.Block {
 	head := chain.CurrentBlock()
 	for i, block := range blocks {
@@ -514,7 +415,7 @@ func ExportAppendChain(blockchain *core.BlockChain, fn string, first uint64, las
 
 // ExportHistory exports blockchain history into the specified directory,
 // following the Era format.
-func ExportHistory(bc *core.BlockChain, dir string, first, last, step uint64) error {
+func ExportHistory(bc *core.BlockChain, dir string, first, last, step uint64, builderfn era.NewBuilderFn, filename era.FilenameFn) error {
 	log.Info("Exporting blockchain history", "dir", dir)
 	if head := bc.CurrentBlock().Number.Uint64(); head < last {
 		log.Warn("Last block beyond head, setting last = head", "head", head, "last", last)
@@ -543,7 +444,7 @@ func ExportHistory(bc *core.BlockChain, dir string, first, last, step uint64) er
 
 	for batch := first; batch <= last; batch += step {
 		idx := int(batch / step)
-		tmpPath := filepath.Join(dir, onedb.Filename(network, idx, common.Hash{}))
+		tmpPath := filepath.Join(dir, filename(network, idx, common.Hash{}))
 
 		if err := func() error {
 			fh, err := os.Create(tmpPath)
@@ -552,7 +453,7 @@ func ExportHistory(bc *core.BlockChain, dir string, first, last, step uint64) er
 			}
 			defer fh.Close()
 
-			bldr := onedb.NewBuilder(fh)
+			bldr := builderfn(fh)
 
 			for j := uint64(0); j < step && batch+j <= last; j++ {
 				n := batch + j

core/rawdb/eradb/eradb.go

@@ -307,7 +307,7 @@ func (db *Store) openEraFile(epoch uint64) (*onedb.Era, error) {
 		return nil, fmt.Errorf("pre-merge era1 file has invalid boundary. %d %% %d != 0", e.Start(), era.MaxSize)
 	}
 	log.Debug("Opened era1 file", "epoch", epoch)
-	return e, nil
+	return e.(*onedb.Era), nil
 }
 
 // doneWithFile signals that the caller has finished using a file.

internal/era/era.go

@@ -1,11 +1,17 @@
 package era
 
 import (
+	"fmt"
 	"io"
 	"math/big"
+	"os"
+	"path"
+	"strconv"
+	"strings"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	// Removed import of internal/era to avoid import cycle and missing metadata error
 )
 
 // Type constants for the e2store entries in the Era1 and EraE formats.
@@ -36,12 +42,74 @@ type Iterator interface {
 	Next() bool
 	Number() uint64
 	Block() (*types.Block, error)
+	BlockAndReceipts() (*types.Block, types.Receipts, error)
 	Receipts() (types.Receipts, error)
 	Error() error
 }
 
 // Builder represents the interface for various types of era formats.
 type Builder interface {
-	Add(block *types.Block, receipts types.Receipts, td *big.Int, proof []byte) error
+	Add(block *types.Block, receipts types.Receipts, td *big.Int, proof Proof) error
+	AddRLP(header, body, receipts, proof []byte, number uint64, hash common.Hash, td, difficulty *big.Int) error
 	Finalize() (common.Hash, error)
 }
+
+// Era represents the interface for reading era data.
+type Era interface {
+	Close() error
+	Start() uint64
+	Count() uint64
+	GetBlockByNumber(num uint64) (*types.Block, error)
+	GetRawBodyByNumber(num uint64) ([]byte, error)
+	GetRawReceiptsByNumber(num uint64) ([]byte, error)
+}
+
+// NewBuilderFn defines a function type for creating a new Builder.
+type NewBuilderFn func(w io.Writer) Builder
+
+// FilenameFn defines a function type for generating a filename based on network, epoch, and root hash.
+type FilenameFn func(network string, epoch int, root common.Hash) string
+
+// FromFn defines a function type for creating an Era from a ReadAtSeekCloser.
+type FromFn func(f ReadAtSeekCloser) (Era, error)
+
+// NewIteratorFn defines a function type for creating a new Iterator from an Era.
+type NewIteratorFn func(e Era) (Iterator, error)
+
+// ReadDir reads all the era1 files in a directory for a given network.
+// Format: <network>-<epoch>-<hexroot>.erae or <network>-<epoch>-<hexroot>.era1
+func ReadDir(dir, network string) ([]string, error) {
+	entries, err := os.ReadDir(dir)
+	var directoryExtension string
+	if err != nil {
+		return nil, fmt.Errorf("error reading directory %s: %w", dir, err)
+	}
+	var (
+		next = uint64(0)
+		eras []string
+	)
+	for i, entry := range entries {
+		fileExtension := path.Ext(entry.Name())
+		if i == 0 {
+			directoryExtension = fileExtension
+		} else if directoryExtension != fileExtension {
+			return nil, fmt.Errorf("directory %s contains mixed era file formats", dir)
+		}
+		if fileExtension != ".erae" || fileExtension != ".era1" {
+			continue
+		}
+		parts := strings.Split(entry.Name(), "-")
+		if len(parts) != 3 || parts[0] != network {
+			// Invalid era1 filename, skip.
+			continue
+		}
+		if epoch, err := strconv.ParseUint(parts[1], 10, 64); err != nil {
+			return nil, fmt.Errorf("malformed era filenames: %s", entry.Name())
+		} else if epoch != next {
+			return nil, fmt.Errorf("missing epoch %d", next)
+		}
+		next += 1
+		eras = append(eras, entry.Name())
+	}
+	return eras, nil
+}