feat: Add support for all the contracts on test/helpers so it's eas…

…y to build E2E tests (#115)

aggoracle/e2e_test.go

@@ -8,15 +8,15 @@ import (
 
 	gerContractL1 "github.com/0xPolygon/cdk-contracts-tooling/contracts/manual/globalexitrootnopush0"
 	"github.com/0xPolygon/cdk/aggoracle"
-	"github.com/0xPolygon/cdk/test/helpers"
+	"github.com/0xPolygon/cdk/test/aggoraclehelpers"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient/simulated"
 	"github.com/stretchr/testify/require"
 )
 
 func TestEVM(t *testing.T) {
-	env := helpers.SetupAggoracleWithEVMChain(t)
+	env := aggoraclehelpers.SetupAggoracleWithEVMChain(t)
 	runTest(t, env.GERL1Contract, env.AggOracleSender, env.L1Client, env.AuthL1)
 }
 

bridgesync/e2e_test.go

@@ -8,60 +8,28 @@ import (
 	"testing"
 	"time"
 
-	"github.com/0xPolygon/cdk-contracts-tooling/contracts/elderberry-paris/polygonzkevmbridgev2"
 	"github.com/0xPolygon/cdk/bridgesync"
 	"github.com/0xPolygon/cdk/etherman"
 	"github.com/0xPolygon/cdk/reorgdetector"
 	"github.com/0xPolygon/cdk/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/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethclient/simulated"
 	"github.com/stretchr/testify/require"
 )
 
-func newSimulatedClient(t *testing.T, auth *bind.TransactOpts) (
-	client *simulated.Backend,
-	bridgeAddr common.Address,
-	bridgeContract *polygonzkevmbridgev2.Polygonzkevmbridgev2,
-) {
-	t.Helper()
-
-	var err error
-	balance, _ := big.NewInt(0).SetString("10000000000000000000000000", 10)
-	address := auth.From
-	genesisAlloc := map[common.Address]types.Account{
-		address: {
-			Balance: balance,
-		},
-	}
-	blockGasLimit := uint64(999999999999999999)
-	client = simulated.NewBackend(genesisAlloc, simulated.WithBlockGasLimit(blockGasLimit))
-
-	bridgeAddr, _, bridgeContract, err = polygonzkevmbridgev2.DeployPolygonzkevmbridgev2(auth, client.Client())
-	require.NoError(t, err)
-	client.Commit()
-
-	return
-}
-
 func TestBridgeEventE2E(t *testing.T) {
 	ctx := context.Background()
 	dbPathSyncer := path.Join(t.TempDir(), "file::memory:?cache=shared")
 	dbPathReorg := t.TempDir()
-	privateKey, err := crypto.GenerateKey()
-	require.NoError(t, err)
-	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(1337))
-	require.NoError(t, err)
-	client, bridgeAddr, bridgeSc := newSimulatedClient(t, auth)
+
+	client, setup := helpers.SimulatedBackend(t, nil, 0)
 	rd, err := reorgdetector.New(client.Client(), reorgdetector.Config{DBPath: dbPathReorg})
 	require.NoError(t, err)
 
 	go rd.Start(ctx) //nolint:errcheck
 
 	testClient := helpers.TestClient{ClientRenamed: client.Client()}
-	syncer, err := bridgesync.NewL1(ctx, dbPathSyncer, bridgeAddr, 10, etherman.LatestBlock, rd, testClient, 0, time.Millisecond*10, 0, 0)
+	syncer, err := bridgesync.NewL1(ctx, dbPathSyncer, setup.EBZkevmBridgeAddr, 10, etherman.LatestBlock, rd, testClient, 0, time.Millisecond*10, 0, 0)
 	require.NoError(t, err)
 
 	go syncer.Start(ctx)
@@ -71,15 +39,15 @@ func TestBridgeEventE2E(t *testing.T) {
 
 	for i := 0; i < 100; i++ {
 		bridge := bridgesync.Bridge{
-			BlockNum:           uint64(2 + i),
+			BlockNum:           uint64(4 + i),
 			Amount:             big.NewInt(0),
 			DepositCount:       uint32(i),
 			DestinationNetwork: 3,
 			DestinationAddress: common.HexToAddress("f00"),
 			Metadata:           []byte{},
 		}
-		tx, err := bridgeSc.BridgeAsset(
-			auth,
+		tx, err := setup.EBZkevmBridgeContract.BridgeAsset(
+			setup.UserAuth,
 			bridge.DestinationNetwork,
 			bridge.DestinationAddress,
 			bridge.Amount,

claimsponsor/e2e_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/0xPolygon/cdk/claimsponsor"
 	"github.com/0xPolygon/cdk/etherman"
 	"github.com/0xPolygon/cdk/log"
+	"github.com/0xPolygon/cdk/test/aggoraclehelpers"
 	"github.com/0xPolygon/cdk/test/helpers"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
@@ -22,7 +23,7 @@ import (
 func TestE2EL1toEVML2(t *testing.T) {
 	// start other needed components
 	ctx := context.Background()
-	env := helpers.SetupAggoracleWithEVMChain(t)
+	env := aggoraclehelpers.SetupAggoracleWithEVMChain(t)
 	dbPathBridgeSyncL1 := path.Join(t.TempDir(), "file::memory:?cache=shared")
 	testClient := helpers.TestClient{ClientRenamed: env.L1Client.Client()}
 	bridgeSyncL1, err := bridgesync.NewL1(ctx, dbPathBridgeSyncL1, env.BridgeL1Addr, 10, etherman.LatestBlock, env.ReorgDetector, testClient, 0, time.Millisecond*10, 0, 0)

dataavailability/datacommittee/datacommittee_test.go

@@ -9,9 +9,9 @@ import (
 	"github.com/0xPolygon/cdk-contracts-tooling/contracts/banana/polygondatacommittee"
 	"github.com/0xPolygon/cdk/log"
 	erc1967proxy "github.com/0xPolygon/cdk/test/contracts/erc1967proxy"
+	"github.com/0xPolygon/cdk/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/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethclient/simulated"
 	"github.com/stretchr/testify/assert"
@@ -20,7 +20,7 @@ import (
 
 func TestUpdateDataCommitteeEvent(t *testing.T) {
 	// Set up testing environment
-	dac, ethBackend, auth, da := newTestingEnv(t)
+	dac, ethBackend, da, auth := newSimulatedDacman(t)
 
 	// Update the committee
 	requiredAmountOfSignatures := big.NewInt(2)
@@ -63,82 +63,39 @@ func init() {
 	})
 }
 
-// This function prepare the blockchain, the wallet with funds and deploy the smc
-func newTestingEnv(t *testing.T) (
-	dac *Backend,
-	ethBackend *simulated.Backend,
-	auth *bind.TransactOpts,
-	da *polygondatacommittee.Polygondatacommittee,
-) {
-	t.Helper()
-	privateKey, err := crypto.GenerateKey()
-	if err != nil {
-		log.Fatal(err)
-	}
-	auth, err = bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(1337))
-	if err != nil {
-		log.Fatal(err)
-	}
-	dac, ethBackend, da, err = newSimulatedDacman(t, auth)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	return dac, ethBackend, auth, da
-}
-
 // NewSimulatedEtherman creates an etherman that uses a simulated blockchain. It's important to notice that the ChainID of the auth
 // must be 1337. The address that holds the auth will have an initial balance of 10 ETH
-func newSimulatedDacman(t *testing.T, auth *bind.TransactOpts) (
-	dacman *Backend,
-	ethBackend *simulated.Backend,
-	da *polygondatacommittee.Polygondatacommittee,
-	err error,
+func newSimulatedDacman(t *testing.T) (
+	*Backend,
+	*simulated.Backend,
+	*polygondatacommittee.Polygondatacommittee,
+	*bind.TransactOpts,
 ) {
 	t.Helper()
-	if auth == nil {
-		// read only client
-		return &Backend{}, nil, nil, nil
-	}
-	// 10000000 ETH in wei
-	balance, _ := new(big.Int).SetString("10000000000000000000000000", 10)
-	address := auth.From
-	genesisAlloc := map[common.Address]types.Account{
-		address: {
-			Balance: balance,
-		},
-	}
-	blockGasLimit := uint64(999999999999999999)
-	client := simulated.NewBackend(genesisAlloc, simulated.WithBlockGasLimit(blockGasLimit))
+
+	ethBackend, setup := helpers.SimulatedBackend(t, nil, 0)
 
 	// DAC Setup
-	addr, _, _, err := smcparis.DeployPolygondatacommittee(auth, client.Client())
-	if err != nil {
-		return &Backend{}, nil, nil, err
-	}
-	client.Commit()
-	proxyAddr, err := deployDACProxy(auth, client.Client(), addr)
-	if err != nil {
-		return &Backend{}, nil, nil, err
-	}
+	addr, _, _, err := smcparis.DeployPolygondatacommittee(setup.UserAuth, ethBackend.Client())
+	require.NoError(t, err)
+	ethBackend.Commit()
 
-	client.Commit()
-	da, err = polygondatacommittee.NewPolygondatacommittee(proxyAddr, client.Client())
-	if err != nil {
-		return &Backend{}, nil, nil, err
-	}
+	proxyAddr, err := deployDACProxy(setup.UserAuth, ethBackend.Client(), addr)
+	require.NoError(t, err)
+	ethBackend.Commit()
 
-	_, err = da.SetupCommittee(auth, big.NewInt(0), []string{}, []byte{})
-	if err != nil {
-		return &Backend{}, nil, nil, err
-	}
-	client.Commit()
+	da, err := polygondatacommittee.NewPolygondatacommittee(proxyAddr, ethBackend.Client())
+	require.NoError(t, err)
+
+	_, err = da.SetupCommittee(setup.UserAuth, big.NewInt(0), []string{}, []byte{})
+	require.NoError(t, err)
+	ethBackend.Commit()
 
 	c := &Backend{
 		dataCommitteeContract: da,
 	}
 
-	return c, client, da, nil
+	return c, ethBackend, da, setup.UserAuth
 }
 
 func deployDACProxy(auth *bind.TransactOpts, client bind.ContractBackend, dacImpl common.Address) (common.Address, error) {

l1infotreesync/e2e_test.go

@@ -2,7 +2,6 @@ package l1infotreesync_test
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"math/big"
 	"path"
@@ -16,6 +15,7 @@ import (
 	"github.com/0xPolygon/cdk/l1infotreesync"
 	"github.com/0xPolygon/cdk/reorgdetector"
 	"github.com/0xPolygon/cdk/test/contracts/verifybatchesmock"
+	"github.com/0xPolygon/cdk/test/helpers"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -25,61 +25,44 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func newSimulatedClient(auth *bind.TransactOpts) (
-	client *simulated.Backend,
-	gerAddr common.Address,
-	verifyAddr common.Address,
-	gerContract *polygonzkevmglobalexitrootv2.Polygonzkevmglobalexitrootv2,
-	verifyContract *verifybatchesmock.Verifybatchesmock,
-	err error,
+func newSimulatedClient(t *testing.T) (
+	*simulated.Backend,
+	*bind.TransactOpts,
+	common.Address,
+	common.Address,
+	*polygonzkevmglobalexitrootv2.Polygonzkevmglobalexitrootv2,
+	*verifybatchesmock.Verifybatchesmock,
 ) {
+	t.Helper()
+
 	ctx := context.Background()
-	balance, _ := new(big.Int).SetString("10000000000000000000000000", 10)
-	address := auth.From
-	genesisAlloc := map[common.Address]types.Account{
-		address: {
-			Balance: balance,
-		},
-	}
-	blockGasLimit := uint64(999999999999999999)
-	client = simulated.NewBackend(genesisAlloc, simulated.WithBlockGasLimit(blockGasLimit))
+	client, setup := helpers.SimulatedBackend(t, nil, 0)
 
-	nonce, err := client.Client().PendingNonceAt(ctx, auth.From)
-	if err != nil {
-		return
-	}
-	precalculatedAddr := crypto.CreateAddress(auth.From, nonce+1)
-	verifyAddr, _, verifyContract, err = verifybatchesmock.DeployVerifybatchesmock(auth, client.Client(), precalculatedAddr)
-	if err != nil {
-		return
-	}
+	nonce, err := client.Client().PendingNonceAt(ctx, setup.UserAuth.From)
+	require.NoError(t, err)
+
+	precalculatedAddr := crypto.CreateAddress(setup.UserAuth.From, nonce+1)
+	verifyAddr, _, verifyContract, err := verifybatchesmock.DeployVerifybatchesmock(setup.UserAuth, client.Client(), precalculatedAddr)
+	require.NoError(t, err)
 	client.Commit()
 
-	gerAddr, _, gerContract, err = polygonzkevmglobalexitrootv2.DeployPolygonzkevmglobalexitrootv2(auth, client.Client(), verifyAddr, auth.From)
-	if err != nil {
-		return
-	}
+	gerAddr, _, gerContract, err := polygonzkevmglobalexitrootv2.DeployPolygonzkevmglobalexitrootv2(setup.UserAuth, client.Client(), verifyAddr, setup.UserAuth.From)
+	require.NoError(t, err)
 	client.Commit()
 
-	if precalculatedAddr != gerAddr {
-		err = errors.New("error calculating addr")
-	}
+	require.Equal(t, precalculatedAddr, gerAddr)
 
-	return
+	return client, setup.UserAuth, gerAddr, verifyAddr, gerContract, verifyContract
 }
 
 func TestE2E(t *testing.T) {
 	ctx := context.Background()
 	dbPath := path.Join(t.TempDir(), "file::memory:?cache=shared")
-	privateKey, err := crypto.GenerateKey()
-	require.NoError(t, err)
-	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(1337))
-	require.NoError(t, err)
+
 	rdm := l1infotreesync.NewReorgDetectorMock(t)
 	rdm.On("Subscribe", mock.Anything).Return(&reorgdetector.Subscription{}, nil)
 	rdm.On("AddBlockToTrack", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
-	client, gerAddr, verifyAddr, gerSc, verifySC, err := newSimulatedClient(auth)
-	require.NoError(t, err)
+	client, auth, gerAddr, verifyAddr, gerSc, verifySC := newSimulatedClient(t)
 	syncer, err := l1infotreesync.New(ctx, dbPath, gerAddr, verifyAddr, 10, etherman.LatestBlock, rdm, client.Client(), time.Millisecond, 0, 100*time.Millisecond, 3,
 		l1infotreesync.FlagAllowWrongContractsAddrs)
 	require.NoError(t, err)
@@ -165,15 +148,13 @@ func TestWithReorgs(t *testing.T) {
 	ctx := context.Background()
 	dbPathSyncer := path.Join(t.TempDir(), "file::memory:?cache=shared")
 	dbPathReorg := t.TempDir()
-	privateKey, err := crypto.GenerateKey()
-	require.NoError(t, err)
-	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(1337))
-	require.NoError(t, err)
-	client, gerAddr, verifyAddr, gerSc, verifySC, err := newSimulatedClient(auth)
-	require.NoError(t, err)
+
+	client, auth, gerAddr, verifyAddr, gerSc, verifySC := newSimulatedClient(t)
+
 	rd, err := reorgdetector.New(client.Client(), reorgdetector.Config{DBPath: dbPathReorg, CheckReorgsInterval: cdktypes.NewDuration(time.Millisecond * 30)})
 	require.NoError(t, err)
 	require.NoError(t, rd.Start(ctx))
+
 	syncer, err := l1infotreesync.New(ctx, dbPathSyncer, gerAddr, verifyAddr, 10, etherman.LatestBlock, rd, client.Client(), time.Millisecond, 0, time.Second, 25,
 		l1infotreesync.FlagAllowWrongContractsAddrs)
 	require.NoError(t, err)
@@ -285,15 +266,13 @@ func TestStressAndReorgs(t *testing.T) {
 	ctx := context.Background()
 	dbPathSyncer := path.Join(t.TempDir(), "file:TestStressAndReorgs:memory:?cache=shared")
 	dbPathReorg := t.TempDir()
-	privateKey, err := crypto.GenerateKey()
-	require.NoError(t, err)
-	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(1337))
-	require.NoError(t, err)
-	client, gerAddr, verifyAddr, gerSc, verifySC, err := newSimulatedClient(auth)
-	require.NoError(t, err)
+
+	client, auth, gerAddr, verifyAddr, gerSc, verifySC := newSimulatedClient(t)
+
 	rd, err := reorgdetector.New(client.Client(), reorgdetector.Config{DBPath: dbPathReorg, CheckReorgsInterval: cdktypes.NewDuration(time.Millisecond * 100)})
 	require.NoError(t, err)
 	require.NoError(t, rd.Start(ctx))
+
 	syncer, err := l1infotreesync.New(ctx, dbPathSyncer, gerAddr, verifyAddr, 10, etherman.LatestBlock, rd, client.Client(), time.Millisecond, 0, time.Second, 100,
 		l1infotreesync.FlagAllowWrongContractsAddrs)
 	require.NoError(t, err)

lastgersync/e2e_test.go

@@ -9,15 +9,15 @@ import (
 
 	"github.com/0xPolygon/cdk/etherman"
 	"github.com/0xPolygon/cdk/lastgersync"
-	"github.com/0xPolygon/cdk/test/helpers"
+	"github.com/0xPolygon/cdk/test/aggoraclehelpers"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/stretchr/testify/require"
 )
 
 func TestE2E(t *testing.T) {
 	ctx := context.Background()
-	env := helpers.SetupAggoracleWithEVMChain(t)
+	env := aggoraclehelpers.SetupAggoracleWithEVMChain(t)
 	dbPathSyncer := t.TempDir()
 	syncer, err := lastgersync.New(
 		ctx,

reorgdetector/reorgdetector_test.go

@@ -2,47 +2,21 @@ package reorgdetector
 
 import (
 	"context"
-	big "math/big"
 	"testing"
 	"time"
 
 	cdktypes "github.com/0xPolygon/cdk/config/types"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethclient/simulated"
+	"github.com/0xPolygon/cdk/test/helpers"
 	"github.com/stretchr/testify/require"
 )
 
-func newSimulatedL1(t *testing.T, auth *bind.TransactOpts) *simulated.Backend {
-	t.Helper()
-
-	balance, _ := new(big.Int).SetString("10000000000000000000000000", 10)
-
-	blockGasLimit := uint64(999999999999999999)
-	client := simulated.NewBackend(map[common.Address]types.Account{
-		auth.From: {
-			Balance: balance,
-		},
-	}, simulated.WithBlockGasLimit(blockGasLimit))
-	client.Commit()
-
-	return client
-}
-
 func Test_ReorgDetector(t *testing.T) {
 	const subID = "test"
 
 	ctx := context.Background()
 
 	// Simulated L1
-	privateKeyL1, err := crypto.GenerateKey()
-	require.NoError(t, err)
-	authL1, err := bind.NewKeyedTransactorWithChainID(privateKeyL1, big.NewInt(1337))
-	require.NoError(t, err)
-	clientL1 := newSimulatedL1(t, authL1)
-	require.NoError(t, err)
+	clientL1, _ := helpers.SimulatedBackend(t, nil, 0)
 
 	// Create test DB dir
 	testDir := t.TempDir()
@@ -92,6 +66,6 @@ func Test_ReorgDetector(t *testing.T) {
 	headersList, ok := reorgDetector.trackedBlocks[subID]
 	reorgDetector.trackedBlocksLock.Unlock()
 	require.True(t, ok)
-	require.Equal(t, 1, headersList.len()) // Only block 2 left
-	require.Equal(t, remainingHeader.Hash(), headersList.get(2).Hash)
+	require.Equal(t, 1, headersList.len()) // Only block 3 left
+	require.Equal(t, remainingHeader.Hash(), headersList.get(4).Hash)
 }

test/aggoraclehelpers/aggoracle_e2e.go

@@ -0,0 +1,199 @@
+package aggoraclehelpers
+
+import (
+	"context"
+	"path"
+	"testing"
+	"time"
+
+	"github.com/0xPolygon/cdk-contracts-tooling/contracts/elderberry-paris/polygonzkevmbridgev2"
+	gerContractL1 "github.com/0xPolygon/cdk-contracts-tooling/contracts/manual/globalexitrootnopush0"
+	gerContractEVMChain "github.com/0xPolygon/cdk-contracts-tooling/contracts/manual/pessimisticglobalexitrootnopush0"
+	"github.com/0xPolygon/cdk/aggoracle"
+	"github.com/0xPolygon/cdk/aggoracle/chaingersender"
+	"github.com/0xPolygon/cdk/etherman"
+	"github.com/0xPolygon/cdk/l1infotreesync"
+	"github.com/0xPolygon/cdk/log"
+	"github.com/0xPolygon/cdk/reorgdetector"
+	"github.com/0xPolygon/cdk/test/helpers"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethclient/simulated"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	NetworkIDL2        = uint32(1)
+	syncBlockChunkSize = 10
+	retries            = 3
+	periodRetry        = time.Millisecond * 100
+)
+
+type AggoracleWithEVMChainEnv struct {
+	L1Client         *simulated.Backend
+	L2Client         *simulated.Backend
+	L1InfoTreeSync   *l1infotreesync.L1InfoTreeSync
+	GERL1Contract    *gerContractL1.Globalexitrootnopush0
+	GERL1Addr        common.Address
+	GERL2Contract    *gerContractEVMChain.Pessimisticglobalexitrootnopush0
+	GERL2Addr        common.Address
+	AuthL1           *bind.TransactOpts
+	AuthL2           *bind.TransactOpts
+	AggOracle        *aggoracle.AggOracle
+	AggOracleSender  aggoracle.ChainSender
+	ReorgDetector    *reorgdetector.ReorgDetector
+	BridgeL1Contract *polygonzkevmbridgev2.Polygonzkevmbridgev2
+	BridgeL1Addr     common.Address
+	BridgeL2Contract *polygonzkevmbridgev2.Polygonzkevmbridgev2
+	BridgeL2Addr     common.Address
+	NetworkIDL2      uint32
+	EthTxManMockL2   *helpers.EthTxManagerMock
+}
+
+func SetupAggoracleWithEVMChain(t *testing.T) *AggoracleWithEVMChainEnv {
+	t.Helper()
+
+	ctx := context.Background()
+	l1Client, syncer, gerL1Contract, gerL1Addr, bridgeL1Contract, bridgeL1Addr, authL1, rd := CommonSetup(t)
+	sender, l2Client, gerL2Contract, gerL2Addr, bridgeL2Contract, bridgeL2Addr, authL2, ethTxManMockL2 := EVMSetup(t)
+	oracle, err := aggoracle.New(
+		log.GetDefaultLogger(), sender,
+		l1Client.Client(), syncer,
+		etherman.LatestBlock, time.Millisecond*20) //nolint:mnd
+	require.NoError(t, err)
+	go oracle.Start(ctx)
+
+	return &AggoracleWithEVMChainEnv{
+		L1Client:         l1Client,
+		L2Client:         l2Client,
+		L1InfoTreeSync:   syncer,
+		GERL1Contract:    gerL1Contract,
+		GERL1Addr:        gerL1Addr,
+		GERL2Contract:    gerL2Contract,
+		GERL2Addr:        gerL2Addr,
+		AuthL1:           authL1,
+		AuthL2:           authL2,
+		AggOracle:        oracle,
+		AggOracleSender:  sender,
+		ReorgDetector:    rd,
+		BridgeL1Contract: bridgeL1Contract,
+		BridgeL1Addr:     bridgeL1Addr,
+		BridgeL2Contract: bridgeL2Contract,
+		BridgeL2Addr:     bridgeL2Addr,
+		NetworkIDL2:      NetworkIDL2,
+		EthTxManMockL2:   ethTxManMockL2,
+	}
+}
+
+func CommonSetup(t *testing.T) (
+	*simulated.Backend,
+	*l1infotreesync.L1InfoTreeSync,
+	*gerContractL1.Globalexitrootnopush0,
+	common.Address,
+	*polygonzkevmbridgev2.Polygonzkevmbridgev2,
+	common.Address,
+	*bind.TransactOpts,
+	*reorgdetector.ReorgDetector,
+) {
+	t.Helper()
+
+	// Config and spin up
+	ctx := context.Background()
+
+	// Simulated L1
+	l1Client, authL1, gerL1Addr, gerL1Contract, bridgeL1Addr, bridgeL1Contract := newSimulatedL1(t)
+
+	// Reorg detector
+	dbPathReorgDetector := t.TempDir()
+	reorg, err := reorgdetector.New(l1Client.Client(), reorgdetector.Config{DBPath: dbPathReorgDetector})
+	require.NoError(t, err)
+
+	// Syncer
+	dbPathSyncer := path.Join(t.TempDir(), "file::memory:?cache=shared")
+	syncer, err := l1infotreesync.New(ctx, dbPathSyncer,
+		gerL1Addr, common.Address{},
+		syncBlockChunkSize, etherman.LatestBlock,
+		reorg, l1Client.Client(),
+		time.Millisecond, 0, periodRetry, retries, l1infotreesync.FlagAllowWrongContractsAddrs)
+	require.NoError(t, err)
+	go syncer.Start(ctx)
+
+	return l1Client, syncer, gerL1Contract, gerL1Addr, bridgeL1Contract, bridgeL1Addr, authL1, reorg
+}
+
+func EVMSetup(t *testing.T) (
+	aggoracle.ChainSender,
+	*simulated.Backend,
+	*gerContractEVMChain.Pessimisticglobalexitrootnopush0,
+	common.Address,
+	*polygonzkevmbridgev2.Polygonzkevmbridgev2,
+	common.Address,
+	*bind.TransactOpts,
+	*helpers.EthTxManagerMock,
+) {
+	t.Helper()
+
+	l2Client, authL2, gerL2Addr, gerL2Sc, bridgeL2Addr, bridgeL2Sc := newSimulatedEVMAggSovereignChain(t)
+	ethTxManMock := helpers.NewEthTxManMock(t, l2Client, authL2)
+	sender, err := chaingersender.NewEVMChainGERSender(log.GetDefaultLogger(),
+		gerL2Addr, authL2.From, l2Client.Client(), ethTxManMock, 0, time.Millisecond*50) //nolint:mnd
+	require.NoError(t, err)
+
+	return sender, l2Client, gerL2Sc, gerL2Addr, bridgeL2Sc, bridgeL2Addr, authL2, ethTxManMock
+}
+
+func newSimulatedL1(t *testing.T) (
+	*simulated.Backend,
+	*bind.TransactOpts,
+	common.Address,
+	*gerContractL1.Globalexitrootnopush0,
+	common.Address,
+	*polygonzkevmbridgev2.Polygonzkevmbridgev2,
+) {
+	t.Helper()
+
+	client, setup := helpers.SimulatedBackend(t, nil, 0)
+
+	precalculatedAddr := crypto.CreateAddress(setup.DeployerAuth.From, 2) //nolint:mnd
+
+	gerAddr, _, gerContract, err := gerContractL1.DeployGlobalexitrootnopush0(setup.DeployerAuth, client.Client(),
+		setup.UserAuth.From, setup.EBZkevmBridgeProxyAddr)
+	require.NoError(t, err)
+	client.Commit()
+
+	require.Equal(t, precalculatedAddr, gerAddr)
+
+	return client, setup.UserAuth, gerAddr, gerContract, setup.EBZkevmBridgeProxyAddr, setup.EBZkevmBridgeProxyContract
+}
+
+func newSimulatedEVMAggSovereignChain(t *testing.T) (
+	*simulated.Backend,
+	*bind.TransactOpts,
+	common.Address,
+	*gerContractEVMChain.Pessimisticglobalexitrootnopush0,
+	common.Address,
+	*polygonzkevmbridgev2.Polygonzkevmbridgev2,
+) {
+	t.Helper()
+
+	client, setup := helpers.SimulatedBackend(t, nil, NetworkIDL2)
+
+	precalculatedAddr := crypto.CreateAddress(setup.DeployerAuth.From, 2) //nolint:mnd
+
+	gerAddr, _, gerContract, err := gerContractEVMChain.DeployPessimisticglobalexitrootnopush0(
+		setup.DeployerAuth, client.Client(), setup.UserAuth.From)
+	require.NoError(t, err)
+	client.Commit()
+
+	globalExitRootSetterRole := common.HexToHash("0x7b95520991dfda409891be0afa2635b63540f92ee996fda0bf695a166e5c5176")
+	_, err = gerContract.GrantRole(setup.DeployerAuth, globalExitRootSetterRole, setup.UserAuth.From)
+	require.NoError(t, err)
+	client.Commit()
+
+	hasRole, _ := gerContract.HasRole(&bind.CallOpts{Pending: false}, globalExitRootSetterRole, setup.UserAuth.From)
+	require.True(t, hasRole)
+	require.Equal(t, precalculatedAddr, gerAddr)
+
+	return client, setup.UserAuth, gerAddr, gerContract, setup.EBZkevmBridgeProxyAddr, setup.EBZkevmBridgeProxyContract
+}

test/helpers/simulated.go

@@ -1,8 +1,24 @@
 package helpers
 
 import (
+	"math/big"
+	"testing"
+
+	"github.com/0xPolygon/cdk-contracts-tooling/contracts/elderberry-paris/polygonzkevmbridgev2"
+	"github.com/0xPolygon/cdk/test/contracts/transparentupgradableproxy"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethclient/simulated"
 	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	defaultBlockGasLimit = uint64(999999999999999999)
+	defaultBalance       = "10000000000000000000000000"
+	chainID              = 1337
 )
 
 type ClientRenamed simulated.Client
@@ -14,3 +30,106 @@ type TestClient struct {
 func (tc TestClient) Client() *rpc.Client {
 	return nil
 }
+
+// SimulatedBackendSetup defines the setup for a simulated backend.
+type SimulatedBackendSetup struct {
+	UserAuth                   *bind.TransactOpts
+	DeployerAuth               *bind.TransactOpts
+	EBZkevmBridgeAddr          common.Address
+	EBZkevmBridgeContract      *polygonzkevmbridgev2.Polygonzkevmbridgev2
+	EBZkevmBridgeProxyAddr     common.Address
+	EBZkevmBridgeProxyContract *polygonzkevmbridgev2.Polygonzkevmbridgev2
+}
+
+// SimulatedBackend creates a simulated backend with two accounts: user and deployer.
+func SimulatedBackend(
+	t *testing.T,
+	balances map[common.Address]types.Account,
+	ebZkevmBridgeNetwork uint32,
+) (*simulated.Backend, *SimulatedBackendSetup) {
+	t.Helper()
+
+	// Define default balance
+	balance, ok := new(big.Int).SetString(defaultBalance, 10) //nolint:mnd
+	require.Truef(t, ok, "failed to set balance")
+
+	// Create user
+	userPK, err := crypto.GenerateKey()
+	require.NoError(t, err)
+	userAuth, err := bind.NewKeyedTransactorWithChainID(userPK, big.NewInt(chainID))
+	require.NoError(t, err)
+
+	// Create deployer
+	deployerPK, err := crypto.GenerateKey()
+	require.NoError(t, err)
+	deployerAuth, err := bind.NewKeyedTransactorWithChainID(deployerPK, big.NewInt(chainID))
+	require.NoError(t, err)
+	precalculatedBridgeAddr := crypto.CreateAddress(deployerAuth.From, 1)
+
+	// Define balances map
+	if balances == nil {
+		balances = make(map[common.Address]types.Account)
+	}
+	balances[userAuth.From] = types.Account{Balance: balance}
+	balances[deployerAuth.From] = types.Account{Balance: balance}
+	balances[precalculatedBridgeAddr] = types.Account{Balance: balance}
+
+	client := simulated.NewBackend(balances, simulated.WithBlockGasLimit(defaultBlockGasLimit))
+
+	// Mine the first block
+	client.Commit()
+
+	// MUST BE DEPLOYED FIRST
+	// Deploy zkevm bridge contract
+	ebZkevmBridgeAddr, _, ebZkevmBridgeContract, err := polygonzkevmbridgev2.DeployPolygonzkevmbridgev2(deployerAuth, client.Client())
+	require.NoError(t, err)
+	client.Commit()
+
+	// Create proxy contract for the bridge
+	var ebZkevmBridgeProxyAddr common.Address
+	var ebZkevmBridgeProxyContract *polygonzkevmbridgev2.Polygonzkevmbridgev2
+	{
+		precalculatedAddr := crypto.CreateAddress(deployerAuth.From, 2) //nolint:mnd
+
+		bridgeABI, err := polygonzkevmbridgev2.Polygonzkevmbridgev2MetaData.GetAbi()
+		require.NoError(t, err)
+		require.NotNil(t, bridgeABI)
+
+		dataCallProxy, err := bridgeABI.Pack("initialize",
+			ebZkevmBridgeNetwork,
+			common.Address{}, // gasTokenAddressMainnet
+			uint32(0),        // gasTokenNetworkMainnet
+			precalculatedAddr,
+			common.Address{},
+			[]byte{}, // gasTokenMetadata
+		)
+		require.NoError(t, err)
+
+		ebZkevmBridgeProxyAddr, _, _, err = transparentupgradableproxy.DeployTransparentupgradableproxy(
+			deployerAuth,
+			client.Client(),
+			ebZkevmBridgeAddr,
+			deployerAuth.From,
+			dataCallProxy,
+		)
+		require.NoError(t, err)
+		require.Equal(t, precalculatedBridgeAddr, ebZkevmBridgeProxyAddr)
+		client.Commit()
+
+		ebZkevmBridgeProxyContract, err = polygonzkevmbridgev2.NewPolygonzkevmbridgev2(ebZkevmBridgeProxyAddr, client.Client())
+		require.NoError(t, err)
+
+		checkGERAddr, err := ebZkevmBridgeProxyContract.GlobalExitRootManager(&bind.CallOpts{})
+		require.NoError(t, err)
+		require.Equal(t, precalculatedAddr, checkGERAddr)
+	}
+
+	return client, &SimulatedBackendSetup{
+		UserAuth:                   userAuth,
+		DeployerAuth:               deployerAuth,
+		EBZkevmBridgeAddr:          ebZkevmBridgeAddr,
+		EBZkevmBridgeContract:      ebZkevmBridgeContract,
+		EBZkevmBridgeProxyAddr:     ebZkevmBridgeProxyAddr,
+		EBZkevmBridgeProxyContract: ebZkevmBridgeProxyContract,
+	}
+}