polygon: Reduce assemble function arguments (#11975)

erigontech · Sep 13, 2024 · 82e0d46 · 82e0d46
1 parent 5d7433c
commit 82e0d46
Show file tree

Hide file tree

Showing 7 changed files with 96 additions and 22 deletions.
diff --git a/cmd/rpcdaemon/cli/config.go b/cmd/rpcdaemon/cli/config.go
@@ -519,12 +519,28 @@ func RemoteServices(ctx context.Context, cfg *httpcfg.HttpCfg, logger log.Logger
 		if cc != nil && cc.Bor != nil {
 			if polygonSync {
 				stateReceiverContractAddress := cc.Bor.GetStateReceiverContract()
-				bridgeReader, err = bridge.AssembleReader(ctx, cfg.DataDir, logger, stateReceiverContractAddress, roTxLimit)
+
+				bridgeConfig := bridge.ReaderConfig{
+					Ctx:                          ctx,
+					DataDir:                      cfg.DataDir,
+					Logger:                       logger,
+					StateReceiverContractAddress: stateReceiverContractAddress,
+					RoTxLimit:                    roTxLimit,
+				}
+				bridgeReader, err = bridge.AssembleReader(bridgeConfig)
 				if err != nil {
 					return nil, nil, nil, nil, nil, nil, nil, ff, nil, nil, err
 				}
 
-				heimdallReader, err = heimdall.AssembleReader(ctx, cc.Bor.CalculateSprintNumber, cfg.DataDir, cfg.Dirs.Tmp, logger, roTxLimit)
+				heimdallConfig := heimdall.ReaderConfig{
+					Ctx:                     ctx,
+					CalculateSprintNumberFn: cc.Bor.CalculateSprintNumber,
+					DataDir:                 cfg.DataDir,
+					TempDir:                 cfg.Dirs.Tmp,
+					Logger:                  logger,
+					RoTxLimit:               roTxLimit,
+				}
+				heimdallReader, err = heimdall.AssembleReader(heimdallConfig)
 				if err != nil {
 					return nil, nil, nil, nil, nil, nil, nil, ff, nil, nil, err
 				}

diff --git a/eth/backend.go b/eth/backend.go
@@ -553,8 +553,25 @@ func New(ctx context.Context, stack *node.Node, config *ethconfig.Config, logger
 			borConfig := consensusConfig.(*borcfg.BorConfig)
 			roTxLimit := int64(stack.Config().Http.DBReadConcurrency)
 
-			polygonBridge = bridge.Assemble(config.Dirs.DataDir, logger, borConfig, heimdallClient, roTxLimit)
-			heimdallService = heimdall.AssembleService(borConfig.CalculateSprintNumber, config.HeimdallURL, dirs.DataDir, tmpdir, logger, roTxLimit)
+			bridgeConfig := bridge.Config{
+				DataDir:      config.Dirs.DataDir,
+				Logger:       logger,
+				BorConfig:    borConfig,
+				EventFetcher: heimdallClient,
+				RoTxLimit:    roTxLimit,
+			}
+			polygonBridge = bridge.Assemble(bridgeConfig)
+
+			heimdallConfig := heimdall.ServiceConfig{
+				CalculateSprintNumberFn: borConfig.CalculateSprintNumber,
+				HeimdallURL:             config.HeimdallURL,
+				DataDir:                 dirs.DataDir,
+				TempDir:                 tmpdir,
+				Logger:                  logger,
+				RoTxLimit:               roTxLimit,
+			}
+			heimdallService = heimdall.AssembleService(heimdallConfig)
+
 			bridgeRPC = bridge.NewBackendServer(ctx, polygonBridge)
 			heimdallRPC = heimdall.NewBackendServer(ctx, heimdallService)
 

diff --git a/polygon/bridge/bridge.go b/polygon/bridge/bridge.go
@@ -40,11 +40,19 @@ type eventFetcher interface {
 	FetchStateSyncEvents(ctx context.Context, fromId uint64, to time.Time, limit int) ([]*heimdall.EventRecordWithTime, error)
 }
 
-func Assemble(dataDir string, logger log.Logger, borConfig *borcfg.BorConfig, eventFetcher eventFetcher, roTxLimit int64) *Bridge {
-	bridgeDB := polygoncommon.NewDatabase(dataDir, kv.PolygonBridgeDB, databaseTablesCfg, logger, false /* accede */, roTxLimit)
+type Config struct {
+	DataDir      string
+	Logger       log.Logger
+	BorConfig    *borcfg.BorConfig
+	EventFetcher eventFetcher
+	RoTxLimit    int64
+}
+
+func Assemble(config Config) *Bridge {
+	bridgeDB := polygoncommon.NewDatabase(config.DataDir, kv.PolygonBridgeDB, databaseTablesCfg, config.Logger, false /* accede */, config.RoTxLimit)
 	bridgeStore := NewStore(bridgeDB)
-	reader := NewReader(bridgeStore, logger, borConfig.StateReceiverContract)
-	return NewBridge(bridgeStore, logger, borConfig, eventFetcher, reader)
+	reader := NewReader(bridgeStore, config.Logger, config.BorConfig.StateReceiverContract)
+	return NewBridge(bridgeStore, config.Logger, config.BorConfig, config.EventFetcher, reader)
 }
 
 func NewBridge(store Store, logger log.Logger, borConfig *borcfg.BorConfig, eventFetcher eventFetcher, reader *Reader) *Bridge {

diff --git a/polygon/bridge/bridge_test.go b/polygon/bridge/bridge_test.go
@@ -30,7 +30,14 @@ func setup(t *testing.T, borConfig borcfg.BorConfig) (*heimdall.MockHeimdallClie
 	ctrl := gomock.NewController(t)
 	logger := testlog.Logger(t, log.LvlDebug)
 	heimdallClient := heimdall.NewMockHeimdallClient(ctrl)
-	b := Assemble(t.TempDir(), logger, &borConfig, heimdallClient, 1)
+	cfg := Config{
+		DataDir:      t.TempDir(),
+		Logger:       logger,
+		BorConfig:    &borConfig,
+		EventFetcher: heimdallClient,
+		RoTxLimit:    1,
+	}
+	b := Assemble(cfg)
 	t.Cleanup(b.Close)
 	return heimdallClient, b
 }

diff --git a/polygon/bridge/reader.go b/polygon/bridge/reader.go
@@ -26,16 +26,24 @@ type Reader struct {
 	stateClientAddress libcommon.Address
 }
 
-func AssembleReader(ctx context.Context, dataDir string, logger log.Logger, stateReceiverContractAddress string, roTxLimit int64) (*Reader, error) {
-	bridgeDB := polygoncommon.NewDatabase(dataDir, kv.PolygonBridgeDB, databaseTablesCfg, logger, true /* accede */, roTxLimit)
+type ReaderConfig struct {
+	Ctx                          context.Context
+	DataDir                      string
+	Logger                       log.Logger
+	StateReceiverContractAddress string
+	RoTxLimit                    int64
+}
+
+func AssembleReader(config ReaderConfig) (*Reader, error) {
+	bridgeDB := polygoncommon.NewDatabase(config.DataDir, kv.PolygonBridgeDB, databaseTablesCfg, config.Logger, true /* accede */, config.RoTxLimit)
 	bridgeStore := NewStore(bridgeDB)
 
-	err := bridgeStore.Prepare(ctx)
+	err := bridgeStore.Prepare(config.Ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	return NewReader(bridgeStore, logger, stateReceiverContractAddress), nil
+	return NewReader(bridgeStore, config.Logger, config.StateReceiverContractAddress), nil
 }
 
 func NewReader(store Store, logger log.Logger, stateReceiverContractAddress string) *Reader {

diff --git a/polygon/heimdall/reader.go b/polygon/heimdall/reader.go
@@ -20,16 +20,25 @@ type Reader struct {
 	spanBlockProducersTracker *spanBlockProducersTracker
 }
 
+type ReaderConfig struct {
+	Ctx                     context.Context
+	CalculateSprintNumberFn CalculateSprintNumberFunc
+	DataDir                 string
+	TempDir                 string
+	Logger                  log.Logger
+	RoTxLimit               int64
+}
+
 // AssembleReader creates and opens the MDBX store. For use cases where the store is only being read from. Must call Close.
-func AssembleReader(ctx context.Context, calculateSprintNumber CalculateSprintNumberFunc, dataDir string, tmpDir string, logger log.Logger, roTxLimit int64) (*Reader, error) {
-	store := NewMdbxServiceStore(logger, dataDir, tmpDir, roTxLimit)
+func AssembleReader(config ReaderConfig) (*Reader, error) {
+	store := NewMdbxServiceStore(config.Logger, config.DataDir, config.TempDir, config.RoTxLimit)
 
-	err := store.Prepare(ctx)
+	err := store.Prepare(config.Ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	return NewReader(calculateSprintNumber, store, logger), nil
+	return NewReader(config.CalculateSprintNumberFn, store, config.Logger), nil
 }
 
 func NewReader(calculateSprintNumber CalculateSprintNumberFunc, store ServiceStore, logger log.Logger) *Reader {

diff --git a/polygon/heimdall/service.go b/polygon/heimdall/service.go
@@ -30,6 +30,15 @@ import (
 	"github.com/erigontech/erigon/polygon/polygoncommon"
 )
 
+type ServiceConfig struct {
+	CalculateSprintNumberFn CalculateSprintNumberFunc
+	HeimdallURL             string
+	DataDir                 string
+	TempDir                 string
+	Logger                  log.Logger
+	RoTxLimit               int64
+}
+
 type Service interface {
 	Span(ctx context.Context, id uint64) (*Span, bool, error)
 	CheckpointsFromBlock(ctx context.Context, startBlock uint64) (Waypoints, error)
@@ -52,11 +61,11 @@ type service struct {
 	spanBlockProducersTracker *spanBlockProducersTracker
 }
 
-func AssembleService(calculateSprintNumberFn CalculateSprintNumberFunc, heimdallUrl string, dataDir string, tmpDir string, logger log.Logger, roTxLimit int64) Service {
-	store := NewMdbxServiceStore(logger, dataDir, tmpDir, roTxLimit)
-	client := NewHeimdallClient(heimdallUrl, logger)
-	reader := NewReader(calculateSprintNumberFn, store, logger)
-	return NewService(calculateSprintNumberFn, client, store, logger, reader)
+func AssembleService(config ServiceConfig) Service {
+	store := NewMdbxServiceStore(config.Logger, config.DataDir, config.TempDir, config.RoTxLimit)
+	client := NewHeimdallClient(config.HeimdallURL, config.Logger)
+	reader := NewReader(config.CalculateSprintNumberFn, store, config.Logger)
+	return NewService(config.CalculateSprintNumberFn, client, store, config.Logger, reader)
 }
 
 func NewService(calculateSprintNumberFn CalculateSprintNumberFunc, client HeimdallClient, store ServiceStore, logger log.Logger, reader *Reader) Service {