Merge pull request #42 from wealdtech/bellatrix

Support bellatrix.

CHANGELOG.md

@@ -1,3 +1,6 @@
+0.6.0
+  - Bellatrix support
+
 0.5.6
   - do not fetch validator data twice for the same epoch
 

go.mod

@@ -3,29 +3,17 @@ module github.com/wealdtech/chaind
 go 1.16
 
 require (
-	github.com/attestantio/go-eth2-client v0.8.2
-	github.com/cespare/xxhash/v2 v2.1.2 // indirect
-	github.com/fatih/color v1.13.0 // indirect
-	github.com/ferranbt/fastssz v0.0.0-20210905181407-59cf6761a7d5 // indirect
-	github.com/goccy/go-yaml v1.9.4 // indirect
+	github.com/attestantio/go-eth2-client v0.11.1
 	github.com/jackc/pgtype v1.8.1
 	github.com/jackc/pgx/v4 v4.13.0
 	github.com/jackc/puddle v1.1.4 // indirect
-	github.com/klauspost/cpuid/v2 v2.0.9 // indirect
-	github.com/mattn/go-colorable v0.1.11 // indirect
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/pkg/errors v0.9.1
-	github.com/prometheus/client_golang v1.11.0
-	github.com/prometheus/common v0.32.1 // indirect
-	github.com/prometheus/procfs v0.7.3 // indirect
-	github.com/prysmaticlabs/go-bitfield v0.0.0-20210809151128-385d8c5e3fb7 // indirect
-	github.com/rs/zerolog v1.25.0
+	github.com/prometheus/client_golang v1.12.1
+	github.com/rs/zerolog v1.26.1
 	github.com/shopspring/decimal v1.3.1 // indirect
 	github.com/spf13/pflag v1.0.5
 	github.com/spf13/viper v1.9.0
 	github.com/stretchr/testify v1.7.0
-	golang.org/x/crypto v0.0.0-20210921155107-089bfa567519 // indirect
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
-	golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359 // indirect
-	golang.org/x/text v0.3.7 // indirect
 )

main.go

@@ -58,7 +58,7 @@ import (
 )
 
 // ReleaseVersion is the release version for the code.
