Pullupstream/v0.5.6

cmd/run.go

@@ -29,7 +29,6 @@ import (
 	"github.com/0xPolygonHermez/zkevm-node/gasprice"
 	"github.com/0xPolygonHermez/zkevm-node/jsonrpc"
 	"github.com/0xPolygonHermez/zkevm-node/jsonrpc/client"
-	"github.com/0xPolygonHermez/zkevm-node/l1infotree"
 	"github.com/0xPolygonHermez/zkevm-node/log"
 	"github.com/0xPolygonHermez/zkevm-node/merkletree"
 	"github.com/0xPolygonHermez/zkevm-node/metrics"
@@ -122,20 +121,17 @@ func start(cliCtx *cli.Context) error {
 		log.Fatal(err)
 	}
 
-	st := newState(cliCtx.Context, c, l2ChainID, []state.ForkIDInterval{}, stateSqlDB, eventLog, needsExecutor, needsStateTree)
-
-	etherman, err := newEtherman(*c, st)
+	etherman, err := etherman.NewClient(c.Etherman, c.NetworkConfig.L1Config, nil)
 	if err != nil {
 		log.Fatal(err)
 	}
-	forkIDIntervals, err := forkIDIntervals(cliCtx.Context, st, etherman, c.NetworkConfig.Genesis.BlockNumber)
+	st, currentForkID := newState(cliCtx.Context, c, etherman, l2ChainID, stateSqlDB, eventLog, needsExecutor, needsStateTree, false)
+
+	etherman, err = newEtherman(*c, st)
 	if err != nil {
-		log.Fatal("error getting forkIDs. Error: ", err)
+		log.Fatal(err)
 	}
-	st.UpdateForkIDIntervalsInMemory(forkIDIntervals)
 
-	currentForkID := forkIDIntervals[len(forkIDIntervals)-1].ForkId
-	log.Infof("Fork ID read from POE SC = %v", forkIDIntervals[len(forkIDIntervals)-1].ForkId)
 	c.Aggregator.ChainID = l2ChainID
 	c.Sequencer.StreamServer.ChainID = l2ChainID
 	log.Infof("Chain ID read from POE SC = %v", l2ChainID)
@@ -220,6 +216,7 @@ func start(cliCtx *cli.Context) error {
 			for _, a := range cliCtx.StringSlice(config.FlagHTTPAPI) {
 				apis[a] = true
 			}
+			st, _ := newState(cliCtx.Context, c, etherman, l2ChainID, stateSqlDB, eventLog, needsExecutor, needsStateTree, true)
 			go runJSONRPCServer(*c, etherman, l2ChainID, poolInstance, st, apis)
 		case SYNCHRONIZER:
 			ev.Component = event.Component_Synchronizer
@@ -379,7 +376,7 @@ func runSynchronizer(cfg config.Config, etherman *etherman.Client, ethTxManagerS
 				log.Fatal("error getting trusted sequencer URI. Error: %v", err)
 			}
 		}
-		log.Debug("trustedSequencerURL ", trustedSequencerURL)
+		log.Info("trustedSequencerURL ", trustedSequencerURL)
 	}
 	zkEVMClient := client.NewClient(trustedSequencerURL)
 
@@ -543,9 +540,7 @@ func waitSignal(cancelFuncs []context.CancelFunc) {
 	}
 }
 
