some more cleanups

0xPolygon · Dec 19, 2024 · 31b98ce · 31b98ce
1 parent 23a0a60
commit 31b98ce
Show file tree

Hide file tree

Showing 5 changed files with 87 additions and 124 deletions.
diff --git a/aggoracle/e2e_test.go b/aggoracle/e2e_test.go
@@ -13,19 +13,19 @@ import (
 )
 
 func TestEVM(t *testing.T) {
-	env := helpers.NewE2EEnvWithEVML2(t)
+	setup := helpers.NewE2EEnvWithEVML2(t)
 
 	for i := 0; i < 10; i++ {
-		_, err := env.GERL1Contract.UpdateExitRoot(env.AuthL1, common.HexToHash(strconv.Itoa(i)))
+		_, err := setup.L1Environment.GERContract.UpdateExitRoot(setup.L1Environment.Auth, common.HexToHash(strconv.Itoa(i)))
 		require.NoError(t, err)
-		env.L1Client.Commit()
+		setup.L1Environment.SimBackend.Commit()
 
-		// wait for the GER to be processed by the L1InfoTree syncer
+		// wait for the GER to be processed by the InfoTree syncer
 		time.Sleep(time.Millisecond * 100)
-		expectedGER, err := env.GERL1Contract.GetLastGlobalExitRoot(&bind.CallOpts{Pending: false})
+		expectedGER, err := setup.L1Environment.GERContract.GetLastGlobalExitRoot(&bind.CallOpts{Pending: false})
 		require.NoError(t, err)
 
-		isInjected, err := env.AggOracleSender.IsGERInjected(expectedGER)
+		isInjected, err := setup.L2Environment.AggoracleSender.IsGERInjected(expectedGER)
 		require.NoError(t, err)
 
 		require.True(t, isInjected, fmt.Sprintf("iteration %d, GER: %s", i, common.Bytes2Hex(expectedGER[:])))

diff --git a/bridgesync/e2e_test.go b/bridgesync/e2e_test.go
@@ -22,7 +22,7 @@ func TestBridgeEventE2E(t *testing.T) {
 		maxReorgDepth         = 2
 		reorgEveryXIterations = 4 // every X blocks go back [1,maxReorgDepth] blocks
 	)
-	env := helpers.NewE2EEnvWithEVML2(t)
+	setup := helpers.NewE2EEnvWithEVML2(t)
 	ctx := context.Background()
 	// Send bridge txs
 	bridgesSent := 0
@@ -39,20 +39,20 @@ func TestBridgeEventE2E(t *testing.T) {
 			Metadata:           []byte{},
 		}
 		lastDepositCount++
-		tx, err := env.BridgeL1Contract.BridgeAsset(
-			env.AuthL1,
+		tx, err := setup.L1Environment.BridgeContract.BridgeAsset(
+			setup.L1Environment.Auth,
 			bridge.DestinationNetwork,
 			bridge.DestinationAddress,
 			bridge.Amount,
 			bridge.OriginAddress,
 			true, nil,
 		)
 		require.NoError(t, err)
-		helpers.CommitBlocks(t, env.L1Client, 1, blockTime)
-		bn, err := env.L1Client.Client().BlockNumber(ctx)
+		helpers.CommitBlocks(t, setup.L1Environment.SimBackend, 1, blockTime)
+		bn, err := setup.L1Environment.SimBackend.Client().BlockNumber(ctx)
 		require.NoError(t, err)
 		bridge.BlockNum = bn
-		receipt, err := env.L1Client.Client().TransactionReceipt(ctx, tx.Hash())
+		receipt, err := setup.L1Environment.SimBackend.Client().TransactionReceipt(ctx, tx.Hash())
 		require.NoError(t, err)
 		require.Equal(t, receipt.Status, types.ReceiptStatusSuccessful)
 		expectedBridges = append(expectedBridges, bridge)
@@ -61,9 +61,9 @@ func TestBridgeEventE2E(t *testing.T) {
 		// Trigger reorg
 		if i%reorgEveryXIterations == 0 {
 			blocksToReorg := 1 + i%maxReorgDepth
-			bn, err := env.L1Client.Client().BlockNumber(ctx)
+			bn, err := setup.L1Environment.SimBackend.Client().BlockNumber(ctx)
 			require.NoError(t, err)
-			helpers.Reorg(t, env.L1Client, uint64(blocksToReorg))
+			helpers.Reorg(t, setup.L1Environment.SimBackend, uint64(blocksToReorg))
 			// Clean expected bridges
 			lastValidBlock := bn - uint64(blocksToReorg)
 			reorgEffective := false
@@ -90,20 +90,20 @@ func TestBridgeEventE2E(t *testing.T) {
 
 	// Wait for syncer to catch up
 	time.Sleep(time.Second * 2) // sleeping since the processor could be up to date, but have pending reorgs
-	lb, err := env.L1Client.Client().BlockNumber(ctx)
+	lb, err := setup.L1Environment.SimBackend.Client().BlockNumber(ctx)
 	require.NoError(t, err)
-	helpers.RequireProcessorUpdated(t, env.BridgeL1Sync, lb)
+	helpers.RequireProcessorUpdated(t, setup.L1Environment.BridgeSync, lb)
 
 	// Get bridges
-	lastBlock, err := env.L1Client.Client().BlockNumber(ctx)
+	lastBlock, err := setup.L1Environment.SimBackend.Client().BlockNumber(ctx)
 	require.NoError(t, err)
-	actualBridges, err := env.BridgeL1Sync.GetBridges(ctx, 0, lastBlock)
+	actualBridges, err := setup.L1Environment.BridgeSync.GetBridges(ctx, 0, lastBlock)
 	require.NoError(t, err)
 
 	// Assert bridges
-	expectedRoot, err := env.BridgeL1Contract.GetRoot(nil)
+	expectedRoot, err := setup.L1Environment.BridgeContract.GetRoot(nil)
 	require.NoError(t, err)
-	root, err := env.BridgeL1Sync.GetExitRootByIndex(ctx, expectedBridges[len(expectedBridges)-1].DepositCount)
+	root, err := setup.L1Environment.BridgeSync.GetExitRootByIndex(ctx, expectedBridges[len(expectedBridges)-1].DepositCount)
 	require.NoError(t, err)
 	require.Equal(t, common.Hash(expectedRoot).Hex(), root.Hash.Hex())
 	require.Equal(t, expectedBridges, actualBridges)

diff --git a/claimsponsor/e2e_test.go b/claimsponsor/e2e_test.go
@@ -21,19 +21,19 @@ import (
 func TestE2EL1toEVML2(t *testing.T) {
 	// start other needed components
 	ctx := context.Background()
-	env := helpers.NewE2EEnvWithEVML2(t)
+	setup := helpers.NewE2EEnvWithEVML2(t)
 
 	// start claim sponsor
 	dbPathClaimSponsor := path.Join(t.TempDir(), "claimsponsorTestE2EL1toEVML2_cs.sqlite")
 	claimer, err := claimsponsor.NewEVMClaimSponsor(
 		log.GetDefaultLogger(),
 		dbPathClaimSponsor,
-		env.L2Client.Client(),
-		env.BridgeL2Addr,
-		env.AuthL2.From,
+		setup.L2Environment.SimBackend.Client(),
+		setup.L2Environment.BridgeAddr,
+		setup.L2Environment.Auth.From,
 		200_000,
 		0,
-		env.EthTxManMockL2,
+		setup.EthTxManagerMock,
 		0, 0, time.Millisecond*10, time.Millisecond*10,
 	)
 	require.NoError(t, err)
@@ -43,26 +43,26 @@ func TestE2EL1toEVML2(t *testing.T) {
 	for i := uint32(0); i < 3; i++ {
 		// Send bridges to L2, wait for GER to be injected on L2
 		amount := new(big.Int).SetUint64(uint64(i) + 1)
-		env.AuthL1.Value = amount
-		_, err := env.BridgeL1Contract.BridgeAsset(env.AuthL1, env.NetworkIDL2, env.AuthL2.From, amount, common.Address{}, true, nil)
+		setup.L1Environment.Auth.Value = amount
+		_, err := setup.L1Environment.BridgeContract.BridgeAsset(setup.L1Environment.Auth, setup.NetworkIDL2, setup.L2Environment.Auth.From, amount, common.Address{}, true, nil)
 		require.NoError(t, err)
-		env.L1Client.Commit()
+		setup.L1Environment.SimBackend.Commit()
 		time.Sleep(time.Millisecond * 300)
 
-		expectedGER, err := env.GERL1Contract.GetLastGlobalExitRoot(&bind.CallOpts{Pending: false})
+		expectedGER, err := setup.L1Environment.GERContract.GetLastGlobalExitRoot(&bind.CallOpts{Pending: false})
 		require.NoError(t, err)
-		isInjected, err := env.AggOracleSender.IsGERInjected(expectedGER)
+		isInjected, err := setup.L2Environment.AggoracleSender.IsGERInjected(expectedGER)
 		require.NoError(t, err)
 		require.True(t, isInjected, fmt.Sprintf("iteration %d, GER: %s", i, common.Bytes2Hex(expectedGER[:])))
 
-		// Build MP using bridgeSyncL1 & env.L1InfoTreeSync
-		info, err := env.L1InfoTreeSync.GetInfoByIndex(ctx, i)
+		// Build MP using bridgeSyncL1 & env.InfoTreeSync
+		info, err := setup.L1Environment.InfoTreeSync.GetInfoByIndex(ctx, i)
 		require.NoError(t, err)
 
-		localProof, err := env.BridgeL1Sync.GetProof(ctx, i, info.MainnetExitRoot)
+		localProof, err := setup.L1Environment.BridgeSync.GetProof(ctx, i, info.MainnetExitRoot)
 		require.NoError(t, err)
 
-		rollupProof, err := env.L1InfoTreeSync.GetRollupExitTreeMerkleProof(ctx, 0, common.Hash{})
+		rollupProof, err := setup.L1Environment.InfoTreeSync.GetRollupExitTreeMerkleProof(ctx, 0, common.Hash{})
 		require.NoError(t, err)
 
 		// Request to sponsor claim
@@ -76,8 +76,8 @@ func TestE2EL1toEVML2(t *testing.T) {
 			RollupExitRoot:      info.RollupExitRoot,
 			OriginNetwork:       0,
 			OriginTokenAddress:  common.Address{},
-			DestinationNetwork:  env.NetworkIDL2,
-			DestinationAddress:  env.AuthL2.From,
+			DestinationNetwork:  setup.NetworkIDL2,
+			DestinationAddress:  setup.L2Environment.Auth.From,
 			Amount:              amount,
 			Metadata:            nil,
 		})
@@ -100,7 +100,7 @@ func TestE2EL1toEVML2(t *testing.T) {
 		require.True(t, succeed)
 
 		// Check on contract that is claimed
-		isClaimed, err := env.BridgeL2Contract.IsClaimed(&bind.CallOpts{Pending: false}, i, 0)
+		isClaimed, err := setup.L2Environment.BridgeContract.IsClaimed(&bind.CallOpts{Pending: false}, i, 0)
 		require.NoError(t, err)
 		require.True(t, isClaimed)
 	}

diff --git a/lastgersync/e2e_test.go b/lastgersync/e2e_test.go
@@ -18,15 +18,15 @@ import (
 
 func TestE2E(t *testing.T) {
 	ctx := context.Background()
-	env := helpers.NewE2EEnvWithEVML2(t)
+	setup := helpers.NewE2EEnvWithEVML2(t)
 	dbPathSyncer := path.Join(t.TempDir(), "lastgersyncTestE2E.sqlite")
 	syncer, err := lastgersync.New(
 		ctx,
 		dbPathSyncer,
-		env.ReorgDetectorL2,
-		env.L2Client.Client(),
-		env.GERL2Addr,
-		env.L1InfoTreeSync,
+		setup.L2Environment.ReorgDetector,
+		setup.L2Environment.SimBackend.Client(),
+		setup.L2Environment.GERAddr,
+		setup.InfoTreeSync,
 		0,
 		0,
 		etherman.LatestBlock,
@@ -38,18 +38,18 @@ func TestE2E(t *testing.T) {
 
 	for i := 0; i < 10; i++ {
 		// Update GER on L1
-		_, err := env.GERL1Contract.UpdateExitRoot(env.AuthL1, common.HexToHash(strconv.Itoa(i)))
+		_, err := setup.L1Environment.GERContract.UpdateExitRoot(setup.L1Environment.Auth, common.HexToHash(strconv.Itoa(i)))
 		require.NoError(t, err)
-		env.L1Client.Commit()
+		setup.L1Environment.SimBackend.Commit()
 		time.Sleep(time.Millisecond * 150)
-		expectedGER, err := env.GERL1Contract.GetLastGlobalExitRoot(&bind.CallOpts{Pending: false})
+		expectedGER, err := setup.L1Environment.GERContract.GetLastGlobalExitRoot(&bind.CallOpts{Pending: false})
 		require.NoError(t, err)
-		isInjected, err := env.AggOracleSender.IsGERInjected(expectedGER)
+		isInjected, err := setup.AggoracleSender.IsGERInjected(expectedGER)
 		require.NoError(t, err)
 		require.True(t, isInjected, fmt.Sprintf("iteration %d, GER: %s", i, common.Bytes2Hex(expectedGER[:])))
 
 		// Wait for syncer to catch up
-		lb, err := env.L2Client.Client().BlockNumber(ctx)
+		lb, err := setup.L2Environment.SimBackend.Client().BlockNumber(ctx)
 		require.NoError(t, err)
 		helpers.RequireProcessorUpdated(t, syncer, lb)