Add mainnet and rollup exit root to broadcast (0xPolygonHermez#921)

* Add mainnet and rollup exit root to broadcast

* fix checks

* rename state method

* increase timeout to connect to braodcast server on e2e test

proto/src/proto/broadcast/v1/broadcast.proto

@@ -26,10 +26,12 @@ message GetBatchResponse {
   string global_exit_root = 2;
   string local_exit_root = 3;
   string state_root = 4;
-  uint64 timestamp = 5;
-  string sequencer = 6;
-  uint64 forced_batch_number = 7;
-  repeated Transaction transactions = 8;
+  string mainnet_exit_root = 5;
+  string rollup_exit_root = 6;
+  uint64 timestamp = 7;
+  string sequencer = 8;
+  uint64 forced_batch_number = 9;
+  repeated Transaction transactions = 10;
 }
 
 // Common

sequencer/broadcast/interfaces.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/0xPolygonHermez/zkevm-node/state"
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/jackc/pgx/v4"
 )
 
@@ -14,4 +15,5 @@ type stateInterface interface {
 	GetBatchByNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (*state.Batch, error)
 	GetEncodedTransactionsByBatchNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (encoded []string, err error)
 	GetForcedBatchByBatchNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (*state.ForcedBatch, error)
+	GetExitRootByGlobalExitRoot(ctx context.Context, ger common.Hash, dbTx pgx.Tx) (*state.GlobalExitRoot, error)
 }

sequencer/broadcast/server.go

@@ -100,12 +100,23 @@ func (s *Server) genericGetBatch(ctx context.Context, batch *state.Batch) (*pb.G
 		return nil, err
 	}
 
