Skip to content

Commit

Permalink
fix: comments
Browse files Browse the repository at this point in the history
  • Loading branch information
@goran-ethernal
goran-ethernal committed Feb 19, 2025
1 parent 77cb826 commit 31d9dab
Show file tree
Hide file tree
Showing 17 changed files with 1,968 additions and 554 deletions.
31 changes: 12 additions & 19 deletions aggsender/l2_etherman.go → aggoracle/chaingerreader/evm.go
View file
Original file line number Diff line number Diff line change
@@ -1,48 +1,41 @@
package aggsender
package chaingerreader

import (
"context"
"fmt"

"github.com/0xPolygon/cdk-contracts-tooling/contracts/l2-sovereign-chain/globalexitrootmanagerl2sovereignchain"
"github.com/agglayer/aggkit/aggsender/types"
"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"
)

// L2GERManager is an interface to interact with the GlobalExitRootManager contract
type L2GERManager interface {
BridgeAddress(*bind.CallOpts) (common.Address, error)
FilterInsertGlobalExitRoot(opts *bind.FilterOpts, newGlobalExitRoot [][32]byte, newHashChainValue [][32]byte) (
*globalexitrootmanagerl2sovereignchain.Globalexitrootmanagerl2sovereignchainInsertGlobalExitRootIterator, error)
// EVMChainGERReader is a component used to read GlobalExitRootManager L2 contract
type EVMChainGERReader struct {
l2GERManager types.L2GERManagerContract
}

// L2Etherman is a component used to interact with L2 contracts
type L2Etherman struct {
l2GERManager L2GERManager
}

// NewL2Etherman creates a new L2Etherman
func NewL2Etherman(l2GERManagerAddr common.Address, l2Client types.EthClient) (*L2Etherman, error) {
// 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 newL2Etherman(l2GERManager, l2GERManagerAddr)
return newEVMChainGERReader(l2GERManager, l2GERManagerAddr)
}

func newL2Etherman(l2GERManager L2GERManager, l2GERManagerAddr common.Address) (*L2Etherman, error) {
func newEVMChainGERReader(l2GERManager types.L2GERManagerContract, l2GERManagerAddr common.Address) (*EVMChainGERReader, error) {
if err := checkGlobalExitRootManagerContract(l2GERManager, l2GERManagerAddr); err != nil {
return nil, err
}

return &L2Etherman{l2GERManager: l2GERManager}, nil
return &EVMChainGERReader{l2GERManager: l2GERManager}, nil
}

// checkGlobalExitRootManagerContract checks if the GlobalExitRootManager contract is valid on given address
func checkGlobalExitRootManagerContract(l2GERManager L2GERManager, contractAddr common.Address) error {
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)
Expand All @@ -52,7 +45,7 @@ func checkGlobalExitRootManagerContract(l2GERManager L2GERManager, contractAddr
}

// GetInjectedGERsForRange returns the injected GlobalExitRoots for the given block range
func (e *L2Etherman) GetInjectedGERsForRange(ctx context.Context, fromBlock, toBlock uint64) ([]common.Hash, error) {
func (e *EVMChainGERReader) GetInjectedGERsForRange(ctx context.Context, fromBlock, toBlock uint64) ([]common.Hash, error) {
iter, err := e.l2GERManager.FilterInsertGlobalExitRoot(
&bind.FilterOpts{
Context: ctx,
Expand Down
20 changes: 10 additions & 10 deletions aggsender/l2_etherman_test.go → aggoracle/chaingerreader/evm_test.go
View file
Original file line number Diff line number Diff line change
@@ -1,11 +1,11 @@
package aggsender
package chaingerreader

import (
"context"
"errors"
"testing"

"github.com/agglayer/aggkit/aggsender/mocks"
"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"
Expand All @@ -15,29 +15,29 @@ import (
"github.com/stretchr/testify/require"
)

func TestNewL2Etherman(t *testing.T) {
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.NewL2GERManager(t)
mockL2GERManager := mocks.NewL2GERManagerContract(t)
mockL2GERManager.On("BridgeAddress", (*bind.CallOpts)(nil)).Return(validAddress, nil)

l2Etherman, err := newL2Etherman(mockL2GERManager, validAddress)
l2Etherman, err := newEVMChainGERReader(mockL2GERManager, validAddress)
assert.NoError(t, err)
assert.NotNil(t, l2Etherman)
mockL2GERManager.AssertExpectations(t)
})

t.Run("failure - invalid contract address", func(t *testing.T) {
t.Parallel()
mockL2GERManager := mocks.NewL2GERManager(t)
mockL2GERManager := mocks.NewL2GERManagerContract(t)
mockL2GERManager.On("BridgeAddress", (*bind.CallOpts)(nil)).Return(invalidAddress, errors.New("invalid address"))

l2Etherman, err := newL2Etherman(mockL2GERManager, invalidAddress)
l2Etherman, err := newEVMChainGERReader(mockL2GERManager, invalidAddress)
assert.Error(t, err)
assert.Nil(t, l2Etherman)
mockL2GERManager.AssertExpectations(t)
Expand All @@ -53,14 +53,14 @@ func TestGetInjectedGERsForRange(t *testing.T) {
t.Parallel()

toBlock := uint64(10)
mockL2GERManager := mocks.NewL2GERManager(t)
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"))

l2Etherman := &L2Etherman{l2GERManager: mockL2GERManager}
l2Etherman := &EVMChainGERReader{l2GERManager: mockL2GERManager}

_, err := l2Etherman.GetInjectedGERsForRange(ctx, 1, toBlock)
require.ErrorContains(t, err, "failed to create iterator")
Expand All @@ -72,7 +72,7 @@ func TestGetInjectedGERsForRange(t *testing.T) {
setup := helpers.L2Setup(t)
setup.EthTxManagerMock.ExpectedCalls = nil

l2Etherman, err := NewL2Etherman(setup.GERAddr, setup.SimBackend.Client())
l2Etherman, err := NewEVMChainGERReader(setup.GERAddr, setup.SimBackend.Client())
require.NoError(t, err)

tx, err := setup.GERContract.InsertGlobalExitRoot(setup.Auth, common.HexToHash("0x1234567890abcdef1234567890abcdef12345678"))
Expand Down
38 changes: 5 additions & 33 deletions aggoracle/chaingersender/evm.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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"`
Expand All @@ -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) {
Expand Down
30 changes: 15 additions & 15 deletions aggoracle/chaingersender/evm_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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",
},
Expand All @@ -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(),
Expand Down Expand Up @@ -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)

Expand Down
Loading

0 comments on commit 31d9dab

Please sign in to comment.