Merge pull request #484 from ethpandaops/gloas-support

Gloas support (ePBS)

Author: pk910

.gitignore

@@ -11,3 +11,5 @@ tmp-*
 .hack/devnet/generated-**
 .hack/devnet/custom-**
 
+cmd/statetransition-test/
+

.hack/devnet/run.sh

@@ -147,6 +147,10 @@ indexer:
   cachePersistenceDelay: 8
   disableIndexWriter: false
   syncEpochCooldown: 1
+  stateCache:
+    enabled: true
+    path: "${__dir}/generated-state-cache"
+    maxStates: 5
 executionIndexer:
   enabled: true
   retention: 4368h

blockdb/blockdb.go

@@ -4,23 +4,25 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/sirupsen/logrus"
+
 	"github.com/ethpandaops/dora/blockdb/pebble"
 	"github.com/ethpandaops/dora/blockdb/s3"
+	"github.com/ethpandaops/dora/blockdb/tiered"
 	"github.com/ethpandaops/dora/blockdb/types"
 	dtypes "github.com/ethpandaops/dora/types"
 )
 
-// BlockDb wraps the underlying storage engine for both beacon block data
-// and execution data.
+// BlockDb is the main wrapper for block database operations.
 type BlockDb struct {
 	engine     types.BlockDbEngine
 	execEngine types.ExecDataEngine // nil if engine doesn't support exec data
 }
 
-// GlobalBlockDb is the global singleton BlockDb instance.
+// GlobalBlockDb is the global block database instance.
 var GlobalBlockDb *BlockDb
 
-// InitWithPebble initializes the global BlockDb with a Pebble backend.
+// InitWithPebble initializes the block database with Pebble (local) storage.
 func InitWithPebble(config dtypes.PebbleBlockDBConfig) error {
 	engine, err := pebble.NewPebbleEngine(config)
 	if err != nil {
@@ -41,7 +43,7 @@ func InitWithPebble(config dtypes.PebbleBlockDBConfig) error {
 	return nil
 }
 
-// InitWithS3 initializes the global BlockDb with an S3 backend.
+// InitWithS3 initializes the block database with S3 (remote) storage.
 func InitWithS3(config dtypes.S3BlockDBConfig) error {
 	engine, err := s3.NewS3Engine(config)
 	if err != nil {
@@ -62,6 +64,27 @@ func InitWithS3(config dtypes.S3BlockDBConfig) error {
 	return nil
 }
 
+// InitWithTiered initializes the block database with tiered storage (Pebble cache + S3 backend).
+func InitWithTiered(config dtypes.TieredBlockDBConfig, logger logrus.FieldLogger) error {
+	engine, err := tiered.NewTieredEngine(config, logger)
+	if err != nil {
+		return err
+	}
+
+	db := &BlockDb{
+		engine: engine,
+	}
+
+	// Check if tiered engine supports exec data
+	if execEngine, ok := engine.(types.ExecDataEngine); ok {
+		db.execEngine = execEngine
+	}
+
+	GlobalBlockDb = db
+
+	return nil
+}
+
 // GetEngine returns the underlying storage engine.
 func (db *BlockDb) GetEngine() types.BlockDbEngine {
 	return db.engine
@@ -71,22 +94,59 @@ func (db *BlockDb) Close() error {
 	return db.engine.Close()
 }
 
-func (db *BlockDb) GetBlock(ctx context.Context, slot uint64, root []byte, parseBlock func(uint64, []byte) (interface{}, error)) (*types.BlockData, error) {
-	return db.engine.GetBlock(ctx, slot, root, parseBlock)
-}
-
-func (db *BlockDb) AddBlock(ctx context.Context, slot uint64, root []byte, header_ver uint64, header_data []byte, body_ver uint64, body_data []byte) (bool, error) {
+// GetBlock retrieves block data with selective loading based on flags.
+func (db *BlockDb) GetBlock(
+	ctx context.Context,
+	slot uint64,
+	root []byte,
+	flags types.BlockDataFlags,
+	parseBlock func(uint64, []byte) (any, error),
+	parsePayload func(uint64, []byte) (any, error),
+) (*types.BlockData, error) {
+	return db.engine.GetBlock(ctx, slot, root, flags, parseBlock, parsePayload)
+}
+
+// GetStoredComponents returns which components exist for a block.
+func (db *BlockDb) GetStoredComponents(ctx context.Context, slot uint64, root []byte) (types.BlockDataFlags, error) {
+	return db.engine.GetStoredComponents(ctx, slot, root)
+}
+
+// AddBlock stores block data. Returns (added, updated, error).
+func (db *BlockDb) AddBlock(
+	ctx context.Context,
+	slot uint64,
+	root []byte,
+	headerVer uint64,
+	headerData []byte,
+	bodyVer uint64,
+	bodyData []byte,
+	payloadVer uint64,
+	payloadData []byte,
+	balVer uint64,
+	balData []byte,
+) (bool, bool, error) {
 	return db.engine.AddBlock(ctx, slot, root, func() (*types.BlockData, error) {
 		return &types.BlockData{
-			HeaderVersion: header_ver,
-			HeaderData:    header_data,
-			BodyVersion:   body_ver,
-			BodyData:      body_data,
+			HeaderVersion:  headerVer,
+			HeaderData:     headerData,
+			BodyVersion:    bodyVer,
+			BodyData:       bodyData,
+			PayloadVersion: payloadVer,
+			PayloadData:    payloadData,
+			BalVersion:     balVer,
+			BalData:        balData,
 		}, nil
 	})
 }
 
-func (db *BlockDb) AddBlockWithCallback(ctx context.Context, slot uint64, root []byte, dataCb func() (*types.BlockData, error)) (bool, error) {
+// AddBlockWithCallback stores block data using a callback for deferred data loading.
+// Returns (added, updated, error).
+func (db *BlockDb) AddBlockWithCallback(
+	ctx context.Context,
+	slot uint64,
+	root []byte,
+	dataCb func() (*types.BlockData, error),
+) (bool, bool, error) {
 	return db.engine.AddBlock(ctx, slot, root, dataCb)
 }