fix: ut, lint

Author: joanestebanr

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

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"testing"
 
+	"github.com/agglayer/aggkit/etherman"
 	aggkittypes "github.com/agglayer/aggkit/types"
 	mocksethclient "github.com/agglayer/aggkit/types/mocks"
 	"github.com/ethereum/go-ethereum/common"
@@ -226,7 +227,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))
 	require.NoError(t, err)
 
 	// Test with the simulated backend - need to mine some blocks first
@@ -251,7 +252,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))
 	require.NoError(t, err)
 
 	// Mine some blocks to create a valid range
@@ -279,7 +280,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))
 	require.NoError(t, err)
 
 	// Mine some blocks to create a valid range

bridgesync/backfill_tx_sender_test.go

@@ -12,8 +12,8 @@ import (
 
 	"github.com/agglayer/aggkit/bridgesync/migrations"
 	"github.com/agglayer/aggkit/db"
+	"github.com/agglayer/aggkit/etherman"
 	"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"
@@ -1643,7 +1643,7 @@ func TestBackfillTxnSenderIntegration(t *testing.T) {
 	require.NoError(t, err)
 
 	// Create real client
-	client, err := aggkittypes.DialWithRetry(t.Context(), rpcURL, nil)
+	client, err := etherman.DialWithRetry(t.Context(), rpcURL, nil)
 	require.NoError(t, err)
 
 	// Create backfill instance

bridgesync/e2e_test.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/agglayer/aggkit/bridgesync"
 	cfgtypes "github.com/agglayer/aggkit/config/types"
+	"github.com/agglayer/aggkit/etherman"
 	"github.com/agglayer/aggkit/log"
 	"github.com/agglayer/aggkit/reorgdetector"
 	"github.com/agglayer/aggkit/test/helpers"
@@ -96,7 +97,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))
 
 	// Get bridges
 	lastBlock, err := l1Setup.SimBackend.Client().BlockNumber(ctx)
@@ -139,7 +140,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), reorgdetector.Config{
 		DBPath:              dbPathReorg,
 		CheckReorgsInterval: cfgtypes.NewDuration(time.Millisecond * 10),
 		FinalizedBlock:      aggkittypes.FinalizedBlock,
@@ -168,7 +169,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)
 
 	// Create the bridge syncer with reorg detector
 	syncer, err := bridgesync.NewL1(ctx, bridgeSyncCfg, rd, ethClient, originNetwork)
@@ -318,7 +319,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), reorgdetector.Config{
 		DBPath:              dbPathReorg,
 		CheckReorgsInterval: cfgtypes.NewDuration(time.Millisecond * 10),
 		FinalizedBlock:      aggkittypes.FinalizedBlock,
@@ -347,7 +348,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)
 	syncer, err := bridgesync.NewL1(ctx, bridgeSyncCfg, rd, ethClient, originNetwork)
 	require.NoError(t, err)
 	require.NotNil(t, syncer)
@@ -429,7 +430,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), reorgdetector.Config{
 		DBPath:              dbPathReorg,
 		CheckReorgsInterval: cfgtypes.NewDuration(time.Millisecond * 10),
 		FinalizedBlock:      aggkittypes.FinalizedBlock,
@@ -458,8 +459,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)
 	// Create the bridge syncer with reorg detector
 	syncer, err := bridgesync.NewL1(ctx, bridgeSyncCfg, rd, ethClient, originNetwork)
 	require.NoError(t, err)

bridgesync/helpers_test.go

