feat: send GER inclusion proofs to aggchain prover

agglayer/types.go

@@ -133,6 +133,7 @@ type Certificate struct {
 	ImportedBridgeExits []*ImportedBridgeExit `json:"imported_bridge_exits"`
 	Metadata            common.Hash           `json:"metadata"`
 	AggchainProof       []byte                `json:"aggchain_proof,omitempty"`
+	CustomChainData     []byte                `json:"custom_chain_data,omitempty"`
 }
 
 // ID returns a string with the ident of this cert (height/certID)

aggoracle/chaingerreader/evm.go

@@ -0,0 +1,81 @@
+package chaingerreader
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/0xPolygon/cdk-contracts-tooling/contracts/l2-sovereign-chain/globalexitrootmanagerl2sovereignchain"
+	"github.com/agglayer/aggkit/aggoracle/types"
+	"github.com/agglayer/aggkit/log"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+// EVMChainGERReader is a component used to read GlobalExitRootManager L2 contract
+type EVMChainGERReader struct {
+	l2GERManager types.L2GERManagerContract
+}
+
+// NewEVMChainGERReader creates a new L2Etherman
+func NewEVMChainGERReader(l2GERManagerAddr common.Address, l2Client types.EthClienter) (*EVMChainGERReader, error) {
+	l2GERManager, err := globalexitrootmanagerl2sovereignchain.NewGlobalexitrootmanagerl2sovereignchain(
+		l2GERManagerAddr, l2Client)
+	if err != nil {
+		return nil, err
+	}
+	return newEVMChainGERReader(l2GERManager, l2GERManagerAddr)
+}
+
+func newEVMChainGERReader(l2GERManager types.L2GERManagerContract,
+	l2GERManagerAddr common.Address) (*EVMChainGERReader, error) {
+	if err := checkGlobalExitRootManagerContract(l2GERManager, l2GERManagerAddr); err != nil {
+		return nil, err
+	}
+
+	return &EVMChainGERReader{l2GERManager: l2GERManager}, nil
+}
+
+// checkGlobalExitRootManagerContract checks if the GlobalExitRootManager contract is valid on given address
+func checkGlobalExitRootManagerContract(l2GERManager types.L2GERManagerContract, contractAddr common.Address) error {
+	bridgeAddr, err := l2GERManager.BridgeAddress(nil)
+	if err != nil {
+		return fmt.Errorf("fail sanity check GlobalExitRootManagerL2(%s) Contract. Err: %w", contractAddr.String(), err)
+	}
+	log.Infof("sanity check GlobalExitRootManagerL2(%s) OK. bridgeAddress: %s", contractAddr.String(), bridgeAddr.String())
+	return nil
+}
+
+// GetInjectedGERsForRange returns the injected GlobalExitRoots for the given block range
+func (e *EVMChainGERReader) GetInjectedGERsForRange(ctx context.Context,
+	fromBlock, toBlock uint64) ([]common.Hash, error) {
+	if fromBlock > toBlock {
+		return nil, fmt.Errorf("invalid block range: fromBlock(%d) > toBlock(%d)", fromBlock, toBlock)
+	}
+
+	iter, err := e.l2GERManager.FilterInsertGlobalExitRoot(
+		&bind.FilterOpts{
+			Context: ctx,
+			Start:   fromBlock,
+			End:     &toBlock,
+		}, nil, nil)
+	if err != nil {
+		log.Errorf("failed to create InsertGlobalExitRoot event iterator: %v", err)
+		return nil, err
+	}
+
+	var gerHashes []common.Hash
+
+	for iter.Next() {
+		if iter.Error() != nil {
+			return nil, iter.Error()
+		}
+
+		gerHashes = append(gerHashes, iter.Event.NewGlobalExitRoot)
+	}
+
+	if err = iter.Close(); err != nil {
+		log.Errorf("failed to close InsertGlobalExitRoot event iterator: %v", err)
+	}
+
+	return gerHashes, nil
+}

aggoracle/chaingerreader/evm_test.go

