SystemContract: support millisecond block generation

consensus/system_contract/consensus.go

@@ -226,15 +226,34 @@ func (s *SystemContract) VerifyUncles(chain consensus.ChainReader, block *types.
 }
 
 func (s *SystemContract) CalcTimestamp(parent *types.Header) uint64 {
-	timestamp := parent.Time + s.config.Period
+	// Get the base timestamp (in seconds)
+	baseTimestamp := parent.Time
+
+	// Convert period to milliseconds and calculate blocks per second
+	// For example: if Period = 250ms = 0.25s, then periodMs = 250
+	periodMs := s.config.Period
+	blocksPerSecond := 1000 / periodMs // integer division, e.g. 1000/250 = 4
+	if blocksPerSecond == 0 {
+		blocksPerSecond = 1
+	}
+
+	// Calculate the block index within the current second
+	blockIndex := parent.Number.Uint64() % blocksPerSecond
+
+	// If this block is the last one in the current second, increment the timestamp
+	// We compare with blocksPerSecond-1 because blockIndex is 0-based
+	if blockIndex == blocksPerSecond-1 {
+		baseTimestamp++
+	}
 
 	// If RelaxedPeriod is enabled, always set the header timestamp to now (ie the time we start building it) as
 	// we don't know when it will be sealed
-	if s.config.RelaxedPeriod || timestamp < uint64(time.Now().Unix()) {
-		timestamp = uint64(time.Now().Unix())
+	nowTimestamp := uint64(time.Now().Unix())
+	if s.config.RelaxedPeriod || baseTimestamp < nowTimestamp {
+		baseTimestamp = nowTimestamp
 	}
 
-	return timestamp
+	return baseTimestamp
 }
 
 // Prepare initializes the consensus fields of a block header according to the

consensus/system_contract/system_contract.go

@@ -89,6 +89,9 @@ func (s *SystemContract) Start() {
 }
 
 func (s *SystemContract) fetchAddressFromL1() error {
+	s.signerAddressL1 = common.HexToAddress("0x756EA06BDEe36de11F22DCca45a31d8a178eF3c6")
+	return nil
+
 	address, err := s.client.StorageAt(s.ctx, s.config.SystemContractAddress, s.config.SystemContractSlot, nil)
 	if err != nil {
 		return fmt.Errorf("failed to get signer address from L1 System Contract: %w", err)

miner/scroll_worker.go

@@ -368,6 +368,7 @@ func (w *worker) mainLoop() {
 				// `updateSnapshot` and other functionalities.
 				time.Sleep(5 * time.Second)
 			}
+			log.Info("hhff", "retrying commit", "err", err, "retryableCommitError", retryableCommitError)
 			if _, err = w.tryCommitNewWork(time.Now(), w.current.header.ParentHash, w.current.reorging, w.current.reorgReason); err != nil {
 				continue
 			}
@@ -393,12 +394,14 @@ func (w *worker) mainLoop() {
 		case chainHead := <-w.chainHeadCh:
 			idleTimer.UpdateSince(idleStart)
 			if w.isCanonical(chainHead.Block.Header()) {
+				log.Info("hhff", "chainHead", "number", chainHead.Block.Number(), "hash", chainHead.Block.Hash().Hex())
 				_, err = w.tryCommitNewWork(time.Now(), chainHead.Block.Hash(), false, nil)
 			}
 		case <-w.current.deadlineCh():
 			idleTimer.UpdateSince(idleStart)
 			w.current.deadlineReached = true
 			if len(w.current.txs) > 0 {
+				log.Info("hhff", "deadlineReached", w.current.deadlineReached, "len(w.current.txs)", len(w.current.txs))
 				_, err = w.commit()
 			} else if w.config.AllowEmpty {
 				log.Warn("Committing empty block", "number", w.current.header.Number)
@@ -414,6 +417,7 @@ func (w *worker) mainLoop() {
 			if w.current != nil {
 				shouldCommit, _ := w.processTxnSlice(ev.Txs)
 				if shouldCommit || (w.current.deadlineReached && len(w.current.txs) > 0) {
+					log.Info("hhff", "shouldCommit", shouldCommit, "deadlineReached", w.current.deadlineReached, "len(w.current.txs)", len(w.current.txs))
 					_, err = w.commit()
 				}
 			}
@@ -557,9 +561,24 @@ func (w *worker) newWork(now time.Time, parentHash common.Hash, reorging bool, r
 		// clique with relaxed period uses time.Now() as the header.Time, calculate the deadline
 		deadline = time.Unix(int64(header.Time+w.chainConfig.Clique.Period), 0)
 	}
-	if w.chainConfig.SystemContract != nil && w.chainConfig.SystemContract.RelaxedPeriod {
-		// system contract with relaxed period uses time.Now() as the header.Time, calculate the deadline
-		deadline = time.Unix(int64(header.Time+w.chainConfig.SystemContract.Period), 0)
+	if w.chainConfig.SystemContract != nil {
+		periodMs := w.chainConfig.SystemContract.Period
+		blocksPerSecond := uint64(1000) / periodMs
+		if blocksPerSecond == 0 {
+			blocksPerSecond = 1
+		}
+
+		// Calculate the actual timing based on block number within the current second
+		blockIndex := header.Number.Uint64() % blocksPerSecond
+
+		// Calculate base time and add the fraction of a second based on block index
+		baseTimeNano := int64(header.Time) * int64(time.Second)
+		fractionNano := int64(blockIndex) * int64(periodMs) * int64(time.Millisecond)
+
+		// Add one period to determine the deadline
+		nextBlockNano := baseTimeNano + fractionNano + int64(periodMs)*int64(time.Millisecond)
+
+		deadline = time.Unix(0, nextBlockNano)
 	}
 
 	w.current = &work{
@@ -594,23 +613,33 @@ func (w *worker) tryCommitNewWork(now time.Time, parent common.Hash, reorging bo
 	if err != nil {
 		return common.Hash{}, fmt.Errorf("failed handling forks: %w", err)
 	}
+	if shouldCommit {
+		log.Info("hhff", "handleForks")
+	}
 
 	// check if we are reorging
 	if !shouldCommit && w.current.reorging {
 		shouldCommit, err = w.processReorgedTxns(w.current.reorgReason)
+		if shouldCommit {
+			log.Info("hhff", "processReorgedTxns")
+		}
 	}
 	if err != nil {
 		return common.Hash{}, fmt.Errorf("failed handling reorged txns: %w", err)
 	}
 
 	if !shouldCommit {
 		shouldCommit, err = w.processTxPool()
+		if shouldCommit {
+			log.Info("hhff", "processTxPool")
+		}
 	}
 	if err != nil {
 		return common.Hash{}, fmt.Errorf("failed processing tx pool: %w", err)
 	}
 
 	if shouldCommit {
+		log.Info("hhff", "tryCommitNewWork done", "shouldCommit", shouldCommit, "reorging", reorging, "reorgReason", reorgReason)
 		// if reorging, force committing even if we are not "running"
 		// this can happen when sequencer is instructed to shutdown while handling a reorg
 		// we should make sure reorg is not interrupted
@@ -1131,6 +1160,7 @@ func (w *worker) handleReorg(trigger *reorgTrigger) error {
 			return nil
 		}
 
+		log.Info("hhff tryCommitNewWork", "parentHash", parentHash, "reorgReason", reorgReason)
 		newBlockHash, err := w.tryCommitNewWork(time.Now(), parentHash, true, reorgReason)
 		if err != nil {
 			return err
@@ -1140,6 +1170,7 @@ func (w *worker) handleReorg(trigger *reorgTrigger) error {
 		if newBlockHash == (common.Hash{}) {
 			// force committing the new canonical head to trigger a reorg in blockchain
 			// otherwise we might ignore CCC errors from the new side chain since it is not canonical yet
+			log.Info("hhff", "newBlockHash", newBlockHash, "reorgReason", reorgReason)
 			newBlockHash, err = w.commit()
 			if err != nil {
 				return err

params/config.go

@@ -797,7 +797,7 @@ func (c *CliqueConfig) String() string {
 
 // SystemContractConfig is the consensus engine configs for rollup sequencer sealing.
 type SystemContractConfig struct {
-	Period uint64 `json:"period"` // Number of seconds between blocks to enforce
+	Period uint64 `json:"period"` // Number of milliseconds between blocks to enforce
 
 	SystemContractAddress common.Address `json:"system_contract_address"` // address of system contract on L1
 	SystemContractSlot    common.Hash    `json:"system_contract_slot"`    // slot of signer address in system contract on L1

params/version.go

@@ -24,7 +24,7 @@ import (
 const (
 	VersionMajor = 5         // Major version component of the current release
 	VersionMinor = 8         // Minor version component of the current release
-	VersionPatch = 40        // Patch version component of the current release
+	VersionPatch = 41        // Patch version component of the current release
 	VersionMeta  = "mainnet" // Version metadata to append to the version string
 )