-func newState(ctx context.Context, c *config.Config, l2ChainID uint64, forkIDIntervals []state.ForkIDInterval, sqlDB *pgxpool.Pool, eventLog *event.EventLog, needsExecutor, needsStateTree bool) *state.State {
-	stateDb := pgstatestorage.NewPostgresStorage(c.State, sqlDB)
-
+func newState(ctx context.Context, c *config.Config, etherman *etherman.Client, l2ChainID uint64, sqlDB *pgxpool.Pool, eventLog *event.EventLog, needsExecutor, needsStateTree, avoidForkIDInMemory bool) (*state.State, uint64) {
 	// Executor
 	var executorClient executor.ExecutorServiceClient
 	if needsExecutor {
@@ -562,30 +557,35 @@ func newState(ctx context.Context, c *config.Config, l2ChainID uint64, forkIDInt
 	stateCfg := state.Config{
 		MaxCumulativeGasUsed:         c.State.Batch.Constraints.MaxCumulativeGasUsed,
 		ChainID:                      l2ChainID,
-		ForkIDIntervals:              forkIDIntervals,
+		ForkIDIntervals:              []state.ForkIDInterval{},
 		MaxResourceExhaustedAttempts: c.Executor.MaxResourceExhaustedAttempts,
 		WaitOnResourceExhaustion:     c.Executor.WaitOnResourceExhaustion,
 		ForkUpgradeBatchNumber:       c.ForkUpgradeBatchNumber,
 		ForkUpgradeNewForkId:         c.ForkUpgradeNewForkId,
 		MaxLogsCount:                 c.RPC.MaxLogsCount,
 		MaxLogsBlockRange:            c.RPC.MaxLogsBlockRange,
 		MaxNativeBlockHashBlockRange: c.RPC.MaxNativeBlockHashBlockRange,
+		AvoidForkIDInMemory:          avoidForkIDInMemory,
 	}
-	allLeaves, err := stateDb.GetAllL1InfoRootEntries(ctx, nil)
+	stateDb := pgstatestorage.NewPostgresStorage(stateCfg, sqlDB)
+	st := state.NewState(stateCfg, stateDb, executorClient, stateTree, eventLog, nil)
+	// This is to force to build cache, and check that DB is ok before starting the application
+	l1inforoot, err := st.GetCurrentL1InfoRoot(ctx, nil)
 	if err != nil {
-		log.Fatal("error getting all leaves. Error: ", err)
-	}
-	var leaves [][32]byte
-	for _, leaf := range allLeaves {
-		leaves = append(leaves, leaf.Hash())
+		log.Fatal("error getting current L1InfoRoot. Error: ", err)
 	}
-	mt, err := l1infotree.NewL1InfoTree(uint8(32), leaves) //nolint:gomnd
+	log.Infof("Starting L1InfoRoot: %v", l1inforoot.String())
+
+	forkIDIntervals, err := forkIDIntervals(ctx, st, etherman, c.NetworkConfig.Genesis.BlockNumber)
 	if err != nil {
-		log.Fatal("error creating L1InfoTree. Error: ", err)
+		log.Fatal("error getting forkIDs. Error: ", err)
 	}
+	st.UpdateForkIDIntervalsInMemory(forkIDIntervals)
+
+	currentForkID := forkIDIntervals[len(forkIDIntervals)-1].ForkId
+	log.Infof("Fork ID read from POE SC = %v", forkIDIntervals[len(forkIDIntervals)-1].ForkId)
 
-	st := state.NewState(stateCfg, stateDb, executorClient, stateTree, eventLog, mt)
-	return st
+	return st, currentForkID
 }
 
 func createPool(cfgPool pool.Config, constraintsCfg state.BatchConstraintsCfg, l2ChainID uint64, st *state.State, eventLog *event.EventLog) *pool.Pool {

config/config_test.go

@@ -42,7 +42,7 @@ func Test_Defaults(t *testing.T) {
 		},
 		{
 			path:          "Synchronizer.L1SynchronizationMode",
-			expectedValue: "parallel",
+			expectedValue: "sequential",
 		},
 		{
 			path:          "Synchronizer.L1ParallelSynchronization.MaxClients",
@@ -491,7 +491,7 @@ func Test_Defaults(t *testing.T) {
 		},
 		{
 			path:          "State.Batch.Constraints.MaxCumulativeGasUsed",
-			expectedValue: uint64(30000000),
+			expectedValue: uint64(1125899906842624),
 		},
 		{
 			path:          "State.Batch.Constraints.MaxKeccakHashes",

config/default.go

@@ -24,7 +24,7 @@ Outputs = ["stderr"]
 		[State.Batch.Constraints]
 		MaxTxsPerBatch = 300
 		MaxBatchBytesSize = 120000
-		MaxCumulativeGasUsed = 30000000
+		MaxCumulativeGasUsed = 1125899906842624
 		MaxKeccakHashes = 2145
 		MaxPoseidonHashes = 252357
 		MaxPoseidonPaddings = 135191
@@ -102,7 +102,7 @@ EnableHttpLog = true
 SyncInterval = "1s"
 SyncChunkSize = 100
 TrustedSequencerURL = "" # If it is empty or not specified, then the value is read from the smc
-L1SynchronizationMode = "parallel"
+L1SynchronizationMode = "sequential"
 	[Synchronizer.L1ParallelSynchronization]
 		MaxClients = 10
 		MaxPendingNoProcessedBlocks = 25

config/environments/local/local.node.config.toml

@@ -19,7 +19,7 @@ Outputs = ["stderr"]
 		[State.Batch.Constraints]
 		MaxTxsPerBatch = 300
 		MaxBatchBytesSize = 120000
-		MaxCumulativeGasUsed = 30000000
+		MaxCumulativeGasUsed = 1125899906842624
 		MaxKeccakHashes = 2145
 		MaxPoseidonHashes = 252357
 		MaxPoseidonPaddings = 135191

dataavailability/datacommittee/datacommittee_test.go

@@ -7,10 +7,10 @@ import (
 	"github.com/0xPolygonHermez/zkevm-node/etherman/smartcontracts/polygondatacommittee"
 	"github.com/0xPolygonHermez/zkevm-node/log"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethclient/simulated"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -63,7 +63,7 @@ func init() {
 // This function prepare the blockchain, the wallet with funds and deploy the smc
 func newTestingEnv(t *testing.T) (
 	dac *DataCommitteeBackend,
-	ethBackend *backends.SimulatedBackend,
+	ethBackend *simulated.Backend,
 	auth *bind.TransactOpts,
 	da *polygondatacommittee.Polygondatacommittee,
 ) {
@@ -87,7 +87,7 @@ func newTestingEnv(t *testing.T) (
 // must be 1337. The address that holds the auth will have an initial balance of 10 ETH
 func newSimulatedDacman(t *testing.T, auth *bind.TransactOpts) (
 	dacman *DataCommitteeBackend,
-	ethBackend *backends.SimulatedBackend,
+	ethBackend *simulated.Backend,
 	da *polygondatacommittee.Polygondatacommittee,
 	err error,
 ) {
@@ -105,17 +105,19 @@ func newSimulatedDacman(t *testing.T, auth *bind.TransactOpts) (
 		},
 	}
 	blockGasLimit := uint64(999999999999999999) //nolint:gomnd
-	client := backends.NewSimulatedBackend(genesisAlloc, blockGasLimit)
+	client := simulated.NewBackend(genesisAlloc, simulated.WithBlockGasLimit(blockGasLimit))
 
 	// DAC Setup
-	_, _, da, err = polygondatacommittee.DeployPolygondatacommittee(auth, client)
+	_, _, da, err = polygondatacommittee.DeployPolygondatacommittee(auth, client.Client())
 	if err != nil {
 		return &DataCommitteeBackend{}, nil, nil, err
 	}
+	client.Commit()
 	_, err = da.Initialize(auth)
 	if err != nil {
 		return &DataCommitteeBackend{}, nil, nil, err
 	}
+	client.Commit()
 	_, err = da.SetupCommittee(auth, big.NewInt(0), []string{}, []byte{})
 	if err != nil {
 		return &DataCommitteeBackend{}, nil, nil, err

db/migrations/state/0009.sql

@@ -2,6 +2,8 @@
 ALTER TABLE IF EXISTS state.fork_id DROP CONSTRAINT IF EXISTS fork_id_block_num_fkey;
 
 -- +migrate Down
+DELETE FROM state.fork_id f
+ WHERE NOT EXISTS(SELECT 1 FROM state.block b WHERE b.block_num = f.block_num);
+
 ALTER TABLE IF EXISTS state.fork_id ADD CONSTRAINT fork_id_block_num_fkey
-FOREIGN KEY(block_num)
-REFERENCES state.block (block_num) ON DELETE CASCADE;
+FOREIGN KEY(block_num) REFERENCES state.block (block_num) ON DELETE CASCADE;

docker-compose.yml

@@ -107,7 +107,7 @@ services:
   zkevm-prover:
     container_name: zkevm-prover
     restart: unless-stopped
-    image: hermeznetwork/zkevm-prover:v4.0.2
+    image: hermeznetwork/zkevm-prover:v4.0.4
     depends_on:
       zkevm-state-db:
         condition: service_healthy