feat(eth): ethereum sync finality support

cli/operator/node.go

@@ -320,13 +320,11 @@
 		if len(executionAddrList) == 1 {
 			ec, err := executionclient.New(
 				cmd.Context(),
+				networkConfig,
 				executionAddrList[0],
 				ssvNetworkConfig.RegistryContractAddr,
 				executionclient.WithLogger(logger),
-				executionclient.WithFollowDistance(executionclient.DefaultFollowDistance),
 				executionclient.WithConnectionTimeout(cfg.ExecutionClient.ConnectionTimeout),
-				executionclient.WithReconnectionInitialInterval(executionclient.DefaultReconnectionInitialInterval),
-				executionclient.WithReconnectionMaxInterval(executionclient.DefaultReconnectionMaxInterval),
 				executionclient.WithHealthInvalidationInterval(executionclient.DefaultHealthInvalidationInterval),
 				executionclient.WithSyncDistanceTolerance(cfg.ExecutionClient.SyncDistanceTolerance),
 			)
@@ -338,13 +336,11 @@
 		} else {
 			ec, err := executionclient.NewMulti(
 				cmd.Context(),
+				networkConfig,
 				executionAddrList,
 				ssvNetworkConfig.RegistryContractAddr,
 				executionclient.WithLoggerMulti(logger),
-				executionclient.WithFollowDistanceMulti(executionclient.DefaultFollowDistance),
 				executionclient.WithConnectionTimeoutMulti(cfg.ExecutionClient.ConnectionTimeout),
-				executionclient.WithReconnectionInitialIntervalMulti(executionclient.DefaultReconnectionInitialInterval),
-				executionclient.WithReconnectionMaxIntervalMulti(executionclient.DefaultReconnectionMaxInterval),
 				executionclient.WithHealthInvalidationIntervalMulti(executionclient.DefaultHealthInvalidationInterval),
 				executionclient.WithSyncDistanceToleranceMulti(cfg.ExecutionClient.SyncDistanceTolerance),
 			)
@@ -403,7 +399,7 @@
 			nodeStorage,
 			dutyStore,
 			signatureVerifier,
-			networkConfig.Forks[spec.DataVersionElectra].Epoch,
+			networkConfig.BeaconConfig.Forks[spec.DataVersionElectra].Epoch,
 			validation.WithLogger(logger),
 		)
 

eth/ethtest/common_test.go

