Add config file support for toggling block and state processing.

cmd/boot.go

@@ -47,7 +47,8 @@ func bootApp() {
 
 	Bc, Db, err := boot.BootApplicationWithRetry(ctx, viper.GetString("db.address"), viper.GetInt("db.port"), viper.GetString("db.name"), viper.GetString("db.username"), viper.GetString("db.password"), viper.GetString("db.driver"),
 		viper.GetString("bc.address"), viper.GetInt("bc.port"), viper.GetString("bc.connectionProtocol"), viper.GetString("bc.type"), viper.GetInt("bc.bootRetryInterval"), viper.GetInt("bc.bootMaxRetry"),
-		viper.GetInt("kg.increment"), "boot", viper.GetBool("t.skipSync"), viper.GetInt("bc.uniqueNodeIdentifier"), viper.GetBool("bc.checkDb"))
+		viper.GetInt("kg.increment"), "boot", viper.GetBool("t.skipSync"), viper.GetInt("bc.uniqueNodeIdentifier"), viper.GetBool("bc.checkDb"),
+		viper.GetBool("bc.performBeaconBlockProcessing"), viper.GetBool("bc.performBeaconStateProcessing"))
 	if err != nil {
 		StopApplicationPreBoot(err, Db)
 	}

cmd/full.go

@@ -62,7 +62,8 @@ func startFullProcessing() {
 
 	Bc, Db, err := boot.BootApplicationWithRetry(ctx, viper.GetString("db.address"), viper.GetInt("db.port"), viper.GetString("db.name"), viper.GetString("db.username"), viper.GetString("db.password"), viper.GetString("db.driver"),
 		viper.GetString("bc.address"), viper.GetInt("bc.port"), viper.GetString("bc.connectionProtocol"), viper.GetString("bc.type"), viper.GetInt("bc.bootRetryInterval"), viper.GetInt("bc.bootMaxRetry"),
-		viper.GetInt("kg.increment"), "head", viper.GetBool("t.skipSync"), viper.GetInt("bc.uniqueNodeIdentifier"), viper.GetBool("bc.checkDb"))
+		viper.GetInt("kg.increment"), "head", viper.GetBool("t.skipSync"), viper.GetInt("bc.uniqueNodeIdentifier"), viper.GetBool("bc.checkDb"),
+		viper.GetBool("bc.performBeaconBlockProcessing"), viper.GetBool("bc.performBeaconStateProcessing"))
 	if err != nil {
 		StopApplicationPreBoot(err, Db)
 	}

cmd/head.go

@@ -50,7 +50,8 @@ func startHeadTracking() {
 
 	Bc, Db, err := boot.BootApplicationWithRetry(ctx, viper.GetString("db.address"), viper.GetInt("db.port"), viper.GetString("db.name"), viper.GetString("db.username"), viper.GetString("db.password"), viper.GetString("db.driver"),
 		viper.GetString("bc.address"), viper.GetInt("bc.port"), viper.GetString("bc.connectionProtocol"), viper.GetString("bc.type"), viper.GetInt("bc.bootRetryInterval"), viper.GetInt("bc.bootMaxRetry"),
-		viper.GetInt("kg.increment"), "head", viper.GetBool("t.skipSync"), viper.GetInt("bc.uniqueNodeIdentifier"), viper.GetBool("bc.checkDb"))
+		viper.GetInt("kg.increment"), "head", viper.GetBool("t.skipSync"), viper.GetInt("bc.uniqueNodeIdentifier"), viper.GetBool("bc.checkDb"),
+		viper.GetBool("bc.performBeaconBlockProcessing"), viper.GetBool("bc.performBeaconStateProcessing"))
 	if err != nil {
 		StopApplicationPreBoot(err, Db)
 	}

cmd/historic.go

@@ -50,7 +50,8 @@ func startHistoricProcessing() {
 
 	Bc, Db, err := boot.BootApplicationWithRetry(ctx, viper.GetString("db.address"), viper.GetInt("db.port"), viper.GetString("db.name"), viper.GetString("db.username"), viper.GetString("db.password"), viper.GetString("db.driver"),
 		viper.GetString("bc.address"), viper.GetInt("bc.port"), viper.GetString("bc.connectionProtocol"), viper.GetString("bc.type"), viper.GetInt("bc.bootRetryInterval"), viper.GetInt("bc.bootMaxRetry"),
-		viper.GetInt("kg.increment"), "historic", viper.GetBool("t.skipSync"), viper.GetInt("bc.uniqueNodeIdentifier"), viper.GetBool("bc.checkDb"))
+		viper.GetInt("kg.increment"), "historic", viper.GetBool("t.skipSync"), viper.GetInt("bc.uniqueNodeIdentifier"), viper.GetBool("bc.checkDb"),
+		viper.GetBool("bc.performBeaconBlockProcessing"), viper.GetBool("bc.performBeaconStateProcessing"))
 	if err != nil {
 		StopApplicationPreBoot(err, Db)
 	}

