improve Rust build perf and cleanup

Makefile

@@ -60,7 +60,7 @@ build: build-rust build-go  build-tools## Builds the binaries locally into ./tar
 
 .PHONY: build-rust
 build-rust:
-	export BUILD_SCRIPT_DISABLED=1 && cargo build --release
+	export BUILD_SCRIPT_DISABLED=1 && cargo build --release --jobs=$(shell nproc)
 
 .PHONY: build-go
 build-go:

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
 	)
-	setup := helpers.NewE2EEnvWithEVML2(t)
+	l1Env, _ := helpers.NewL1EnvWithL2EVM(t)
 	ctx := context.Background()
 	// Send bridge txs
 	bridgesSent := 0
@@ -39,20 +39,20 @@ func TestBridgeEventE2E(t *testing.T) {
 			Metadata:           []byte{},
 		}
 		lastDepositCount++
-		tx, err := setup.L1Environment.BridgeContract.BridgeAsset(
-			setup.L1Environment.Auth,
+		tx, err := l1Env.BridgeContract.BridgeAsset(
+			l1Env.Auth,
 			bridge.DestinationNetwork,
 			bridge.DestinationAddress,
 			bridge.Amount,
 			bridge.OriginAddress,
 			true, nil,
 		)
 		require.NoError(t, err)
-		helpers.CommitBlocks(t, setup.L1Environment.SimBackend, 1, blockTime)
-		bn, err := setup.L1Environment.SimBackend.Client().BlockNumber(ctx)
+		helpers.CommitBlocks(t, l1Env.SimBackend, 1, blockTime)
+		bn, err := l1Env.SimBackend.Client().BlockNumber(ctx)
 		require.NoError(t, err)
 		bridge.BlockNum = bn
-		receipt, err := setup.L1Environment.SimBackend.Client().TransactionReceipt(ctx, tx.Hash())
+		receipt, err := l1Env.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 := setup.L1Environment.SimBackend.Client().BlockNumber(ctx)
+			bn, err := l1Env.SimBackend.Client().BlockNumber(ctx)
 			require.NoError(t, err)
-			helpers.Reorg(t, setup.L1Environment.SimBackend, uint64(blocksToReorg))
+			helpers.Reorg(t, l1Env.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 := setup.L1Environment.SimBackend.Client().BlockNumber(ctx)
+	lb, err := l1Env.SimBackend.Client().BlockNumber(ctx)
 	require.NoError(t, err)
-	helpers.RequireProcessorUpdated(t, setup.L1Environment.BridgeSync, lb)
+	helpers.RequireProcessorUpdated(t, l1Env.BridgeSync, lb)
 
 	// Get bridges
-	lastBlock, err := setup.L1Environment.SimBackend.Client().BlockNumber(ctx)
+	lastBlock, err := l1Env.SimBackend.Client().BlockNumber(ctx)
 	require.NoError(t, err)
-	actualBridges, err := setup.L1Environment.BridgeSync.GetBridges(ctx, 0, lastBlock)
+	actualBridges, err := l1Env.BridgeSync.GetBridges(ctx, 0, lastBlock)
 	require.NoError(t, err)
 
 	// Assert bridges
-	expectedRoot, err := setup.L1Environment.BridgeContract.GetRoot(nil)
+	expectedRoot, err := l1Env.BridgeContract.GetRoot(nil)
 	require.NoError(t, err)
-	root, err := setup.L1Environment.BridgeSync.GetExitRootByIndex(ctx, expectedBridges[len(expectedBridges)-1].DepositCount)
+	root, err := l1Env.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)

claimsponsor/e2e_test.go

@@ -21,19 +21,19 @@ import (
 func TestE2EL1toEVML2(t *testing.T) {
 	// start other needed components
 	ctx := context.Background()
-	setup := helpers.NewE2EEnvWithEVML2(t)
+	l1Env, l2Env := helpers.NewL1EnvWithL2EVM(t)
 
 	// start claim sponsor
 	dbPathClaimSponsor := path.Join(t.TempDir(), "claimsponsorTestE2EL1toEVML2_cs.sqlite")
 	claimer, err := claimsponsor.NewEVMClaimSponsor(
 		log.GetDefaultLogger(),
 		dbPathClaimSponsor,
-		setup.L2Environment.SimBackend.Client(),
-		setup.L2Environment.BridgeAddr,
-		setup.L2Environment.Auth.From,
+		l2Env.SimBackend.Client(),
+		l2Env.BridgeAddr,
+		l2Env.Auth.From,
 		200_000,
 		0,
-		setup.EthTxManagerMock,
+		l2Env.EthTxManagerMock,
 		0, 0, time.Millisecond*10, time.Millisecond*10,
 	)
 	require.NoError(t, err)
@@ -43,29 +43,29 @@ 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)
-		setup.L1Environment.Auth.Value = amount
-		_, err := setup.L1Environment.BridgeContract.BridgeAsset(setup.L1Environment.Auth, setup.NetworkIDL2, setup.L2Environment.Auth.From, amount, common.Address{}, true, nil)
+		l1Env.Auth.Value = amount
+		_, err := l1Env.BridgeContract.BridgeAsset(l1Env.Auth, l2Env.NetworkID, l2Env.Auth.From, amount, common.Address{}, true, nil)
 		require.NoError(t, err)
-		setup.L1Environment.SimBackend.Commit()
+		l1Env.SimBackend.Commit()
 		time.Sleep(time.Millisecond * 300)
 
-		expectedGER, err := setup.L1Environment.GERContract.GetLastGlobalExitRoot(&bind.CallOpts{Pending: false})
+		expectedGER, err := l1Env.GERContract.GetLastGlobalExitRoot(&bind.CallOpts{Pending: false})
 		require.NoError(t, err)
-		_, err = setup.L2Environment.GERContract.InsertGlobalExitRoot(setup.L2Environment.Auth, expectedGER)
+		_, err = l2Env.GERContract.InsertGlobalExitRoot(l2Env.Auth, expectedGER)
 		require.NoError(t, err)
-		setup.L2Environment.SimBackend.Commit()
-		gerIndex, err := setup.L2Environment.GERContract.GlobalExitRootMap(nil, expectedGER)
+		l2Env.SimBackend.Commit()
+		gerIndex, err := l2Env.GERContract.GlobalExitRootMap(nil, expectedGER)
 		require.NoError(t, err)
 		require.Equal(t, big.NewInt(int64(i)+1), gerIndex, fmt.Sprintf("iteration %d, GER: %s is not updated on L2", i, common.Bytes2Hex(expectedGER[:])))
 
 		// Build MP using bridgeSyncL1 & env.InfoTreeSync
-		info, err := setup.L1Environment.InfoTreeSync.GetInfoByIndex(ctx, i)
+		info, err := l1Env.InfoTreeSync.GetInfoByIndex(ctx, i)
 		require.NoError(t, err)
 
-		localProof, err := setup.L1Environment.BridgeSync.GetProof(ctx, i, info.MainnetExitRoot)
+		localProof, err := l1Env.BridgeSync.GetProof(ctx, i, info.MainnetExitRoot)
 		require.NoError(t, err)
 
-		rollupProof, err := setup.L1Environment.InfoTreeSync.GetRollupExitTreeMerkleProof(ctx, 0, common.Hash{})
+		rollupProof, err := l1Env.InfoTreeSync.GetRollupExitTreeMerkleProof(ctx, 0, common.Hash{})
 		require.NoError(t, err)
 
 		// Request to sponsor claim
@@ -79,8 +79,8 @@ func TestE2EL1toEVML2(t *testing.T) {
 			RollupExitRoot:      info.RollupExitRoot,
 			OriginNetwork:       0,
 			OriginTokenAddress:  common.Address{},
-			DestinationNetwork:  setup.NetworkIDL2,
-			DestinationAddress:  setup.L2Environment.Auth.From,
+			DestinationNetwork:  l2Env.NetworkID,
+			DestinationAddress:  l2Env.Auth.From,
 			Amount:              amount,
 			Metadata:            nil,
 		})
@@ -103,7 +103,7 @@ func TestE2EL1toEVML2(t *testing.T) {
 		require.True(t, succeed)
 
 		// Check on contract that is claimed
-		isClaimed, err := setup.L2Environment.BridgeContract.IsClaimed(&bind.CallOpts{Pending: false}, i, 0)
+		isClaimed, err := l2Env.BridgeContract.IsClaimed(&bind.CallOpts{Pending: false}, i, 0)
 		require.NoError(t, err)
 		require.True(t, isClaimed)
 	}

docs/SUMMARY.md

@@ -3,4 +3,3 @@
 - [Getting Started](./getting_started.md)
     - [Local Debug](./local_debug.md)
 - [DA Integration](./da_integration.md)
-- [Non-EVM integrations](./non_evm_integration.md)

lastgersync/e2e_test.go

@@ -19,15 +19,15 @@ import (
 
 func TestE2E(t *testing.T) {
 	ctx := context.Background()
-	setup := helpers.NewE2EEnvWithEVML2(t)
+	l1Env, l2Env := helpers.NewL1EnvWithL2EVM(t)
 	dbPathSyncer := path.Join(t.TempDir(), "lastgersyncTestE2E.sqlite")
 	syncer, err := lastgersync.New(
 		ctx,
 		dbPathSyncer,
-		setup.L2Environment.ReorgDetector,
-		setup.L2Environment.SimBackend.Client(),
-		setup.L2Environment.GERAddr,
-		setup.InfoTreeSync,
+		l2Env.ReorgDetector,
+		l2Env.SimBackend.Client(),
+		l2Env.GERAddr,
+		l1Env.InfoTreeSync,
 		0,
 		0,
 		etherman.LatestBlock,
@@ -39,21 +39,21 @@ func TestE2E(t *testing.T) {
 
 	for i := 0; i < 10; i++ {
 		// Update GER on L1
-		_, err := setup.L1Environment.GERContract.UpdateExitRoot(setup.L1Environment.Auth, common.HexToHash(strconv.Itoa(i)))
+		_, err := l1Env.GERContract.UpdateExitRoot(l1Env.Auth, common.HexToHash(strconv.Itoa(i)))
 		require.NoError(t, err)
-		setup.L1Environment.SimBackend.Commit()
+		l1Env.SimBackend.Commit()
 		time.Sleep(time.Millisecond * 150)
-		expectedGER, err := setup.L1Environment.GERContract.GetLastGlobalExitRoot(&bind.CallOpts{Pending: false})
+		expectedGER, err := l1Env.GERContract.GetLastGlobalExitRoot(&bind.CallOpts{Pending: false})
 		require.NoError(t, err)
-		_, err = setup.L2Environment.GERContract.InsertGlobalExitRoot(setup.L2Environment.Auth, expectedGER)
+		_, err = l2Env.GERContract.InsertGlobalExitRoot(l2Env.Auth, expectedGER)
 		require.NoError(t, err)
-		setup.L2Environment.SimBackend.Commit()
-		gerIndex, err := setup.L2Environment.GERContract.GlobalExitRootMap(nil, expectedGER)
+		l2Env.SimBackend.Commit()
+		gerIndex, err := l2Env.GERContract.GlobalExitRootMap(nil, expectedGER)
 		require.NoError(t, err)
 		require.Equal(t, big.NewInt(int64(i+1)), gerIndex, fmt.Sprintf("iteration %d, GER: %s is not updated on L2", i, common.Bytes2Hex(expectedGER[:])))
 
 		// Wait for syncer to catch up
-		lb, err := setup.L2Environment.SimBackend.Client().BlockNumber(ctx)
+		lb, err := l2Env.SimBackend.Client().BlockNumber(ctx)
 		require.NoError(t, err)
 		helpers.RequireProcessorUpdated(t, syncer, lb)
 

sequencesender/sequencesender.go

@@ -29,6 +29,13 @@ const ten = 10
 // EthTxManager represents the eth tx manager interface
 type EthTxManager interface {
 	Start()
+	Add(ctx context.Context,
+		to *common.Address,
+		value *big.Int,
+		data []byte,
+		gasOffset uint64,
+		sidecar *ethtypes.BlobTxSidecar,
+	) (common.Hash, error)
 	AddWithGas(
 		ctx context.Context,
 		to *common.Address,