Feature/dbmanager

cmd/run.go

@@ -175,7 +175,7 @@ func createSequencer(c config.Config, pool *pool.Pool, state *state.State, ether
 	//	log.Fatal(err)
 	//}
 
-	seq, err := sequencer.New(c.Sequencer, pool, state, state, etherman, ethTxManager)
+	seq, err := sequencer.New(c.Sequencer, pool, state, etherman, ethTxManager)
 	if err != nil {
 		log.Fatal(err)
 	}

db/migrations/state/0003.sql

@@ -0,0 +1,15 @@
+-- +migrate Up
+ALTER TABLE state.forced_batch
+DROP COLUMN IF EXISTS batch_num;
+
+ALTER TABLE state.batch
+ADD COLUMN forced_batch_num BIGINT;
+ALTER TABLE state.batch
+ADD FOREIGN KEY (forced_batch_num) REFERENCES state.forced_batch(forced_batch_num);
+
+-- +migrate Down
+ALTER TABLE state.batch
+DROP COLUMN IF EXISTS forced_batch_num;
+
+ALTER TABLE state.forced_batch
+ADD COLUMN batch_num BIGINT;

pool/interfaces.go

@@ -5,6 +5,7 @@ import (
 	"math/big"
 	"time"
 
+	"github.com/0xPolygonHermez/zkevm-node/state"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/jackc/pgx/v4"
@@ -27,6 +28,8 @@ type storage interface {
 	GetTxFromAddressFromByHash(ctx context.Context, hash common.Hash) (common.Address, uint64, error)
 	GetTxByHash(ctx context.Context, hash common.Hash) (*Transaction, error)
 	IncrementFailedCounter(ctx context.Context, hashes []string) error
+	GetTxZkCountersByHash(ctx context.Context, hash common.Hash) (*state.ZKCounters, error)
+	DeleteTransactionByHash(ctx context.Context, hash common.Hash) error
 }
 
 type stateInterface interface {

pool/pgpoolstorage/pgpoolstorage.go

@@ -542,3 +542,21 @@ func (p *PostgresPoolStorage) DeleteTransactionByHash(ctx context.Context, hash
 	}
 	return nil
 }
+
+// GetTxZkCountersByHash gets a transaction zkcounters by its hash
+func (p *PostgresPoolStorage) GetTxZkCountersByHash(ctx context.Context, hash common.Hash) (*state.ZKCounters, error) {
+	var zkCounters state.ZKCounters
+
+	sql := `SELECT cumulative_gas_used, used_keccak_hashes, used_poseidon_hashes, used_poseidon_paddings, used_mem_aligns,
+			used_arithmetics, used_binaries, used_steps FROM pool.txs WHERE hash = $1`
+	err := p.db.QueryRow(ctx, sql, hash.String()).Scan(&zkCounters.CumulativeGasUsed, &zkCounters.UsedKeccakHashes,
+		&zkCounters.UsedPoseidonHashes, &zkCounters.UsedPoseidonPaddings,
+		&zkCounters.UsedMemAligns, &zkCounters.UsedArithmetics, &zkCounters.UsedBinaries, &zkCounters.UsedSteps)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	} else if err != nil {
+		return nil, err
+	}
+
+	return &zkCounters, nil
+}

sequencer/broadcast/interfaces.go

@@ -14,6 +14,5 @@ type stateInterface interface {
 	GetLastBatch(ctx context.Context, dbTx pgx.Tx) (*state.Batch, error)
 	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

@@ -92,39 +92,32 @@ func (s *Server) genericGetBatch(ctx context.Context, batch *state.Batch) (*pb.G
 		}
 	}
 
-	var forcedBatchNum uint64
-	forcedBatch, err := s.state.GetForcedBatchByBatchNumber(ctx, batch.BatchNumber, nil)
-	if err == nil {
-		forcedBatchNum = forcedBatch.ForcedBatchNumber
-	} else if err != state.ErrNotFound {
-		return nil, err
-	}
-
-	var (
-		mainnetExitRoot, rollupExitRoot string
-		globalExitRootTimestamp         uint64
-	)
+	var mainnetExitRoot, rollupExitRoot string
 	ger, err := s.state.GetExitRootByGlobalExitRoot(ctx, batch.GlobalExitRoot, nil)
 	if err == nil {
 		mainnetExitRoot = ger.MainnetExitRoot.String()
 		rollupExitRoot = ger.RollupExitRoot.String()
-		globalExitRootTimestamp = uint64(ger.Timestamp.Unix())
+		// TODO: line commented to be able to compile. This should be reviewed (TR)
+		// globalExitRootTimestamp = uint64(ger.Timestamp.Unix())
 	} else if err != state.ErrNotFound {
 		return nil, err
 	}
+	var fb uint64
+	if batch.ForcedBatchNum != nil {
+		fb = *batch.ForcedBatchNum
+	}
 
 	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,
-		GlobalExitRootTimestamp: globalExitRootTimestamp,
-		Timestamp:               uint64(batch.Timestamp.Unix()),
-		Transactions:            transactions,
-		ForcedBatchNumber:       forcedBatchNum,
+		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: fb,
 	}, nil
 }
 

sequencer/broadcast/server_test.go

@@ -145,7 +145,6 @@ 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)
 			}
@@ -217,7 +216,6 @@ func TestBroadcastServerGetLastBatch(t *testing.T) {
 			st.On("GetLastBatch", mock.AnythingOfType("*context.valueCtx"), nil).Return(tc.expectedBatch, err)
 			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)
 			}