refactor: simulated backend so that it correctly initializes bridge c…

…ontract

aggoracle/e2e_test.go

@@ -6,40 +6,26 @@ import (
 	"testing"
 	"time"
 
-	gerContractL1 "github.com/0xPolygon/cdk-contracts-tooling/contracts/l2-sovereign-chain-paris/polygonzkevmglobalexitrootv2"
-	"github.com/0xPolygon/cdk/aggoracle"
 	"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/ethclient/simulated"
 	"github.com/stretchr/testify/require"
 )
 
 func TestEVM(t *testing.T) {
 	env := helpers.NewE2EEnvWithEVML2(t)
-	runTest(t, env.GERL1Contract, env.AggOracleSender, env.L1Client, env.AuthL1)
-}
-
-func runTest(
-	t *testing.T,
-	gerL1Contract *gerContractL1.Polygonzkevmglobalexitrootv2,
-	sender aggoracle.ChainSender,
-	l1Client *simulated.Backend,
-	authL1 *bind.TransactOpts,
-) {
-	t.Helper()
 
 	for i := 0; i < 10; i++ {
-		_, err := gerL1Contract.UpdateExitRoot(authL1, common.HexToHash(strconv.Itoa(i)))
+		_, err := env.GERL1Contract.UpdateExitRoot(env.AuthL1, common.HexToHash(strconv.Itoa(i)))
 		require.NoError(t, err)
-		l1Client.Commit()
+		env.L1Client.Commit()
 
 		// wait for the GER to be processed by the L1InfoTree syncer
 		time.Sleep(time.Millisecond * 100)
-		expectedGER, err := gerL1Contract.GetLastGlobalExitRoot(&bind.CallOpts{Pending: false})
+		expectedGER, err := env.GERL1Contract.GetLastGlobalExitRoot(&bind.CallOpts{Pending: false})
 		require.NoError(t, err)
 
-		isInjected, err := sender.IsGERInjected(expectedGER)
+		isInjected, err := env.AggOracleSender.IsGERInjected(expectedGER)
 		require.NoError(t, err)
 
 		require.True(t, isInjected, fmt.Sprintf("iteration %d, GER: %s", i, common.Bytes2Hex(expectedGER[:])))

bridgesync/e2e_test.go

@@ -24,7 +24,6 @@ func TestBridgeEventE2E(t *testing.T) {
 	)
 	env := helpers.NewE2EEnvWithEVML2(t)
 	ctx := context.Background()
-
 	// Send bridge txs
 	bridgesSent := 0
 	reorgs := 0
@@ -35,7 +34,7 @@ func TestBridgeEventE2E(t *testing.T) {
 		bridge := bridgesync.Bridge{
 			Amount:             big.NewInt(0),
 			DepositCount:       lastDepositCount,
-			DestinationNetwork: uint32(i),
+			DestinationNetwork: uint32(i + 1),
 			DestinationAddress: common.HexToAddress("f00"),
 			Metadata:           []byte{},
 		}
@@ -48,6 +47,7 @@ func TestBridgeEventE2E(t *testing.T) {
 			bridge.OriginAddress,
 			true, nil,
 		)
+		t.Logf("BridgeAsset err: %+v", err)
 		require.NoError(t, err)
 		helpers.CommitBlocks(t, env.L1Client, 1, blockTime)
 		bn, err := env.L1Client.Client().BlockNumber(ctx)

claimsponsor/e2e_test.go

@@ -67,21 +67,20 @@ func TestE2EL1toEVML2(t *testing.T) {
 
 		// Request to sponsor claim
 		globalIndex := bridgesync.GenerateGlobalIndex(true, 0, i)
-		err = claimer.AddClaimToQueue(
-			&claimsponsor.Claim{
-				LeafType:            claimsponsor.LeafTypeAsset,
-				ProofLocalExitRoot:  localProof,
-				ProofRollupExitRoot: rollupProof,
-				GlobalIndex:         globalIndex,
-				MainnetExitRoot:     info.MainnetExitRoot,
-				RollupExitRoot:      info.RollupExitRoot,
-				OriginNetwork:       0,
-				OriginTokenAddress:  common.Address{},
-				DestinationNetwork:  env.NetworkIDL2,
-				DestinationAddress:  env.AuthL2.From,
-				Amount:              amount,
-				Metadata:            nil,
-			})
+		err = claimer.AddClaimToQueue(&claimsponsor.Claim{
+			LeafType:            claimsponsor.LeafTypeAsset,
+			ProofLocalExitRoot:  localProof,
+			ProofRollupExitRoot: rollupProof,
+			GlobalIndex:         globalIndex,
+			MainnetExitRoot:     info.MainnetExitRoot,
+			RollupExitRoot:      info.RollupExitRoot,
+			OriginNetwork:       0,
+			OriginTokenAddress:  common.Address{},
+			DestinationNetwork:  env.NetworkIDL2,
+			DestinationAddress:  env.AuthL2.From,
+			Amount:              amount,
+			Metadata:            nil,
+		})
 		require.NoError(t, err)
 
 		// Wait until success

dataavailability/datacommittee/datacommittee_test.go

@@ -5,10 +5,10 @@ import (
 	"math/big"
 	"testing"
 
-	smcparis "github.com/0xPolygon/cdk-contracts-tooling/contracts/banana-paris/polygondatacommittee"
+	scparis "github.com/0xPolygon/cdk-contracts-tooling/contracts/banana-paris/polygondatacommittee"
 	"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/contracts/erc1967proxy"
 	"github.com/0xPolygon/cdk/test/helpers"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
@@ -20,7 +20,7 @@ import (
 
 func TestUpdateDataCommitteeEvent(t *testing.T) {
 	// Set up testing environment
-	dac, ethBackend, da, auth := newSimulatedDacman(t)
+	dac, ethBackend, da, auth := newSimulatedDACBackend(t)
 
 	// Update the committee
 	requiredAmountOfSignatures := big.NewInt(2)
@@ -65,18 +65,18 @@ func init() {
 
 // 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) (
+func newSimulatedDACBackend(t *testing.T) (
 	*Backend,
 	*simulated.Backend,
 	*polygondatacommittee.Polygondatacommittee,
 	*bind.TransactOpts,
 ) {
 	t.Helper()
 
-	ethBackend, setup := helpers.SimulatedBackend(t, nil, 0)
+	ethBackend, setup := helpers.NewSimulatedBackend(t, nil)
 
 	// DAC Setup
-	addr, _, _, err := smcparis.DeployPolygondatacommittee(setup.UserAuth, ethBackend.Client())
+	addr, _, _, err := scparis.DeployPolygondatacommittee(setup.UserAuth, ethBackend.Client())
 	require.NoError(t, err)
 	ethBackend.Commit()
 

l1infotreesync/e2e_test.go

@@ -35,21 +35,23 @@ func newSimulatedClient(t *testing.T) (
 ) {
 	t.Helper()
 	ctx := context.Background()
-	client, setup := helpers.SimulatedBackend(t, nil, 0)
+	client, setup := helpers.NewSimulatedBackend(t, nil)
 
 	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)
+	precalculatedGERAddr := crypto.CreateAddress(setup.UserAuth.From, nonce+1)
+	verifyAddr, _, verifyContract, err := verifybatchesmock.DeployVerifybatchesmock(setup.UserAuth, client.Client(), precalculatedGERAddr)
 	require.NoError(t, err)
 	client.Commit()
 
 	gerAddr, _, gerContract, err := polygonzkevmglobalexitrootv2.DeployPolygonzkevmglobalexitrootv2(setup.UserAuth, client.Client(), verifyAddr, setup.UserAuth.From)
 	require.NoError(t, err)
+	require.Equal(t, precalculatedGERAddr, gerAddr)
 	client.Commit()
 
-	require.Equal(t, precalculatedAddr, gerAddr)
+	err = setup.DeployBridge(client, gerAddr, 0)
+	require.NoError(t, err)
 
 	return client, setup.UserAuth, gerAddr, verifyAddr, gerContract, verifyContract
 }

test/helpers/e2e.go

@@ -59,11 +59,13 @@ func NewE2EEnvWithEVML2(t *testing.T) *AggoracleWithEVMChainEnv {
 	t.Helper()
 
 	ctx := context.Background()
+	// Setup L1
 	l1Client, syncer,
 		gerL1Contract, gerL1Addr,
 		bridgeL1Contract, bridgeL1Addr,
 		authL1, rdL1, bridgeL1Sync := CommonSetup(t)
 
+	// Setup L2 EVM
 	sender, l2Client, gerL2Contract, gerL2Addr,
 		bridgeL2Contract, bridgeL2Addr, authL2,
 		ethTxManMockL2, bridgeL2Sync, rdL2 := L2SetupEVM(t)
@@ -123,7 +125,6 @@ func CommonSetup(t *testing.T) (
 ) {
 	t.Helper()
 
-	// Config and spin up
 	ctx := context.Background()
 
 	// Simulated L1
@@ -245,17 +246,25 @@ func newSimulatedL1(t *testing.T) (
 ) {
 	t.Helper()
 
-	client, setup := SimulatedBackend(t, nil, 0)
+	client, setup := NewSimulatedBackend(t, nil)
 
-	expectedGERAddr := crypto.CreateAddress(setup.DeployerAuth.From, 2) //nolint:mnd
+	ctx := context.Background()
+	nonce, err := client.Client().PendingNonceAt(ctx, setup.DeployerAuth.From)
+	require.NoError(t, err)
+
+	// DeployBridge function sends two transactions (bridge and proxy contract deployment)
+	calculatedGERAddr := crypto.CreateAddress(setup.DeployerAuth.From, nonce+2) //nolint:mnd
+
+	err = setup.DeployBridge(client, calculatedGERAddr, 0)
+	require.NoError(t, err)
 
 	gerAddr, _, gerContract, err := polygonzkevmglobalexitrootv2.DeployPolygonzkevmglobalexitrootv2(
 		setup.DeployerAuth, client.Client(),
 		setup.UserAuth.From, setup.BridgeProxyAddr)
 	require.NoError(t, err)
 	client.Commit()
 
-	require.Equal(t, expectedGERAddr, gerAddr)
+	require.Equal(t, calculatedGERAddr, gerAddr)
 
 	return client, setup.UserAuth, gerAddr, gerContract, setup.BridgeProxyAddr, setup.BridgeProxyContract
 }
@@ -270,7 +279,7 @@ func newSimulatedEVML2SovereignChain(t *testing.T) (
 ) {
 	t.Helper()
 
-	client, setup := SimulatedBackend(t, nil, rollupID)
+	client, setup := NewSimulatedBackend(t, nil)
 
 	gerL2Addr, _, _, err := globalexitrootmanagerl2sovereignchain.DeployGlobalexitrootmanagerl2sovereignchain(
 		setup.DeployerAuth, client.Client(), setup.BridgeProxyAddr)
@@ -298,5 +307,12 @@ func newSimulatedEVML2SovereignChain(t *testing.T) (
 		gerProxyAddr, client.Client())
 	require.NoError(t, err)
 
+	err = setup.DeployBridge(client, gerProxyAddr, rollupID)
+	require.NoError(t, err)
+
+	actualGERAddr, err := setup.BridgeProxyContract.GlobalExitRootManager(nil)
+	require.NoError(t, err)
+	require.Equal(t, gerProxyAddr, actualGERAddr)
+
 	return client, setup.UserAuth, gerProxyAddr, gerL2Contract, setup.BridgeProxyAddr, setup.BridgeProxyContract
 }

test/helpers/ethtxmanmock_e2e.go

@@ -60,11 +60,11 @@ func NewEthTxManMock(
 
 			gas, err := client.Client().EstimateGas(ctx, msg)
 			if err != nil {
-				log.Errorf("eth_estimateGas invocation failed: %s", err)
+				log.Errorf("eth_estimateGas invocation failed: %+v", err)
 
 				res, err := client.Client().CallContract(ctx, msg, nil)
 				if err != nil {
-					log.Errorf("eth_call invocation failed: %s", err)
+					log.Errorf("eth_call invocation failed: %+v", err)
 				} else {
 					log.Debugf("contract call result: %s", hex.EncodeToString(res))
 				}