fix forcedBatch trusted state

jsonrpc/endpoints_zkevm_test.go

@@ -869,6 +869,7 @@ func TestGetBatchByNumber(t *testing.T) {
 			WithTxDetail: true,
 			ExpectedResult: &types.Batch{
 				Number:              1,
+				ForcedBatchNumber:   ptrArgUint64FromUint64(1),
 				Coinbase:            common.HexToAddress("0x1"),
 				StateRoot:           common.HexToHash("0x2"),
 				AccInputHash:        common.HexToHash("0x3"),
@@ -894,8 +895,10 @@ func TestGetBatchByNumber(t *testing.T) {
 					Return(uint64(tc.ExpectedResult.Number), nil).
 					Once()
 
+				var fb uint64 = 1
 				batch := &state.Batch{
 					BatchNumber:    1,
+					ForcedBatchNum: &fb,
 					Coinbase:       common.HexToAddress("0x1"),
 					StateRoot:      common.HexToHash("0x2"),
 					AccInputHash:   common.HexToHash("0x3"),
@@ -1066,6 +1069,9 @@ func TestGetBatchByNumber(t *testing.T) {
 					err = json.Unmarshal(res.Result, &batch)
 					require.NoError(t, err)
 					assert.Equal(t, tc.ExpectedResult.Number.Hex(), batch["number"].(string))
+					if tc.ExpectedResult.ForcedBatchNumber != nil {
+						assert.Equal(t, tc.ExpectedResult.ForcedBatchNumber.Hex(), batch["forcedBatchNumber"].(string))
+					}
 					assert.Equal(t, tc.ExpectedResult.Coinbase.String(), batch["coinbase"].(string))
 					assert.Equal(t, tc.ExpectedResult.StateRoot.String(), batch["stateRoot"].(string))
 					assert.Equal(t, tc.ExpectedResult.GlobalExitRoot.String(), batch["globalExitRoot"].(string))

jsonrpc/types/types.go

@@ -326,6 +326,7 @@ func NewBlock(b *types.Block, fullTx bool) *Block {
 // Batch structure
 type Batch struct {
 	Number              ArgUint64           `json:"number"`
+	ForcedBatchNumber   *ArgUint64          `json:"forcedBatchNumber,omitempty"`
 	Coinbase            common.Address      `json:"coinbase"`
 	StateRoot           common.Hash         `json:"stateRoot"`
 	GlobalExitRoot      common.Hash         `json:"globalExitRoot"`
@@ -352,6 +353,10 @@ func NewBatch(batch *state.Batch, virtualBatch *state.VirtualBatch, verifiedBatc
 		Coinbase:        batch.Coinbase,
 		LocalExitRoot:   batch.LocalExitRoot,
 	}
+	if batch.ForcedBatchNum != nil {
+		fb := ArgUint64(*batch.ForcedBatchNum)
+		res.ForcedBatchNumber = &fb
+	}
 
 	if virtualBatch != nil {
 		res.SendSequencesTxHash = &virtualBatch.TxHash

jsonrpc/types/types_test.go

@@ -137,9 +137,10 @@ func TestBatchUnmarshal(t *testing.T) {
 		},
 		{
 			name: "with txs",
-			json: `{"number":"0x1","coinbase":"0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266","stateRoot":"0x49e7b7eb6bb34b07a1063cd2c7a9cac88845c1867e8a026d69fc00b862c2ca72","globalExitRoot":"0x0000000000000000000000000000000000000000000000000000000000000001","localExitRoot":"0x0000000000000000000000000000000000000000000000000000000000000002","accInputHash":"0x0000000000000000000000000000000000000000000000000000000000000003","timestamp":"0x64133495","sendSequencesTxHash":"0x0000000000000000000000000000000000000000000000000000000000000004","verifyBatchTxHash":"0x0000000000000000000000000000000000000000000000000000000000000005","transactions":[{"nonce":"0x8","gasPrice":"0x3b9aca00","gas":"0x5208","to":"0xb48ca794d49eec406a5dd2c547717e37b5952a83","value":"0xde0b6b3a7640000","input":"0x","v":"0x7f5","r":"0x27d94abdecca8324d23221cec81f0a3398d7eee2dc831f698fe12447695897d5","s":"0x1b9f1d7cabbb69d309f9e6ffe10b3e205ad86af1058f4dbacdd06a8db03a5669","hash":"0xd0433908a0b56ec6d90758abfe5ae11185e13bedb3d70e8ab7c0d7e3f0e395b5","from":"0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266","blockHash":"0x7e8efeb2b5bb9aaef68a9b2f5b6c0a14900745380a68f72f9c15f978546109cc","blockNumber":"0x1","transactionIndex":"0x0","chainId":"0x3e9","type":"0x0"}]}`,
+			json: `{"number":"0x1","forcedBatchNumber":"1","coinbase":"0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266","stateRoot":"0x49e7b7eb6bb34b07a1063cd2c7a9cac88845c1867e8a026d69fc00b862c2ca72","globalExitRoot":"0x0000000000000000000000000000000000000000000000000000000000000001","localExitRoot":"0x0000000000000000000000000000000000000000000000000000000000000002","accInputHash":"0x0000000000000000000000000000000000000000000000000000000000000003","timestamp":"0x64133495","sendSequencesTxHash":"0x0000000000000000000000000000000000000000000000000000000000000004","verifyBatchTxHash":"0x0000000000000000000000000000000000000000000000000000000000000005","transactions":[{"nonce":"0x8","gasPrice":"0x3b9aca00","gas":"0x5208","to":"0xb48ca794d49eec406a5dd2c547717e37b5952a83","value":"0xde0b6b3a7640000","input":"0x","v":"0x7f5","r":"0x27d94abdecca8324d23221cec81f0a3398d7eee2dc831f698fe12447695897d5","s":"0x1b9f1d7cabbb69d309f9e6ffe10b3e205ad86af1058f4dbacdd06a8db03a5669","hash":"0xd0433908a0b56ec6d90758abfe5ae11185e13bedb3d70e8ab7c0d7e3f0e395b5","from":"0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266","blockHash":"0x7e8efeb2b5bb9aaef68a9b2f5b6c0a14900745380a68f72f9c15f978546109cc","blockNumber":"0x1","transactionIndex":"0x0","chainId":"0x3e9","type":"0x0"}]}`,
 			expected: Batch{
 				Number:              1,
+				ForcedBatchNumber:   ArgUint64Ptr(1),
 				Coinbase:            common.HexToAddress("0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266"),
 				StateRoot:           common.HexToHash("0x49e7b7eb6bb34b07a1063cd2c7a9cac88845c1867e8a026d69fc00b862c2ca72"),
 				GlobalExitRoot:      common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"),
@@ -200,6 +201,7 @@ func TestBatchUnmarshal(t *testing.T) {
 		require.NoError(t, err)
 
 		assert.Equal(t, testCase.expected.Number, result.Number)
+		assert.Equal(t, testCase.expected.ForcedBatchNumber, result.ForcedBatchNumber)
 		assert.Equal(t, testCase.expected.Coinbase, result.Coinbase)
 		assert.Equal(t, testCase.expected.StateRoot, result.StateRoot)
 		assert.Equal(t, testCase.expected.GlobalExitRoot, result.GlobalExitRoot)

state/pgstatestorage.go

@@ -9,7 +9,6 @@ import (
 	"time"
 
 	"github.com/0xPolygonHermez/zkevm-node/hex"
-	"github.com/0xPolygonHermez/zkevm-node/log"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/jackc/pgx/v4"
@@ -955,7 +954,6 @@ func (p *PostgresStorage) storeGenesisBatch(ctx context.Context, batch Batch, db
 // in this batch yet. In other words it's the creation of a WIP batch.
 // Note that this will add a batch with batch number N + 1, where N it's the greatest batch number on the state.
 func (p *PostgresStorage) openBatch(ctx context.Context, batchContext ProcessingContext, dbTx pgx.Tx) error {
-	log.Debug("Inserting forced batch num: ", batchContext.ForcedBatchNum)
 	const openBatchSQL = "INSERT INTO state.batch (batch_num, global_exit_root, timestamp, coinbase, forced_batch_num) VALUES ($1, $2, $3, $4, $5)"
 
 	e := p.getExecQuerier(dbTx)

synchronizer/synchronizer.go

@@ -762,7 +762,6 @@ func (s *ClientSynchronizer) processSequenceBatches(sequencedBatches []etherman.
 			log.Debug("Setting forced batch num: ", forcedBatches[0].ForcedBatchNumber)
 			batch.ForcedBatchNum = &forcedBatches[0].ForcedBatchNumber
 		}
-		log.Debug("Forced batch Num: ", batch.ForcedBatchNum)
 
 		// Now we need to check the batch. ForcedBatches should be already stored in the batch table because this is done by the sequencer
 		processCtx := state.ProcessingContext{
@@ -781,7 +780,6 @@ func (s *ClientSynchronizer) processSequenceBatches(sequencedBatches []etherman.
 			if errors.Is(err, state.ErrNotFound) || errors.Is(err, state.ErrStateNotSynchronized) {
 				log.Debugf("BatchNumber: %d, not found in trusted state. Storing it...", batch.BatchNumber)
 				// If it is not found, store batch
-				log.Debug("forcedBatchNum before 1: ", processCtx.ForcedBatchNum)
 				newStateRoot, err := s.state.ProcessAndStoreClosedBatch(s.ctx, processCtx, batch.BatchL2Data, dbTx, metrics.SynchronizerCallerLabel)
 				if err != nil {
 					log.Errorf("error storing trustedBatch. BatchNumber: %d, BlockNumber: %d, error: %v", batch.BatchNumber, blockNumber, err)
@@ -862,7 +860,6 @@ func (s *ClientSynchronizer) processSequenceBatches(sequencedBatches []etherman.
 				log.Errorf("error resetting trusted state. BatchNumber: %d, BlockNumber: %d, error: %v", batch.BatchNumber, blockNumber, err)
 				return err
 			}
-			log.Debug("forcedBatchNum before 2: ", processCtx.ForcedBatchNum)
 			_, err = s.state.ProcessAndStoreClosedBatch(s.ctx, processCtx, batch.BatchL2Data, dbTx, metrics.SynchronizerCallerLabel)
 			if err != nil {
 				log.Errorf("error storing trustedBatch. BatchNumber: %d, BlockNumber: %d, error: %v", batch.BatchNumber, blockNumber, err)
@@ -1192,6 +1189,10 @@ func (s *ClientSynchronizer) processTrustedBatch(trustedBatch *types.Batch, dbTx
 		Timestamp:      time.Unix(int64(trustedBatch.Timestamp), 0),
 		GlobalExitRoot: trustedBatch.GlobalExitRoot,
 	}
+	if trustedBatch.ForcedBatchNumber != nil {
+		fb := uint64(*trustedBatch.ForcedBatchNumber)
+		processCtx.ForcedBatchNum = &fb
+	}
 	if err := s.state.OpenBatch(s.ctx, processCtx, dbTx); err != nil {
 		log.Errorf("error opening batch %d", trustedBatch.Number)
 		return err