Add Jovian activation configuration

op-batcher/batcher/sync_actions.go

@@ -33,7 +33,7 @@ func (s syncActions) String() string {
 // computeSyncActions determines the actions that should be taken based on the inputs provided. The inputs are the current
 // state of the batcher (blocks and channels), the new sync status, and the previous current L1 block. The actions are returned
 // in a struct specifying the number of blocks to prune, the number of channels to prune, whether to wait for node sync, the block
-// range to load into the local state, and whether to clear the state entirely. Returns an boolean indicating if the sequencer is out of sync.
+// range to load into the local state, and whether to clear the state entirely. Returns a boolean indicating if the sequencer is out of sync.
 func computeSyncActions[T channelStatuser](newSyncStatus eth.SyncStatus, prevCurrentL1 eth.L1BlockRef, blocks queue.Queue[*types.Block], channels []T, l log.Logger) (syncActions, bool) {
 
 	// PART 1: Initial checks on the sync status

op-chain-ops/genesis/config.go

@@ -351,6 +351,9 @@ type UpgradeScheduleDeployConfig struct {
 	// L2GenesisIsthmusTimeOffset is the number of seconds after genesis block that the Isthmus hard fork activates.
 	// Set it to 0 to activate at genesis. Nil to disable Isthmus.
 	L2GenesisIsthmusTimeOffset *hexutil.Uint64 `json:"l2GenesisIsthmusTimeOffset,omitempty"`
+	// L2GenesisJovianTimeOffset is the number of seconds after genesis block that the Jovian hard fork activates.
+	// Set it to 0 to activate at genesis. Nil to disable Jovian.
+	L2GenesisJovianTimeOffset *hexutil.Uint64 `json:"l2GenesisJovianTimeOffset,omitempty"`
 	// L2GenesisInteropTimeOffset is the number of seconds after genesis block that the Interop hard fork activates.
 	// Set it to 0 to activate at genesis. Nil to disable Interop.
 	L2GenesisInteropTimeOffset *hexutil.Uint64 `json:"l2GenesisInteropTimeOffset,omitempty"`
@@ -395,6 +398,8 @@ func (d *UpgradeScheduleDeployConfig) ForkTimeOffset(fork rollup.ForkName) *uint
 		return (*uint64)(d.L2GenesisHoloceneTimeOffset)
 	case rollup.Isthmus:
 		return (*uint64)(d.L2GenesisIsthmusTimeOffset)
+	case rollup.Jovian:
+		return (*uint64)(d.L2GenesisJovianTimeOffset)
 	case rollup.Interop:
 		return (*uint64)(d.L2GenesisInteropTimeOffset)
 	default:
@@ -420,6 +425,8 @@ func (d *UpgradeScheduleDeployConfig) SetForkTimeOffset(fork rollup.ForkName, of
 		d.L2GenesisHoloceneTimeOffset = (*hexutil.Uint64)(offset)
 	case rollup.Isthmus:
 		d.L2GenesisIsthmusTimeOffset = (*hexutil.Uint64)(offset)
+	case rollup.Jovian:
+		d.L2GenesisJovianTimeOffset = (*hexutil.Uint64)(offset)
 	case rollup.Interop:
 		d.L2GenesisInteropTimeOffset = (*hexutil.Uint64)(offset)
 	default:
@@ -488,6 +495,10 @@ func (d *UpgradeScheduleDeployConfig) IsthmusTime(genesisTime uint64) *uint64 {
 	return offsetToUpgradeTime(d.L2GenesisIsthmusTimeOffset, genesisTime)
 }
 
+func (d *UpgradeScheduleDeployConfig) JovianTime(genesisTime uint64) *uint64 {
+	return offsetToUpgradeTime(d.L2GenesisJovianTimeOffset, genesisTime)
+}
+
 func (d *UpgradeScheduleDeployConfig) InteropTime(genesisTime uint64) *uint64 {
 	return offsetToUpgradeTime(d.L2GenesisInteropTimeOffset, genesisTime)
 }
@@ -521,6 +532,7 @@ func (d *UpgradeScheduleDeployConfig) forks() []Fork {
 		{L2GenesisTimeOffset: d.L2GenesisGraniteTimeOffset, Name: string(L2AllocsGranite)},
 		{L2GenesisTimeOffset: d.L2GenesisHoloceneTimeOffset, Name: string(L2AllocsHolocene)},
 		{L2GenesisTimeOffset: d.L2GenesisIsthmusTimeOffset, Name: string(L2AllocsIsthmus)},
+		{L2GenesisTimeOffset: d.L2GenesisJovianTimeOffset, Name: string(L2AllocsJovian)},
 	}
 }
 
@@ -1028,6 +1040,7 @@ func (d *DeployConfig) RollupConfig(l1StartBlock *types.Header, l2GenesisBlockHa
 		GraniteTime:             d.GraniteTime(l1StartTime),
 		HoloceneTime:            d.HoloceneTime(l1StartTime),
 		IsthmusTime:             d.IsthmusTime(l1StartTime),
+		JovianTime:              d.JovianTime(l1StartTime),
 		InteropTime:             d.InteropTime(l1StartTime),
 		ProtocolVersionsAddress: d.ProtocolVersionsProxy,
 		AltDAConfig:             altDA,

op-chain-ops/genesis/genesis.go

@@ -70,6 +70,7 @@ func NewL2Genesis(config *DeployConfig, l1StartHeader *types.Header) (*core.Gene
 		GraniteTime:             config.GraniteTime(l1StartTime),
 		HoloceneTime:            config.HoloceneTime(l1StartTime),
 		IsthmusTime:             config.IsthmusTime(l1StartTime),
+		JovianTime:              config.JovianTime(l1StartTime),
 		PragueTime:              config.IsthmusTime(l1StartTime),
 		InteropTime:             config.InteropTime(l1StartTime),
 		Optimism: &params.OptimismConfig{

op-chain-ops/genesis/layer_two.go

@@ -28,6 +28,7 @@ const (
 	L2AllocsGranite  L2AllocsMode = "granite"
 	L2AllocsHolocene L2AllocsMode = "holocene"
 	L2AllocsIsthmus  L2AllocsMode = "isthmus"
+	L2AllocsJovian   L2AllocsMode = "jovian"
 )
 
 var (

op-chain-ops/interopgen/recipe.go

@@ -237,6 +237,7 @@ func InteropL2DevConfig(l1ChainID, l2ChainID uint64, addrs devkeys.Addresses, me
 				L2GenesisGraniteTimeOffset:  new(hexutil.Uint64),
 				L2GenesisHoloceneTimeOffset: new(hexutil.Uint64),
 				L2GenesisIsthmusTimeOffset:  new(hexutil.Uint64),
+				L2GenesisJovianTimeOffset:   new(hexutil.Uint64),
 				L2GenesisInteropTimeOffset:  new(hexutil.Uint64),
 				L1CancunTimeOffset:          new(hexutil.Uint64),
 				L1PragueTimeOffset:          new(hexutil.Uint64),

op-e2e/e2eutils/setup.go

@@ -209,6 +209,7 @@ func Setup(t require.TestingT, deployParams *DeployParams, alloc *AllocParams) *
 		GraniteTime:            deployConf.GraniteTime(uint64(deployConf.L1GenesisBlockTimestamp)),
 		HoloceneTime:           deployConf.HoloceneTime(uint64(deployConf.L1GenesisBlockTimestamp)),
 		IsthmusTime:            deployConf.IsthmusTime(uint64(deployConf.L1GenesisBlockTimestamp)),
+		JovianTime:             deployConf.JovianTime(uint64(deployConf.L1GenesisBlockTimestamp)),
 		InteropTime:            deployConf.InteropTime(uint64(deployConf.L1GenesisBlockTimestamp)),
 		AltDAConfig:            pcfg,
 		ChainOpConfig: &params.OptimismConfig{
@@ -239,7 +240,8 @@ func SystemConfigFromDeployConfig(deployConfig *genesis.DeployConfig) eth.System
 }
 
 func ApplyDeployConfigForks(deployConfig *genesis.DeployConfig) {
-	isIsthmus := os.Getenv("OP_E2E_USE_ISTHMUS") == "true"
+	isJovian := os.Getenv("OP_E2E_USE_JOVIAN") == "true"
+	isIsthmus := isJovian || os.Getenv("OP_E2E_USE_ISTHMUS") == "true"
 	isHolocene := isIsthmus || os.Getenv("OP_E2E_USE_HOLOCENE") == "true"
 	isGranite := isHolocene || os.Getenv("OP_E2E_USE_GRANITE") == "true"
 	isFjord := isGranite || os.Getenv("OP_E2E_USE_FJORD") == "true"
@@ -263,6 +265,9 @@ func ApplyDeployConfigForks(deployConfig *genesis.DeployConfig) {
 	if isIsthmus {
 		deployConfig.L2GenesisIsthmusTimeOffset = new(hexutil.Uint64)
 	}
+	if isJovian {
+		deployConfig.L2GenesisJovianTimeOffset = new(hexutil.Uint64)
+	}
 	// Canyon and lower is activated by default
 	deployConfig.L2GenesisCanyonTimeOffset = new(hexutil.Uint64)
 	deployConfig.L2GenesisRegolithTimeOffset = new(hexutil.Uint64)

op-e2e/faultproofs/precompile_test.go

@@ -49,7 +49,7 @@ func testPrecompiles(t *testing.T, allocType e2e_config.AllocType) {
 			op_e2e.InitParallel(t, op_e2e.UsesCannon)
 			ctx := context.Background()
 			genesisTime := hexutil.Uint64(0)
-			cfg := e2esys.IsthmusSystemConfig(t, &genesisTime, e2esys.WithAllocType(allocType))
+			cfg := e2esys.JovianSystemConfig(t, &genesisTime, e2esys.WithAllocType(allocType))
 			// We don't need a verifier - just the sequencer is enough
 			delete(cfg.Nodes, "verifier")
 

op-e2e/system/e2esys/setup.go

@@ -197,6 +197,7 @@ func RegolithSystemConfig(t *testing.T, regolithTimeOffset *hexutil.Uint64, opts
 	cfg.DeployConfig.L2GenesisGraniteTimeOffset = nil
 	cfg.DeployConfig.L2GenesisHoloceneTimeOffset = nil
 	cfg.DeployConfig.L2GenesisIsthmusTimeOffset = nil
+	cfg.DeployConfig.L2GenesisJovianTimeOffset = nil
 	// ADD NEW FORKS HERE!
 	return cfg
 }
@@ -246,6 +247,12 @@ func IsthmusSystemConfig(t *testing.T, isthmusTimeOffset *hexutil.Uint64, opts .
 	return cfg
 }
 
+func JovianSystemConfig(t *testing.T, jovianTimeOffset *hexutil.Uint64, opts ...SystemConfigOpt) SystemConfig {
+	cfg := IsthmusSystemConfig(t, &genesisTime, opts...)
+	cfg.DeployConfig.L2GenesisJovianTimeOffset = jovianTimeOffset
+	return cfg
+}
+
 func writeDefaultJWT(t testing.TB) string {
 	// Sadly the geth node config cannot load JWT secret from memory, it has to be a file
 	jwtPath := path.Join(t.TempDir(), "jwt_secret")
@@ -647,6 +654,7 @@ func (cfg SystemConfig) Start(t *testing.T, startOpts ...StartOption) (*System,
 			GraniteTime:             cfg.DeployConfig.GraniteTime(uint64(cfg.DeployConfig.L1GenesisBlockTimestamp)),
 			HoloceneTime:            cfg.DeployConfig.HoloceneTime(uint64(cfg.DeployConfig.L1GenesisBlockTimestamp)),
 			IsthmusTime:             cfg.DeployConfig.IsthmusTime(uint64(cfg.DeployConfig.L1GenesisBlockTimestamp)),
+			JovianTime:              cfg.DeployConfig.JovianTime(uint64(cfg.DeployConfig.L1GenesisBlockTimestamp)),
 			InteropTime:             cfg.DeployConfig.InteropTime(uint64(cfg.DeployConfig.L1GenesisBlockTimestamp)),
 			ProtocolVersionsAddress: cfg.L1Deployments.ProtocolVersionsProxy,
 			AltDAConfig:             rollupAltDAConfig,

op-node/rollup/chain_spec.go

@@ -42,6 +42,7 @@ const (
 	Granite  ForkName = "granite"
 	Holocene ForkName = "holocene"
 	Isthmus  ForkName = "isthmus"
+	Jovian   ForkName = "jovian"
 	Interop  ForkName = "interop"
 	// ADD NEW FORKS TO AllForks BELOW!
 	None ForkName = "none"
@@ -57,6 +58,7 @@ var AllForks = []ForkName{
 	Granite,
 	Holocene,
 	Isthmus,
+	Jovian,
 	Interop,
 	// ADD NEW FORKS HERE!
 }
@@ -195,6 +197,9 @@ func (s *ChainSpec) CheckForkActivation(log log.Logger, block eth.L2BlockRef) {
 		if s.config.IsIsthmus(block.Time) {
 			s.currentFork = Isthmus
 		}
+		if s.config.IsJovian(block.Time) {
+			s.currentFork = Jovian
+		}
 		if s.config.IsInterop(block.Time) {
 			s.currentFork = Interop
 		}
@@ -221,6 +226,8 @@ func (s *ChainSpec) CheckForkActivation(log log.Logger, block eth.L2BlockRef) {
 		foundActivationBlock = s.config.IsHoloceneActivationBlock(block.Time)
 	case Isthmus:
 		foundActivationBlock = s.config.IsIsthmusActivationBlock(block.Time)
+	case Jovian:
+		foundActivationBlock = s.config.IsJovianActivationBlock(block.Time)
 	case Interop:
 		foundActivationBlock = s.config.IsInteropActivationBlock(block.Time)
 	}

op-node/rollup/chain_spec_test.go

@@ -47,6 +47,7 @@ var testConfig = Config{
 	GraniteTime:             u64ptr(60),
 	HoloceneTime:            u64ptr(70),
 	IsthmusTime:             u64ptr(80),
+	JovianTime:              u64ptr(90),
 	InteropTime:             nil,
 	BatchInboxAddress:       common.HexToAddress("0xff00000000000000000000000000000000000010"),
 	DepositContractAddress:  common.HexToAddress("0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"),
@@ -191,10 +192,16 @@ func TestCheckForkActivation(t *testing.T) {
 			expectedCurrentFork: Isthmus,
 			expectedLog:         "Detected hardfork activation block",
 		},
+		{
+			name:                "Jovian activation",
+			block:               eth.L2BlockRef{Time: 90, Number: 11, Hash: common.Hash{0xb}},
+			expectedCurrentFork: Jovian,
+			expectedLog:         "Detected hardfork activation block",
+		},
 		{
 			name:                "No more hardforks",
-			block:               eth.L2BlockRef{Time: 700, Number: 11, Hash: common.Hash{0xb}},
-			expectedCurrentFork: Isthmus,
+			block:               eth.L2BlockRef{Time: 700, Number: 12, Hash: common.Hash{0xc}},
+			expectedCurrentFork: Jovian,
 			expectedLog:         "",
 		},
 	}

op-node/rollup/superchain.go

@@ -89,6 +89,7 @@ func LoadOPStackRollupConfig(chainID uint64) (*Config, error) {
 		GraniteTime:            hardforks.GraniteTime,
 		HoloceneTime:           hardforks.HoloceneTime,
 		IsthmusTime:            hardforks.IsthmusTime,
+		JovianTime:             hardforks.JovianTime,
 		BatchInboxAddress:      chConfig.BatchInboxAddr,
 		DepositContractAddress: *addrs.OptimismPortalProxy,
 		L1SystemConfigAddress:  *addrs.SystemConfigProxy,

op-node/rollup/types.go

@@ -125,6 +125,10 @@ type Config struct {
 	// Active if IsthmusTime != nil && L2 block timestamp >= *IsthmusTime, inactive otherwise.
 	IsthmusTime *uint64 `json:"isthmus_time,omitempty"`
 
+	// JovianTime sets the activation time of the Jovian network upgrade.
+	// Active if JovianTime != nil && L2 block timestamp >= *JovianTime, inactive otherwise.
+	JovianTime *uint64 `json:"jovian_time,omitempty"`
+
 	// InteropTime sets the activation time for an experimental feature-set, activated like a hardfork.
 	// Active if InteropTime != nil && L2 block timestamp >= *InteropTime, inactive otherwise.
 	InteropTime *uint64 `json:"interop_time,omitempty"`
@@ -432,6 +436,11 @@ func (c *Config) IsIsthmus(timestamp uint64) bool {
 	return c.IsthmusTime != nil && timestamp >= *c.IsthmusTime
 }
 
+// IsJovian returns true if the Jovian hardfork is active at or past the given timestamp.
+func (c *Config) IsJovian(timestamp uint64) bool {
+	return c.JovianTime != nil && timestamp >= *c.JovianTime
+}
+
 // IsInterop returns true if the Interop hardfork is active at or past the given timestamp.
 func (c *Config) IsInterop(timestamp uint64) bool {
 	return c.InteropTime != nil && timestamp >= *c.InteropTime
@@ -495,6 +504,14 @@ func (c *Config) IsIsthmusActivationBlock(l2BlockTime uint64) bool {
 		!c.IsIsthmus(l2BlockTime-c.BlockTime)
 }
 
+// IsJovianActivationBlock returns whether the specified block is the first block subject to the
+// Jovian upgrade.
+func (c *Config) IsJovianActivationBlock(l2BlockTime uint64) bool {
+	return c.IsJovian(l2BlockTime) &&
+		l2BlockTime >= c.BlockTime &&
+		!c.IsJovian(l2BlockTime-c.BlockTime)
+}
+
 func (c *Config) IsInteropActivationBlock(l2BlockTime uint64) bool {
 	return c.IsInterop(l2BlockTime) &&
 		l2BlockTime >= c.BlockTime &&
@@ -518,6 +535,9 @@ func (c *Config) ActivateAtGenesis(hardfork ForkName) {
 	case Interop:
 		c.InteropTime = new(uint64)
 		fallthrough
+	case Jovian:
+		c.JovianTime = new(uint64)
+		fallthrough
 	case Isthmus:
 		c.IsthmusTime = new(uint64)
 		fallthrough
@@ -675,6 +695,7 @@ func (c *Config) Description(l2Chains map[string]string) string {
 	banner += fmt.Sprintf("  - Granite: %s\n", fmtForkTimeOrUnset(c.GraniteTime))
 	banner += fmt.Sprintf("  - Holocene: %s\n", fmtForkTimeOrUnset(c.HoloceneTime))
 	banner += fmt.Sprintf("  - Isthmus: %s\n", fmtForkTimeOrUnset(c.IsthmusTime))
+	banner += fmt.Sprintf("  - Jovian: %s\n", fmtForkTimeOrUnset(c.JovianTime))
 	banner += fmt.Sprintf("  - Interop: %s\n", fmtForkTimeOrUnset(c.InteropTime))
 	// Report the protocol version
 	banner += fmt.Sprintf("Node supports up to OP-Stack Protocol Version: %s\n", OPStackSupport)
@@ -712,6 +733,7 @@ func (c *Config) LogDescription(log log.Logger, l2Chains map[string]string) {
 		"granite_time", fmtForkTimeOrUnset(c.GraniteTime),
 		"holocene_time", fmtForkTimeOrUnset(c.HoloceneTime),
 		"isthmus_time", fmtForkTimeOrUnset(c.IsthmusTime),
+		"jovian_time", fmtForkTimeOrUnset(c.JovianTime),
 		"interop_time", fmtForkTimeOrUnset(c.InteropTime),
 		"alt_da", c.AltDAConfig != nil,
 	)

op-node/rollup/types_test.go

@@ -186,7 +186,9 @@ func TestRandomConfigDescription(t *testing.T) {
 		config.HoloceneTime = &h
 		i := uint64(1677119341)
 		config.IsthmusTime = &i
-		it := uint64(1677119342)
+		j := uint64(1677119342)
+		config.JovianTime = &j
+		it := uint64(1677119343)
 		config.InteropTime = &it
 
 		out := config.Description(nil)
@@ -291,6 +293,15 @@ func TestActivations(t *testing.T) {
 				return c.IsIsthmus(t)
 			},
 		},
+		{
+			name: "Jovian",
+			setUpgradeTime: func(t *uint64, c *Config) {
+				c.JovianTime = t
+			},
+			checkEnabled: func(t uint64, c *Config) bool {
+				return c.IsJovian(t)
+			},
+		},
 		{
 			name: "Interop",
 			setUpgradeTime: func(t *uint64, c *Config) {
@@ -563,7 +574,8 @@ func TestConfig_Check(t *testing.T) {
 				graniteTime := uint64(6)
 				holoceneTime := uint64(7)
 				isthmusTime := uint64(8)
-				interopTime := uint64(9)
+				jovianTime := uint64(9)
+				interopTime := uint64(10)
 				cfg.RegolithTime = &regolithTime
 				cfg.CanyonTime = &canyonTime
 				cfg.DeltaTime = &deltaTime
@@ -572,6 +584,7 @@ func TestConfig_Check(t *testing.T) {
 				cfg.GraniteTime = &graniteTime
 				cfg.HoloceneTime = &holoceneTime
 				cfg.IsthmusTime = &isthmusTime
+				cfg.JovianTime = &jovianTime
 				cfg.InteropTime = &interopTime
 			},
 			expectedErr: nil,

op-service/eth/types.go

@@ -364,22 +364,23 @@ func BlockAsPayload(bl *types.Block, config *params.ChainConfig) (*ExecutionPayl
 	}
 
 	payload := &ExecutionPayload{
-		ParentHash:    bl.ParentHash(),
-		FeeRecipient:  bl.Coinbase(),
-		StateRoot:     Bytes32(bl.Root()),
-		ReceiptsRoot:  Bytes32(bl.ReceiptHash()),
-		LogsBloom:     Bytes256(bl.Bloom()),
-		PrevRandao:    Bytes32(bl.MixDigest()),
-		BlockNumber:   Uint64Quantity(bl.NumberU64()),
-		GasLimit:      Uint64Quantity(bl.GasLimit()),
-		GasUsed:       Uint64Quantity(bl.GasUsed()),
-		Timestamp:     Uint64Quantity(bl.Time()),
-		ExtraData:     bl.Extra(),
-		BaseFeePerGas: Uint256Quantity(*baseFee),
-		BlockHash:     bl.Hash(),
-		Transactions:  opaqueTxs,
-		ExcessBlobGas: (*Uint64Quantity)(bl.ExcessBlobGas()),
-		BlobGasUsed:   (*Uint64Quantity)(bl.BlobGasUsed()),
+		ParentHash:      bl.ParentHash(),
+		FeeRecipient:    bl.Coinbase(),
+		StateRoot:       Bytes32(bl.Root()),
+		ReceiptsRoot:    Bytes32(bl.ReceiptHash()),
+		LogsBloom:       Bytes256(bl.Bloom()),
+		PrevRandao:      Bytes32(bl.MixDigest()),
+		BlockNumber:     Uint64Quantity(bl.NumberU64()),
+		GasLimit:        Uint64Quantity(bl.GasLimit()),
+		GasUsed:         Uint64Quantity(bl.GasUsed()),
+		Timestamp:       Uint64Quantity(bl.Time()),
+		ExtraData:       bl.Extra(),
+		BaseFeePerGas:   Uint256Quantity(*baseFee),
+		BlockHash:       bl.Hash(),
+		Transactions:    opaqueTxs,
+		ExcessBlobGas:   (*Uint64Quantity)(bl.ExcessBlobGas()),
+		BlobGasUsed:     (*Uint64Quantity)(bl.BlobGasUsed()),
+		WithdrawalsRoot: bl.WithdrawalsRoot(),
 	}
 
 	if config.ShanghaiTime != nil && uint64(payload.Timestamp) >= *config.ShanghaiTime {

op-wheel/commands.go

@@ -258,6 +258,7 @@ func rollupFromGethConfig(cfg *params.ChainConfig) *rollup.Config {
 		GraniteTime:  cfg.GraniteTime,
 		HoloceneTime: cfg.HoloceneTime,
 		IsthmusTime:  cfg.IsthmusTime,
+		JovianTime:   cfg.JovianTime,
 		InteropTime:  cfg.InteropTime,
 	}
 }

packages/contracts-bedrock/scripts/L2Genesis.s.sol

@@ -182,9 +182,14 @@ contract L2Genesis is Deployer {
         if (writeForkGenesisAllocs(_fork, Fork.HOLOCENE, _mode)) {
             return;
         }
+
         if (writeForkGenesisAllocs(_fork, Fork.ISTHMUS, _mode)) {
             return;
         }
+
+        if (writeForkGenesisAllocs(_fork, Fork.JOVIAN, _mode)) {
+            return;
+        }
     }
 
     function writeForkGenesisAllocs(Fork _latest, Fork _current, OutputMode _mode) internal returns (bool isLatest_) {