Rollup upgrade

contracts/contracts/l1/rollup/Rollup.sol

@@ -174,6 +174,15 @@ contract Rollup is IRollup, OwnableUpgradeable, PausableUpgradeable {
         emit UpdateProofRewardPercent(0, _proofRewardPercent);
     }
 
+    function initialize2(bytes32 _prevStateRoot) external reinitializer(2) {
+        require(_getInitializedVersion() == 2, "must have initialized!");
+        require(_prevStateRoot != bytes32(0), "can not set state root with bytes32(0)!");
+
+        if (committedStateRoots[lastCommittedBatchIndex] == bytes32(0)) {
+            committedStateRoots[lastCommittedBatchIndex] = _prevStateRoot;
+        }
+    }
+
     /************************
      * Restricted Functions *
      ************************/
@@ -185,6 +194,8 @@ contract Rollup is IRollup, OwnableUpgradeable, PausableUpgradeable {
 
         (uint256 memPtr, bytes32 _batchHash) = _loadBatchHeader(_batchHeader);
         uint256 _batchIndex = BatchHeaderCodecV0.getBatchIndex(memPtr);
+        // check batch index is 0
+        require(_batchIndex == 0, "invalid batch index");
         bytes32 _postStateRoot = BatchHeaderCodecV0.getPostStateHash(memPtr);
         require(_postStateRoot != bytes32(0), "zero state root");
         // check all fields except `dataHash` and `lastBlockHash` are zero

contracts/contracts/test/Rollup.t.sol

@@ -714,6 +714,15 @@ contract RollupTest is L1MessageBaseTest {
     function test_importGenesisBlock_succeeds() public {
         bytes memory batchHeader;
         bytes32 bytesData1 = bytes32(uint256(1));
+        // invalid batch index, revert
+        batchHeader = new bytes(249);
+        assembly {
+            mstore(add(batchHeader, add(0x20, 1)), shl(192, 1)) // batchIndex = 1
+        }
+        hevm.expectRevert("invalid batch index");
+        hevm.prank(multisig);
+        rollup.importGenesisBatch(batchHeader);
+
         // zero state root, revert
         batchHeader = new bytes(249);
         hevm.expectRevert("zero state root");

contracts/hardhat.config.ts

@@ -17,6 +17,7 @@ import "./tasks/proxy_upgrade"
 import "./tasks/staking_upgrade"
 import "./tasks/verifier_upgrade"
 import "./tasks/token_deploy"
+import "./tasks/mainnet_upgrade"
 import "./src/plugin"
 import * as process from "process";
 

contracts/tasks/mainnet_upgrade.ts

@@ -0,0 +1,25 @@
+import "@nomiclabs/hardhat-web3";
+import "@nomiclabs/hardhat-ethers";
+import "@nomiclabs/hardhat-waffle";
+
+import { task } from "hardhat/config";
+import { ContractFactoryName } from "../src/types";
+
+task("rollup-upgrade-hc")
+    .addParam("l2cid")
+    .addParam("prevStateRoot")
+    .setAction(async (taskArgs, hre) => {
+        const chainId = taskArgs.l2cid
+
+        const RollupFactoryName = ContractFactoryName.Rollup
+
+        const RollupFactory = await hre.ethers.getContractFactory(RollupFactoryName)
+        const rollupNewImpl = await RollupFactory.deploy(chainId)
+        await rollupNewImpl.deployed()
+        let blockNumber = await hre.ethers.provider.getBlockNumber()
+        console.log(`Rollup new impl deploy at ${rollupNewImpl.address} and height ${blockNumber}`)
+
+        console.log("initialize2 abi code: ", RollupFactory.interface.encodeFunctionData('initialize2', [
+            taskArgs.prevStateRoot,
+        ]))
+    })

tx-submitter/entry.go

@@ -16,6 +16,7 @@ import (
 	"morph-l2/tx-submitter/db"
 	"morph-l2/tx-submitter/event"
 	"morph-l2/tx-submitter/iface"
+	"morph-l2/tx-submitter/l1checker"
 	"morph-l2/tx-submitter/metrics"
 	"morph-l2/tx-submitter/services"
 	"morph-l2/tx-submitter/utils"
@@ -194,6 +195,9 @@ func Main() func(ctx *cli.Context) error {
 			return fmt.Errorf("failed to connect leveldb: %w", err)
 		}
 
+		// blockmonitor
+		bm := l1checker.NewBlockMonitor(cfg.BlockNotIncreasedThreshold, l1Client)
+
 		// new rollup service
 		sr := services.NewRollup(
 			ctx,
@@ -211,6 +215,7 @@ func Main() func(ctx *cli.Context) error {
 			rsaPriv,
 			rotator,
 			ldb,
+			bm,
 		)
 
 		// metrics

tx-submitter/flags/flags.go

@@ -298,6 +298,14 @@ var (
 		EnvVar: prefixEnvVar("LEVELDB_PATH_NAME"),
 		Value:  "submitter-leveldb",
 	}
+
+	// l1 block not incremented threshold
+	BlockNotIncreasedThreshold = cli.Int64Flag{
+		Name:   "block_not_increased_threshold",
+		Usage:  "The threshold for block not incremented",
+		Value:  5,
+		EnvVar: prefixEnvVar("BLOCK_NOT_INCREASED_THRESHOLD"),
+	}
 )
 
 var requiredFlags = []cli.Flag{
@@ -352,6 +360,7 @@ var optionalFlags = []cli.Flag{
 	StakingEventStoreFileFlag,
 	EventIndexStepFlag,
 	LeveldbPathNameFlag,
+	BlockNotIncreasedThreshold,
 }
 
 // Flags contains the list of configuration options available to the binary.

tx-submitter/l1checker/blockmonitor.go

@@ -0,0 +1,67 @@
+package l1checker
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"morph-l2/tx-submitter/iface"
+
+	"github.com/morph-l2/go-ethereum/log"
+)
+
+const blockTime = time.Second * 12
+
+type IBlockMonitor interface {
+	BlockNotIncreasedIn(time.Duration) bool
+}
+
+type BlockMonitor struct {
+	blockGenerateTime    time.Duration //12s for Dencun
+	latestBlockTime      time.Time
+	noGrowthBlockCntTime time.Duration
+	client               iface.L1Client
+	mu                   sync.Mutex
+}
+
+func NewBlockMonitor(notGrowthInBlocks int64, client iface.L1Client) *BlockMonitor {
+	return &BlockMonitor{
+		blockGenerateTime:    blockTime,
+		latestBlockTime:      time.Time{},
+		noGrowthBlockCntTime: time.Duration(notGrowthInBlocks) * blockTime,
+		client:               client,
+	}
+}
+
+func (m *BlockMonitor) StartMonitoring() {
+	ticker := time.NewTicker(m.blockGenerateTime)
+	for ; ; <-ticker.C {
+		header, err := m.client.HeaderByNumber(context.Background(), nil)
+		if err != nil {
+			log.Warn("failed to get block in blockmonitor", "error", err)
+			continue
+		}
+		m.SetLatestBlockTime(time.Unix(int64(header.Time), 0))
+	}
+}
+
+func (m *BlockMonitor) IsGrowth() bool {
+	t := m.GetLatestBlockTime()
+	if t.IsZero() {
+		log.Warn("latest block time is zero")
+		return false
+	}
+	return time.Since(t) < m.noGrowthBlockCntTime
+}
+
+func (m *BlockMonitor) SetLatestBlockTime(t time.Time) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.latestBlockTime = t
+}
+
+func (m *BlockMonitor) GetLatestBlockTime() time.Time {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return m.latestBlockTime
+}

tx-submitter/l1checker/blockmonitor_test.go

@@ -0,0 +1,23 @@
+package l1checker
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestIsGrowth(t *testing.T) {
+
+	blockCnt := int64(2)
+	monitor := NewBlockMonitor(blockCnt, nil)
+	monitor.latestBlockTime = time.Time{}
+	require.Equal(t, false, monitor.IsGrowth())
+
+	monitor.latestBlockTime = time.Now()
+	require.Equal(t, true, monitor.IsGrowth())
+
+	monitor.latestBlockTime = time.Now().Add(-monitor.noGrowthBlockCntTime)
+	require.Equal(t, false, monitor.IsGrowth())
+
+}

tx-submitter/services/rollup.go

@@ -30,6 +30,7 @@ import (
 	"morph-l2/tx-submitter/db"
 	"morph-l2/tx-submitter/event"
 	"morph-l2/tx-submitter/iface"
+	"morph-l2/tx-submitter/l1checker"
 	"morph-l2/tx-submitter/localpool"
 	"morph-l2/tx-submitter/metrics"
 	"morph-l2/tx-submitter/utils"
@@ -75,6 +76,7 @@ type Rollup struct {
 	collectedL1FeeSum float64
 	// batchcache
 	batchCache map[uint64]*eth.RPCRollupBatch
+	bm         *l1checker.BlockMonitor
 }
 
 func NewRollup(
@@ -93,6 +95,7 @@ func NewRollup(
 	rsaPriv *rsa.PrivateKey,
 	rotator *Rotator,
 	ldb *db.Db,
+	bm *l1checker.BlockMonitor,
 ) *Rollup {
 
 	return &Rollup{
@@ -113,6 +116,7 @@ func NewRollup(
 		externalRsaPriv: rsaPriv,
 		batchCache:      make(map[uint64]*eth.RPCRollupBatch),
 		ldb:             ldb,
+		bm:              bm,
 	}
 }
 
@@ -144,6 +148,10 @@ func (r *Rollup) Start() error {
 		return fmt.Errorf("init fee metrics sum failed: %w", err)
 	}
 
+	/// start services
+	// start l1 monitor
+	go r.bm.StartMonitoring()
+
 	// metrics
 	go utils.Loop(r.ctx, 10*time.Second, func() {
 
@@ -1090,6 +1098,10 @@ func (r *Rollup) SendTx(tx *types.Transaction) error {
 	if tx == nil {
 		return errors.New("nil tx")
 	}
+	// l1 health check
+	if !r.bm.IsGrowth() {
+		return fmt.Errorf("block not growth in %d blocks time", r.cfg.BlockNotIncreasedThreshold)
+	}
 
 	err := sendTx(r.L1Client, r.cfg.TxFeeLimit, tx)
 	if err != nil {

tx-submitter/utils/config.go

@@ -105,7 +105,8 @@ type Config struct {
 	// event indexer index step
 	EventIndexStep uint64
 	// leveldb path name
-	LeveldbPathName string
+	LeveldbPathName            string
+	BlockNotIncreasedThreshold int64
 }
 
 // NewConfig parses the DriverConfig from the provided flags or environment variables.
@@ -175,6 +176,8 @@ func NewConfig(ctx *cli.Context) (Config, error) {
 		EventIndexStep: ctx.GlobalUint64(flags.EventIndexStepFlag.Name),
 		// leveldb path name
 		LeveldbPathName: ctx.GlobalString(flags.LeveldbPathNameFlag.Name),
+		// BlockNotIncreasedThreshold
+		BlockNotIncreasedThreshold: ctx.GlobalInt64(flags.BlockNotIncreasedThreshold.Name),
 	}
 
 	return cfg, nil