+	var mainnetExitRoot, rollupExitRoot string
+	ger, err := s.state.GetExitRootByGlobalExitRoot(ctx, batch.GlobalExitRoot, nil)
+	if err == nil {
+		mainnetExitRoot = ger.MainnetExitRoot.String()
+		rollupExitRoot = ger.RollupExitRoot.String()
+	} else if err != state.ErrNotFound {
+		return nil, err
+	}
+
 	return &pb.GetBatchResponse{
 		BatchNumber:       batch.BatchNumber,
 		GlobalExitRoot:    batch.GlobalExitRoot.String(),
 		Sequencer:         batch.Coinbase.String(),
 		LocalExitRoot:     batch.LocalExitRoot.String(),
 		StateRoot:         batch.StateRoot.String(),
+		MainnetExitRoot:   mainnetExitRoot,
+		RollupExitRoot:    rollupExitRoot,
 		Timestamp:         uint64(batch.Timestamp.Unix()),
 		Transactions:      transactions,
 		ForcedBatchNumber: forcedBatchNum,

sequencer/broadcast/server_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/0xPolygonHermez/zkevm-node/sequencer/broadcast"
 	"github.com/0xPolygonHermez/zkevm-node/sequencer/broadcast/pb"
 	"github.com/0xPolygonHermez/zkevm-node/state"
+	"github.com/0xPolygonHermez/zkevm-node/test/operations"
 	"github.com/0xPolygonHermez/zkevm-node/test/testutils"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/stretchr/testify/mock"
@@ -63,11 +64,10 @@ func initialize() {
 		panic(err)
 	}
 
-	// TODO: this package shouldn't be using a function from test package
-	// err = operations.WaitGRPCHealthy(address)
-	// if err != nil {
-	// 	panic(err)
-	// }
+	err = operations.WaitGRPCHealthy(address)
+	if err != nil {
+		panic(err)
+	}
 }
 
 func teardown() {
@@ -105,6 +105,7 @@ func TestBroadcastServerGetBatch(t *testing.T) {
 		expectedBatch       *state.Batch
 		expectedForcedBatch *state.ForcedBatch
 		expectedEncodedTxs  []string
+		expectedGER         *state.GlobalExitRoot
 		expectedErr         bool
 		expectedErrMsg      string
 	}{
@@ -120,6 +121,10 @@ func TestBroadcastServerGetBatch(t *testing.T) {
 				ForcedBatchNumber: 1,
 			},
 			expectedEncodedTxs: []string{"tx1", "tx2", "tx3"},
+			expectedGER: &state.GlobalExitRoot{
+				MainnetExitRoot: common.HexToHash("b"),
+				RollupExitRoot:  common.HexToHash("c"),
+			},
 		},
 		{
 			description:      "query errors are returned",
@@ -140,7 +145,9 @@ func TestBroadcastServerGetBatch(t *testing.T) {
 			st.On("GetBatchByNumber", mock.AnythingOfType("*context.valueCtx"), tc.inputBatchNumber, nil).Return(tc.expectedBatch, err)
 			st.On("GetEncodedTransactionsByBatchNumber", mock.AnythingOfType("*context.valueCtx"), tc.inputBatchNumber, nil).Return(tc.expectedEncodedTxs, err)
 			st.On("GetForcedBatchByBatchNumber", mock.AnythingOfType("*context.valueCtx"), tc.inputBatchNumber, nil).Return(tc.expectedForcedBatch, err)
-
+			if tc.expectedBatch != nil {
+				st.On("GetExitRootByGlobalExitRoot", mock.AnythingOfType("*context.valueCtx"), tc.expectedBatch.GlobalExitRoot, nil).Return(tc.expectedGER, err)
+			}
 			broadcastSrv.SetState(st)
 
 			client := pb.NewBroadcastServiceClient(conn)
@@ -156,6 +163,9 @@ func TestBroadcastServerGetBatch(t *testing.T) {
 				for i, encoded := range tc.expectedEncodedTxs {
 					require.Equal(t, encoded, actualBatch.Transactions[i].Encoded)
 				}
+				require.Equal(t, tc.expectedGER.MainnetExitRoot.String(), actualBatch.MainnetExitRoot)
+				require.Equal(t, tc.expectedGER.RollupExitRoot.String(), actualBatch.RollupExitRoot)
+
 				require.True(t, st.AssertExpectations(t))
 			}
 		})
@@ -168,20 +178,25 @@ func TestBroadcastServerGetLastBatch(t *testing.T) {
 		expectedBatch       *state.Batch
 		expectedForcedBatch *state.ForcedBatch
 		expectedEncodedTxs  []string
+		expectedGER         *state.GlobalExitRoot
 		expectedErr         bool
 		expectedErrMsg      string
 	}{
 		{
 			description: "happy path",
 			expectedBatch: &state.Batch{
 				BatchNumber:    14,
-				GlobalExitRoot: common.HexToHash("b"),
+				GlobalExitRoot: common.HexToHash("a"),
 				Timestamp:      time.Now(),
 			},
 			expectedForcedBatch: &state.ForcedBatch{
 				ForcedBatchNumber: 1,
 			},
 			expectedEncodedTxs: []string{"tx1", "tx2", "tx3"},
+			expectedGER: &state.GlobalExitRoot{
+				MainnetExitRoot: common.HexToHash("b"),
+				RollupExitRoot:  common.HexToHash("c"),
+			},
 		},
 		{
 			description:    "query errors are returned",
@@ -202,6 +217,7 @@ func TestBroadcastServerGetLastBatch(t *testing.T) {
 			if tc.expectedBatch != nil {
 				st.On("GetEncodedTransactionsByBatchNumber", mock.AnythingOfType("*context.valueCtx"), tc.expectedBatch.BatchNumber, nil).Return(tc.expectedEncodedTxs, err)
 				st.On("GetForcedBatchByBatchNumber", mock.AnythingOfType("*context.valueCtx"), tc.expectedBatch.BatchNumber, nil).Return(tc.expectedForcedBatch, err)
+				st.On("GetExitRootByGlobalExitRoot", mock.AnythingOfType("*context.valueCtx"), tc.expectedBatch.GlobalExitRoot, nil).Return(tc.expectedGER, err)
 			}
 
 			broadcastSrv.SetState(st)
@@ -217,6 +233,9 @@ func TestBroadcastServerGetLastBatch(t *testing.T) {
 				for i, encoded := range tc.expectedEncodedTxs {
 					require.Equal(t, encoded, actualBatch.Transactions[i].Encoded)
 				}
+				require.Equal(t, tc.expectedGER.MainnetExitRoot.String(), actualBatch.MainnetExitRoot)
+				require.Equal(t, tc.expectedGER.RollupExitRoot.String(), actualBatch.RollupExitRoot)
+
 				require.True(t, st.AssertExpectations(t))
 			}
 		})

state/pgstatestorage.go

@@ -1377,3 +1377,26 @@ func (p *PostgresStorage) AddLog(ctx context.Context, l *types.Log, dbTx pgx.Tx)
 		l.Address.String(), l.Data, topicsAsBytes[0], topicsAsBytes[1], topicsAsBytes[2], topicsAsBytes[3])
 	return err
 }
+
+// GetExitRootByGlobalExitRoot returns the mainnet and rollup exit root given
+// a global exit root number.
+func (p *PostgresStorage) GetExitRootByGlobalExitRoot(ctx context.Context, ger common.Hash, dbTx pgx.Tx) (*GlobalExitRoot, error) {
+	var (
+		exitRoot  GlobalExitRoot
+		globalNum uint64
+		err       error
+	)
+
+	const sql = "SELECT block_num, global_exit_root_num, mainnet_exit_root, rollup_exit_root, global_exit_root FROM state.exit_root WHERE global_exit_root = $1 ORDER BY block_num DESC LIMIT 1"
+
+	e := p.getExecQuerier(dbTx)
+	err = e.QueryRow(ctx, sql, ger).Scan(&exitRoot.BlockNumber, &globalNum, &exitRoot.MainnetExitRoot, &exitRoot.RollupExitRoot, &exitRoot.GlobalExitRoot)
+
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	} else if err != nil {
+		return nil, err
+	}
+	exitRoot.GlobalExitRootNum = new(big.Int).SetUint64(globalNum)
+	return &exitRoot, nil
+}