feat: hash from rpc instead of calculated v2 1389

aggoracle/oracle.go

@@ -8,7 +8,7 @@ import (
 	"github.com/agglayer/aggkit/aggoracle/metrics"
 	"github.com/agglayer/aggkit/l1infotreesync"
 	"github.com/agglayer/aggkit/log"
-	"github.com/ethereum/go-ethereum"
+	"github.com/agglayer/aggkit/types"
 	"github.com/ethereum/go-ethereum/common"
 )
 
@@ -29,7 +29,7 @@ type ChainSender interface {
 type AggOracle struct {
 	logger            *log.Logger
 	waitPeriodNextGER time.Duration
-	l1Client          ethereum.ChainReader
+	l1Client          types.EthChainReader
 	l1Info            L1InfoTreeSyncer
 	chainSender       ChainSender
 }
@@ -38,7 +38,7 @@ type AggOracle struct {
 func New(
 	logger *log.Logger,
 	chainSender ChainSender,
-	l1Client ethereum.ChainReader,
+	l1Client types.EthChainReader,
 	l1InfoTreeSyncer L1InfoTreeSyncer,
 	waitPeriodNextGER time.Duration,
 ) (*AggOracle, error) {

aggsender/query/l1info_tree_data_query.go

@@ -3,7 +3,6 @@ package query
 import (
 	"context"
 	"fmt"
-	"math/big"
 
 	"github.com/0xPolygon/cdk-contracts-tooling/contracts/aggchain-multisig/agglayerger"
 	"github.com/agglayer/aggkit/aggsender/types"
@@ -15,8 +14,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )
 
-var finalizedBlockBigInt = big.NewInt(int64(aggkittypes.Finalized))
-
 var _ types.L1InfoTreeDataQuerier = (*L1InfoTreeDataQuerier)(nil)
 
 // L1InfoTreeDataQuerier is a struct that holds the logic to query the L1 Info tree data
@@ -143,13 +140,13 @@ func (l *L1InfoTreeDataQuerier) GetProofForGER(
 
 // getLatestProcessedFinalizedBlock returns the latest processed finalized block from the l1infotreesyncer
 func (l *L1InfoTreeDataQuerier) getLatestProcessedFinalizedBlock(ctx context.Context) (uint64, error) {
-	lastFinalizedL1Block, err := l.l1Client.HeaderByNumber(ctx, finalizedBlockBigInt)
+	lastFinalizedL1Block, err := l.l1Client.CustomHeaderByNumber(ctx, &aggkittypes.FinalizedBlock)
 	if err != nil {
 		return 0, fmt.Errorf("error getting latest finalized L1 block: %w", err)
 	}
 
 	lastProcessedBlockNum, lastProcessedBlockHash, err := l.l1InfoTreeSyncer.GetProcessedBlockUntil(ctx,
-		lastFinalizedL1Block.Number.Uint64())
+		lastFinalizedL1Block.Number)
 	if err != nil {
 		return 0, fmt.Errorf("error getting latest processed block from l1infotreesyncer: %w", err)
 	}
@@ -158,25 +155,25 @@ func (l *L1InfoTreeDataQuerier) getLatestProcessedFinalizedBlock(ctx context.Con
 		return 0, fmt.Errorf("l1infotreesyncer did not process any block yet")
 	}
 
-	if lastFinalizedL1Block.Number.Uint64() > lastProcessedBlockNum {
+	if lastFinalizedL1Block.Number > lastProcessedBlockNum {
 		// syncer has a lower block than the finalized block, so we need to get that block from the l1 node
-		lastFinalizedL1Block, err = l.l1Client.HeaderByNumber(ctx, new(big.Int).SetUint64(lastProcessedBlockNum))
+		lastFinalizedL1Block, err = l.l1Client.CustomHeaderByNumber(ctx, aggkittypes.NewBlockNumber(lastProcessedBlockNum))
 		if err != nil {
 			return 0, fmt.Errorf("error getting latest processed finalized block: %d: %w",
 				lastProcessedBlockNum, err)
 		}
 	}
 
-	if (lastProcessedBlockHash == common.Hash{}) || (lastProcessedBlockHash == lastFinalizedL1Block.Hash()) {
+	if (lastProcessedBlockHash == common.Hash{}) || (lastProcessedBlockHash == lastFinalizedL1Block.Hash) {
 		// if the hash is empty it means that this is an old block that was processed before this
 		// feature was added, so we will consider it finalized
-		return lastFinalizedL1Block.Number.Uint64(), nil
+		return lastFinalizedL1Block.Number, nil
 	}
 
 	return 0, fmt.Errorf("l1infotreesyncer returned a different hash for "+
 		"the latest finalized block: %d. Might be that syncer did not process a reorg yet. "+
 		"Expected hash: %s, got: %s", lastProcessedBlockNum,
-		lastFinalizedL1Block.Hash().String(), lastProcessedBlockHash.String())
+		lastFinalizedL1Block.Hash.String(), lastProcessedBlockHash.String())
 }
 
 // GetInfoByIndex returns the L1 Info tree leaf for the given index

aggsender/query/l1info_tree_data_query_test.go

@@ -3,15 +3,14 @@ package query
 import (
 	"context"
 	"errors"
-	"math/big"
 	"testing"
 
 	"github.com/agglayer/aggkit/aggsender/mocks"
 	"github.com/agglayer/aggkit/l1infotreesync"
 	treetypes "github.com/agglayer/aggkit/tree/types"
+	aggkittypes "github.com/agglayer/aggkit/types"
 	aggkittypesmocks "github.com/agglayer/aggkit/types/mocks"
 	"github.com/ethereum/go-ethereum/common"
-	gethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/stretchr/testify/require"
 )
 
@@ -103,6 +102,8 @@ func Test_GetFinalizedL1InfoTreeData(t *testing.T) {
 	}
 }
 
+var finalizedBlockBigInt = &aggkittypes.FinalizedBlock
+
 func Test_AggchainProverFlow_GetLatestProcessedFinalizedBlock(t *testing.T) {
 	t.Parallel()
 
@@ -117,56 +118,56 @@ func Test_AggchainProverFlow_GetLatestProcessedFinalizedBlock(t *testing.T) {
 		{
 			name: "error getting latest finalized L1 block",
 			mockFn: func(mockL1InfoTreeSyncer *mocks.L1InfoTreeSyncer, mockL1Client *aggkittypesmocks.BaseEthereumClienter) {
-				mockL1Client.On("HeaderByNumber", ctx, finalizedBlockBigInt).Return(nil, errors.New("some error"))
+				mockL1Client.On("CustomHeaderByNumber", ctx, finalizedBlockBigInt).Return(nil, errors.New("some error"))
 			},
 			expectedError: "error getting latest finalized L1 block: some error",
 		},
 		{
 			name: "error getting latest processed block from l1infotreesyncer",
 			mockFn: func(mockL1InfoTreeSyncer *mocks.L1InfoTreeSyncer, mockL1Client *aggkittypesmocks.BaseEthereumClienter) {
-				l1Header := &gethtypes.Header{Number: big.NewInt(10)}
-				mockL1Client.On("HeaderByNumber", ctx, finalizedBlockBigInt).Return(l1Header, nil)
-				mockL1InfoTreeSyncer.On("GetProcessedBlockUntil", ctx, l1Header.Number.Uint64()).Return(uint64(0), common.Hash{}, errors.New("some error"))
+				l1Header := &aggkittypes.BlockHeader{Number: 10}
+				mockL1Client.On("CustomHeaderByNumber", ctx, finalizedBlockBigInt).Return(l1Header, nil)
+				mockL1InfoTreeSyncer.On("GetProcessedBlockUntil", ctx, l1Header.Number).Return(uint64(0), common.Hash{}, errors.New("some error"))
 			},
 			expectedError: "error getting latest processed block from l1infotreesyncer: some error",
 		},
 		{
 			name: "l1infotreesyncer did not process any block yet",
 			mockFn: func(mockL1InfoTreeSyncer *mocks.L1InfoTreeSyncer, mockL1Client *aggkittypesmocks.BaseEthereumClienter) {
-				l1Header := &gethtypes.Header{Number: big.NewInt(10)}
-				mockL1Client.On("HeaderByNumber", ctx, finalizedBlockBigInt).Return(l1Header, nil)
-				mockL1InfoTreeSyncer.On("GetProcessedBlockUntil", ctx, l1Header.Number.Uint64()).Return(uint64(0), common.Hash{}, nil)
+				l1Header := &aggkittypes.BlockHeader{Number: 10}
+				mockL1Client.On("CustomHeaderByNumber", ctx, finalizedBlockBigInt).Return(l1Header, nil)
+				mockL1InfoTreeSyncer.On("GetProcessedBlockUntil", ctx, l1Header.Number).Return(uint64(0), common.Hash{}, nil)
 			},
 			expectedError: "l1infotreesyncer did not process any block yet",
 		},
 		{
 			name: "error getting latest processed finalized block",
 			mockFn: func(mockL1InfoTreeSyncer *mocks.L1InfoTreeSyncer, mockL1Client *aggkittypesmocks.BaseEthereumClienter) {
-				l1Header := &gethtypes.Header{Number: big.NewInt(10)}
-				mockL1Client.On("HeaderByNumber", ctx, finalizedBlockBigInt).Return(l1Header, nil)
-				mockL1InfoTreeSyncer.On("GetProcessedBlockUntil", ctx, l1Header.Number.Uint64()).Return(uint64(9), common.Hash{}, nil)
-				mockL1Client.On("HeaderByNumber", ctx, big.NewInt(9)).Return(nil, errors.New("some error"))
+				l1Header := &aggkittypes.BlockHeader{Number: 10}
+				mockL1Client.On("CustomHeaderByNumber", ctx, finalizedBlockBigInt).Return(l1Header, nil)
+				mockL1InfoTreeSyncer.On("GetProcessedBlockUntil", ctx, l1Header.Number).Return(uint64(9), common.Hash{}, nil)
+				mockL1Client.On("CustomHeaderByNumber", ctx, aggkittypes.NewBlockNumber(9)).Return(nil, errors.New("some error"))
 			},
 			expectedError: "error getting latest processed finalized block: 9: some error",
 		},
 		{
 			name: "l1infotreesyncer returned a different hash for the latest finalized block",
 			mockFn: func(mockL1InfoTreeSyncer *mocks.L1InfoTreeSyncer, mockL1Client *aggkittypesmocks.BaseEthereumClienter) {
-				l1Header := &gethtypes.Header{Number: big.NewInt(10)}
-				mockL1Client.On("HeaderByNumber", ctx, finalizedBlockBigInt).Return(l1Header, nil)
-				mockL1InfoTreeSyncer.On("GetProcessedBlockUntil", ctx, l1Header.Number.Uint64()).Return(
-					l1Header.Number.Uint64(), common.HexToHash("0x2"), nil)
+				l1Header := &aggkittypes.BlockHeader{Number: 10, Hash: common.HexToHash("0xabc")}
+				mockL1Client.On("CustomHeaderByNumber", ctx, finalizedBlockBigInt).Return(l1Header, nil)
+				mockL1InfoTreeSyncer.On("GetProcessedBlockUntil", ctx, l1Header.Number).Return(
+					l1Header.Number, common.HexToHash("0x2"), nil)
 			},
 			expectedError: "l1infotreesyncer returned a different hash for the latest finalized block: 10. " +
 				"Might be that syncer did not process a reorg yet.",
 		},
 		{
 			name: "success",
 			mockFn: func(mockL1InfoTreeSyncer *mocks.L1InfoTreeSyncer, mockL1Client *aggkittypesmocks.BaseEthereumClienter) {
-				l1Header := &gethtypes.Header{Number: big.NewInt(10)}
-				mockL1Client.On("HeaderByNumber", ctx, finalizedBlockBigInt).Return(l1Header, nil)
-				mockL1InfoTreeSyncer.On("GetProcessedBlockUntil", ctx, l1Header.Number.Uint64()).Return(
-					l1Header.Number.Uint64(), l1Header.Hash(), nil)
+				l1Header := &aggkittypes.BlockHeader{Number: 10}
+				mockL1Client.On("CustomHeaderByNumber", ctx, finalizedBlockBigInt).Return(l1Header, nil)
+				mockL1InfoTreeSyncer.On("GetProcessedBlockUntil", ctx, l1Header.Number).Return(
+					l1Header.Number, l1Header.Hash, nil)
 			},
 			expectedBlock: 10,
 		},

bridgesync/agglayer_bridge_l2_reader_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/agglayer/aggkit/bridgesync/types"
 	aggkitcommon "github.com/agglayer/aggkit/common"
+	"github.com/agglayer/aggkit/etherman"
 	aggkittypes "github.com/agglayer/aggkit/types"
 	mocksethclient "github.com/agglayer/aggkit/types/mocks"
 	"github.com/ethereum/go-ethereum/common"
@@ -228,7 +229,7 @@ func TestAgglayerBridgeL2Reader_GetUnsetClaimsForBlockRange_SimulatedBackend(t *
 	// Use the client from the simulated backend
 	client := simulatedBackend.Client()
 
-	reader, err := NewAgglayerBridgeL2Reader(bridgeAddr, client)
+	reader, err := NewAgglayerBridgeL2Reader(bridgeAddr, etherman.NewDefaultEthClient(client, nil, nil))
 	require.NoError(t, err)
 
 	// Test with the simulated backend - need to mine some blocks first
@@ -253,7 +254,7 @@ func TestAgglayerBridgeL2Reader_GetUnsetClaimsForBlockRange_WithRealEvents(t *te
 	// Use the client from the simulated backend
 	client := simulatedBackend.Client()
 
-	reader, err := NewAgglayerBridgeL2Reader(bridgeAddr, client)
+	reader, err := NewAgglayerBridgeL2Reader(bridgeAddr, etherman.NewDefaultEthClient(client, nil, nil))
 	require.NoError(t, err)
 
 	// Mine some blocks to create a valid range
@@ -281,7 +282,7 @@ func TestAgglayerBridgeL2Reader_GetUnsetClaimsForBlockRange_IteratorBehavior(t *
 	// Use the client from the simulated backend
 	client := simulatedBackend.Client()
 
-	reader, err := NewAgglayerBridgeL2Reader(bridgeAddr, client)
+	reader, err := NewAgglayerBridgeL2Reader(bridgeAddr, etherman.NewDefaultEthClient(client, nil, nil))
 	require.NoError(t, err)
 
 	// Mine some blocks to create a valid range

bridgesync/backfill_tx_sender_test.go

@@ -13,8 +13,9 @@ import (
 	"github.com/0xPolygon/cdk-contracts-tooling/contracts/aggchain-multisig/agglayerbridge"
 	"github.com/agglayer/aggkit/bridgesync/migrations"
 	"github.com/agglayer/aggkit/db"
+	"github.com/agglayer/aggkit/etherman"
+	ethermanconfig "github.com/agglayer/aggkit/etherman/config"
 	"github.com/agglayer/aggkit/log"
-	aggkittypes "github.com/agglayer/aggkit/types"
 	"github.com/agglayer/aggkit/types/mocks"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/stretchr/testify/mock"
@@ -1635,13 +1636,15 @@ func TestBackfillTxnSenderIntegration(t *testing.T) {
 
 	err = tx.Commit()
 	require.NoError(t, err)
-
+	logger := log.WithFields("module", "test")
 	// Create real client
-	client, err := aggkittypes.DialWithRetry(t.Context(), rpcURL, nil)
+	client, err := etherman.DialWithRetry(t.Context(), logger, &ethermanconfig.RPCClientConfig{
+		URL: rpcURL,
+	})
 	require.NoError(t, err)
 
 	// Create backfill instance
-	logger := log.WithFields("module", "test")
+
 	backfiller, err := NewBackfillTxnSender(dbPath, client, common.HexToAddress("0x1234"), logger)
 	require.NoError(t, err)
 	defer backfiller.Close()

bridgesync/bridgesync.go

@@ -153,14 +153,14 @@ func newBridgeSync(
 	}
 
 	if lastProcessedBlock < cfg.InitialBlockNum {
-		header, err := ethClient.HeaderByNumber(ctx, new(big.Int).SetUint64(cfg.InitialBlockNum))
+		header, err := ethClient.CustomHeaderByNumber(ctx, aggkittypes.NewBlockNumber(cfg.InitialBlockNum))
 		if err != nil {
 			return nil, fmt.Errorf("failed to get initial block %d: %w", cfg.InitialBlockNum, err)
 		}
 
 		err = processor.ProcessBlock(ctx, sync.Block{
 			Num:  cfg.InitialBlockNum,
-			Hash: header.Hash(),
+			Hash: header.Hash,
 		})
 		if err != nil {
 			return nil, err

bridgesync/downloader_test.go

@@ -11,10 +11,10 @@ import (
 	"github.com/0xPolygon/cdk-contracts-tooling/contracts/aggchain-multisig/agglayerbridgel2"
 	"github.com/0xPolygon/cdk-contracts-tooling/contracts/aggchain-multisig/polygonzkevmbridge"
 	bridgetypes "github.com/agglayer/aggkit/bridgesync/types"
+	"github.com/agglayer/aggkit/etherman"
 	logger "github.com/agglayer/aggkit/log"
 	"github.com/agglayer/aggkit/sync"
 	treetypes "github.com/agglayer/aggkit/tree/types"
-	aggkittypes "github.com/agglayer/aggkit/types"
 	"github.com/agglayer/aggkit/types/mocks"
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/common"
@@ -34,7 +34,7 @@ func TestExtractTxnAddressesExploratory(t *testing.T) {
 	l1url := os.Getenv("L1URL")
 	ethRawClient, err := ethclient.Dial(l1url)
 	require.NoError(t, err)
-	ethClient := aggkittypes.NewDefaultEthClient(ethRawClient, ethRawClient.Client())
+	ethClient := etherman.NewDefaultEthClient(ethRawClient, ethRawClient.Client(), nil)
 	bridgeAddr := common.HexToAddress("0x2a3dd3eb832af982ec71669e178424b10dca2ede")
 	agglayerBridge, err := agglayerbridge.NewAgglayerbridge(bridgeAddr, ethRawClient)
 	require.NoError(t, err)
@@ -114,7 +114,7 @@ func TestExtractCallDataCaseNotMatchingExploratory(t *testing.T) {
 	l1url := os.Getenv("L1URL")
 	ethRawClient, err := ethclient.Dial(l1url)
 	require.NoError(t, err)
-	ethClient := aggkittypes.NewDefaultEthClient(ethRawClient, ethRawClient.Client())
+	ethClient := etherman.NewDefaultEthClient(ethRawClient, ethRawClient.Client(), nil)
 	foundCalls, rootCall, err := extractCallData(ethClient, common.HexToAddress("0x2a3dd3eb832af982ec71669e178424b10dca2ede"),
 		common.HexToHash("0x280334ea89e49380d29e3c3931b9217bf699eaa7fa23e126c74a05eea1258503"),
 		logger.WithFields("module", "test"), nil)
@@ -139,7 +139,7 @@ func TestExtractCallDataCaseMessageExploratory(t *testing.T) {
 	l1url := os.Getenv("L1URL")
 	ethRawClient, err := ethclient.Dial(l1url)
 	require.NoError(t, err)
-	ethClient := aggkittypes.NewDefaultEthClient(ethRawClient, ethRawClient.Client())
+	ethClient := etherman.NewDefaultEthClient(ethRawClient, ethRawClient.Client(), nil)
 	foundCalls, rootCall, err := extractCallData(ethClient, common.HexToAddress("0x2a3dd3eb832af982ec71669e178424b10dca2ede"),
 		common.HexToHash("0x84a7e20778bd35231bfaefdcbb4ada9169b08658db49d69d38e3f467a799db38"),
 		logger.WithFields("module", "test"), nil)

bridgesync/e2e_test.go

@@ -10,6 +10,8 @@ import (
 
 	"github.com/agglayer/aggkit/bridgesync"
 	cfgtypes "github.com/agglayer/aggkit/config/types"
+	"github.com/agglayer/aggkit/etherman"
+	ethermanconfig "github.com/agglayer/aggkit/etherman/config"
 	"github.com/agglayer/aggkit/log"
 	"github.com/agglayer/aggkit/reorgdetector"
 	"github.com/agglayer/aggkit/test/helpers"
@@ -23,6 +25,12 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+var (
+	ethClientConfig = &ethermanconfig.RPCClientConfig{
+		HashFromJSON: false,
+	}
+)
+
 func TestBridgeEventE2E(t *testing.T) {
 	const (
 		blockTime    = time.Millisecond * 10
@@ -102,7 +110,7 @@ func TestBridgeEventE2E(t *testing.T) {
 	time.Sleep(time.Second * 2) // sleeping since the processor could be up to date, but have pending reorgs
 
 	lb := getFinalizedBlockNumber(t, ctx, l1Setup.SimBackend.Client())
-	helpers.RequireProcessorUpdated(t, l1Setup.BridgeSync, lb, l1Setup.SimBackend.Client())
+	helpers.RequireProcessorUpdated(t, l1Setup.BridgeSync, lb, etherman.NewDefaultEthClient(l1Setup.SimBackend.Client(), nil, nil))
 
 	// Get bridges
 	lastBlock, err := l1Setup.SimBackend.Client().BlockNumber(ctx)
@@ -145,7 +153,7 @@ func TestBridgeL1SyncerWithReorgDetector(t *testing.T) {
 	//nolint:dogsled
 	client, auth, _, _, bridgeAddr, bridgeContract, _ := helpers.NewSimulatedL1(t)
 
-	rd, err := reorgdetector.New(client.Client(), reorgdetector.Config{
+	rd, err := reorgdetector.New(etherman.NewDefaultEthClient(client.Client(), nil, nil), reorgdetector.Config{
 		DBPath:              dbPathReorg,
 		CheckReorgsInterval: cfgtypes.NewDuration(time.Millisecond * 10),
 		FinalizedBlock:      aggkittypes.FinalizedBlock,
@@ -174,7 +182,7 @@ func TestBridgeL1SyncerWithReorgDetector(t *testing.T) {
 			require.True(t, ok)
 			arg.Input = bridgesync.BridgeAssetMethodID
 		}).Return(nil)
-	ethClient := aggkittypes.NewDefaultEthClient(client.Client(), rpcClient)
+	ethClient := etherman.NewDefaultEthClient(client.Client(), rpcClient, ethClientConfig)
 
 	// Create the bridge syncer with reorg detector
 	syncer, err := bridgesync.NewL1(ctx, bridgeSyncCfg, rd, ethClient, originNetwork)
@@ -324,7 +332,7 @@ func TestReorgWithSameHashEdgeCase(t *testing.T) {
 	//nolint:dogsled
 	client, auth, _, _, bridgeAddr, bridgeContract, _ := helpers.NewSimulatedL1(t)
 
-	rd, err := reorgdetector.New(client.Client(), reorgdetector.Config{
+	rd, err := reorgdetector.New(etherman.NewDefaultEthClient(client.Client(), nil, nil), reorgdetector.Config{
 		DBPath:              dbPathReorg,
 		CheckReorgsInterval: cfgtypes.NewDuration(time.Millisecond * 10),
 		FinalizedBlock:      aggkittypes.FinalizedBlock,
@@ -353,7 +361,7 @@ func TestReorgWithSameHashEdgeCase(t *testing.T) {
 			require.True(t, ok)
 			arg.Input = bridgesync.BridgeAssetMethodID
 		}).Return(nil)
-	ethClient := aggkittypes.NewDefaultEthClient(client.Client(), rpcClient)
+	ethClient := etherman.NewDefaultEthClient(client.Client(), rpcClient, ethClientConfig)
 	syncer, err := bridgesync.NewL1(ctx, bridgeSyncCfg, rd, ethClient, originNetwork)
 	require.NoError(t, err)
 	require.NotNil(t, syncer)
@@ -435,7 +443,7 @@ func TestBridgeL1SyncerWithMultipleReorgs(t *testing.T) {
 	//nolint:dogsled
 	client, auth, _, _, bridgeAddr, bridgeContract, _ := helpers.NewSimulatedL1(t)
 
-	rd, err := reorgdetector.New(client.Client(), reorgdetector.Config{
+	rd, err := reorgdetector.New(etherman.NewDefaultEthClient(client.Client(), nil, nil), reorgdetector.Config{
 		DBPath:              dbPathReorg,
 		CheckReorgsInterval: cfgtypes.NewDuration(time.Millisecond * 10),
 		FinalizedBlock:      aggkittypes.FinalizedBlock,
@@ -464,8 +472,7 @@ func TestBridgeL1SyncerWithMultipleReorgs(t *testing.T) {
 			require.True(t, ok)
 			arg.Input = bridgesync.BridgeAssetMethodID
 		}).Return(nil)
-	ethClient := aggkittypes.NewDefaultEthClient(client.Client(), rpcClient)
-
+	ethClient := etherman.NewDefaultEthClient(client.Client(), rpcClient, ethClientConfig)
 	// Create the bridge syncer with reorg detector
 	syncer, err := bridgesync.NewL1(ctx, bridgeSyncCfg, rd, ethClient, originNetwork)
 	require.NoError(t, err)