config/example.ipld-eth-beacon-indexer-config.json

@@ -16,7 +16,9 @@
     "maxHistoricProcessWorker": 2,
     "connectionProtocol": "http",
     "uniqueNodeIdentifier": 100,
-    "checkDb": true
+    "checkDb": true,
+    "performBeaconStateProcessing": false,
+    "performBeaconBlockProcessing": true
   },
   "t": {
     "skipSync": true

config/tel.ipld-eth-beacon-indexer-config.json

@@ -0,0 +1,40 @@
+{
+  "db": {
+    "address": "localhost",
+    "password": "secret12",
+    "port": 45432,
+    "username": "postgres",
+    "name": "postgres",
+    "driver": "PGX"
+  },
+  "bc": {
+    "address": "localhost",
+    "port": 8001,
+    "type": "lighthouse",
+    "bootRetryInterval": 30,
+    "bootMaxRetry": 5,
+    "maxHistoricProcessWorker": 2,
+    "connectionProtocol": "http",
+    "uniqueNodeIdentifier": 100,
+    "checkDb": true
+  },
+  "t": {
+    "skipSync": true
+  },
+  "log": {
+    "level": "debug",
+    "output": true,
+    "file": "./ipld-eth-beacon-indexer.log",
+    "format": "json"
+  },
+  "kg": {
+    "increment": 10000,
+    "processKnownGaps": true,
+    "maxKnownGapsWorker": 2
+  },
+  "pm": {
+    "address": "localhost",
+    "port": 9000,
+    "metrics": true
+  }
+}

internal/boot/boot.go

@@ -42,11 +42,11 @@ var (
 //
 // 3. Make sure the node is synced, unless disregardSync is true.
 func BootApplication(ctx context.Context, dbHostname string, dbPort int, dbName string, dbUsername string, dbPassword string, driverName string,
-	bcAddress string, bcPort int, bcConnectionProtocol string, bcKgTableIncrement int, disregardSync bool, uniqueNodeIdentifier int, checkDb bool) (*beaconclient.BeaconClient, sql.Database, error) {
+	bcAddress string, bcPort int, bcConnectionProtocol string, bcKgTableIncrement int, disregardSync bool, uniqueNodeIdentifier int, checkDb bool, performBeaconBlockProcessing bool, performBeaconStateProcessing bool) (*beaconclient.BeaconClient, sql.Database, error) {
 	log.Info("Booting the Application")
 
 	log.Debug("Creating the Beacon Client")
-	Bc, err := beaconclient.CreateBeaconClient(ctx, bcConnectionProtocol, bcAddress, bcPort, bcKgTableIncrement, uniqueNodeIdentifier, checkDb)
+	Bc, err := beaconclient.CreateBeaconClient(ctx, bcConnectionProtocol, bcAddress, bcPort, bcKgTableIncrement, uniqueNodeIdentifier, checkDb, performBeaconBlockProcessing, performBeaconStateProcessing)
 	if err != nil {
 		return Bc, nil, err
 	}
@@ -86,14 +86,15 @@ func BootApplication(ctx context.Context, dbHostname string, dbPort int, dbName
 // Add retry logic to ensure that we are give the Beacon Client and the DB time to start.
 func BootApplicationWithRetry(ctx context.Context, dbHostname string, dbPort int, dbName string, dbUsername string, dbPassword string, driverName string,
 	bcAddress string, bcPort int, bcConnectionProtocol string, bcType string, bcRetryInterval int, bcMaxRetry int, bcKgTableIncrement int,
-	startUpMode string, disregardSync bool, uniqueNodeIdentifier int, checkDb bool) (*beaconclient.BeaconClient, sql.Database, error) {
+	startUpMode string, disregardSync bool, uniqueNodeIdentifier int, checkDb bool, performBeaconBlockProcessing bool, performBeaconStateProcessing bool) (*beaconclient.BeaconClient, sql.Database, error) {
 	var err error
 
 	if bcMaxRetry < 0 {
 		i := 0
 		for {
 			BC, DB, err = BootApplication(ctx, dbHostname, dbPort, dbName, dbUsername, dbPassword, driverName,
-				bcAddress, bcPort, bcConnectionProtocol, bcKgTableIncrement, disregardSync, uniqueNodeIdentifier, checkDb)
+				bcAddress, bcPort, bcConnectionProtocol, bcKgTableIncrement, disregardSync, uniqueNodeIdentifier, checkDb,
+				performBeaconBlockProcessing, performBeaconStateProcessing)
 			if err != nil {
 				log.WithFields(log.Fields{
 					"retryNumber": i,
@@ -108,7 +109,8 @@ func BootApplicationWithRetry(ctx context.Context, dbHostname string, dbPort int
 	} else {
 		for i := 0; i < bcMaxRetry; i++ {
 			BC, DB, err = BootApplication(ctx, dbHostname, dbPort, dbName, dbUsername, dbPassword, driverName,
-				bcAddress, bcPort, bcConnectionProtocol, bcKgTableIncrement, disregardSync, uniqueNodeIdentifier, checkDb)
+				bcAddress, bcPort, bcConnectionProtocol, bcKgTableIncrement, disregardSync, uniqueNodeIdentifier, checkDb,
+				performBeaconBlockProcessing, performBeaconStateProcessing)
 			if err != nil {
 				log.WithFields(log.Fields{
 					"retryNumber": i,

internal/boot/boot_test.go

@@ -25,66 +25,68 @@ import (
 
 var _ = Describe("Boot", func() {
 	var (
-		dbAddress            string = "localhost"
+		dbAddress             string = "localhost"
-		dbPort               int    = 8076
+		dbPort                int    = 8076
-		dbName               string = "vulcanize_testing"
+		dbName                string = "vulcanize_testing"
-		dbUsername           string = "vdbm"
+		dbUsername            string = "vdbm"
-		dbPassword           string = "password"
+		dbPassword            string = "password"
-		dbDriver             string = "PGX"
+		dbDriver              string = "PGX"
-		bcAddress            string = "localhost"
+		bcAddress             string = "localhost"
-		bcPort               int    = 5052
+		bcPort                int    = 5052
-		bcConnectionProtocol string = "http"
+		bcConnectionProtocol  string = "http"
-		bcType               string = "lighthouse"
+		bcType                string = "lighthouse"
-		bcBootRetryInterval  int    = 1
+		bcBootRetryInterval   int    = 1
-		bcBootMaxRetry       int    = 5
+		bcBootMaxRetry        int    = 5
-		bcKgTableIncrement   int    = 10
+		bcKgTableIncrement    int    = 10
-		bcUniqueIdentifier   int    = 100
+		bcUniqueIdentifier    int    = 100
-		bcCheckDb            bool   = false
+		bcCheckDb             bool   = false
+		bcProcessBeaconBlocks bool   = true
+		bcProcessBeaconState  bool   = true
 	)
 	Describe("Booting the application", Label("integration"), func() {
 		Context("When the DB and BC are both up and running, we skip checking for a synced head, and we are processing head", func() {
 			It("Should connect successfully", func() {
-				_, db, err := boot.BootApplicationWithRetry(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "head", true, bcUniqueIdentifier, bcCheckDb)
+				_, db, err := boot.BootApplicationWithRetry(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "head", true, bcUniqueIdentifier, bcCheckDb, bcProcessBeaconBlocks, bcProcessBeaconState)
 				defer db.Close()
 				Expect(err).ToNot(HaveOccurred())
 			})
 		})
 		Context("When the DB and BC are both up and running, we skip checking for a synced head, and we are processing historic ", func() {
 			It("Should connect successfully", func() {
-				_, db, err := boot.BootApplicationWithRetry(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "historic", true, bcUniqueIdentifier, bcCheckDb)
+				_, db, err := boot.BootApplicationWithRetry(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "historic", true, bcUniqueIdentifier, bcCheckDb, bcProcessBeaconBlocks, bcProcessBeaconState)
 				defer db.Close()
 				Expect(err).ToNot(HaveOccurred())
 			})
 		})
 		Context("When the DB and BC are both up and running, and we check for a synced head", func() {
 			It("Should not connect successfully", func() {
-				_, db, err := boot.BootApplicationWithRetry(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "head", false, bcUniqueIdentifier, bcCheckDb)
+				_, db, err := boot.BootApplicationWithRetry(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "head", false, bcUniqueIdentifier, bcCheckDb, bcProcessBeaconBlocks, bcProcessBeaconState)
 				defer db.Close()
 				Expect(err).To(HaveOccurred())
 			})
 		})
 		Context("When the DB and BC are both up and running, we skip checking for a synced head, but the unique identifier is 0", func() {
 			It("Should not connect successfully", func() {
-				_, db, err := boot.BootApplicationWithRetry(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "head", false, 0, bcCheckDb)
+				_, db, err := boot.BootApplicationWithRetry(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "head", false, 0, bcCheckDb, bcProcessBeaconBlocks, bcProcessBeaconState)
 				defer db.Close()
 				Expect(err).To(HaveOccurred())
 			})
 		})
 		Context("When the DB is running but not the BC", func() {
 			It("Should not connect successfully", func() {
-				_, _, err := boot.BootApplication(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, "hi", 100, bcConnectionProtocol, bcKgTableIncrement, true, bcUniqueIdentifier, bcCheckDb)
+				_, _, err := boot.BootApplication(context.Background(), dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, "hi", 100, bcConnectionProtocol, bcKgTableIncrement, true, bcUniqueIdentifier, bcCheckDb, bcProcessBeaconBlocks, bcProcessBeaconState)
 				Expect(err).To(HaveOccurred())
 			})
 		})
 		Context("When the BC is running but not the DB", func() {
 			It("Should not connect successfully", func() {
-				_, _, err := boot.BootApplication(context.Background(), "hi", 10, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcKgTableIncrement, true, bcUniqueIdentifier, bcCheckDb)
+				_, _, err := boot.BootApplication(context.Background(), "hi", 10, dbName, dbUsername, dbPassword, dbDriver, bcAddress, bcPort, bcConnectionProtocol, bcKgTableIncrement, true, bcUniqueIdentifier, bcCheckDb, bcProcessBeaconBlocks, bcProcessBeaconState)
 				Expect(err).To(HaveOccurred())
 			})
 		})
 		Context("When neither the BC or DB are running", func() {
 			It("Should not connect successfully", func() {
-				_, _, err := boot.BootApplication(context.Background(), "hi", 10, dbName, dbUsername, dbPassword, dbDriver, "hi", 100, bcConnectionProtocol, bcKgTableIncrement, true, bcUniqueIdentifier, bcCheckDb)
+				_, _, err := boot.BootApplication(context.Background(), "hi", 10, dbName, dbUsername, dbPassword, dbDriver, "hi", 100, bcConnectionProtocol, bcKgTableIncrement, true, bcUniqueIdentifier, bcCheckDb, bcProcessBeaconBlocks, bcProcessBeaconState)
 				Expect(err).To(HaveOccurred())
 			})
 		})

internal/shutdown/shutdown_test.go

@@ -51,6 +51,8 @@ var (
 	bcKgTableIncrement     int           = 10
 	bcUniqueIdentifier     int           = 100
 	bcCheckDb              bool          = false
+	bcProcessBeaconBlocks  bool          = true
+	bcProcessBeaconState   bool          = true
 	maxWaitSecondsShutdown time.Duration = time.Duration(1) * time.Second
 	DB                     sql.Database
 	BC                     *beaconclient.BeaconClient
@@ -63,7 +65,7 @@ var _ = Describe("Shutdown", func() {
 	BeforeEach(func() {
 		ctx = context.Background()
 		BC, DB, err = boot.BootApplicationWithRetry(ctx, dbAddress, dbPort, dbName, dbUsername, dbPassword, dbDriver, bcAddress,
-			bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "head", true, bcUniqueIdentifier, bcCheckDb)
+			bcPort, bcConnectionProtocol, bcType, bcBootRetryInterval, bcBootMaxRetry, bcKgTableIncrement, "head", true, bcUniqueIdentifier, bcCheckDb, bcProcessBeaconBlocks, bcProcessBeaconState)
 		notifierCh = make(chan os.Signal, 1)
 		Expect(err).To(BeNil())
 	})

pkg/beaconclient/beaconclient.go

@@ -90,7 +90,8 @@ type SseError struct {
 }
 
 // A Function to create the BeaconClient.
-func CreateBeaconClient(ctx context.Context, connectionProtocol string, bcAddress string, bcPort int, bcKgTableIncrement int, uniqueNodeIdentifier int, checkDb bool) (*BeaconClient, error) {
+func CreateBeaconClient(ctx context.Context, connectionProtocol string, bcAddress string, bcPort int,
+	bcKgTableIncrement int, uniqueNodeIdentifier int, checkDb bool, performBeaconBlockProcessing bool, performBeaconStateProcessing bool) (*BeaconClient, error) {
 	if uniqueNodeIdentifier == 0 {
 		uniqueNodeIdentifier := rand.Int()
 		log.WithField("randomUniqueNodeIdentifier", uniqueNodeIdentifier).Warn("No uniqueNodeIdentifier provided, we are going to use a randomly generated one.")
@@ -112,8 +113,8 @@ func CreateBeaconClient(ctx context.Context, connectionProtocol string, bcAddres
 		Metrics:                      metrics,
 		UniqueNodeIdentifier:         uniqueNodeIdentifier,
 		CheckDb:                      checkDb,
-		PerformBeaconBlockProcessing: true,
+		PerformBeaconBlockProcessing: performBeaconBlockProcessing,
-		PerformBeaconStateProcessing: false,
+		PerformBeaconStateProcessing: performBeaconStateProcessing,
 		//FinalizationTracking: createSseEvent[FinalizedCheckpoint](endpoint, bcFinalizedTopicEndpoint),
 	}, nil
 }
@@ -156,10 +157,10 @@ func (se *SseEvents[P]) initClient() {
 	log.WithFields(log.Fields{"endpoint": se.Endpoint}).Info("Creating SSE client")
 	client := sse.NewClient(se.Endpoint)
 	client.ReconnectNotify = func(err error, duration time.Duration) {
-		log.WithFields(log.Fields{"endpoint": se.Endpoint}).Warn("Reconnecting SSE client")
+		log.WithFields(log.Fields{"endpoint": se.Endpoint}).Debug("Reconnecting SSE client")
 	}
 	client.OnDisconnect(func(c *sse.Client) {
-		log.WithFields(log.Fields{"endpoint": se.Endpoint}).Warn("SSE client disconnected")
+		log.WithFields(log.Fields{"endpoint": se.Endpoint}).Debug("SSE client disconnected")
 	})
 	se.sseClient = client
 }

pkg/beaconclient/capturehead_test.go

@@ -223,24 +223,6 @@ var (
 			SignedBeaconBlock: filepath.Join("ssz-data", "3797056", "should-not-exist.txt"),
 			BeaconState:       filepath.Join("ssz-data", "3797056", "beacon-state.ssz"),
 		},
-		"4636671": {
-			HeadMessage: beaconclient.Head{
-				Slot:                      "4636671",
-				Block:                     "0xe7d4f3b7924c30ae047fceabb853b8afdae32b85e0a87ab6c4c37421b353a1da",
-				State:                     "0x66146a0bc8656a63aaf5dd357f327cac58c83fc90582ced82bebcc6e5f11855b",
-				CurrentDutyDependentRoot:  "",
-				PreviousDutyDependentRoot: "",
-				EpochTransition:           false,
-				ExecutionOptimistic:       false,
-			},
-			TestNotes:                     "The last Altair block",
-			SignedBeaconBlock:             filepath.Join("ssz-data", "4636671", "signed-beacon-block.ssz"),
-			BeaconState:                   filepath.Join("ssz-data", "4636671", "beacon-state.ssz"),
-			CorrectEth1DataBlockHash:      "0xa5b11e0cfb9ffd53e298f0d24fe07bc7a19ada6e52fa3f09397e1b34c07b4ec6",
-			CorrectParentRoot:             "0x47fc3b7a28512a2570438c02bd0b96ebcac8bbcd97eed6d50f15454f37ac51b8",
-			CorrectSignedBeaconBlockMhKey: "",
-			CorrectBeaconStateMhKey:       "",
-		},
 		"4636672": {
 			HeadMessage: beaconclient.Head{
 				Slot:                      "4636672",
@@ -288,19 +270,21 @@ var (
 		},
 	}
 	TestConfig = Config{
-		protocol:                protocol,
+		protocol:                     protocol,
-		address:                 address,
+		address:                      address,
-		port:                    port,
+		port:                         port,
-		dummyParentRoot:         dummyParentRoot,
+		dummyParentRoot:              dummyParentRoot,
-		dbHost:                  dbHost,
+		dbHost:                       dbHost,
-		dbPort:                  dbPort,
+		dbPort:                       dbPort,
-		dbName:                  dbName,
+		dbName:                       dbName,
-		dbUser:                  dbUser,
+		dbUser:                       dbUser,
-		dbPassword:              dbPassword,
+		dbPassword:                   dbPassword,
-		dbDriver:                dbDriver,
+		dbDriver:                     dbDriver,
-		knownGapsTableIncrement: knownGapsTableIncrement,
+		knownGapsTableIncrement:      knownGapsTableIncrement,
-		bcUniqueIdentifier:      bcUniqueIdentifier,
+		bcUniqueIdentifier:           bcUniqueIdentifier,
-		checkDb:                 true,
+		checkDb:                      true,
+		performBeaconStateProcessing: true,
+		performBeaconBlockProcessing: true,
 	}
 
 	BeaconNodeTester = TestBeaconNode{
@@ -541,19 +525,21 @@ var _ = Describe("Capturehead", Label("head"), func() {
 })
 
 type Config struct {
-	protocol                string
+	protocol                     string
-	address                 string
+	address                      string
-	port                    int
+	port                         int
-	dummyParentRoot         string
+	dummyParentRoot              string
-	dbHost                  string
+	dbHost                       string
-	dbPort                  int
+	dbPort                       int
-	dbName                  string
+	dbName                       string
-	dbUser                  string
+	dbUser                       string
-	dbPassword              string
+	dbPassword                   string
-	dbDriver                string
+	dbDriver                     string
-	knownGapsTableIncrement int
+	knownGapsTableIncrement      int
-	bcUniqueIdentifier      int
+	bcUniqueIdentifier           int
-	checkDb                 bool
+	checkDb                      bool
+	performBeaconBlockProcessing bool
+	performBeaconStateProcessing bool
 }
 
 //////////////////////////////////////////////////////
@@ -563,7 +549,7 @@ type Config struct {
 // Must run before each test. We can't use the beforeEach because of the way
 // Gingko treats race conditions.
 func setUpTest(config Config, maxSlot string) *beaconclient.BeaconClient {
-	bc, err := beaconclient.CreateBeaconClient(context.Background(), config.protocol, config.address, config.port, config.knownGapsTableIncrement, config.bcUniqueIdentifier, config.checkDb)
+	bc, err := beaconclient.CreateBeaconClient(context.Background(), config.protocol, config.address, config.port, config.knownGapsTableIncrement, config.bcUniqueIdentifier, config.checkDb, config.performBeaconBlockProcessing, config.performBeaconStateProcessing)
 	Expect(err).ToNot(HaveOccurred())
 	db, err := postgres.SetupPostgresDb(config.dbHost, config.dbPort, config.dbName, config.dbUser, config.dbPassword, config.dbDriver)
 	Expect(err).ToNot(HaveOccurred())
@@ -611,12 +597,11 @@ func validateSignedBeaconBlock(bc *beaconclient.BeaconClient, headMessage beacon
 func validateBeaconState(bc *beaconclient.BeaconClient, headMessage beaconclient.Head, correctMhKey string) {
 	dbSlot, stateRoot, mhKey := queryDbBeaconState(bc.Db, headMessage.Slot, headMessage.State)
 	log.Info("validateBeaconState: ", headMessage)
-	baseSlot, err := strconv.Atoi(headMessage.Slot)
+	baseSlot, err := strconv.ParseUint(headMessage.Slot, 10, 64)
 	Expect(err).ToNot(HaveOccurred())
 	Expect(dbSlot).To(Equal(baseSlot))
 	Expect(stateRoot).To(Equal(headMessage.State))
 	Expect(mhKey).To(Equal(correctMhKey))
-
 }
 
 // Wrapper function to send a head message to the beaconclient

pkg/beaconclient/healthcheck_test.go

@@ -31,11 +31,10 @@ var _ = Describe("Healthcheck", func() {
 
 	BeforeEach(func() {
 		var err error
-		Bc, err = beaconclient.CreateBeaconClient(context.Background(), "http", "localhost", 8005, 10, bcUniqueIdentifier, false)
+		Bc, err = beaconclient.CreateBeaconClient(context.Background(), "http", "localhost", 8005, 10, bcUniqueIdentifier, false, true, true)
 		Expect(err).ToNot(HaveOccurred())
-		errBc, err = beaconclient.CreateBeaconClient(context.Background(), "http", "blah-blah", 1010, 10, bcUniqueIdentifier, false)
+		errBc, err = beaconclient.CreateBeaconClient(context.Background(), "http", "blah-blah", 1010, 10, bcUniqueIdentifier, false, true, true)
 		Expect(err).ToNot(HaveOccurred())
-
 	})
 	Describe("Connecting to the lighthouse client", Label("integration"), func() {
 		Context("When the client is running", func() {