use forkID while encoding/decoding txs (#2219)

0xPolygonHermez · Jun 23, 2023 · c44883f · c44883f
1 parent 277cada
commit c44883f
Show file tree

Hide file tree

Showing 21 changed files with 208 additions and 108 deletions.
diff --git a/ci/e2e-group10/forced_batches_test.go b/ci/e2e-group10/forced_batches_test.go
@@ -24,6 +24,7 @@ import (
 const (
 	toAddressHex      = "0x4d5Cf5032B2a844602278b01199ED191A86c93ff"
 	gerFinalityBlocks = uint64(250)
+	forkID5           = 5
 )
 
 var (
@@ -60,7 +61,7 @@ func TestForcedBatches(t *testing.T) {
 	unsignedTx := types.NewTransaction(nonce, toAddress, amount, gasLimit, gasPrice, nil)
 	signedTx, err := auth.Signer(auth.From, unsignedTx)
 	require.NoError(t, err)
-	encodedTxs, err := state.EncodeTransactions([]types.Transaction{*signedTx}, constants.EffectivePercentage)
+	encodedTxs, err := state.EncodeTransactions([]types.Transaction{*signedTx}, constants.EffectivePercentage, forkID5)
 	require.NoError(t, err)
 	forcedBatch, err := sendForcedBatch(t, encodedTxs, opsman)
 	require.NoError(t, err)

diff --git a/ci/e2e-group10/forced_batches_vector_group2_test.go b/ci/e2e-group10/forced_batches_vector_group2_test.go
@@ -71,7 +71,7 @@ func TestForcedBatchesVectorFiles(t *testing.T) {
 				require.Equal(t, testCase.ExpectedOldStateRoot, actualOldStateRoot.Hex())
 				decodedData, err := hex.DecodeHex(testCase.BatchL2Data)
 				require.NoError(t, err)
-				_, txBytes, _, err := state.DecodeTxs(decodedData)
+				_, txBytes, _, err := state.DecodeTxs(decodedData, forkID5)
 				forcedBatch, err := sendForcedBatchForVector(t, txBytes, opsman)
 				require.NoError(t, err)
 				actualNewStateRoot := forcedBatch.StateRoot

diff --git a/ci/e2e-group11/forced_batches_vector_group3_test.go b/ci/e2e-group11/forced_batches_vector_group3_test.go
@@ -23,6 +23,10 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+const (
+	forkID5 = 5
+)
+
 func TestForcedBatchesVectorFiles(t *testing.T) {
 
 	if testing.Short() {
@@ -71,7 +75,7 @@ func TestForcedBatchesVectorFiles(t *testing.T) {
 				require.Equal(t, testCase.ExpectedOldStateRoot, actualOldStateRoot.Hex())
 				decodedData, err := hex.DecodeHex(testCase.BatchL2Data)
 				require.NoError(t, err)
-				_, txBytes, _, err := state.DecodeTxs(decodedData)
+				_, txBytes, _, err := state.DecodeTxs(decodedData, forkID5)
 				forcedBatch, err := sendForcedBatchForVector(t, txBytes, opsman)
 				require.NoError(t, err)
 				actualNewStateRoot := forcedBatch.StateRoot

diff --git a/ci/e2e-group9/forced_batches_vector_group1_test.go b/ci/e2e-group9/forced_batches_vector_group1_test.go
@@ -23,6 +23,10 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+const (
+	forkID5 = 5
+)
+
 func TestForcedBatchesVectorFiles(t *testing.T) {
 
 	if testing.Short() {
@@ -71,7 +75,7 @@ func TestForcedBatchesVectorFiles(t *testing.T) {
 				require.Equal(t, testCase.ExpectedOldStateRoot, actualOldStateRoot.Hex())
 				decodedData, err := hex.DecodeHex(testCase.BatchL2Data)
 				require.NoError(t, err)
-				_, txBytes, _, err := state.DecodeTxs(decodedData)
+				_, txBytes, _, err := state.DecodeTxs(decodedData, forkID5)
 				require.NoError(t, err)
 				forcedBatch, err := sendForcedBatchForVector(t, txBytes, opsman)
 				require.NoError(t, err)

diff --git a/cmd/run.go b/cmd/run.go
@@ -129,6 +129,8 @@ func start(cliCtx *cli.Context) error {
 	log.Infof("Fork ID read from POE SC = %v", currentForkID)
 	c.Aggregator.ChainID = l2ChainID
 	c.Aggregator.ForkId = currentForkID
+	c.Sequencer.DBManager.ForkID = currentForkID
+	c.Sequencer.Finalizer.ForkID = currentForkID
 	log.Infof("Chain ID read from POE SC = %v", l2ChainID)
 
 	ctx := context.Background()

diff --git a/etherman/etherman_test.go b/etherman/etherman_test.go
@@ -26,6 +26,10 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+const (
+	forkID5 = 5
+)
+
 func init() {
 	log.Init(log.Config{
 		Level:   "debug",
@@ -315,7 +319,7 @@ func TestSendSequences(t *testing.T) {
 	require.NoError(t, err)
 
 	tx1 := types.NewTransaction(uint64(0), common.Address{}, big.NewInt(10), uint64(1), big.NewInt(10), []byte{})
-	batchL2Data, err := state.EncodeTransactions([]types.Transaction{*tx1}, constants.EffectivePercentage)
+	batchL2Data, err := state.EncodeTransactions([]types.Transaction{*tx1}, constants.EffectivePercentage, forkID5)
 	require.NoError(t, err)
 	sequence := ethmanTypes.Sequence{
 		GlobalExitRoot: ger,

diff --git a/jsonrpc/endpoints_zkevm_test.go b/jsonrpc/endpoints_zkevm_test.go
@@ -20,6 +20,10 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+const (
+	forkID5 = 5
+)
+
 func TestConsolidatedBlockNumber(t *testing.T) {
 	s, m, _ := newSequencerMockedServer(t)
 	defer s.Stop()
@@ -708,7 +712,7 @@ func TestGetBatchByNumber(t *testing.T) {
 					batchTxs = append(batchTxs, *tx)
 					effectivePercentages = append(effectivePercentages, state.MaxEffectivePercentage)
 				}
-				batchL2Data, err := state.EncodeTransactions(batchTxs, effectivePercentages)
+				batchL2Data, err := state.EncodeTransactions(batchTxs, effectivePercentages, forkID5)
 				require.NoError(t, err)
 				tc.ExpectedResult.BatchL2Data = batchL2Data
 				batch := &state.Batch{
@@ -821,7 +825,7 @@ func TestGetBatchByNumber(t *testing.T) {
 					batchTxs = append(batchTxs, *tx)
 					effectivePercentages = append(effectivePercentages, state.MaxEffectivePercentage)
 				}
-				batchL2Data, err := state.EncodeTransactions(batchTxs, effectivePercentages)
+				batchL2Data, err := state.EncodeTransactions(batchTxs, effectivePercentages, forkID5)
 				require.NoError(t, err)
 
 				batch := &state.Batch{
@@ -959,7 +963,7 @@ func TestGetBatchByNumber(t *testing.T) {
 					batchTxs = append(batchTxs, *tx)
 					effectivePercentages = append(effectivePercentages, state.MaxEffectivePercentage)
 				}
-				batchL2Data, err := state.EncodeTransactions(batchTxs, effectivePercentages)
+				batchL2Data, err := state.EncodeTransactions(batchTxs, effectivePercentages, forkID5)
 				require.NoError(t, err)
 				batch := &state.Batch{
 					BatchNumber:    1,

diff --git a/pool/pool_test.go b/pool/pool_test.go
@@ -37,6 +37,7 @@ import (
 )
 
 const (
+	forkID5          = 5
 	senderPrivateKey = "0x28b2b0318721be8c8339199172cd7cc8f5e273800a35616ec893083a4b32c02e"
 	senderAddress    = "0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D"
 )
@@ -271,7 +272,7 @@ func Test_AddPreEIP155Tx(t *testing.T) {
 	batchL2Data := "0xe580843b9aca00830186a0941275fbb540c8efc58b812ba83b0d0b8b9917ae98808464fbb77c6b39bdc5f8e458aba689f2a1ff8c543a94e4817bda40f3fe34080c4ab26c1e3c2fc2cda93bc32f0a79940501fd505dcf48d94abfde932ebf1417f502cb0d9de81bff"
 	b, err := hex.DecodeHex(batchL2Data)
 	require.NoError(t, err)
-	txs, _, _, err := state.DecodeTxs(b)
+	txs, _, _, err := state.DecodeTxs(b, forkID5)
 	require.NoError(t, err)
 
 	tx := txs[0]

diff --git a/sequencer/config.go b/sequencer/config.go
@@ -124,6 +124,9 @@ type FinalizerCfg struct {
 
 	// TimestampResolution is the resolution of the timestamp used to close a batch
 	TimestampResolution types.Duration `mapstructure:"TimestampResolution"`
+
+	// ForkID is the fork id of the chain
+	ForkID uint64 `mapstructure:"ForkID"`
 }
 
 // WorkerCfg contains the Worker's configuration properties
@@ -136,6 +139,7 @@ type WorkerCfg struct {
 type DBManagerCfg struct {
 	PoolRetrievalInterval    types.Duration `mapstructure:"PoolRetrievalInterval"`
 	L2ReorgRetrievalInterval types.Duration `mapstructure:"L2ReorgRetrievalInterval"`
+	ForkID                   uint64         `mapstructure:"ForkID"`
 }
 
 // EffectiveGasPriceCfg contains the configuration properties for the effective gas price

diff --git a/sequencer/dbmanager.go b/sequencer/dbmanager.go
@@ -183,7 +183,7 @@ func (d *dbManager) StoreProcessedTxAndDeleteFromPool(ctx context.Context, tx tr
 		return err
 	}
 
-	txData, err := state.EncodeTransaction(tx.response.Tx, uint8(tx.response.EffectivePercentage))
+	txData, err := state.EncodeTransaction(tx.response.Tx, uint8(tx.response.EffectivePercentage), d.cfg.ForkID)
 	if err != nil {
 		return err
 	}
@@ -236,15 +236,15 @@ func (d *dbManager) GetWIPBatch(ctx context.Context) (*WipBatch, error) {
 		previousLastBatch = lastBatches[1]
 	}
 
-	lastBatchTxs, _, _, err := state.DecodeTxs(lastBatch.BatchL2Data)
+	lastBatchTxs, _, _, err := state.DecodeTxs(lastBatch.BatchL2Data, d.cfg.ForkID)
 	if err != nil {
 		return nil, err
 	}
 	lastBatch.Transactions = lastBatchTxs
 
 	var prevLastBatchTxs []types.Transaction
 	if previousLastBatch != nil {
-		prevLastBatchTxs, _, _, err = state.DecodeTxs(previousLastBatch.BatchL2Data)
+		prevLastBatchTxs, _, _, err = state.DecodeTxs(previousLastBatch.BatchL2Data, d.cfg.ForkID)
 		if err != nil {
 			return nil, err
 		}
@@ -395,7 +395,7 @@ func (d *dbManager) CloseBatch(ctx context.Context, params ClosingBatchParameter
 		ClosingReason:  params.ClosingReason,
 	}
 
-	batchL2Data, err := state.EncodeTransactions(params.Txs, params.EffectivePercentages)
+	batchL2Data, err := state.EncodeTransactions(params.Txs, params.EffectivePercentages, d.cfg.ForkID)
 	if err != nil {
 		return err
 	}

diff --git a/sequencer/finalizer.go b/sequencer/finalizer.go
@@ -1014,7 +1014,7 @@ func (f *finalizer) reprocessFullBatch(ctx context.Context, batchNum uint64, exp
 		Caller:         stateMetrics.SequencerCallerLabel,
 	}
 	log.Infof("reprocessFullBatch: BatchNumber: %d, OldStateRoot: %s, Ger: %s", batch.BatchNumber, f.batch.initialStateRoot.String(), batch.GlobalExitRoot.String())
-	txs, _, _, err := state.DecodeTxs(batch.BatchL2Data)
+	txs, _, _, err := state.DecodeTxs(batch.BatchL2Data, f.cfg.ForkID)
 
 	if err != nil {
 		log.Errorf("reprocessFullBatch: error decoding BatchL2Data before reprocessing full batch: %d. Error: %v", batch.BatchNumber, err)

diff --git a/state/batch.go b/state/batch.go
@@ -148,9 +148,10 @@ func (s *State) ProcessSequencerBatch(ctx context.Context, batchNumber uint64, b
 	}
 
 	txs := []types.Transaction{}
+	forkID := GetForkIDByBatchNumber(s.cfg.ForkIDIntervals, batchNumber)
 
 	if processBatchResponse.Responses != nil && len(processBatchResponse.Responses) > 0 {
-		txs, _, _, err = DecodeTxs(batchL2Data)
+		txs, _, _, err = DecodeTxs(batchL2Data, forkID)
 		if err != nil && !errors.Is(err, ErrInvalidData) {
 			return nil, err
 		}
@@ -195,7 +196,7 @@ func (s *State) ProcessBatch(ctx context.Context, request ProcessRequest, update
 		return nil, err
 	}
 
-	txs, _, effP, err := DecodeTxs(request.Transactions)
+	txs, _, effP, err := DecodeTxs(request.Transactions, forkID)
 	if err != nil && !errors.Is(err, ErrInvalidData) {
 		return nil, err
 	}
@@ -407,7 +408,8 @@ func (s *State) CloseBatch(ctx context.Context, receipt ProcessingReceipt, dbTx
 // ProcessAndStoreClosedBatch is used by the Synchronizer to add a closed batch into the data base
 func (s *State) ProcessAndStoreClosedBatch(ctx context.Context, processingCtx ProcessingContext, encodedTxs []byte, dbTx pgx.Tx, caller metrics.CallerLabel) (common.Hash, error) {
 	// Decode transactions
-	decodedTransactions, _, _, err := DecodeTxs(encodedTxs)
+	forkID := GetForkIDByBatchNumber(s.cfg.ForkIDIntervals, processingCtx.BatchNumber)
+	decodedTransactions, _, _, err := DecodeTxs(encodedTxs, forkID)
 	if err != nil && !errors.Is(err, ErrInvalidData) {
 		log.Debugf("error decoding transactions: %v", err)
 		return common.Hash{}, err

diff --git a/state/helper.go b/state/helper.go
@@ -12,6 +12,7 @@ import (
 )
 
 const (
+	forkID5      = 5
 	double       = 2
 	ether155V    = 27
 	etherPre155V = 35
@@ -30,7 +31,7 @@ const (
 )
 
 // EncodeTransactions RLP encodes the given transactions
-func EncodeTransactions(txs []types.Transaction, effectivePercentages []uint8) ([]byte, error) {
+func EncodeTransactions(txs []types.Transaction, effectivePercentages []uint8, forkID uint64) ([]byte, error) {
 	var batchL2Data []byte
 
 	for i, tx := range txs {
@@ -40,11 +41,13 @@ func EncodeTransactions(txs []types.Transaction, effectivePercentages []uint8) (
 		}
 		batchL2Data = append(batchL2Data, txData...)
 
-		effectivePercentageAsHex, err := hex.DecodeHex(fmt.Sprintf("%x", effectivePercentages[i]))
-		if err != nil {
-			return nil, err
+		if forkID >= forkID5 {
+			effectivePercentageAsHex, err := hex.DecodeHex(fmt.Sprintf("%x", effectivePercentages[i]))
+			if err != nil {
+				return nil, err
+			}
+			batchL2Data = append(batchL2Data, effectivePercentageAsHex...)
 		}
-		batchL2Data = append(batchL2Data, effectivePercentageAsHex...)
 	}
 
 	return batchL2Data, nil
@@ -109,8 +112,8 @@ func EncodeTransactionWithoutEffectivePercentage(tx types.Transaction) ([]byte,
 }
 
 // EncodeTransaction RLP encodes the given transaction
-func EncodeTransaction(tx types.Transaction, effectivePercentage uint8) ([]byte, error) {
-	return EncodeTransactions([]types.Transaction{tx}, []uint8{effectivePercentage})
+func EncodeTransaction(tx types.Transaction, effectivePercentage uint8, forkID uint64) ([]byte, error) {
+	return EncodeTransactions([]types.Transaction{tx}, []uint8{effectivePercentage}, forkID)
 }
 
 // EncodeUnsignedTransaction RLP encodes the given unsigned transaction
@@ -157,7 +160,7 @@ func EncodeUnsignedTransaction(tx types.Transaction, chainID uint64, forcedNonce
 }
 
 // DecodeTxs extracts Transactions for its encoded form
-func DecodeTxs(txsData []byte) ([]types.Transaction, []byte, []uint8, error) {
+func DecodeTxs(txsData []byte, forkID uint64) ([]types.Transaction, []byte, []uint8, error) {
 	// Process coded txs
 	var pos uint64
 	var txs []types.Transaction
@@ -196,7 +199,11 @@ func DecodeTxs(txsData []byte) ([]types.Transaction, []byte, []uint8, error) {
 			length = n + num - f7 // num - f7 is the header. For example 0xf7
 		}
 
-		endPos := pos + length + rLength + sLength + vLength + headerByteLength + efficiencyPercentageByteLength
+		endPos := pos + length + rLength + sLength + vLength + headerByteLength
+
+		if forkID >= forkID5 {
+			endPos += efficiencyPercentageByteLength
+		}
 
 		if endPos > txDataLength {
 			err := fmt.Errorf("endPos %d is bigger than txDataLength %d", endPos, txDataLength)
@@ -222,8 +229,11 @@ func DecodeTxs(txsData []byte) ([]types.Transaction, []byte, []uint8, error) {
 		rData := txsData[dataStart : dataStart+rLength]
 		sData := txsData[dataStart+rLength : dataStart+rLength+sLength]
 		vData := txsData[dataStart+rLength+sLength : dataStart+rLength+sLength+vLength]
-		efficiencyPercentage := txsData[dataStart+rLength+sLength+vLength : endPos]
-		efficiencyPercentages = append(efficiencyPercentages, uint8(efficiencyPercentage[0]))
+
+		if forkID >= forkID5 {
+			efficiencyPercentage := txsData[dataStart+rLength+sLength+vLength : endPos]
+			efficiencyPercentages = append(efficiencyPercentages, uint8(efficiencyPercentage[0]))
+		}
 
 		pos = endPos