fix

cmd/run.go

@@ -2,16 +2,10 @@ package main
 
 import (
 	"context"
+	"crypto/ecdsa"
 	"errors"
 	"fmt"
-	"net"
-	"net/http"
-	"net/http/pprof"
-	"os"
-	"os/signal"
-	"runtime"
-	"time"
-
+	dataCommitteeClient "github.com/0xPolygon/cdk-data-availability/client"
 	datastreamerlog "github.com/0xPolygonHermez/zkevm-data-streamer/log"
 	"github.com/0xPolygonHermez/zkevm-node"
 	"github.com/0xPolygonHermez/zkevm-node/aggregator"
@@ -35,9 +29,17 @@ import (
 	"github.com/0xPolygonHermez/zkevm-node/state"
 	"github.com/0xPolygonHermez/zkevm-node/state/runtime/executor"
 	"github.com/0xPolygonHermez/zkevm-node/synchronizer"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/jackc/pgx/v4/pgxpool"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"github.com/urfave/cli/v2"
+	"net"
+	"net/http"
+	"net/http/pprof"
+	"os"
+	"os/signal"
+	"runtime"
+	"time"
 )
 
 func start(cliCtx *cli.Context) error {
@@ -316,7 +318,7 @@ func runSynchronizer(cfg config.Config, etherman *etherman.Client, ethTxManagerS
 	etm := ethtxmanager.New(cfg.EthTxManager, etherman, ethTxManagerStorage, st)
 	sy, err := synchronizer.NewSynchronizer(
 		cfg.IsTrustedSequencer, etherman, etherManForL1, st, pool, etm,
-		zkEVMClient, eventLog, cfg.NetworkConfig.Genesis, cfg.Synchronizer, cfg.Log.Environment == "development",
+		zkEVMClient, eventLog, cfg.NetworkConfig.Genesis, cfg.Synchronizer, &dataCommitteeClient.ClientFactory{}, cfg.Log.Environment == "development",
 	)
 	if err != nil {
 		log.Fatal(err)
@@ -409,17 +411,27 @@ func createSequenceSender(cfg config.Config, pool *pool.Pool, etmStorage *ethtxm
 		log.Fatal(err)
 	}
 
-	auth, err := etherman.LoadAuthFromKeyStore(cfg.SequenceSender.PrivateKey.Path, cfg.SequenceSender.PrivateKey.Password)
+	var seqPrivKey *ecdsa.PrivateKey
+	auth, pk, err := etherman.LoadAuthFromKeyStore(cfg.SequenceSender.PrivateKey.Path, cfg.SequenceSender.PrivateKey.Password)
 	if err != nil {
 		log.Fatal(err)
 	}
+	log.Infof("from pk %s, from sender %s", crypto.PubkeyToAddress(pk.PublicKey), cfg.SequenceSender.SenderAddress.String())
+	if crypto.PubkeyToAddress(pk.PublicKey) == cfg.SequenceSender.SenderAddress {
+		seqPrivKey = pk
+	}
+
+	if seqPrivKey == nil {
+		log.Fatal("Sequencer private key not found")
+	}
+
 	cfg.SequenceSender.SenderAddress = auth.From
 
 	cfg.SequenceSender.ForkUpgradeBatchNumber = cfg.ForkUpgradeBatchNumber
 
 	ethTxManager := ethtxmanager.New(cfg.EthTxManager, etherman, etmStorage, st)
 
-	seqSender, err := sequencesender.New(cfg.SequenceSender, st, etherman, ethTxManager, eventLog)
+	seqSender, err := sequencesender.New(cfg.SequenceSender, st, etherman, ethTxManager, eventLog, seqPrivKey)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -512,7 +524,7 @@ func createEthTxManager(cfg config.Config, etmStorage *ethtxmanager.PostgresStor
 	}
 
 	for _, privateKey := range cfg.EthTxManager.PrivateKeys {
-		_, err := etherman.LoadAuthFromKeyStore(privateKey.Path, privateKey.Password)
+		_, _, err := etherman.LoadAuthFromKeyStore(privateKey.Path, privateKey.Password)
 		if err != nil {
 			log.Fatal(err)
 		}

go.mod

@@ -1,8 +1,9 @@
 module github.com/0xPolygonHermez/zkevm-node
 
-go 1.21
+go 1.19
 
 require (
+	github.com/0xPolygon/cdk-data-availability v0.0.0-20230830141533-4064ada790a6
 	github.com/0xPolygonHermez/zkevm-data-streamer v0.1.11
 	github.com/didip/tollbooth/v6 v6.1.2
 	github.com/dop251/goja v0.0.0-20230806174421-c933cf95e127
@@ -24,7 +25,7 @@ require (
 	github.com/spf13/afero v1.10.0
 	github.com/spf13/viper v1.17.0
 	github.com/stretchr/testify v1.8.4
-	github.com/umbracle/ethgo v0.1.3
+	github.com/umbracle/ethgo v0.1.4-0.20230712173909-df37dddf16f0
 	github.com/urfave/cli/v2 v2.25.7
 	go.uber.org/zap v1.26.0
 	golang.org/x/crypto v0.14.0
@@ -111,6 +112,7 @@ require (
 	github.com/mattn/go-isatty v0.0.17 // indirect
 	github.com/mattn/go-runewidth v0.0.9 // indirect
 	github.com/matttproud/golang_protobuf_extensions/v2 v2.0.0 // indirect
+	github.com/miguelmota/go-solidity-sha3 v0.1.1 // indirect
 	github.com/mmcloughlin/addchain v0.4.0 // indirect
 	github.com/olekukonko/tablewriter v0.0.5 // indirect
 	github.com/pelletier/go-toml/v2 v2.1.0 // indirect
@@ -166,3 +168,7 @@ require (
 	github.com/prometheus/client_golang v1.17.0
 	golang.org/x/exp v0.0.0-20230905200255-921286631fa9
 )
+
+replace github.com/0xPolygon/cdk-data-availability => github.com/okx/cdk-data-availability v0.0.1-dac.0.20230913020111-2ec48291d6db
+
+replace github.com/0xPolygonHermez/zkevm-node => ./

sequencer/interfaces.go

@@ -5,7 +5,6 @@ import (
 	"math/big"
 	"time"
 
-	ethmanTypes "github.com/0xPolygonHermez/zkevm-node/etherman/types"
 	"github.com/0xPolygonHermez/zkevm-node/pool"
 	"github.com/0xPolygonHermez/zkevm-node/state"
 	"github.com/0xPolygonHermez/zkevm-node/state/metrics"
@@ -34,13 +33,11 @@ type txPool interface {
 
 // etherman contains the methods required to interact with ethereum.
 type etherman interface {
-	EstimateGasSequenceBatches(sender common.Address, sequences []ethmanTypes.Sequence, l2CoinBase common.Address) (*types.Transaction, error)
 	GetSendSequenceFee(numBatches uint64) (*big.Int, error)
 	TrustedSequencer() (common.Address, error)
 	GetLatestBatchNumber() (uint64, error)
 	GetLastBatchTimestamp() (uint64, error)
 	GetLatestBlockTimestamp(ctx context.Context) (uint64, error)
-	BuildSequenceBatchesTxData(sender common.Address, sequences []ethmanTypes.Sequence, l2CoinBase common.Address) (to *common.Address, data []byte, err error)
 	GetLatestBlockNumber(ctx context.Context) (uint64, error)
 }
 

sequencesender/sequencesender.go

@@ -2,6 +2,7 @@ package sequencesender
 
 import (
 	"context"
+	"crypto/ecdsa"
 	"errors"
 	"fmt"
 	"time"
@@ -13,7 +14,6 @@ import (
 	"github.com/0xPolygonHermez/zkevm-node/log"
 	"github.com/0xPolygonHermez/zkevm-node/sequencer/metrics"
 	"github.com/0xPolygonHermez/zkevm-node/state"
-	ethTypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/jackc/pgx/v4"
 )
 
@@ -32,20 +32,22 @@ var (
 // SequenceSender represents a sequence sender
 type SequenceSender struct {
 	cfg          Config
+	privKey      *ecdsa.PrivateKey
 	state        stateInterface
 	ethTxManager ethTxManager
 	etherman     etherman
 	eventLog     *event.EventLog
 }
 
 // New inits sequence sender
-func New(cfg Config, state stateInterface, etherman etherman, manager ethTxManager, eventLog *event.EventLog) (*SequenceSender, error) {
+func New(cfg Config, state stateInterface, etherman etherman, manager ethTxManager, eventLog *event.EventLog, privKey *ecdsa.PrivateKey) (*SequenceSender, error) {
 	return &SequenceSender{
 		cfg:          cfg,
 		state:        state,
 		etherman:     etherman,
 		ethTxManager: manager,
 		eventLog:     eventLog,
+		privKey:      privKey,
 	}, nil
 }
 
@@ -107,7 +109,12 @@ func (s *SequenceSender) tryToSendSequence(ctx context.Context, ticker *time.Tic
 	metrics.SequencesSentToL1(float64(sequenceCount))
 
 	// add sequence to be monitored
-	to, data, err := s.etherman.BuildSequenceBatchesTxData(s.cfg.SenderAddress, sequences, s.cfg.L2Coinbase)
+	signaturesAndAddrs, err := s.getSignaturesAndAddrsFromDataCommittee(ctx, sequences)
+	if err != nil {
+		log.Error("error getting signatures and addresses from the data committee: ", err)
+		return
+	}
+	to, data, err := s.etherman.BuildSequenceBatchesTxData(s.cfg.SenderAddress, sequences, s.cfg.L2Coinbase, signaturesAndAddrs)
 	if err != nil {
 		log.Error("error estimating new sequenceBatches to add to eth tx manager: ", err)
 		return
@@ -136,8 +143,6 @@ func (s *SequenceSender) getSequencesToSend(ctx context.Context) ([]types.Sequen
 	sequences := []types.Sequence{}
 	// var estimatedGas uint64
 
-	var tx *ethTypes.Transaction
-
 	// Add sequences until too big for a single L1 tx or last batch is reached
 	for {
 		//Check if the next batch belongs to a new forkid, in this case we need to stop sequencing as we need to
@@ -177,28 +182,9 @@ func (s *SequenceSender) getSequencesToSend(ctx context.Context) ([]types.Sequen
 		}
 
 		sequences = append(sequences, seq)
-		// Check if can be send
-		tx, err = s.etherman.EstimateGasSequenceBatches(s.cfg.SenderAddress, sequences, s.cfg.L2Coinbase)
-		if err == nil && tx.Size() > s.cfg.MaxTxSizeForL1 {
-			metrics.SequencesOvesizedDataError()
-			log.Infof("oversized Data on TX oldHash %s (txSize %d > %d)", tx.Hash(), tx.Size(), s.cfg.MaxTxSizeForL1)
-			err = ErrOversizedData
-		}
-		if err != nil {
-			log.Infof("Handling estimage gas send sequence error: %v", err)
-			sequences, err = s.handleEstimateGasSendSequenceErr(ctx, sequences, currentBatchNumToSequence, err)
-			if sequences != nil {
-				// Handling the error gracefully, re-processing the sequence as a sanity check
-				_, err = s.etherman.EstimateGasSequenceBatches(s.cfg.SenderAddress, sequences, s.cfg.L2Coinbase)
-				return sequences, err
-			}
-			return sequences, err
-		}
-		// estimatedGas = tx.Gas()
+		if len(sequences) == int(s.cfg.MaxBatchesForL1) {
+			log.Info("sequence should be sent to L1, because MaxBatchesForL1 (%d) has been reached", s.cfg.MaxBatchesForL1)
 
-		//Check if the current batch is the last before a change to a new forkid, in this case we need to close and send the sequence to L1
-		if (s.cfg.ForkUpgradeBatchNumber != 0) && (currentBatchNumToSequence == (s.cfg.ForkUpgradeBatchNumber)) {
-			log.Infof("sequence should be sent to L1, as we have reached the batch %d from which a new forkid is applied (upgrade)", s.cfg.ForkUpgradeBatchNumber)
 			return sequences, nil
 		}
 
@@ -229,72 +215,6 @@ func (s *SequenceSender) getSequencesToSend(ctx context.Context) ([]types.Sequen
 	return nil, nil
 }
 
-// handleEstimateGasSendSequenceErr handles an error on the estimate gas. It will return:
-// nil, error: impossible to handle gracefully
-// sequence, nil: handled gracefully. Potentially manipulating the sequences
-// nil, nil: a situation that requires waiting
-func (s *SequenceSender) handleEstimateGasSendSequenceErr(
-	ctx context.Context,
-	sequences []types.Sequence,
-	currentBatchNumToSequence uint64,
-	err error,
-) ([]types.Sequence, error) {
-	// Insufficient allowance
-	if errors.Is(err, ethman.ErrInsufficientAllowance) {
-		return nil, err
-	}
-	if isDataForEthTxTooBig(err) {
-		// Remove the latest item and send the sequences
-		log.Infof(
-			"Done building sequences, selected batches to %d. Batch %d caused the L1 tx to be too big",
-			currentBatchNumToSequence-1, currentBatchNumToSequence,
-		)
-		sequences = sequences[:len(sequences)-1]
-		return sequences, nil
-	}
-
-	// while estimating gas a new block is not created and the POE SC may return
-	// an error regarding timestamp verification, this must be handled
-	if errors.Is(err, ethman.ErrTimestampMustBeInsideRange) {
-		// query the sc about the value of its lastTimestamp variable
-		lastTimestamp, err := s.etherman.GetLastBatchTimestamp()
-		if err != nil {
-			return nil, err
-		}
-		// check POE SC lastTimestamp against sequences' one
-		for _, seq := range sequences {
-			if seq.Timestamp < int64(lastTimestamp) {
-				// TODO: gracefully handle this situation by creating an L2 reorg
-				log.Fatalf("sequence timestamp %d is < POE SC lastTimestamp %d", seq.Timestamp, lastTimestamp)
-			}
-			lastTimestamp = uint64(seq.Timestamp)
-		}
-		blockTimestamp, err := s.etherman.GetLatestBlockTimestamp(ctx)
-		if err != nil {
-			log.Error("error getting block timestamp: ", err)
-		}
-		log.Debugf("block.timestamp: %d is smaller than seq.Timestamp: %d. A new block must be mined in L1 before the gas can be estimated.", blockTimestamp, sequences[0].Timestamp)
-		return nil, nil
-	}
-
-	// Unknown error
-	if len(sequences) == 1 {
-		// TODO: gracefully handle this situation by creating an L2 reorg
-		log.Errorf(
-			"Error when estimating gas for BatchNum %d (alone in the sequences): %v",
-			currentBatchNumToSequence, err,
-		)
-	}
-	// Remove the latest item and send the sequences
-	log.Infof(
-		"Done building sequences, selected batches to %d. Batch %d excluded due to unknown error: %v",
-		currentBatchNumToSequence, currentBatchNumToSequence+1, err,
-	)
-	sequences = sequences[:len(sequences)-1]
-
-	return sequences, nil
-}
-
 func isDataForEthTxTooBig(err error) bool {
 	return errors.Is(err, ethman.ErrGasRequiredExceedsAllowance) ||
 		errors.Is(err, ErrOversizedData) ||

state/pgstatestorage_test.go

@@ -967,3 +967,30 @@ func TestGetNativeBlockHashesInRange(t *testing.T) {
 
 	require.NoError(t, dbTx.Commit(ctx))
 }
+
+func TestGetBatchL2DataByNumber(t *testing.T) {
+	// Init database instance
+	initOrResetDB()
+	ctx := context.Background()
+	tx, err := testState.BeginStateTransaction(ctx)
+	require.NoError(t, err)
+	defer func() { require.NoError(t, tx.Commit(ctx)) }()
+
+	// empty case
+	var batchNum uint64 = 4
+	const openBatchSQL = "INSERT INTO state.batch (batch_num, raw_txs_data) VALUES ($1, $2)"
+	_, err = tx.Exec(ctx, openBatchSQL, batchNum, nil)
+	require.NoError(t, err)
+	data, err := testState.GetBatchL2DataByNumber(ctx, batchNum, tx)
+	require.NoError(t, err)
+	assert.Nil(t, data)
+
+	// not empty case
+	expectedData := []byte("foo bar")
+	batchNum = 5
+	_, err = tx.Exec(ctx, openBatchSQL, batchNum, expectedData)
+	require.NoError(t, err)
+	actualData, err := testState.GetBatchL2DataByNumber(ctx, batchNum, tx)
+	require.NoError(t, err)
+	assert.Equal(t, expectedData, actualData)
+}