-var ReleaseVersion = "0.5.6"
+var ReleaseVersion = "0.6.0"
 
 func main() {
 	os.Exit(main2())
@@ -79,8 +79,15 @@ func main2() int {
 	}
 
 	// runCommands will not return if a command is run.
-	if exit := runCommands(); exit {
-		return 0
+	exit, err := runCommands(ctx)
+	if err != nil {
+		log.Error().Err(err).Msg("Command returned error")
+	}
+	if exit {
+		if err == nil {
+			return 0
+		}
+		return 1
 	}
 
 	logModules()
@@ -223,26 +230,36 @@ func startMonitor(ctx context.Context) (metrics.Service, error) {
 	return monitor, nil
 }
 
-func startServices(ctx context.Context, monitor metrics.Service) error {
+func startDatabase(ctx context.Context) (chaindb.Service, error) {
 	log.Trace().Msg("Starting chain database service")
 	chainDB, err := postgresqlchaindb.New(ctx,
 		postgresqlchaindb.WithLogLevel(util.LogLevel("chaindb")),
 		postgresqlchaindb.WithConnectionURL(viper.GetString("chaindb.url")),
 	)
 	if err != nil {
-		return errors.Wrap(err, "failed to start chain database service")
+		return nil, errors.Wrap(err, "failed to start chain database service")
 	}
+	return chainDB, err
+}
 
+func startServices(ctx context.Context, monitor metrics.Service) error {
 	log.Trace().Msg("Checking for schema upgrades")
-	requiresRefetch, err := chainDB.Upgrade(ctx)
+	chainDB, err := startDatabase(ctx)
 	if err != nil {
-		return errors.Wrap(err, "failed to upgrade chain database")
+		return err
 	}
-	if requiresRefetch {
-		// The upgrade requires us to refetch blocks, so set up the options accordingly.
-		// These will be picked up by the blocks service.
-		viper.Set("blocks.start-slot", 0)
-		viper.Set("blocks.refetch", true)
+
+	if _, isUpgrader := chainDB.(*postgresqlchaindb.Service); isUpgrader {
+		requiresRefetch, err := chainDB.(*postgresqlchaindb.Service).Upgrade(ctx)
+		if err != nil {
+			return errors.Wrap(err, "failed to upgrade chain database")
+		}
+		if requiresRefetch {
+			// The upgrade requires us to refetch blocks, so set up the options accordingly.
+			// These will be picked up by the blocks service.
+			viper.Set("blocks.start-slot", 0)
+			viper.Set("blocks.refetch", true)
+		}
 	}
 
 	log.Trace().Msg("Starting Ethereum 2 client service")
@@ -678,11 +695,11 @@ func startSyncCommittees(
 
 // runCommands runs commands if required.
 // Returns true if an exit is required.
-func runCommands() bool {
+func runCommands(_ context.Context) (bool, error) {
 	if viper.GetBool("version") {
 		fmt.Printf("%s\n", ReleaseVersion)
-		return true
+		return true, nil
 	}
 
-	return false
+	return false, nil
 }

services/blocks/standard/handler.go

@@ -17,10 +17,12 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"math/big"
 
 	eth2client "github.com/attestantio/go-eth2-client"
 	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/altair"
+	"github.com/attestantio/go-eth2-client/spec/bellatrix"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/wealdtech/chaind/services/chaindb"
@@ -106,6 +108,8 @@ func (s *Service) OnBlock(ctx context.Context, signedBlock *spec.VersionedSigned
 		return s.onBlockPhase0(ctx, signedBlock.Phase0, dbBlock)
 	case spec.DataVersionAltair:
 		return s.onBlockAltair(ctx, signedBlock.Altair, dbBlock)
+	case spec.DataVersionBellatrix:
+		return s.onBlockBellatrix(ctx, signedBlock.Bellatrix, dbBlock)
 	default:
 		return errors.New("unknown block version")
 	}
@@ -185,6 +189,46 @@ func (s *Service) onBlockAltair(ctx context.Context, signedBlock *altair.SignedB
 	return nil
 }
 
+func (s *Service) onBlockBellatrix(ctx context.Context, signedBlock *bellatrix.SignedBeaconBlock, dbBlock *chaindb.Block) error {
+	if err := s.updateAttestationsForBlock(ctx,
+		signedBlock.Message.Slot,
+		dbBlock.Root,
+		signedBlock.Message.Body.Attestations); err != nil {
+		return errors.Wrap(err, "failed to update attestations")
+	}
+	if err := s.updateProposerSlashingsForBlock(ctx,
+		signedBlock.Message.Slot,
+		dbBlock.Root,
+		signedBlock.Message.Body.ProposerSlashings); err != nil {
+		return errors.Wrap(err, "failed to update proposer slashings")
+	}
+	if err := s.updateAttesterSlashingsForBlock(ctx,
+		signedBlock.Message.Slot,
+		dbBlock.Root,
+		signedBlock.Message.Body.AttesterSlashings); err != nil {
+		return errors.Wrap(err, "failed to update attester slashings")
+	}
+	if err := s.updateDepositsForBlock(ctx,
+		signedBlock.Message.Slot,
+		dbBlock.Root,
+		signedBlock.Message.Body.Deposits); err != nil {
+		return errors.Wrap(err, "failed to update deposits")
+	}
+	if err := s.updateVoluntaryExitsForBlock(ctx,
+		signedBlock.Message.Slot,
+		dbBlock.Root,
+		signedBlock.Message.Body.VoluntaryExits); err != nil {
+		return errors.Wrap(err, "failed to update voluntary exits")
+	}
+	if err := s.updateSyncAggregateForBlock(ctx,
+		signedBlock.Message.Slot,
+		dbBlock.Root,
+		signedBlock.Message.Body.SyncAggregate); err != nil {
+		return errors.Wrap(err, "failed to update sync aggregate")
+	}
+	return nil
+}
+
 func (s *Service) updateAttestationsForBlock(ctx context.Context,
 	slot phase0.Slot,
 	blockRoot phase0.Root,
@@ -296,6 +340,8 @@ func (s *Service) dbBlock(
 		return s.dbBlockPhase0(ctx, block.Phase0.Message)
 	case spec.DataVersionAltair:
 		return s.dbBlockAltair(ctx, block.Altair.Message)
+	case spec.DataVersionBellatrix:
+		return s.dbBlockBellatrix(ctx, block.Bellatrix.Message)
 	default:
 		return nil, errors.New("unknown block version")
 	}
@@ -379,6 +425,68 @@ func (*Service) dbBlockAltair(
 	return dbBlock, nil
 }
 
+func (*Service) dbBlockBellatrix(
+	// skipcq: RVV-B0012
+	ctx context.Context,
+	block *bellatrix.BeaconBlock,
+) (*chaindb.Block, error) {
+	bodyRoot, err := block.Body.HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to calculate body root")
+	}
+
+	header := &phase0.BeaconBlockHeader{
+		Slot:          block.Slot,
+		ProposerIndex: block.ProposerIndex,
+		ParentRoot:    block.ParentRoot,
+		StateRoot:     block.StateRoot,
+		BodyRoot:      bodyRoot,
+	}
+	root, err := header.HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to calculate block root")
+	}
+
+	// base fee per gas is stored little-endian but we need it
+	// big-endian for big.Int.
+	var baseFeePerGasBEBytes [32]byte
+	for i := 0; i < 32; i++ {
+		baseFeePerGasBEBytes[i] = block.Body.ExecutionPayload.BaseFeePerGas[32-1-i]
+	}
+	baseFeePerGas := new(big.Int).SetBytes(baseFeePerGasBEBytes[:])
+
+	dbBlock := &chaindb.Block{
+		Slot:             block.Slot,
+		ProposerIndex:    block.ProposerIndex,
+		Root:             root,
+		Graffiti:         block.Body.Graffiti,
+		RANDAOReveal:     block.Body.RANDAOReveal,
+		BodyRoot:         bodyRoot,
+		ParentRoot:       block.ParentRoot,
+		StateRoot:        block.StateRoot,
+		ETH1BlockHash:    block.Body.ETH1Data.BlockHash,
+		ETH1DepositCount: block.Body.ETH1Data.DepositCount,
+		ETH1DepositRoot:  block.Body.ETH1Data.DepositRoot,
+		ExecutionPayload: &chaindb.ExecutionPayload{
+			ParentHash:    block.Body.ExecutionPayload.ParentHash,
+			FeeRecipient:  block.Body.ExecutionPayload.FeeRecipient,
+			StateRoot:     block.Body.ExecutionPayload.StateRoot,
+			ReceiptsRoot:  block.Body.ExecutionPayload.ReceiptsRoot,
+			LogsBloom:     block.Body.ExecutionPayload.LogsBloom,
+			PrevRandao:    block.Body.ExecutionPayload.PrevRandao,
+			BlockNumber:   block.Body.ExecutionPayload.BlockNumber,
+			GasLimit:      block.Body.ExecutionPayload.GasLimit,
+			GasUsed:       block.Body.ExecutionPayload.GasUsed,
+			Timestamp:     block.Body.ExecutionPayload.Timestamp,
+			ExtraData:     block.Body.ExecutionPayload.ExtraData,
+			BaseFeePerGas: baseFeePerGas,
+			BlockHash:     block.Body.ExecutionPayload.BlockHash,
+		},
+	}
+
+	return dbBlock, nil
+}
+
 func (s *Service) dbAttestation(
 	ctx context.Context,
 	inclusionSlot phase0.Slot,

services/blocks/standard/service.go

@@ -205,6 +205,7 @@ func (s *Service) catchup(ctx context.Context, md *metadata) {
 			return
 		}
 		log.Trace().Msg("Updated block")
+		monitorBlockProcessed(slot)
 	}
 }
 

services/chaindb/postgresql/blocks.go

@@ -34,7 +34,7 @@ func (s *Service) SetBlock(ctx context.Context, block *chaindb.Block) error {
 		canonical.Valid = true
 		canonical.Bool = *block.Canonical
 	}
-	_, err := tx.Exec(ctx, `
+	if _, err := tx.Exec(ctx, `
       INSERT INTO t_blocks(f_slot
                           ,f_proposer_index
                           ,f_root
@@ -75,13 +75,12 @@ func (s *Service) SetBlock(ctx context.Context, block *chaindb.Block) error {
 		block.ETH1BlockHash,
 		block.ETH1DepositCount,
 		block.ETH1DepositRoot[:],
-	)
-	if canonical.Valid {
-		val := canonical.Bool
-		block.Canonical = &val
+	); err != nil {
+		return err
 	}
 
-	return err
+	// Also set execution payload (will return without error if payload is not set).
+	return s.setExecutionPayload(ctx, block)
 }
 
 // BlocksBySlot fetches all blocks with the given slot.