@@ -10,6 +10,7 @@ import (
 
 	aggkitcommon "github.com/agglayer/aggkit/common"
 	cfgtypes "github.com/agglayer/aggkit/config/types"
+	"github.com/agglayer/aggkit/etherman"
 	"github.com/agglayer/aggkit/log"
 	aggkittypes "github.com/agglayer/aggkit/types"
 	ethereum "github.com/ethereum/go-ethereum"
@@ -49,7 +50,7 @@ func startGeth(t *testing.T, ctx context.Context, cancelFn context.CancelFunc) (
 	retryHandler, err := cfg.NewRetryHandler()
 	require.NoError(t, err, "failed to create retry handler")
 
-	client, err := aggkittypes.DialWithRetry(t.Context(), "http://127.0.0.1:8545", retryHandler)
+	client, err := etherman.DialWithRetry(t.Context(), "http://127.0.0.1:8545", retryHandler)
 	require.NoError(t, err)
 
 	auth := createAuth(t, ctx, "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", client)

etherman/config/network_test.go

@@ -17,6 +17,7 @@ import (
 
 // Test for issue: 1389
 func TestEthClientExploratory(t *testing.T) {
+	t.Skip("explotaroty test")
 	l2url := os.Getenv("L2URL")
 	ethRawClient, err := ethclient.Dial(l2url)
 	require.NoError(t, err)
@@ -29,8 +30,8 @@ func TestEthClientExploratory(t *testing.T) {
 	hash := header.Hash()
 	fmt.Printf("block hash: %s\n", hash.Hex())
 
-	ethRawClient.Client().BatchCall(nil)
-
+	err = ethRawClient.Client().BatchCall(nil)
+	require.NoError(t, err)
 }
 
 func TestGetString(t *testing.T) {

etherman/default_eth_client.go

@@ -26,7 +26,8 @@ type DefaultEthClient struct {
 
 // DialWithRetry attempts to connect to an Ethereum client with retries and exponential backoff.
 // It returns an EthClienter on success or an error if all attempts fail.
-func DialWithRetry(ctx context.Context, url string, retryHandler commontypes.RetryHandler) (aggkittypes.EthClienter, error) {
+func DialWithRetry(ctx context.Context, url string,
+	retryHandler commontypes.RetryHandler) (aggkittypes.EthClienter, error) {
 	return aggkitcommon.Execute(retryHandler, ctx, log.Infof, fmt.Sprintf("dial %s rpc", url),
 		func() (aggkittypes.EthClienter, error) {
 			client, err := ethclient.Dial(url)
@@ -38,24 +39,22 @@ func DialWithRetry(ctx context.Context, url string, retryHandler commontypes.Ret
 }
 
 func NewDefaultEthClient(client aggkittypes.EthereumClienter, rpcClient aggkittypes.RPCClienter) *DefaultEthClient {
-	if rpcClient == nil {
-		rpcClient = &NoopRPCClient{}
-	}
 	return &DefaultEthClient{
 		EthereumClienter: client,
 		RPCClienter:      rpcClient,
 	}
 }
 
 func (c *DefaultEthClient) CustomBlockNumber(ctx context.Context, number aggkittypes.BlockName) (uint64, error) {
-	ethHeader, err := c.EthereumClienter.HeaderByNumber(ctx, number.ToBigInt())
+	ethHeader, err := c.HeaderByNumber(ctx, number.ToBigInt())
 	if err != nil {
 		return 0, err
 	}
 	return ethHeader.Number.Uint64(), nil
 }
 
-func (c *DefaultEthClient) CustomHeaderByNumber(ctx context.Context, number *aggkittypes.BlockNumberFinality) (*aggkittypes.BlockHeader, error) {
+func (c *DefaultEthClient) CustomHeaderByNumber(ctx context.Context,
+	number *aggkittypes.BlockNumberFinality) (*aggkittypes.BlockHeader, error) {
 	if number == nil {
 		number = &aggkittypes.LatestBlock
 	}
@@ -64,26 +63,26 @@ func (c *DefaultEthClient) CustomHeaderByNumber(ctx context.Context, number *agg
 	if err != nil {
 		return nil, err
 	}
-
+	var result *aggkittypes.BlockHeader
 	if c.HashFromJSON {
-		rpcGetBlockByNumber, err := c.rpcGetBlockByNumber(ctx, numberBigInt)
+		result, err = c.rpcGetBlockByNumber(ctx, numberBigInt)
 		if err != nil {
 			return nil, err
 		}
-		return rpcGetBlockByNumber, nil
-	}
-
-	ethHeader, err := c.EthereumClienter.HeaderByNumber(ctx, numberBigInt)
-	if err != nil {
-		return nil, err
+	} else {
+		ethHeader, err := c.HeaderByNumber(ctx, numberBigInt)
+		if err != nil {
+			return nil, err
+		}
+		result = aggkittypes.NewBlockHeaderFromEthHeader(ethHeader)
 	}
-	res := aggkittypes.NewBlockHeaderFromEthHeader(ethHeader)
-	res.RequestedBlock = number
-	return res, nil
 
+	result.RequestedBlock = number
+	return result, nil
 }
 
-func (c *DefaultEthClient) resolveBlockNumber(ctx context.Context, number *aggkittypes.BlockNumberFinality) (*big.Int, error) {
+func (c *DefaultEthClient) resolveBlockNumber(ctx context.Context,
+	number *aggkittypes.BlockNumberFinality) (*big.Int, error) {
 	// If is a number or don't have offset with 1 query it's enough
 	if number.IsConstant() || !number.HasOffset() {
 		return number.ToBigInt(), nil
@@ -107,3 +106,25 @@ func (c *DefaultEthClient) rpcGetBlockByNumber(ctx context.Context, number *big.
 	}
 	return rawEthHeader.ToBlockHeader()
 }
+
+func (c *DefaultEthClient) Call(result any, method string, args ...any) error {
+	if c.RPCClienter == nil {
+		return ErrNotImplemented
+	}
+	return c.RPCClienter.Call(result, method, args...)
+}
+
+func (c *DefaultEthClient) BatchCallContext(ctx context.Context, b []rpc.BatchElem) error {
+	if c.RPCClienter == nil {
+		return ErrNotImplemented
+	}
+	return c.RPCClienter.BatchCallContext(ctx, b)
+}
+
+func (c *DefaultEthClient) CallContext(ctx context.Context,
+	result interface{}, method string, args ...interface{}) error {
+	if c.RPCClienter == nil {
+		return ErrNotImplemented
+	}
+	return c.RPCClienter.CallContext(ctx, result, method, args...)
+}