Electra upgrade (Snowfork#1283)

* electra upgrade

* relayer progress

* more electra work

* fix config

* fixes

* fix tests

* update go version

* containers

* electra changes

* try testing lodestar + electra

* revert local script

* mekong network setup

* electra updates

* fixes

* fixes

* fix tests

* electra local net

* fix config

* cleanup

* fixes

* progress

* fix execution header proof

* revert testing changes

* adds tests

* cleanup

* cleanup

* uses geth binary instead of docker

* removes all traces of capella

* devnet6 fixes

* update bindings

Author: claravanstaden

.github/workflows/relayer.yml

@@ -22,7 +22,7 @@ jobs:
       - name: setup go
         uses: actions/checkout@v4
         with:
-          go-version: '^1.20.1'
+          go-version: '^1.22.5'
 
       - name: check go version
         run: go version

relayer/README.md

@@ -46,7 +46,7 @@ To generate the SSZ encodings:
 
 ```
 go install github.com/ferranbt/fastssz/sszgen
-sszgen --path relays/beacon/state/beacon.go --objs BeaconStateCapellaMainnet,BlockRootsContainerMainnet,TransactionsRootContainer,BeaconBlockCapellaMainnet,WithdrawalsRootContainerMainnet
+sszgen --path relays/beacon/state/beacon.go --objs BlockRootsContainerMainnet,TransactionsRootContainer,WithdrawalsRootContainerMainnet,BeaconStateDenebMainnet,BeaconBlockDenebMainnet,SignedBeaconBlockDeneb,SignedBeaconBlockElectra,BeaconStateElectra,BeaconBlockElectra
 ```
 
 ## Configuration

relayer/cmd/generate_beacon_data.go

@@ -402,7 +402,8 @@ func generateBeaconTestFixture(cmd *cobra.Command, _ []string) error {
 			for {
 				nextFinalizedUpdateScale, err := s.GetFinalizedUpdate()
 				if err != nil {
-					return fmt.Errorf("get next finalized header update: %w", err)
+					log.Error(err)
+					continue
 				}
 				nextFinalizedUpdate := nextFinalizedUpdateScale.Payload.ToJSON()
 				nextFinalizedUpdatePeriod := p.ComputeSyncPeriodAtSlot(nextFinalizedUpdate.FinalizedHeader.Slot)
@@ -416,7 +417,8 @@ func generateBeaconTestFixture(cmd *cobra.Command, _ []string) error {
 					// generate nextSyncCommitteeUpdate
 					nextSyncCommitteeUpdateScale, err := s.GetSyncCommitteePeriodUpdate(initialSyncPeriod+1, 0)
 					if err != nil {
-						return fmt.Errorf("get sync committee update: %w", err)
+						log.Error(err)
+						continue
 					}
 					nextSyncCommitteeUpdate := nextSyncCommitteeUpdateScale.Payload.ToJSON()
 					err = writeJSONToFile(nextSyncCommitteeUpdate, fmt.Sprintf("%s/%s", pathToBeaconTestFixtureFiles, "next-sync-committee-update.json"))

relayer/cmd/import_beacon_state.go

@@ -92,7 +92,7 @@ func importBeaconState(cmd *cobra.Command, _ []string) error {
 		return fmt.Errorf("read finalized state data from file: %w", err)
 	}
 
-	afterDenebFork := (conf.Source.Beacon.Spec.DenebForkEpoch + 1) * 32
+	afterDenebFork := (conf.Source.Beacon.Spec.ForkVersions.Deneb + 1) * 32
 
 	attestedState, err := syncer.UnmarshalBeaconState(afterDenebFork, attestedData)
 	if err != nil {

relayer/magefile.go

@@ -13,7 +13,7 @@ func Build() {
 }
 
 func BuildMain() error {
-	err := sh.Run("sszgen", "--path", "relays/beacon/state", "--objs", "BeaconStateCapellaMainnet,BlockRootsContainerMainnet,TransactionsRootContainer,BeaconBlockCapellaMainnet,WithdrawalsRootContainerMainnet,BeaconStateDenebMainnet,BeaconBlockDenebMainnet")
+	err := sh.Run("sszgen", "--path", "relays/beacon/state", "--objs", "BlockRootsContainerMainnet,TransactionsRootContainer,WithdrawalsRootContainerMainnet,BeaconStateDenebMainnet,BeaconBlockDenebMainnet,SignedBeaconBlockDeneb,SignedBeaconBlockElectra,BeaconStateElectra,BeaconBlockElectra")
 	if err != nil {
 		return err
 	}

relayer/relays/beacon/config/config.go

@@ -11,10 +11,15 @@ type Config struct {
 }
 
 type SpecSettings struct {
-	SyncCommitteeSize            uint64 `mapstructure:"syncCommitteeSize"`
-	SlotsInEpoch                 uint64 `mapstructure:"slotsInEpoch"`
-	EpochsPerSyncCommitteePeriod uint64 `mapstructure:"epochsPerSyncCommitteePeriod"`
-	DenebForkEpoch               uint64 `mapstructure:"denebForkedEpoch"`
+	SyncCommitteeSize            uint64       `mapstructure:"syncCommitteeSize"`
+	SlotsInEpoch                 uint64       `mapstructure:"slotsInEpoch"`
+	EpochsPerSyncCommitteePeriod uint64       `mapstructure:"epochsPerSyncCommitteePeriod"`
+	ForkVersions                 ForkVersions `mapstructure:"forkVersions"`
+}
+
+type ForkVersions struct {
+	Deneb   uint64 `mapstructure:"deneb"`
+	Electra uint64 `mapstructure:"electra"`
 }
 
 type SourceConfig struct {

relayer/relays/beacon/header/header_test.go

@@ -23,7 +23,10 @@ func TestSyncInterimFinalizedUpdate_WithDataFromAPI(t *testing.T) {
 	settings := config.SpecSettings{
 		SlotsInEpoch:                 32,
 		EpochsPerSyncCommitteePeriod: 256,
-		DenebForkEpoch:               0,
+		ForkVersions: config.ForkVersions{
+			Deneb:   0,
+			Electra: 800000,
+		},
 	}
 	p := protocol.New(settings, MaxRedundancy)
 	client := mock.API{}
@@ -81,7 +84,10 @@ func TestSyncInterimFinalizedUpdate_WithDataFromStore(t *testing.T) {
 	settings := config.SpecSettings{
 		SlotsInEpoch:                 32,
 		EpochsPerSyncCommitteePeriod: 256,
-		DenebForkEpoch:               0,
+		ForkVersions: config.ForkVersions{
+			Deneb:   0,
+			Electra: 800000,
+		},
 	}
 	p := protocol.New(settings, MaxRedundancy)
 	client := mock.API{}
@@ -147,7 +153,10 @@ func TestSyncInterimFinalizedUpdate_WithDataFromStoreWithDifferentBlocks(t *test
 	settings := config.SpecSettings{
 		SlotsInEpoch:                 32,
 		EpochsPerSyncCommitteePeriod: 256,
-		DenebForkEpoch:               0,
+		ForkVersions: config.ForkVersions{
+			Deneb:   0,
+			Electra: 800000,
+		},
 	}
 	p := protocol.New(settings, MaxRedundancy)
 	client := mock.API{}
@@ -213,7 +222,10 @@ func TestSyncInterimFinalizedUpdate_BeaconStateNotAvailableInAPIAndStore(t *test
 	settings := config.SpecSettings{
 		SlotsInEpoch:                 32,
 		EpochsPerSyncCommitteePeriod: 256,
-		DenebForkEpoch:               0,
+		ForkVersions: config.ForkVersions{
+			Deneb:   0,
+			Electra: 800000,
+		},
 	}
 	p := protocol.New(settings, MaxRedundancy)
 	client := mock.API{}
@@ -257,7 +269,10 @@ func TestSyncInterimFinalizedUpdate_NoValidBlocksFound(t *testing.T) {
 	settings := config.SpecSettings{
 		SlotsInEpoch:                 32,
 		EpochsPerSyncCommitteePeriod: 256,
-		DenebForkEpoch:               0,
+		ForkVersions: config.ForkVersions{
+			Deneb:   0,
+			Electra: 800000,
+		},
 	}
 	p := protocol.New(settings, MaxRedundancy)
 	client := mock.API{}
@@ -332,7 +347,6 @@ func TestFindLatestCheckPoint(t *testing.T) {
 	settings := config.SpecSettings{
 		SlotsInEpoch:                 4,
 		EpochsPerSyncCommitteePeriod: 2,
-		DenebForkEpoch:               0,
 	}
 	maxRedundancy := uint64(2)
 	p := protocol.New(settings, maxRedundancy)

relayer/relays/beacon/header/syncer/api/api.go

@@ -36,6 +36,7 @@ type BeaconAPI interface {
 	GetBeaconBlockBySlot(slot uint64) (BeaconBlockResponse, error)
 	GetBeaconBlockRoot(slot uint64) (common.Hash, error)
 	GetBeaconBlock(blockID common.Hash) (BeaconBlockResponse, error)
+	GetBeaconBlockBytes(blockID common.Hash) ([]byte, error)
 	GetSyncCommitteePeriodUpdate(from uint64) (SyncCommitteePeriodUpdateResponse, error)
 	GetLatestFinalizedUpdate() (LatestFinalisedUpdateResponse, error)
 	GetBeaconState(stateIdOrSlot string) ([]byte, error)
@@ -417,7 +418,7 @@ func (b *BeaconClient) GetBeaconState(stateIdOrSlot string) ([]byte, error) {
 	res, err := b.httpClient.Do(req)
 	endTime := time.Now()
 	duration := endTime.Sub(startTime)
-	log.WithFields(log.Fields{"startTime": startTime.Format(time.UnixDate), "endTime": endTime.Format(time.UnixDate), "duration": duration.Seconds()}).Warn("beacon state download time")
+	log.WithFields(log.Fields{"startTime": startTime.Format(time.UnixDate), "endTime": endTime.Format(time.UnixDate), "duration": duration.Seconds()}).Info("beacon state download time")
 
 	if err != nil {
 		return data, err
@@ -436,3 +437,31 @@ func (b *BeaconClient) GetBeaconState(stateIdOrSlot string) ([]byte, error) {
 	data = buf.Bytes()
 	return data, nil
 }
+
+func (b *BeaconClient) GetBeaconBlockBytes(blockID common.Hash) ([]byte, error) {
+	var data []byte
+	req, err := http.NewRequest("GET", fmt.Sprintf("%s/eth/v2/beacon/blocks/%s", b.stateEndpoint, blockID), nil)
+	if err != nil {
+		return data, err
+	}
+
+	req.Header.Add("Accept", "application/octet-stream")
+
+	res, err := b.httpClient.Do(req)
+	if err != nil {
+		return data, err
+	}
+
+	if res.StatusCode != http.StatusOK {
+		if res.StatusCode == 404 {
+			return data, ErrNotFound
+		}
+
+		return data, fmt.Errorf("%s: %d", DoHTTPRequestErrorMessage, res.StatusCode)
+	}
+
+	buf := new(bytes.Buffer)
+	buf.ReadFrom(res.Body)
+	data = buf.Bytes()
+	return data, nil
+}

relayer/relays/beacon/header/syncer/api/api_deneb.go

@@ -3,9 +3,7 @@ package api
 import (
 	"math/big"
 
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/snowfork/go-substrate-rpc-client/v4/types"
-	beaconjson "github.com/snowfork/snowbridge/relayer/relays/beacon/header/syncer/json"
 	"github.com/snowfork/snowbridge/relayer/relays/beacon/header/syncer/scale"
 	"github.com/snowfork/snowbridge/relayer/relays/beacon/state"
 	"github.com/snowfork/snowbridge/relayer/relays/util"
@@ -55,49 +53,3 @@ func DenebExecutionPayloadToScale(e *state.ExecutionPayloadDeneb) (scale.Executi
 	}, nil
 }
 
-func DenebJsonExecutionPayloadHeaderToScale(e *beaconjson.FullExecutionPayloadHeaderJson) (scale.ExecutionPayloadHeaderDeneb, error) {
-	var executionPayloadHeader scale.ExecutionPayloadHeaderDeneb
-	var baseFeePerGas big.Int
-	baseFeePerGasU64, err := util.ToUint64(e.BaseFeePerGas)
-	if err != nil {
-		return executionPayloadHeader, err
-	}
-	blockNumber, err := util.ToUint64(e.BlockNumber)
-	if err != nil {
-		return executionPayloadHeader, err
-	}
-	baseFeePerGas.SetUint64(baseFeePerGasU64)
-	gasLimit, err := util.ToUint64(e.GasLimit)
-	if err != nil {
-		return executionPayloadHeader, err
-	}
-	gasUsed, err := util.ToUint64(e.GasUsed)
-	if err != nil {
-		return executionPayloadHeader, err
-	}
-	timestamp, err := util.ToUint64(e.Timestamp)
-	if err != nil {
-		return executionPayloadHeader, err
-	}
-	blobGasUsed, _ := util.ToUint64(e.BlobGasUsed)
-	excessBlobGas, _ := util.ToUint64(e.ExcessBlobGas)
-	return scale.ExecutionPayloadHeaderDeneb{
-		ParentHash:       types.NewH256(common.HexToHash(e.ParentHash).Bytes()),
-		FeeRecipient:     types.NewH160(common.HexToAddress(e.FeeRecipient).Bytes()),
-		StateRoot:        types.NewH256(common.HexToHash(e.StateRoot).Bytes()),
-		ReceiptsRoot:     types.NewH256(common.HexToHash(e.ReceiptsRoot).Bytes()),
-		LogsBloom:        common.FromHex(e.LogsBloom),
-		PrevRandao:       types.NewH256(common.HexToHash(e.PrevRandao).Bytes()),
-		BlockNumber:      types.NewU64(blockNumber),
-		GasLimit:         types.NewU64(gasLimit),
-		GasUsed:          types.NewU64(gasUsed),
-		Timestamp:        types.NewU64(timestamp),
-		ExtraData:        common.FromHex(e.ExtraData),
-		BaseFeePerGas:    types.NewU256(baseFeePerGas),
-		BlockHash:        types.NewH256(common.HexToHash(e.BlockHash).Bytes()),
-		TransactionsRoot: types.NewH256(common.HexToHash(e.TransactionsRoot).Bytes()),
-		WithdrawalsRoot:  types.NewH256(common.HexToHash(e.WithdrawalsRoot).Bytes()),
-		BlobGasUsed:      types.NewU64(blobGasUsed),
-		ExcessBlobGas:    types.NewU64(excessBlobGas),
-	}, nil
-}