feat: wip

Author: joanestebanr

etherman/default_eth_client.go

@@ -0,0 +1,109 @@
+package etherman
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+
+	aggkitcommon "github.com/agglayer/aggkit/common"
+	commontypes "github.com/agglayer/aggkit/common/types"
+	"github.com/agglayer/aggkit/log"
+	aggkittypes "github.com/agglayer/aggkit/types"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+var _ aggkittypes.EthClienter = (*DefaultEthClient)(nil)
+
+type DefaultEthClient struct {
+	aggkittypes.EthereumClienter
+	aggkittypes.RPCClienter
+
+	// If true, the block Hash is getted from JSON RPC
+	// if false, the block Hash is getted from go-ethereum RLP hashing of header
+	HashFromJSON bool
+}
+
+// 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) {
+	return aggkitcommon.Execute(retryHandler, ctx, log.Infof, fmt.Sprintf("dial %s rpc", url),
+		func() (aggkittypes.EthClienter, error) {
+			client, err := ethclient.Dial(url)
+			if err != nil {
+				return nil, err
+			}
+			return NewDefaultEthClient(client, client.Client()), nil
+		})
+}
+
+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())
+	if err != nil {
+		return 0, err
+	}
+	return ethHeader.Number.Uint64(), nil
+}
+
+func (c *DefaultEthClient) CustomHeaderByNumber(ctx context.Context, number *aggkittypes.BlockNumberFinality) (*aggkittypes.BlockHeader, error) {
+	if number == nil {
+		number = &aggkittypes.LatestBlock
+	}
+	// The number can have an offset, so maybe we need to resolve the blockName, apply offset to require the header
+	numberBigInt, err := c.resolveBlockNumber(ctx, number)
+	if err != nil {
+		return nil, err
+	}
+
+	if c.HashFromJSON {
+		rpcGetBlockByNumber, 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
+	}
+	res := aggkittypes.NewBlockHeaderFromEthHeader(ethHeader)
+	res.RequestedBlock = number
+	return res, nil
+
+}
+
+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
+	}
+	// Resolve the base block number
+	hdr, err := c.rpcGetBlockByNumber(ctx, number.ToBigInt())
+	if err != nil {
+		return nil, err
+	}
+	num := number.CalculateBlockNumber(hdr.Number)
+	return big.NewInt(int64(num)), nil
+}
+
+func (c *DefaultEthClient) rpcGetBlockByNumber(ctx context.Context, number *big.Int) (*aggkittypes.BlockHeader, error) {
+	blockArg := rpc.BlockNumber(number.Int64()).String()
+	fmt.Printf("rpcGetBlockByNumber: requesting block %s via JSON RPC\n", blockArg)
+	var rawEthHeader *blockRawEth
+	err := c.CallContext(ctx, &rawEthHeader, "eth_getBlockByNumber", blockArg, false)
+	if err != nil {
+		return nil, fmt.Errorf("rpcGetBlockByNumber: %w", err)
+	}
+	return rawEthHeader.ToBlockHeader()
+}

etherman/default_eth_client_test.go

@@ -0,0 +1,78 @@
+package etherman
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"os"
+	"testing"
+
+	ethermanconfig "github.com/agglayer/aggkit/etherman/config"
+	aggkittypes "github.com/agglayer/aggkit/types"
+	"github.com/agglayer/aggkit/types/mocks"
+	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDefaultEthClientExploratory(t *testing.T) {
+	l2url := os.Getenv("L2URL")
+	ctx := t.Context()
+	cfg := ethermanconfig.L2RPCClientConfig{
+		RPCClientConfig: ethermanconfig.RPCClientConfig{
+			URL: l2url,
+		},
+		Mode: ethermanconfig.RPCModeBasic,
+	}
+
+	client, err := NewRPCClient(ctx, cfg)
+	require.NoError(t, err)
+	clientEth, ok := client.(*DefaultEthClient)
+	require.True(t, ok)
+	clientEth.HashFromJSON = true
+	number := big.NewInt(123)
+	fmt.Printf("block: %s\n", rpc.BlockNumber(number.Int64()).String())
+	fmt.Printf("block: %s\n", rpc.BlockNumber(rpc.SafeBlockNumber).String())
+	fmt.Printf("block: %s\n", rpc.BlockNumber(rpc.LatestBlockNumber).String())
+	bn, err := aggkittypes.NewBlockNumberFinality("FinalizedBlock/10")
+	require.NoError(t, err)
+	header, err := clientEth.CustomHeaderByNumber(ctx, &bn)
+	require.NoError(t, err)
+	fmt.Printf("header: %+v\n", header)
+
+	//client.CustomHeaderByNumber(ctx, number)
+}
+
+func TestDefaultEthClient_CustomHeaderByNumber(t *testing.T) {
+	mockEthClient := mocks.NewEthereumClienter(t)
+	mockRPCClient := mocks.NewRPCClienter(t)
+
+	client := NewDefaultEthClient(mockEthClient, mockRPCClient)
+	bn, err := aggkittypes.NewBlockNumberFinality("FinalizedBlock/5")
+	require.NoError(t, err)
+
+	// Setup mock for rpcGetBlockByNumber
+	mockRPCClient.
+		EXPECT().
+		CallContext(
+			mock.Anything,
+			mock.AnythingOfType("*etherman.blockRawEth"),
+			"eth_getBlockByNumber",
+			rpc.BlockNumber(100).String(),
+		).
+		Return(nil).
+		Run(func(ctx context.Context, result interface{}, method string, args ...interface{}) {
+			rawEth := args[0].(**blockRawEth)
+			*rawEth = &blockRawEth{
+				Number: "0x64", // 100 in hex
+				Hash:   "0xabc123",
+			}
+		})
+	// Call CustomHeaderByNumber
+	header, err := client.CustomHeaderByNumber(context.Background(), &bn)
+	require.NoError(t, err)
+	require.NotNil(t, header)
+	require.Equal(t, uint64(100), header.Number)
+	require.Equal(t, "0xabc123", header.Hash.Hex())
+	require.Equal(t, &bn, header.RequestedBlock)
+}

etherman/rpcnoopclient.go

@@ -0,0 +1,29 @@
+package etherman
+
+import (
+	"context"
+	"errors"
+
+	aggkittypes "github.com/agglayer/aggkit/types"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+var (
+	_                 aggkittypes.RPCClienter = (*NoopRPCClient)(nil)
+	ErrNotImplemented                         = errors.New("Not implemented")
+)
+
+// NoopRPCClient is no operation implementation for the RPCClienter interface
+type NoopRPCClient struct{}
+
+func (c *NoopRPCClient) Call(result any, method string, args ...any) error {
+	return ErrNotImplemented
+}
+
+func (c *NoopRPCClient) BatchCallContext(ctx context.Context, b []rpc.BatchElem) error {
+	return ErrNotImplemented
+}
+
+func (c *NoopRPCClient) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error {
+	return ErrNotImplemented
+}