params: define PasteurTime (bnb-chain#3552)

allformless · web-flow · commit a09636225f31 · 2026-02-09T11:18:54.000+08:00
diff --git a/cmd/geth/chaincmd.go b/cmd/geth/chaincmd.go
@@ -75,6 +75,7 @@ var (
 			utils.OverrideMendel,
 			utils.OverrideBPO1,
 			utils.OverrideBPO2,
+			utils.OverridePasteur,
 			utils.OverrideVerkle,
 			// utils.MultiDataBaseFlag,
 		}, utils.DatabaseFlags),
@@ -365,6 +366,10 @@ func initGenesis(ctx *cli.Context) error {
 		v := ctx.Uint64(utils.OverrideBPO2.Name)
 		overrides.OverrideBPO2 = &v
 	}
+	if ctx.IsSet(utils.OverridePasteur.Name) {
+		v := ctx.Uint64(utils.OverridePasteur.Name)
+		overrides.OverridePasteur = &v
+	}
 	if ctx.IsSet(utils.OverrideVerkle.Name) {
 		v := ctx.Uint64(utils.OverrideVerkle.Name)
 		overrides.OverrideVerkle = &v
diff --git a/cmd/geth/config.go b/cmd/geth/config.go
@@ -286,6 +286,10 @@ func makeFullNode(ctx *cli.Context) (*node.Node, ethapi.Backend) {
 		v := ctx.Uint64(utils.OverrideBPO2.Name)
 		cfg.Eth.OverrideBPO2 = &v
 	}
+	if ctx.IsSet(utils.OverridePasteur.Name) {
+		v := ctx.Uint64(utils.OverridePasteur.Name)
+		cfg.Eth.OverridePasteur = &v
+	}
 	if ctx.IsSet(utils.OverrideVerkle.Name) {
 		v := ctx.Uint64(utils.OverrideVerkle.Name)
 		cfg.Eth.OverrideVerkle = &v
diff --git a/cmd/geth/main.go b/cmd/geth/main.go
@@ -80,6 +80,7 @@ var (
 		utils.OverrideMendel,
 		utils.OverrideBPO1,
 		utils.OverrideBPO2,
+		utils.OverridePasteur,
 		utils.OverrideVerkle,
 		utils.OverrideGenesisFlag,
 		utils.OverrideFullImmutabilityThreshold,
diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go
@@ -334,6 +334,11 @@ var (
 		Usage:    "Manually specify the bpo2 fork timestamp, overriding the bundled setting",
 		Category: flags.EthCategory,
 	}
+	OverridePasteur = &cli.Uint64Flag{
+		Name:     "override.pasteur",
+		Usage:    "Manually specify the Pasteur fork timestamp, overriding the bundled setting",
+		Category: flags.EthCategory,
+	}
 	OverrideVerkle = &cli.Uint64Flag{
 		Name:     "override.verkle",
 		Usage:    "Manually specify the Verkle fork timestamp, overriding the bundled setting",
diff --git a/core/genesis.go b/core/genesis.go
@@ -275,6 +275,7 @@ type ChainOverrides struct {
 	OverrideMendel         *uint64
 	OverrideBPO1           *uint64
 	OverrideBPO2           *uint64
+	OverridePasteur        *uint64
 	OverrideVerkle         *uint64
 }
 
@@ -316,6 +317,9 @@ func (o *ChainOverrides) apply(cfg *params.ChainConfig) error {
 	if o.OverrideBPO2 != nil {
 		cfg.BPO2Time = o.OverrideBPO2
 	}
+	if o.OverridePasteur != nil {
+		cfg.PasteurTime = o.OverridePasteur
+	}
 	if o.OverrideVerkle != nil {
 		cfg.VerkleTime = o.OverrideVerkle
 	}
diff --git a/eth/backend.go b/eth/backend.go
@@ -269,6 +269,10 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
 		chainConfig.BPO2Time = config.OverrideBPO2
 		overrides.OverrideBPO2 = config.OverrideBPO2
 	}
+	if config.OverridePasteur != nil {
+		chainConfig.PasteurTime = config.OverridePasteur
+		overrides.OverridePasteur = config.OverridePasteur
+	}
 	if config.OverrideVerkle != nil {
 		chainConfig.VerkleTime = config.OverrideVerkle
 		overrides.OverrideVerkle = config.OverrideVerkle
diff --git a/eth/catalyst/simulated_beacon.go b/eth/catalyst/simulated_beacon.go
@@ -100,7 +100,7 @@ type SimulatedBeacon struct {
 
 func payloadVersion(config *params.ChainConfig, time uint64) engine.PayloadVersion {
 	switch config.LatestFork(time) {
-	case forks.BPO5, forks.BPO4, forks.BPO3, forks.BPO2, forks.BPO1, forks.Mendel, forks.Osaka,
+	case forks.Pasteur, forks.BPO5, forks.BPO4, forks.BPO3, forks.BPO2, forks.BPO1, forks.Mendel, forks.Osaka,
 		forks.Fermi, forks.Maxwell, forks.Lorentz, forks.Prague, forks.Cancun:
 		return engine.PayloadV3
 	case forks.Paris, forks.Shanghai:
diff --git a/eth/ethconfig/config.go b/eth/ethconfig/config.go
@@ -234,6 +234,9 @@ type Config struct {
 	// OverrideBPO2 (TODO: remove after the fork)
 	OverrideBPO2 *uint64 `toml:",omitempty"`
 
+	// OverridePasteur (TODO: remove after the fork)
+	OverridePasteur *uint64 `toml:",omitempty"`
+
 	// OverrideVerkle (TODO: remove after the fork)
 	OverrideVerkle *uint64 `toml:",omitempty"`
 
diff --git a/eth/ethconfig/gen_config.go b/eth/ethconfig/gen_config.go
diff --git a/eth/tracers/api.go b/eth/tracers/api.go
@@ -1303,6 +1303,18 @@ func overrideConfig(original *params.ChainConfig, override *params.ChainConfig)
 		copy.MendelTime = timestamp
 		canon = false
 	}
+	if timestamp := override.BPO1Time; timestamp != nil {
+		copy.BPO1Time = timestamp
+		canon = false
+	}
+	if timestamp := override.BPO2Time; timestamp != nil {
+		copy.BPO2Time = timestamp
+		canon = false
+	}
+	if timestamp := override.PasteurTime; timestamp != nil {
+		copy.PasteurTime = timestamp
+		canon = false
+	}
 	if timestamp := override.VerkleTime; timestamp != nil {
 		copy.VerkleTime = timestamp
 		canon = false
diff --git a/params/config.go b/params/config.go
@@ -252,6 +252,10 @@ var (
 		FermiTime:           newUint64(1768357800), // 2026-01-14 02:30:00 AM UTC
 		OsakaTime:           nil,
 		MendelTime:          nil,
+		BPO1Time:            nil, // will be skipped in BSC
+		BPO2Time:            nil, // will be skipped in BSC
+		AmsterdamTime:       nil,
+		PasteurTime:         nil,
 
 		Parlia: &ParliaConfig{},
 		BlobScheduleConfig: &BlobScheduleConfig{
@@ -302,6 +306,10 @@ var (
 		FermiTime:           newUint64(1762741500), // 2025-11-10 02:25:00 AM UTC
 		OsakaTime:           nil,
 		MendelTime:          nil,
+		BPO1Time:            nil, // will be skipped in BSC
+		BPO2Time:            nil, // will be skipped in BSC
+		AmsterdamTime:       nil,
+		PasteurTime:         nil,
 
 		Parlia: &ParliaConfig{},
 		BlobScheduleConfig: &BlobScheduleConfig{
@@ -350,10 +358,14 @@ var (
 		PragueTime:          newUint64(0),
 		LorentzTime:         newUint64(0),
 		MaxwellTime:         newUint64(0),
+		FermiTime:           newUint64(0),
 		// TODO: set them to `0` when passed on the mainnet
-		FermiTime:  nil,
-		OsakaTime:  nil,
-		MendelTime: nil,
+		OsakaTime:     nil,
+		MendelTime:    nil,
+		BPO1Time:      nil, // will be skipped in BSC
+		BPO2Time:      nil, // will be skipped in BSC
+		AmsterdamTime: nil,
+		PasteurTime:   nil,
 
 		Parlia: &ParliaConfig{},
 		BlobScheduleConfig: &BlobScheduleConfig{
@@ -716,6 +728,7 @@ type ChainConfig struct {
 	BPO4Time       *uint64 `json:"bpo4Time,omitempty"`       // BPO4 switch time (nil = no fork, 0 = already on bpo4)
 	BPO5Time       *uint64 `json:"bpo5Time,omitempty"`       // BPO5 switch time (nil = no fork, 0 = already on bpo5)
 	AmsterdamTime  *uint64 `json:"amsterdamTime,omitempty"`  // Amsterdam switch time (nil = no fork, 0 = already on amsterdam)
+	PasteurTime    *uint64 `json:"pasteurTime,omitempty"`    // PasteurTime switch time (nil = no fork, 0 = already on pasteurTime)
 	VerkleTime     *uint64 `json:"verkleTime,omitempty"`     // Verkle switch time (nil = no fork, 0 = already on verkle)
 
 	// TerminalTotalDifficulty is the amount of total difficulty reached by
@@ -902,10 +915,25 @@ func (c *ChainConfig) String() string {
 		MendelTime = big.NewInt(0).SetUint64(*c.MendelTime)
 	}
 
+	var BPO1Time *big.Int
+	if c.BPO1Time != nil {
+		BPO1Time = big.NewInt(0).SetUint64(*c.BPO1Time)
+	}
+
+	var BPO2Time *big.Int
+	if c.BPO2Time != nil {
+		BPO2Time = big.NewInt(0).SetUint64(*c.BPO2Time)
+	}
+
+	var PasteurTime *big.Int
+	if c.PasteurTime != nil {
+		PasteurTime = big.NewInt(0).SetUint64(*c.PasteurTime)
+	}
+
 	return fmt.Sprintf("{ChainID: %v, Engine: %v, Homestead: %v DAO: %v DAOSupport: %v EIP150: %v EIP155: %v EIP158: %v Byzantium: %v Constantinople: %v Petersburg: %v Istanbul: %v, Muir Glacier: %v, Ramanujan: %v, Niels: %v, "+
 		"MirrorSync: %v, Bruno: %v, Berlin: %v, YOLO v3: %v, CatalystBlock: %v, London: %v, ArrowGlacier: %v, MergeFork:%v, Euler: %v, Gibbs: %v, Nano: %v, Moran: %v, Planck: %v,Luban: %v, Plato: %v, Hertz: %v, Hertzfix: %v, "+
 		"ShanghaiTime: %v, KeplerTime: %v, FeynmanTime: %v, FeynmanFixTime: %v, CancunTime: %v, HaberTime: %v, HaberFixTime: %v, BohrTime: %v, PascalTime: %v, PragueTime: %v, LorentzTime: %v, MaxwellTime: %v, FermiTime: %v, "+
-		"OsakaTime: %v, MendelTime: %v}",
+		"OsakaTime: %v, MendelTime: %v, BPO1Time: %v, BPO2Time: %v, PasteurTime: %v}",
 		c.ChainID,
 		engine,
 		c.HomesteadBlock,
@@ -953,6 +981,9 @@ func (c *ChainConfig) String() string {
 		FermiTime,
 		OsakaTime,
 		MendelTime,
+		BPO1Time,
+		BPO2Time,
+		PasteurTime,
 	)
 }
 
@@ -1443,6 +1474,20 @@ func (c *ChainConfig) IsAmsterdam(num *big.Int, time uint64) bool {
 	return c.IsLondon(num) && isTimestampForked(c.AmsterdamTime, time)
 }
 
+// IsPasteur returns whether time is either equal to the Pasteur fork time or greater.
+func (c *ChainConfig) IsPasteur(num *big.Int, time uint64) bool {
+	return c.IsLondon(num) && isTimestampForked(c.PasteurTime, time)
+}
+
+// IsOnPasteur eturns whether currentBlockTime is either equal to the Pasteur fork time or greater firstly.
+func (c *ChainConfig) IsOnPasteur(currentBlockNumber *big.Int, lastBlockTime uint64, currentBlockTime uint64) bool {
+	lastBlockNumber := new(big.Int)
+	if currentBlockNumber.Cmp(big.NewInt(1)) >= 0 {
+		lastBlockNumber.Sub(currentBlockNumber, big.NewInt(1))
+	}
+	return !c.IsPasteur(lastBlockNumber, lastBlockTime) && c.IsPasteur(currentBlockNumber, currentBlockTime)
+}
+
 // IsVerkle returns whether time is either equal to the Verkle fork time or greater.
 func (c *ChainConfig) IsVerkle(num *big.Int, time uint64) bool {
 	return c.IsLondon(num) && isTimestampForked(c.VerkleTime, time)
@@ -1537,6 +1582,7 @@ func (c *ChainConfig) CheckConfigForkOrder() error {
 		{name: "bpo4", timestamp: c.BPO4Time, optional: true},
 		{name: "bpo5", timestamp: c.BPO5Time, optional: true},
 		{name: "amsterdam", timestamp: c.AmsterdamTime, optional: true},
+		{name: "pasteurTime", timestamp: c.PasteurTime, optional: true},
 	} {
 		if lastFork.name != "" {
 			switch {
@@ -1779,6 +1825,9 @@ func (c *ChainConfig) checkCompatible(newcfg *ChainConfig, headNumber *big.Int,
 	if isForkTimestampIncompatible(c.AmsterdamTime, newcfg.AmsterdamTime, headTimestamp) {
 		return newTimestampCompatError("Amsterdam fork timestamp", c.AmsterdamTime, newcfg.AmsterdamTime)
 	}
+	if isForkTimestampIncompatible(c.PasteurTime, newcfg.PasteurTime, headTimestamp) {
+		return newTimestampCompatError("Pasteur fork timestamp", c.PasteurTime, newcfg.PasteurTime)
+	}
 	return nil
 }
 
@@ -1799,6 +1848,8 @@ func (c *ChainConfig) LatestFork(time uint64) forks.Fork {
 	london := c.LondonBlock
 
 	switch {
+	case c.IsPasteur(london, time):
+		return forks.Pasteur
 	case c.IsAmsterdam(london, time):
 		return forks.Amsterdam
 	case c.IsBPO5(london, time):
@@ -1886,6 +1937,10 @@ func (c *ChainConfig) ActiveSystemContracts(time uint64) map[string]common.Addre
 // the fork isn't defined or isn't a time-based fork.
 func (c *ChainConfig) Timestamp(fork forks.Fork) *uint64 {
 	switch {
+	case fork == forks.Pasteur:
+		return c.PasteurTime
+	case fork == forks.Amsterdam:
+		return c.AmsterdamTime
 	case fork == forks.BPO5:
 		return c.BPO5Time
 	case fork == forks.BPO4:
@@ -2067,7 +2122,8 @@ type Rules struct {
 	IsHertzfix                                              bool
 	IsShanghai, IsKepler, IsFeynman, IsCancun, IsHaber      bool
 	IsBohr, IsPascal, IsPrague, IsLorentz, IsMaxwell        bool
-	IsFermi, IsOsaka, IsMendel, IsAmsterdam, IsVerkle       bool
+	IsFermi, IsOsaka, IsMendel                              bool
+	IsAmsterdam, IsPasteur, IsVerkle                        bool
 }
 
 // Rules ensures c's ChainID is not nil.
@@ -2114,6 +2170,7 @@ func (c *ChainConfig) Rules(num *big.Int, isMerge bool, timestamp uint64) Rules
 		IsOsaka:          (isMerge || c.IsInBSC()) && c.IsOsaka(num, timestamp),
 		IsMendel:         c.IsMendel(num, timestamp),
 		IsAmsterdam:      (isMerge || c.IsInBSC()) && c.IsAmsterdam(num, timestamp),
+		IsPasteur:        c.IsPasteur(num, timestamp),
 		IsVerkle:         c.IsVerkle(num, timestamp),
 		IsEIP4762:        isVerkle,
 	}
diff --git a/params/forks/forks.go b/params/forks/forks.go
@@ -45,6 +45,7 @@ const (
 	Fermi
 	Osaka
 	Mendel
+	Pasteur // BOP1 will be skipped in BSC, so let Pasteur be the next to Mendel
 	BPO1
 	BPO2
 	BPO3
@@ -93,4 +94,5 @@ var forkToString = map[Fork]string{
 	BPO4:             "BPO4",
 	BPO5:             "BPO5",
 	Amsterdam:        "Amsterdam",
+	Pasteur:          "Pasteur",
 }

Original file line number	Diff line number	Diff line change
`@@ -275,6 +275,7 @@ type ChainOverrides struct {`
`275`	`275`	`OverrideMendel *uint64`
`276`	`276`	`OverrideBPO1 *uint64`
`277`	`277`	`OverrideBPO2 *uint64`
	`278`	`+ OverridePasteur *uint64`
`278`	`279`	`OverrideVerkle *uint64`
`279`	`280`	`}`
`280`	`281`
`@@ -316,6 +317,9 @@ func (o ChainOverrides) apply(cfg params.ChainConfig) error {`
`316`	`317`	`if o.OverrideBPO2 != nil {`
`317`	`318`	`cfg.BPO2Time = o.OverrideBPO2`
`318`	`319`	`}`
	`320`	`+ if o.OverridePasteur != nil {`
	`321`	`+ cfg.PasteurTime = o.OverridePasteur`
	`322`	`+ }`
`319`	`323`	`if o.OverrideVerkle != nil {`
`320`	`324`	`cfg.VerkleTime = o.OverrideVerkle`
`321`	`325`	`}`