SystemContract: support millisecond block generation

consensus/system_contract/consensus.go

@@ -226,15 +226,33 @@ 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())
+	// If RelaxedPeriod is enabled, always set the header timestamp to now
+	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,7 +89,10 @@
 }
 
 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

@@ -558,8 +558,23 @@ func (w *worker) newWork(now time.Time, parentHash common.Hash, reorging bool, r
 		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)
+		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{

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