@@ -0,0 +1,102 @@
+package chaingerreader
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/agglayer/aggkit/aggoracle/mocks"
+	"github.com/agglayer/aggkit/test/helpers"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewChainGERReader(t *testing.T) {
+	t.Parallel()
+
+	validAddress := common.HexToAddress("0x1234567890abcdef1234567890abcdef12345678")
+	invalidAddress := common.Address{}
+
+	t.Run("success", func(t *testing.T) {
+		t.Parallel()
+		mockL2GERManager := mocks.NewL2GERManagerContract(t)
+		mockL2GERManager.On("BridgeAddress", (*bind.CallOpts)(nil)).Return(validAddress, nil)
+
+		gerReader, err := newEVMChainGERReader(mockL2GERManager, validAddress)
+		require.NoError(t, err)
+		require.NotNil(t, gerReader)
+		mockL2GERManager.AssertExpectations(t)
+	})
+
+	t.Run("failure - invalid contract address", func(t *testing.T) {
+		t.Parallel()
+		mockL2GERManager := mocks.NewL2GERManagerContract(t)
+		mockL2GERManager.On("BridgeAddress", (*bind.CallOpts)(nil)).Return(invalidAddress, errors.New("invalid address"))
+
+		l2Etherman, err := newEVMChainGERReader(mockL2GERManager, invalidAddress)
+		require.Error(t, err)
+		require.Nil(t, l2Etherman)
+		mockL2GERManager.AssertExpectations(t)
+	})
+}
+
+func TestGetInjectedGERsForRange(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+
+	t.Run("invalid block range", func(t *testing.T) {
+		t.Parallel()
+
+		mockL2GERManager := mocks.NewL2GERManagerContract(t)
+		gerReader := &EVMChainGERReader{l2GERManager: mockL2GERManager}
+
+		_, err := gerReader.GetInjectedGERsForRange(ctx, 10, 1)
+		require.ErrorContains(t, err, "invalid block range: fromBlock(10) > toBlock(1)")
+	})
+
+	t.Run("failed to create iterator", func(t *testing.T) {
+		t.Parallel()
+
+		toBlock := uint64(10)
+		mockL2GERManager := mocks.NewL2GERManagerContract(t)
+		mockL2GERManager.On("FilterInsertGlobalExitRoot", &bind.FilterOpts{
+			Context: ctx,
+			Start:   1,
+			End:     &toBlock,
+		}, mock.Anything, mock.Anything).Return(nil, errors.New("failed to create iterator"))
+
+		gerReader := &EVMChainGERReader{l2GERManager: mockL2GERManager}
+
+		_, err := gerReader.GetInjectedGERsForRange(ctx, 1, toBlock)
+		require.ErrorContains(t, err, "failed to create iterator")
+	})
+
+	t.Run("success", func(t *testing.T) {
+		t.Parallel()
+
+		setup := helpers.L2Setup(t)
+		setup.EthTxManagerMock.ExpectedCalls = nil
+
+		gerReader, err := NewEVMChainGERReader(setup.GERAddr, setup.SimBackend.Client())
+		require.NoError(t, err)
+
+		tx, err := setup.GERContract.InsertGlobalExitRoot(setup.Auth, common.HexToHash("0x1234567890abcdef1234567890abcdef12345678"))
+		require.NoError(t, err)
+
+		// commit one block
+		setup.SimBackend.Commit()
+
+		receipt, err := setup.SimBackend.Client().TransactionReceipt(ctx, tx.Hash())
+		require.NoError(t, err)
+		require.Equal(t, receipt.Status, types.ReceiptStatusSuccessful)
+
+		injectedGERs, err := gerReader.GetInjectedGERsForRange(ctx, 1, 10)
+		require.NoError(t, err)
+		require.Len(t, injectedGERs, 1)
+		require.Equal(t, common.HexToHash("0x1234567890abcdef1234567890abcdef12345678"), injectedGERs[0])
+	})
+}

aggoracle/chaingersender/evm.go

@@ -3,49 +3,21 @@ package chaingersender
 import (
 	"context"
 	"fmt"
-	"math/big"
 	"time"
 
 	"github.com/0xPolygon/cdk-contracts-tooling/contracts/l2-sovereign-chain/globalexitrootmanagerl2sovereignchain"
 	"github.com/0xPolygon/zkevm-ethtx-manager/ethtxmanager"
 	ethtxtypes "github.com/0xPolygon/zkevm-ethtx-manager/types"
+	"github.com/agglayer/aggkit/aggoracle/types"
 	cfgtypes "github.com/agglayer/aggkit/config/types"
 	"github.com/agglayer/aggkit/log"
-	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
 )
 
 const insertGERFuncName = "insertGlobalExitRoot"
 