@@ -7,14 +7,18 @@ import (
 	"net/http/httptest"
 	"strings"
 	"testing"
+	"time"
 
+	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	ethcommon "github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/rpc"
 	"go.uber.org/mock/gomock"
 	"go.uber.org/zap/zaptest"
 
+	"github.com/ssvlabs/ssv/networkconfig"
+
 	"github.com/ssvlabs/ssv/eth/eventsyncer"
 	"github.com/ssvlabs/ssv/eth/executionclient"
 	"github.com/ssvlabs/ssv/eth/simulator"
@@ -64,7 +68,8 @@ type TestEnv struct {
 	httpSrv        *httptest.Server
 	validatorCtrl  *mocks.MockController
 	mockCtrl       *gomock.Controller
-	followDistance *uint64
+	networkConfig  networkconfig.NetworkConfig
+	followDistance uint64
 }
 
 func (e *TestEnv) shutdown() {
@@ -88,12 +93,24 @@ func (e *TestEnv) setup(
 	testAddresses []*ethcommon.Address,
 	validatorsCount uint64,
 	operatorsCount uint64,
+	useFinalityFork bool,
 ) error {
-	if e.followDistance == nil {
-		e.SetDefaultFollowDistance()
-	}
 	logger := zaptest.NewLogger(t)
 
+	// Set up network config with recent genesis time to avoid high epoch calculations
+	e.networkConfig = networkconfig.TestNetwork
+	e.networkConfig.GenesisTime = time.Now().Add(-1 * time.Minute) // Recent genesis
+
+	if useFinalityFork {
+		e.followDistance = 0
+		e.networkConfig.SSVConfig.Forks.Forks[1].Epoch = phase0.Epoch(1)
+		e.networkConfig.GenesisTime = time.Now().Add(-10 * time.Hour) // A bit earlier genesis time
+	} else {
+		e.followDistance = executionclient.DefaultFollowDistance
+		e.networkConfig.SSVConfig.Forks.Forks[1].Epoch = phase0.Epoch(1000000)
+
+	}
+
 	// Create operators RSA keys
 	ops, err := createOperators(operatorsCount, 0)
 	if err != nil {
@@ -167,13 +184,13 @@ func (e *TestEnv) setup(
 		return fmt.Errorf("contractCode is empty")
 	}
 
-	// Create a client and connect to the simulator
 	e.execClient, err = executionclient.New(
 		ctx,
+		e.networkConfig,
 		addr,
 		contractAddr,
 		executionclient.WithLogger(logger),
-		executionclient.WithFollowDistance(*e.followDistance),
+		executionclient.WithFollowDistance(e.followDistance),
 	)
 	if err != nil {
 		return err
@@ -206,18 +223,14 @@ func (e *TestEnv) setup(
 	return nil
 }
 
-func (e *TestEnv) SetDefaultFollowDistance() {
-	// 8 is current production offset
-	value := uint64(8)
-	e.followDistance = &value
-}
-
-func (e *TestEnv) CloseFollowDistance(blockNum *uint64) {
-	for i := uint64(0); i < *e.followDistance; i++ {
+// MineAndFinalize mines enough blocks to ensure finality.
+func (e *TestEnv) MineAndFinalize(blockNum *uint64) {
+	for i := uint64(0); i < e.networkConfig.SlotsPerEpoch*2; i++ {
 		commitBlock(e.sim, blockNum)
 	}
 }
 
+// commitBlock creates a new block and increments block counter.
 func commitBlock(sim *simulator.Backend, blockNum *uint64) {
 	sim.Commit()
 	*blockNum++

eth/ethtest/eth_e2e_test.go

@@ -2,13 +2,13 @@ package ethtest
 
 import (
 	"context"
-	"fmt"
 	"math/big"
 	"testing"
 	"time"
 
 	ethcommon "github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/mock/gomock"
 
@@ -25,8 +25,20 @@ var (
 	testAddrBob   = crypto.PubkeyToAddress(testKeyBob.PublicKey)
 )
 
-// E2E tests for ETH package
-func TestEthExecLayer(t *testing.T) {
+// TestEthExecLayer_PreFork tests ETH package with follow distance approach (pre-fork).
+// TODO: use the correct name when we know the name of the fork.
+func TestEthExecLayer_PreFork(t *testing.T) {
+	runTestEthExecLayer(t, false)
+}
+
+// TestEthExecLayer_PostFork tests ETH package with finality approach (post-fork)
+// TODO: use the correct name when we know the name of the fork.
+func TestEthExecLayer_PostFork(t *testing.T) {
+	runTestEthExecLayer(t, true)
+}
+
+// E2E tests for ETH package with configurable finality approach
+func runTestEthExecLayer(t *testing.T, useFinalityFork bool) {
 	ctx, cancel := context.WithCancel(t.Context())
 	defer cancel()
 
@@ -45,10 +57,10 @@ func TestEthExecLayer(t *testing.T) {
 	expectedNonce := registrystorage.Nonce(0)
 
 	testEnv := TestEnv{}
-	testEnv.SetDefaultFollowDistance()
 
 	defer testEnv.shutdown()
-	err := testEnv.setup(t, ctx, testAddresses, 7, 4)
+
+	err := testEnv.setup(t, ctx, testAddresses, 7, 4, useFinalityFork)
 	require.NoError(t, err)
 
 	var (
@@ -83,7 +95,7 @@ func TestEthExecLayer(t *testing.T) {
 			opAddedInput.prepare(ops, auth)
 			opAddedInput.produce()
 
-			testEnv.CloseFollowDistance(&blockNum)
+			testEnv.MineAndFinalize(&blockNum)
 		}
 
 		// BLOCK 3:  VALIDATOR ADDED:
@@ -96,15 +108,32 @@ func TestEthExecLayer(t *testing.T) {
 			valAddInput := NewTestValidatorRegisteredInput(common)
 			valAddInput.prepare(validators, shares, ops, auth, &expectedNonce, []uint32{0, 1})
 			valAddInput.produce()
-			testEnv.CloseFollowDistance(&blockNum)
+			testEnv.MineAndFinalize(&blockNum)
+
+			// Check how the EventSyncer determines which blocks to process
+			var expectedLastHandledBlock uint64
+
+			if useFinalityFork {
+				// When using finality fork, check the finalized block number
+				finalizedBlock, err := testEnv.sim.Client().HeaderByNumber(ctx, big.NewInt(rpc.FinalizedBlockNumber.Int64()))
+				require.NoError(t, err)
+				expectedLastHandledBlock = finalizedBlock.Number.Uint64()
+			} else {
+				// When using follow distance, the last handled block is the current block minus follow distance
+				currentBlock, err := testEnv.sim.Client().BlockNumber(ctx)
+				t.Logf("Current block number: %d", currentBlock)
+				require.NoError(t, err)
+				expectedLastHandledBlock = currentBlock - testEnv.followDistance
+				t.Logf("Expected last handled block: %d", expectedLastHandledBlock)
+			}
 
 			// Run SyncHistory
 			lastHandledBlockNum, err = eventSyncer.SyncHistory(ctx, lastHandledBlockNum)
+			t.Logf("Last handled block number after SyncHistory: %d", lastHandledBlockNum)
 			require.NoError(t, err)
 
-			//check all the events were handled correctly and block number was increased
-			require.Equal(t, blockNum-*testEnv.followDistance, lastHandledBlockNum)
-			fmt.Println("lastHandledBlockNum", lastHandledBlockNum)
+			// Check that the last handled block number matches our expectation
+			require.Equal(t, expectedLastHandledBlock, lastHandledBlockNum)
 
 			// Check that operators were successfully registered
 			operators, err := nodeStorage.ListOperators(nil, 0, 10)
@@ -154,7 +183,7 @@ func TestEthExecLayer(t *testing.T) {
 			valAddInput := NewTestValidatorRegisteredInput(common)
 			valAddInput.prepare(validators, shares, ops, auth, &expectedNonce, []uint32{2, 3, 4, 5, 6})
 			valAddInput.produce()
-			testEnv.CloseFollowDistance(&blockNum)
+			testEnv.MineAndFinalize(&blockNum)
 
 			// Wait until the state is changed
 			time.Sleep(time.Millisecond * 5000)
@@ -185,7 +214,7 @@ func TestEthExecLayer(t *testing.T) {
 				cluster,
 			)
 			valExit.produce()
-			testEnv.CloseFollowDistance(&blockNum)
+			testEnv.MineAndFinalize(&blockNum)
 
 			// Wait to make sure the state is not changed
 			time.Sleep(time.Millisecond * 500)
@@ -210,7 +239,7 @@ func TestEthExecLayer(t *testing.T) {
 				cluster,
 			)
 			valRemove.produce()
-			testEnv.CloseFollowDistance(&blockNum)
+			testEnv.MineAndFinalize(&blockNum)
 
 			// Wait until the state is changed
 			time.Sleep(time.Millisecond * 500)
@@ -240,7 +269,7 @@ func TestEthExecLayer(t *testing.T) {
 				},
 			})
 			clusterLiquidate.produce()
-			testEnv.CloseFollowDistance(&blockNum)
+			testEnv.MineAndFinalize(&blockNum)
 
 			// Wait until the state is changed
 			time.Sleep(time.Millisecond * 300)
@@ -280,7 +309,7 @@ func TestEthExecLayer(t *testing.T) {
 				},
 			})
 			clusterReactivated.produce()
-			testEnv.CloseFollowDistance(&blockNum)
+			testEnv.MineAndFinalize(&blockNum)
 
 			// Wait until the state is changed
 			time.Sleep(time.Millisecond * 300)
@@ -303,7 +332,7 @@ func TestEthExecLayer(t *testing.T) {
 			opRemoved := NewOperatorRemovedEventInput(common)
 			opRemoved.prepare([]uint64{1, 2}, auth)
 			opRemoved.produce()
-			testEnv.CloseFollowDistance(&blockNum)
+			testEnv.MineAndFinalize(&blockNum)
 
 			// TODO: this should be adjusted when eth/eventhandler/handlers.go#L109 is resolved
 		}
@@ -317,7 +346,7 @@ func TestEthExecLayer(t *testing.T) {
 				{auth, &testAddrBob},
 			})
 			setFeeRecipient.produce()
-			testEnv.CloseFollowDistance(&blockNum)
+			testEnv.MineAndFinalize(&blockNum)
 
 			// Wait until the state is changed
 			time.Sleep(time.Millisecond * 300)