-type EthClienter interface {
-	ethereum.LogFilterer
-	ethereum.BlockNumberReader
-	ethereum.ChainReader
-	bind.ContractBackend
-}
-
-type EthTxManager interface {
-	Remove(ctx context.Context, id common.Hash) error
-	ResultsByStatus(ctx context.Context,
-		statuses []ethtxtypes.MonitoredTxStatus,
-	) ([]ethtxtypes.MonitoredTxResult, error)
-	Result(ctx context.Context, id common.Hash) (ethtxtypes.MonitoredTxResult, error)
-	Add(ctx context.Context,
-		to *common.Address,
-		value *big.Int,
-		data []byte,
-		gasOffset uint64,
-		sidecar *types.BlobTxSidecar,
-	) (common.Hash, error)
-}
-
-type L2GERManagerContract interface {
-	GlobalExitRootMap(opts *bind.CallOpts, ger [common.HashLength]byte) (*big.Int, error)
-}
-
 type EVMConfig struct {
 	GlobalExitRootL2Addr common.Address      `mapstructure:"GlobalExitRootL2"`
 	URLRPCL2             string              `mapstructure:"URLRPCL2"`
@@ -57,20 +29,20 @@ type EVMConfig struct {
 type EVMChainGERSender struct {
 	logger *log.Logger
 
-	l2GERManager     L2GERManagerContract
+	l2GERManager     types.L2GERManagerContract
 	l2GERManagerAddr common.Address
 	l2GERManagerAbi  *abi.ABI
 
-	ethTxMan            EthTxManager
+	ethTxMan            types.EthTxManager
 	gasOffset           uint64
 	waitPeriodMonitorTx time.Duration
 }
 
 func NewEVMChainGERSender(
 	logger *log.Logger,
 	l2GERManagerAddr common.Address,
-	l2Client EthClienter,
-	ethTxMan EthTxManager,
+	l2Client types.EthClienter,
+	ethTxMan types.EthTxManager,
 	gasOffset uint64,
 	waitPeriodMonitorTx time.Duration,
 ) (*EVMChainGERSender, error) {

aggoracle/chaingersender/evm_test.go

@@ -42,39 +42,37 @@ func TestEVMChainGERSender_InjectGER(t *testing.T) {
 		name            string
 		addReturnTxID   common.Hash
 		addReturnErr    error
-		resultReturn    types.MonitoredTxResult
+		resultReturn    *types.MonitoredTxResult
 		resultReturnErr error
 		expectedErr     string
 	}{
 		{
 			name:            "successful injection",
 			addReturnTxID:   txID,
 			addReturnErr:    nil,
-			resultReturn:    types.MonitoredTxResult{Status: types.MonitoredTxStatusMined, MinedAtBlockNumber: big.NewInt(123)},
+			resultReturn:    &types.MonitoredTxResult{Status: types.MonitoredTxStatusMined, MinedAtBlockNumber: big.NewInt(123)},
 			resultReturnErr: nil,
 			expectedErr:     "",
 		},
 		{
 			name:            "injection fails due to transaction failure",
 			addReturnTxID:   txID,
 			addReturnErr:    nil,
-			resultReturn:    types.MonitoredTxResult{Status: types.MonitoredTxStatusFailed},
+			resultReturn:    &types.MonitoredTxResult{Status: types.MonitoredTxStatusFailed},
 			resultReturnErr: nil,
 			expectedErr:     "inject GER tx",
 		},
 		{
-			name:            "injection fails due to Add method error",
-			addReturnTxID:   common.Hash{},
-			addReturnErr:    errors.New("add error"),
-			resultReturn:    types.MonitoredTxResult{},
-			resultReturnErr: nil,
-			expectedErr:     "add error",
+			name:          "injection fails due to Add method error",
+			addReturnTxID: common.Hash{},
+			addReturnErr:  errors.New("add error"),
+			expectedErr:   "add error",
 		},
 		{
 			name:            "injection fails due to Result method error",
 			addReturnTxID:   txID,
 			addReturnErr:    nil,
-			resultReturn:    types.MonitoredTxResult{},
+			resultReturn:    &types.MonitoredTxResult{},
 			resultReturnErr: errors.New("result error"),
 			expectedErr:     "result error",
 		},
@@ -85,13 +83,15 @@ func TestEVMChainGERSender_InjectGER(t *testing.T) {
 			ctx, cancelFn := context.WithTimeout(context.Background(), time.Millisecond*500)
 			defer cancelFn()
 
-			ethTxMan := new(mocks.EthTxManagerMock)
+			ethTxMan := mocks.NewEthTxManager(t)
 			ethTxMan.
 				On("Add", ctx, &l2GERManagerAddr, common.Big0, mock.Anything, mock.Anything, mock.Anything).
 				Return(tt.addReturnTxID, tt.addReturnErr)
-			ethTxMan.
-				On("Result", ctx, tt.addReturnTxID).
-				Return(tt.resultReturn, tt.resultReturnErr)
+			if tt.resultReturn != nil || tt.resultReturnErr != nil {
+				ethTxMan.
+					On("Result", ctx, tt.addReturnTxID).
+					Return(*tt.resultReturn, tt.resultReturnErr)
+			}
 
 			sender := &EVMChainGERSender{
 				logger:              log.GetDefaultLogger(),
@@ -145,7 +145,7 @@ func TestEVMChainGERSender_IsGERInjected(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			mockL2GERManager := new(mocks.L2GERManagerMock)
+			mockL2GERManager := mocks.NewL2GERManagerContract(t)
 			mockL2GERManager.On("GlobalExitRootMap", mock.Anything, mock.Anything).
 				Return(tt.mockReturn, tt.mockError)